Files
WizardMerge/frontends/README.md
2025-12-26 04:10:33 +00:00

185 lines
5.5 KiB
Markdown

# WizardMerge Frontends
This directory contains multiple frontend implementations for WizardMerge, each designed for different use cases and workflows.
## Available Frontends
### 1. Qt6 Desktop Frontend (`qt6/`)
**Type**: Native desktop application
**Language**: C++ with Qt6 and QML
**Platforms**: Linux, Windows, macOS
A native desktop application providing the best performance and integration with desktop environments.
**Features**:
- Native window management and desktop integration
- Offline capability with embedded backend option
- High-performance rendering
- Three-panel diff viewer with QML-based UI
- Keyboard shortcuts and native file dialogs
**Best for**: Desktop users who want a fast, native application with full offline support.
See [qt6/README.md](qt6/README.md) for build and usage instructions.
### 2. Next.js Web Frontend (`nextjs/`)
**Type**: Web application
**Language**: TypeScript with React/Next.js
**Runtime**: bun
A modern web-based interface accessible from any browser.
**Features**:
- Cross-platform browser access
- No installation required
- Real-time collaboration (planned)
- Responsive design
- Easy deployment and updates
**Best for**: Teams needing shared access, cloud deployments, or users who prefer web interfaces.
See [nextjs/README.md](nextjs/README.md) for development and deployment instructions.
### 3. CLI Frontend (`cli/`)
**Type**: Command-line interface
**Language**: C++
**Platforms**: Linux, Windows, macOS
A command-line tool for automation and scripting.
**Features**:
- Non-interactive batch processing
- Scriptable and automatable
- CI/CD pipeline integration
- Git workflow integration
- Minimal dependencies
**Best for**: Automation, scripting, CI/CD pipelines, and terminal-based workflows.
See [cli/README.md](cli/README.md) for usage and examples.
## Architecture
All frontends communicate with the WizardMerge C++ backend through a common HTTP API:
```
┌─────────────────────────────────────────────────┐
│ Frontends │
│ ┌────────────┐ ┌────────────┐ ┌──────────┐ │
│ │ Qt6 Native │ │ Next.js │ │ CLI │ │
│ │ (C++) │ │(TypeScript)│ │ (C++) │ │
│ └─────┬──────┘ └──────┬─────┘ └────┬─────┘ │
└────────┼─────────────────┼─────────────┼───────┘
│ │ │
└─────────────────┼─────────────┘
HTTP REST API
┌─────────────────▼──────────────────┐
│ WizardMerge C++ Backend │
│ (Drogon HTTP Server) │
│ │
│ - Three-way merge algorithm │
│ - Conflict detection │
│ - Auto-resolution │
│ - Semantic analysis │
└────────────────────────────────────┘
```
### Backend API
The backend provides a REST API on port 8080 (configurable):
- `POST /api/merge` - Perform three-way merge
All frontends use this common API, ensuring consistent merge behavior regardless of the interface used.
## Choosing a Frontend
| Feature | Qt6 | Next.js | CLI |
|---------|-----|---------|-----|
| Native Performance | ✓ | - | ✓ |
| Offline Support | ✓ | - | ✓ |
| Web Browser Access | - | ✓ | - |
| Collaboration | - | ✓ (planned) | - |
| Automation/Scripting | - | - | ✓ |
| Visual UI | ✓ | ✓ | - |
| Installation Required | ✓ | - | ✓ |
| Platform Support | All | All | All |
## Building All Frontends
### Prerequisites
Install dependencies for all frontends you want to build:
```bash
# Qt6 (for qt6 frontend)
# Ubuntu/Debian:
sudo apt-get install qt6-base-dev qt6-declarative-dev
# macOS:
brew install qt@6
# Next.js (for nextjs frontend)
curl -fsSL https://bun.sh/install | bash
# CLI (for cli frontend)
# Ubuntu/Debian:
sudo apt-get install libcurl4-openssl-dev
# macOS:
brew install curl
```
### Build All
```bash
# Build Qt6 frontend
cd qt6
mkdir build && cd build
cmake .. -G Ninja
ninja
cd ../..
# Build/setup Next.js frontend
cd nextjs
bun install
bun run build
cd ..
# Build CLI frontend
cd cli
mkdir build && cd build
cmake .. -G Ninja
ninja
cd ../..
```
## Development Guidelines
When developing a frontend:
1. **Consistency**: Maintain consistent UX across all frontends where applicable
2. **API Usage**: Use the common backend API for all merge operations
3. **Error Handling**: Properly handle backend connection errors and API failures
4. **Documentation**: Update frontend-specific README files
5. **Testing**: Add tests for new features
### Adding a New Frontend
To add a new frontend implementation:
1. Create a new directory under `frontends/`
2. Implement the UI using your chosen technology
3. Use the backend HTTP API (`POST /api/merge`)
4. Add a README.md with build and usage instructions
5. Update this file to list the new frontend
## License
See [../LICENSE](../LICENSE) for details.