A fast, native Git client with built-in smart conflict resolution
Desktop • Conflict engine • CLI • MCP Server • Architecture • Roadmap • Code signing
GitWand is a lightweight, native Git client built with Tauri 2 and Vue 3. It covers the full daily workflow — changes, history, branches, push/pull — and goes further with automatic resolution of trivial merge conflicts, integrated PR code review with inline comments, and a Git Tree as the primary history view. Since v1.3, AI assists every step of the workflow — branch naming, PR writing, hunk-level review, semantic squash, and natural-language commit search. v2.7+ adds multi-repo Workspaces and Worktrees; v2.8 adds Agent Sessions (MCP); v2.9 adds a cross-repo Launchpad.
The Git Tree is the primary history view — a full-resolution DAG that renders the branch topology as an SVG with trunk-pinning, lane cooldowns, WIP node, and ref badges. Click any commit to see its diff; right-click to checkout, reset, branch, tag, or cherry-pick. Branches, stashes, and tags are all managed from here without a separate panel.
Staged, unstaged, untracked, and conflicted files in a sidebar with inline diffs in the main area. Stage, unstage, discard, and commit without leaving the interface. Partial staging at the line or hunk level.
Summary + description fields, optional commit signature, Ctrl+Enter shortcut. Unpushed commits can be amended directly from the Git Tree — a pencil icon appears on hover, opening an overlay pre-filled with the existing message.
Click the branch name in the header to search, switch, create, or delete branches. Merge any branch from the dedicated merge button. Each non-current branch shows a merge preview button that simulates the merge result before committing.
Before merging a branch, GitWand predicts the outcome without touching the working tree — using git merge-base, git show, and git merge-file -p --diff3. The result shows a per-file breakdown:
- Auto-resolvable — GitWand can handle it automatically
- Partial — some hunks need manual resolution
- Manual — complex conflicts requiring human judgment
- Add/delete — file added on one side, deleted on the other
A badge summarises the overall result: Clean merge, 100% auto-resolvable, or N conflicts to review.
One-click push and pull with badge counters showing ahead/behind commits. Auto-fetch runs in the background every 30 seconds.
Side-by-side or inline toggle, persisted across sessions. Syntax highlighting for 30+ languages, word-level diff using LCS, collapsible unchanged regions, canvas minimap, hunk navigation (prev/next), double-column line numbers.
Full file history with git log --follow, blame view grouped by commit, time-travel diff between any two versions of a file.
The current repo name in the header opens a dropdown showing recently opened repositories. Pin favourites, switch instantly — no file picker needed. Workspaces (v2.7) group multiple repos into a single dashboard with cross-repo status, coordinated push/pull, and quick-create worktrees (⌘⇧N).
Launchpad (⌘L, v2.9) is a cross-repo dashboard with four tabs — WIP, PRs, Issues, Team — for a bird's-eye view of everything in flight. Pin or snooze any item; the Team tab loads lazily for performance on large workspaces.
Browse, create, checkout, and merge GitHub PRs without leaving the app. The PR list sits in the sidebar and the full detail — diff, CI checks, comments, inline review — fills the main area.
- Inline comments — read and write review comments anchored to diff lines, with full threading and code suggestions (
```suggestion ```blocks applicable in one click) - Review submission — Approve / Request changes / Comment, with a draft queue to accumulate comments before sending
- 🧠 Intelligence panel — conflict prediction (
git merge-treebefore merging), hotspot analysis, review scope, static AI suggestions, file review history
The Agents panel (v2.8) shows active MCP sessions and lets you launch Claude Code directly from GitWand — the agent's changes appear live in the diff viewer. The MCP catalog (Settings > MCP) lets you install any MCP server in one click.
Language (FR/EN, OS auto-detected), theme (dark/light/system), commit signature, diff mode, AI provider (Claude / OpenAI-compatible / Ollama), external editor, Git binary path, switch behavior (stash/ask/refuse). All persisted in app settings.
Download the latest build for your platform from GitHub Releases:
- macOS —
.dmg(Universal: Apple Silicon + Intel, Developer ID signed + Apple-notarized) - Linux —
.AppImageor.deb - Windows —
.msior.exe
git clone https://github.com/devlint/GitWand.git
cd GitWand
pnpm install
# Browser dev mode — no Rust needed
cd apps/desktop && pnpm dev:web
# Tauri desktop mode — requires Rust toolchain
# Install Rust: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source "$HOME/.cargo/env"
pnpm --filter desktop tauri devGitWand's core engine (@gitwand/core) automatically resolves trivial Git merge conflicts. It never touches complex or ambiguous hunks.
GitWand uses a pattern registry — the classifier evaluates patterns in priority order, each declaring whether it requires diff3 (base available), diff2, or works on both.
| Pattern | Description | Confidence |
|---|---|---|
| same_change | Both branches made the exact same edit | Certain |
| one_side_change | Only one branch modified the block | Certain |
| delete_no_change | One branch deleted, the other didn't touch it | Certain |
| non_overlapping | Additions at different locations in the block | High |
| whitespace_only | Same logic, different indentation/spacing | High |
| reorder_only | Same lines, different order — pure permutation | High |
| insertion_at_boundary | Pure insertions on both sides, base intact | High |
| value_only_change | Scalar value update (version number, constant) | Medium |
| generated_file | File matches a known generated-file path pattern | High |
| complex | Overlapping edits — never auto-resolved | — |
Every resolution carries a ConfidenceScore object rather than a simple label:
{
score: 84, // 0–100 composite score
label: "high", // "certain" | "high" | "medium" | "low"
dimensions: {
typeClassification: 90, // certainty of the detected pattern
dataRisk: 20, // risk of data loss if auto-resolved
scopeImpact: 10, // impact of change size
},
boosters: ["Path matches generated-file pattern: lockfile"],
penalties: ["Content will be regenerated — theirs assumed more recent"],
}Score formula: score = typeClassification − dataRisk×0.4 − scopeImpact×0.15
For structured files, GitWand uses semantic resolvers before falling back to text matching:
- JSON / JSONC — recursive key-by-key merge using
JSON.parse/JSON.stringify. Handles nested objects, detects unresolvable scalar conflicts, strips comments in.jsonc. - Markdown — section-aware merge by ATX heading (H1–H6). Merges independent sections, falls back to text if the same section is modified on both sides.
Create a .gitwandrc file at the project root to define resolution strategies:
{
"policy": "prefer-merge",
"patternOverrides": {
"*.lock": "prefer-theirs",
"src/generated/**": "prefer-theirs",
"CHANGELOG.md": "prefer-ours"
}
}Available policies: prefer-ours, prefer-theirs, prefer-safety, prefer-merge, strict.
Every classification step is logged in a DecisionTrace for auditing and debugging:
✓ src/config.ts — 3/3 resolved
L12 [one_side_change] certain — Only the incoming branch modified this block.
L25 [same_change] certain — Both branches made the exact same edit.
L41 [value_only_change:json] high — Scalar value updated on one side (version field).
# Use directly with npx
npx @gitwand/cli resolve
# Or install globally
npm install -g @gitwand/cligitwand resolve # Resolve all conflicted files in the repo
gitwand resolve --dry-run # Preview without writing
gitwand resolve --verbose # Detailed decision trace
gitwand status # Show conflict status per file
gitwand resolve --ci # CI mode: JSON output + semantic exit codesThe --ci / --json flag returns a full structured report with composite confidence scores, decision traces, and pending hunks for LLM-assisted resolution:
{
"version": "0.1.0",
"timestamp": "2026-04-14T12:00:00.000Z",
"summary": {
"files": 2,
"totalConflicts": 5,
"autoResolved": 4,
"remaining": 1,
"allResolved": false
},
"files": [
{
"path": "src/config.ts",
"totalConflicts": 3,
"autoResolved": 3,
"remaining": 0,
"validation": {
"isValid": true,
"hasResidualMarkers": false,
"syntaxError": null
},
"resolutions": [
{
"line": 15,
"type": "one_side_change",
"resolved": true,
"explanation": "Only one side modified this block",
"confidence": {
"score": 95,
"label": "certain",
"typeClassification": 100,
"dataRisk": 5,
"scopeImpact": 10
},
"trace": {
"selected": "theirs",
"hasBase": true,
"summary": "One-side change detected — incoming accepted.",
"steps": ["..."]
}
}
],
"pendingHunks": []
}
]
}The pendingHunks array gives AI agents and CI scripts everything they need to handle the conflicts that GitWand can't auto-resolve — the ours/theirs/base content, the classification trace, and the confidence breakdown.
GitWand ships an MCP (Model Context Protocol) server that exposes its conflict resolution engine to AI agents — Claude Code, Claude Desktop, Cursor, Windsurf, and any MCP-compatible client.
Add this to your MCP client configuration (e.g. claude_desktop_config.json or .claude/settings.json):
{
"mcpServers": {
"gitwand": {
"command": "npx",
"args": ["-y", "@gitwand/mcp"]
}
}
}The server defaults to the working directory of the client. To pin it to a specific repo, add "--cwd", "/absolute/path/to/repo" to the args array. With Claude Code, install in one line:
claude mcp add gitwand -- npx -y @gitwand/mcp| Tool | Description |
|---|---|
gitwand_status |
List conflicted files with their complexity and auto-resolvability |
gitwand_resolve_conflicts |
Auto-resolve trivial conflicts, return DecisionTrace + pendingHunks |
gitwand_preview_merge |
Dry-run resolution — stats and risk assessment without writing files |
gitwand_explain_hunk |
Explain why a specific hunk was classified its type (full trace + context) |
gitwand_apply_resolution |
Apply a custom (LLM-provided) resolution to a specific complex hunk |
| URI | Description |
|---|---|
gitwand://repo/conflicts |
Current conflict state — files, counts, types |
gitwand://repo/policy |
Active .gitwandrc configuration |
gitwand://hunk/{file}/{line} |
Raw hunk content for a specific conflict |
The MCP server enables a powerful workflow where GitWand handles the trivial conflicts automatically and the LLM tackles the complex ones:
- LLM calls
gitwand_preview_merge— sees how many conflicts exist and how many GitWand can handle - LLM calls
gitwand_resolve_conflicts— GitWand auto-resolves the easy ones, returnspendingHunksfor the rest - LLM reads the
pendingHunks— each one contains ours/theirs/base content and a full decision trace - LLM calls
gitwand_apply_resolutionfor each pending hunk — writes its resolution directly
GitWand also ships .claude/commands/ for Claude Code:
/resolve # Full conflict resolution workflow
/preview # Merge preview and risk assessmentgitwand/
├── packages/
│ ├── core/ @gitwand/core — Resolution engine (TypeScript, browser-safe)
│ │ parser, resolver, classifier, format resolvers,
│ │ confidence scoring, tree-sitter structural dispatch
│ ├── cli/ @gitwand/cli — Command-line interface
│ ├── mcp/ @gitwand/mcp — MCP server (stdio transport)
│ │ tools (5), resources (3), Claude Code commands
│ └── vscode/ VS Code extension — CodeLens, diagnostics, status bar
├── apps/
│ └── desktop/ Tauri 2 + Vue 3 desktop app
│ src-tauri/ Rust backend (git commands, IPC, libgit2)
│ src/ Vue frontend (stores, composables, panels)
└── .claude/
└── commands/ Claude Code slash commands (/resolve, /preview)
The core engine is framework-agnostic and usable as a library:
import { resolve } from "@gitwand/core";
const result = resolve(conflictedContent, "src/app.ts");
console.log(`${result.stats.autoResolved}/${result.stats.totalConflicts} resolved`);
// With options
const result = resolve(content, "package.json", {
policy: "prefer-merge",
minConfidence: "medium",
patternOverrides: { "*.lock": "prefer-theirs" },
});git clone https://github.com/devlint/GitWand.git
cd GitWand
pnpm install
pnpm build # Build all packages
pnpm test # Tests across all workspacescd packages/core
pnpm test:bench # vitest bench — ops/s per fixture sizeBaseline results on Apple M-series:
| Input | Throughput |
|---|---|
| 1 conflict / ~30 lines | ~249 000 ops/s |
| 5 conflicts / ~140 lines | ~40 000 ops/s |
| 50 conflicts / ~1350 lines | ~4 500 ops/s |
| JSON/Markdown format-aware | ~137 000 ops/s |
GitWand uses a zero-dependency type-safe i18n system. fr.ts is the reference locale defined with as const. en.ts must match the same structure — TypeScript enforces it. The useI18n() composable provides t(key, ...args) with dotted key resolution and positional interpolation. OS language is auto-detected; users can override in Settings.
See ROADMAP.md for the full phased plan — upcoming features, competitive analysis, and shipped version history.
Windows builds of GitWand are code-signed. Free code signing provided by SignPath.io, certificate by SignPath Foundation.
| Role | Member |
|---|---|
| Committers / Reviewers | Laurent Guitton |
| Approvers | Laurent Guitton |
This program will not transfer any information to other networked systems unless specifically requested by the user.
MIT — Laurent Guitton