Skip to content
Back to search

GitWand

The Git client that actually resolves conflicts: 8 deterministic patterns auto-resolve the ones that were never decisions, full trace on the rest. Native (Tauri 2 + Rust), free, MIT.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/devlint/GitWand with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/devlint/GitWand'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/devlint--gitwand/badge.svg)](/listings/devlint--gitwand)

HTML

<a href="/listings/devlint--gitwand"><img src="/api/listings/devlint--gitwand/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Download the latest build for your platform from [GitHub Releases](https://github.com/devlint/GitWand/releases):

- **macOS** — `.dmg` (Universal: Apple Silicon + Intel, Developer ID signed + Apple-notarized) - **Linux** — `.AppImage` or `.deb` - **Windows** — `.msi` or `.exe`

On Windows, you can also install via [winget](https://learn.microsoft.com/windows/package-manager/):

winget install Devlint.GitWand

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 472 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <p align="center">
  2. <img src="assets/logo.svg" alt="GitWand" width="300" height="120">
  3. </p>
  4. <h1 align="center">GitWand</h1>
  5. <p align="center">
  6. <strong>A fast, native Git client with built-in smart conflict resolution</strong>
  7. </p>
  8. <p align="center">
  9. <a href="#desktop-app">Desktop</a> &bull;
  10. <a href="#conflict-resolution-engine">Conflict engine</a> &bull;
  11. <a href="#cli">CLI</a> &bull;
  12. <a href="#mcp-server">MCP Server</a> &bull;
  13. <a href="#architecture">Architecture</a> &bull;
  14. <a href="./ROADMAP.md">Roadmap</a> &bull;
  15. <a href="#code-signing-policy">Code signing</a>
  16. </p>
  17. <p align="center">
  18. <img alt="License" src="https://img.shields.io/badge/license-MIT-8B5CF6">
  19. <img alt="TypeScript" src="https://img.shields.io/badge/TypeScript-100%25-3178C6">
  20. <img alt="Version" src="https://img.shields.io/badge/version-3.13.2-22c55e">
  21. </p>
  22. <p align="center">
  23. <a href="https://github.com/sponsors/devlint">
  24. <img alt="Github Sponsor" src="https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub&color=%23fe8e86">
  25. </a>
  26. </p>
  27. ---
  28. 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; v2.10 brings multi-forge pull requests across **GitHub, GitLab, Bitbucket and Azure DevOps**; v2.13 adds inline AI code review; v2.18 overlays CI check annotations directly on the diff; v2.19 adds **OAuth device-flow sign-in for GitHub and Azure DevOps** (no `gh` CLI required) plus **cross-fork pull requests**. The 3.x line makes GitWand a daily driver for AI-assisted work: v3.0 turns the cross-repo dashboard into **Today**, a triaged action inbox, and publishes the **VS Code extension on the Marketplace**; v3.2 adds an **integrated terminal with AI agent tabs** — including one-click AI tasks in isolated worktrees — and a dockable **File Explorer / Editor panel**. v3.11 makes the **Conflict Predictor run the merge** it predicts and adds **Gitea and Forgejo**; v3.12 brings GitWand's own terminal emulator, a WIP row in the Git Tree and AI agents kept away from your tokens; v3.13 turns **worktrees into environments** — per-repo setup and teardown commands, merge-back of an agent's work as a merge, rebase or squash, and removed worktrees restorable from the Time Machine.
  29. ## Desktop app
  30. ### Git Tree
  31. 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. A **filter mode** (v3.2) recalculates the DAG to show only matching commits, with quick branch/author toggles, date-bucket separators, branch-name autocomplete, and `#<PR number>` lookup that resolves straight to the PR's branch.
  32. ### Repository view
  33. 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.
  34. ### Commit workflow
  35. 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.
  36. ### Branches
  37. 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.
  38. ### Merge preview
  39. 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:
  40. - **Auto-resolvable** — GitWand can handle it automatically
  41. - **Partial** — some hunks need manual resolution
  42. - **Manual** — complex conflicts requiring human judgment
  43. - **Add/delete** — file added on one side, deleted on the other
  44. A badge summarises the overall result: `Clean merge`, `100% auto-resolvable`, or `N conflicts to review`.
  45. ### Push & Pull
  46. One-click push and pull with badge counters showing ahead/behind commits. Auto-fetch runs in the background every 30 seconds.
  47. ### Diff viewer
  48. 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.
  49. ### File history & blame
  50. Full file history with `git log --follow`, blame view grouped by commit, time-travel diff between any two versions of a file.
  51. ### Repo switcher & Workspaces
  52. 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`). Each project tab carries a **worktree submenu** (v3.2) listing `main` plus every worktree — select one to switch that project's checkout in place, no extra tab.
  53. ### Today
  54. **Today** (`⌘L`; introduced as Launchpad in v2.9, reworked in v3.0) is a cross-repo **triaged action inbox**: everything in flight — WIP, PRs, Issues, Team — sorted into urgency tiers, each row carrying a state-aware primary action (Merge · Review · Resolve · Reply · See failure). Pin or snooze any item; the Team tab loads lazily for performance on large workspaces.
  55. ### Pull Requests & Code Review
  56. Browse, create, checkout, and merge pull/merge requests across **GitHub, GitLab, Bitbucket, Azure DevOps, Gitea and Forgejo** without leaving the app. GitWand auto-detects the forge from the remote and routes to the right provider; accounts are managed once in Settings. The PR list sits in the sidebar and the full detail — diff, CI checks, comments, inline review — fills the main area.
  57. - **Sign in with OAuth** — "Sign in with GitHub" and "Sign in with Azure DevOps" use the OAuth device flow; tokens are stored in the OS keychain and the GitHub PR workflow runs tokenless over the REST API, with **no `gh` CLI required** (the CLI path still works when no token is configured)
  58. - **Cross-fork pull requests** — when `origin` is a fork, open a PR straight against the upstream parent (default), and see the PRs you opened upstream listed alongside your fork's own
  59. - **Inline comments** — read and write review comments anchored to diff lines, with full threading and code suggestions (` ```suggestion ``` ` blocks applicable in one click)
  60. - **Inline CI check annotations** — failed-check annotations overlay the diff with gutter icons (❌/⚠/ℹ) and hover tooltips, with a per-file count in the sidebar (GitHub, GitLab and Bitbucket)
  61. - **Review submission** — Approve / Request changes / Comment, with a draft queue to accumulate comments before sending
  62. - **🧠 Intelligence panel** — conflict prediction (`git merge-tree` before merging), hotspot analysis, review scope, static AI suggestions, file review history
  63. ### Agent Sessions
  64. 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.
  65. ### Integrated terminal & AI tasks
  66. The **terminal panel** (v3.2) renders through WebGL with inline search (`Ctrl+F`), clickable links, and typed tabs — `shell`, `claude`, `codex` — each with its own icon and an unread-output dot. "Launch Claude Code" / "Launch Codex" open a real PTY tab, and **"New AI task"** creates a scratch git worktree and opens a Claude Code tab in it in one click — the agent works in isolation, and when it's done you either **merge the work back or delete the worktree** from the project tab's submenu. Hardened with a shell-executable whitelist, `safe_repo_path()` on all filesystem operations, and PTY orphan prevention.
  67. ### File Explorer / Editor
  68. A dockable **Files panel** (v3.2, drag/resize/fullscreen) lists the full repo tree — gitignore-aware, via `git ls-files` — and opens files in a lazy-loaded CodeMirror 6 editor with syntax highlighting, per-tab undo history, and a lock/undo/save toolbar. Reachable from the Files tile in the AppDock, with per-repo layout settings.
  69. ### Settings
  70. Language (English, French, Spanish, Brazilian Portuguese, Simplified Chinese — OS auto-detected), theme (dark/light/system), commit signature, diff mode, external editor, Git binary path, and switch behavior (stash/ask/refuse). **AI providers** cover API backends (Claude / OpenAI-compatible / Ollama) and local CLI agents (Claude Code, Codex, opencode, GitHub Copilot CLI), each with its own model picker. **Accounts** manages forge sign-in — OAuth device flow for GitHub and Azure DevOps, App Passwords / CLI for the others. All persisted in app settings.
  71. ### Installing
  72. Download the latest build for your platform from [GitHub Releases](https://github.com/devlint/GitWand/releases):
  73. - **macOS** — `.dmg` (Universal: Apple Silicon + Intel, Developer ID signed + Apple-notarized)
  74. - **Linux** — `.AppImage` or `.deb`
  75. - **Windows** — `.msi` or `.exe`
  76. On Windows, you can also install via [winget](https://learn.microsoft.com/windows/package-manager/):
  77. ```bash
  78. winget install Devlint.GitWand
  79. ```
  80. ### Running from source
  81. ```bash
  82. git clone https://github.com/devlint/GitWand.git
  83. cd GitWand
  84. pnpm install
  85. # Browser dev mode — no Rust needed
  86. cd apps/desktop && pnpm dev:web
  87. # Tauri desktop mode — requires Rust toolchain
  88. # Install Rust: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
  89. source "$HOME/.cargo/env"
  90. # Desktop Dev Build (In the apps/desktop/ folder)
  91. pnpm --filter desktop tauri dev
  92. # On linux you may have to run
  93. WEBKIT_DISABLE_COMPOSITING_MODE=1 pnpm --filter desktop tauri dev
  94. ```
  95. ---
  96. ## Conflict resolution engine
  97. GitWand's core engine (`@gitwand/core`) automatically resolves trivial Git merge conflicts. It never touches complex or ambiguous hunks.
  98. ### Resolution patterns
  99. 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.
  100. The registry holds **12 patterns**, of which **8 auto-apply**. The other four either propose a resolution you confirm, are opt-in, or hand the hunk back untouched.
  101. | Pattern | Priority | Auto-applies | Description | Typical confidence |
  102. |---|---|---|---|---|
  103. | **same_change** | 10 | Yes | Both branches made the exact same edit | Certain |
  104. | **delete_no_change** | 20 | Yes | One side deleted the block, the other left it untouched | Certain |
  105. | **one_side_change** | 30 | Yes | Only one branch modified the block | Certain |
  106. | **non_overlapping** | 40 | Yes | Additions at different locations in the block | High |
  107. | **whitespace_only** | 50 | Yes | Same logic, different indentation/spacing | High |
  108. | **reorder_only** | 55 | Yes | Same lines, different order, a pure permutation | High |
  109. | **insertion_at_boundary** | 57 | Yes | Pure insertions on both sides, base intact | High |
  110. | **value_only_change** | 60 | Yes | Both sides changed the same scalar (version, hash, timestamp) | High to medium |
  111. | **token_level_merge** | 65 | No, proposes | Disjoint token edits on the same line, merged into a proposal you confirm | Medium |
  112. | **refactoring_aware_merge** | 970 | No, opt-in | Rename or move detected and replayed across the conflict | High |
  113. | **llm_proposed** | 998 | No, opt-in | Model-proposed resolution, validated post-merge | Medium |
  114. | **complex** | 999 | No | Overlapping edits, always surfaced with a full trace | Low |
  115. The confidence column is indicative: every hunk carries a computed `ConfidenceScore` (see below), not a fixed label. `value_only_change`, for instance, scores on the ratio of volatile tokens to total tokens and rejects the hunk outright below its threshold.
  116. **Not a registry pattern:** `generated_file` is a separate reclassification pass that runs after classification. When a hunk's path matches a generated-file glob (lockfiles, bundles, `dist/`, plus anything in `generatedFiles`), the resolver rewrites it to `generated_file` and, by default, declines with an actionable reason rather than guessing — [measured on 1,662 real merges](https://github.com/devlint/GitWand/tree/main/benchmark), auto-merging generated files diverged from what teams actually shipped in almost every case. GitWand tells you to resolve the source file and re-run the installer/build instead. Opt back into the old accept-theirs/semantic-merge behavior with `.gitwandrc`'s `resolveGeneratedFiles: true` or `gitwand resolve --resolve-generated`. `generated_file` appears in `ConflictType` but never in the classifier registry.
  117. ### Composite confidence score
  118. Every resolution carries a `ConfidenceScore` object rather than a simple label:
  119. ```ts
  120. {
  121. score: 84, // 0–100 composite score
  122. label: "high", // "certain" | "high" | "medium" | "low"
  123. dimensions: {
  124. typeClassification: 90, // certainty of the detected pattern
  125. dataRisk: 20, // risk of data loss if auto-resolved
  126. scopeImpact: 10, // impact of change size
  127. },
  128. boosters: ["Path matches generated-file pattern: lockfile"],
  129. penalties: ["Content will be regenerated — theirs assumed more recent"],
  130. }
  131. ```
  132. (Shape shown for a `generated_file` hunk with `resolveGeneratedFiles: true` — the default is to decline generated files rather than score and apply them; see the pattern table above.)
  133. Score formula: `score = typeClassification − dataRisk×0.4 − scopeImpact×0.15`
  134. ### Format-aware resolvers
  135. For structured files, GitWand uses semantic resolvers before falling back to text matching:
  136. - **JSON / JSONC** — recursive key-by-key merge using `JSON.parse`/`JSON.stringify`. Handles nested objects, detects unresolvable scalar conflicts, strips comments in `.jsonc`.
  137. - **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.
  138. ### Configurable merge policies
  139. Create a `.gitwandrc` file at the project root to define resolution strategies:
  140. ```json
  141. {
  142. "policy": "prefer-merge",
  143. "patternOverrides": {
  144. "*.lock": "prefer-theirs",
  145. "src/generated/**": "prefer-theirs",
  146. "CHANGELOG.md": "prefer-ours"
  147. }
  148. }
  149. ```
  150. Available policies: `prefer-ours`, `prefer-theirs`, `prefer-safety`, `prefer-merge`, `strict`.
  151. ### Decision trace
  152. Every classification step is logged in a `DecisionTrace` for auditing and debugging:
  153. ```
  154. ✓ src/config.ts — 3/3 resolved
  155. L12 [one_side_change] certain — Only the incoming branch modified this block.
  156. L25 [same_change] certain — Both branches made the exact same edit.
  157. L41 [value_only_change:json] high — Scalar value updated on one side (version field).
  158. ```
  159. ---
  160. ## CLI
  161. [![npm](https://img.shields.io/npm/v/@gitwand/cli?color=22c55e&label=%40gitwand%2Fcli)](https://www.npmjs.com/package/@gitwand/cli)
  162. ```bash
  163. # Use directly with npx
  164. npx @gitwand/cli resolve
  165. # Or install globally
  166. npm install -g @gitwand/cli
  167. ```
  168. ```bash
  169. gitwand resolve # Resolve all conflicted files in the repo
  170. gitwand resolve --dry-run # Preview without writing
  171. gitwand resolve --verbose # Detailed decision trace
  172. gitwand status # Show conflict status per file
  173. gitwand resolve --ci # CI mode: JSON output + semantic exit codes
  174. ```
  175. ### Enriched JSON output
  176. The `--ci` / `--json` flag returns a full structured report with composite confidence scores, decision traces, and pending hunks for LLM-assisted resolution:
  177. ```json
  178. {
  179. "version": "0.1.0",
  180. "timestamp": "2026-04-14T12:00:00.000Z",
  181. "summary": {
  182. "files": 2,
  183. "totalConflicts": 5,
  184. "autoResolved": 4,
  185. "remaining": 1,
  186. "allResolved": false
  187. },
  188. "files": [
  189. {
  190. "path": "src/config.ts",
  191. "totalConflicts": 3,
  192. "autoResolved": 3,
  193. "remaining": 0,
  194. "validation": {
  195. "isValid": true,
  196. "hasResidualMarkers": false,
  197. "syntaxError": null
  198. },
  199. "resolutions": [
  200. {
  201. "line": 15,
  202. "type": "one_side_change",
  203. "resolved": true,
  204. "explanation": "Only one side modified this block",
  205. "confidence": {
  206. "score": 95,
  207. "label": "certain",
  208. "typeClassification": 100,
  209. "dataRisk": 5,
  210. "scopeImpact": 10
  211. },
  212. "trace": {
  213. "selected": "theirs",
  214. "hasBase": true,
  215. "summary": "One-side change detected — incoming accepted.",
  216. "steps": ["..."]
  217. }
  218. }
  219. ],
  220. "pendingHunks": []
  221. }
  222. ]
  223. }
  224. ```
  225. 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.
  226. ---
  227. ## MCP Server
  228. [![npm](https://img.shields.io/npm/v/@gitwand/mcp?color=22c55e&label=%40gitwand%2Fmcp)](https://www.npmjs.com/package/@gitwand/mcp)
  229. [![MCP Registry](https://img.shields.io/badge/MCP%20Registry-listed-22c55e)](https://registry.modelcontextprotocol.io/?search=gitwand)
  230. 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.
  231. ### Setup
  232. Add this to your MCP client configuration (e.g. `claude_desktop_config.json` or `.claude/settings.json`):
  233. ```json
  234. {
  235. "mcpServers": {
  236. "gitwand": {
  237. "command": "npx",
  238. "args": ["-y", "@gitwand/mcp"]
  239. }
  240. }
  241. }
  242. ```
  243. 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:
  244. ```bash
  245. claude mcp add gitwand -- npx -y @gitwand/mcp
  246. ```
  247. ### Tools
  248. | Tool | Description |
  249. |------|-------------|
  250. | `gitwand_status` | List conflicted files with their complexity and auto-resolvability |
  251. | `gitwand_resolve_conflicts` | Auto-resolve trivial conflicts, return DecisionTrace + pendingHunks |
  252. | `gitwand_preview_merge` | Dry-run resolution — stats and risk assessment without writing files |
  253. | `gitwand_explain_hunk` | Explain why a specific hunk was classified its type (full trace + context) |
  254. | `gitwand_apply_resolution` | Apply a custom (LLM-provided) resolution to a specific complex hunk |
  255. | `gitwand_resolve_hunk` | Ask the connected agent to propose a resolution for one pending hunk (ours/theirs/base + trace returned) |
  256. | `gitwand_resolve_hunk_llm` | Validate an LLM-proposed resolution through the post-merge gate, then apply it to disk |
  257. ### Resources
  258. | URI | Description |
  259. |-----|-------------|
  260. | `gitwand://repo/conflicts` | Current conflict state — files, counts, types |
  261. | `gitwand://repo/policy` | Active `.gitwandrc` configuration |
  262. | `gitwand://hunk/{file}/{line}` | Raw hunk content for a specific conflict |
  263. ### The human ↔ LLM collaboration loop
  264. The MCP server enables a powerful workflow where GitWand handles the trivial conflicts automatically and the LLM tackles the complex ones:
  265. 1. **LLM calls `gitwand_preview_merge`** — sees how many conflicts exist and how many GitWand can handle
  266. 2. **LLM calls `gitwand_resolve_conflicts`** — GitWand auto-resolves the easy ones, returns `pendingHunks` for the rest
  267. 3. **LLM reads the `pendingHunks`** — each one contains ours/theirs/base content and a full decision trace
  268. 4. **LLM calls `gitwand_apply_resolution`** for each pending hunk — writes its resolution directly
  269. ### Claude Code slash commands
  270. GitWand also ships `.claude/commands/` for Claude Code:
  271. ```bash
  272. /resolve # Full conflict resolution workflow
  273. /preview # Merge preview and risk assessment
  274. ```
  275. ---
  276. ## Architecture
  277. ```
  278. gitwand/
  279. ├── packages/
  280. │ ├── core/ @gitwand/core — Resolution engine (TypeScript, browser-safe)
  281. │ │ parser, resolver, classifier, format resolvers,
  282. │ │ confidence scoring, tree-sitter structural dispatch
  283. │ ├── cli/ @gitwand/cli — Command-line interface
  284. │ ├── mcp/ @gitwand/mcp — MCP server (stdio transport)
  285. │ │ tools (7), resources (3), Claude Code commands
  286. │ └── vscode/ VS Code extension — CodeLens, diagnostics, status bar
  287. ├── apps/
  288. │ └── desktop/ Tauri 2 + Vue 3 desktop app
  289. │ src-tauri/ Rust backend (git commands, IPC, libgit2)
  290. │ src/ Vue frontend (stores, composables, panels)
  291. └── .claude/
  292. └── commands/ Claude Code slash commands (/resolve, /preview)
  293. ```
  294. The core engine is framework-agnostic and usable as a library:
  295. ```ts
  296. import { resolve } from "@gitwand/core";
  297. const result = resolve(conflictedContent, "src/app.ts");
  298. console.log(`${result.stats.autoResolved}/${result.stats.totalConflicts} resolved`);
  299. // With options
  300. const result = resolve(content, "package.json", {
  301. policy: "prefer-merge",
  302. minConfidence: "medium",
  303. patternOverrides: { "*.lock": "prefer-theirs" },
  304. });
  305. ```
  306. ---
  307. ## Development
  308. ```bash
  309. git clone https://github.com/devlint/GitWand.git
  310. cd GitWand
  311. pnpm install
  312. pnpm build # Build all packages
  313. pnpm test # Tests across all workspaces
  314. ```
  315. ### Running benchmarks
  316. ```bash
  317. cd packages/core
  318. pnpm test:bench # vitest bench — ops/s per fixture size
  319. ```
  320. Baseline results on Apple M-series:
  321. | Input | Throughput |
  322. |---|---|
  323. | 1 conflict / ~30 lines | ~249 000 ops/s |
  324. | 5 conflicts / ~140 lines | ~40 000 ops/s |
  325. | 50 conflicts / ~1350 lines | ~4 500 ops/s |
  326. | JSON/Markdown format-aware | ~137 000 ops/s |
  327. ### Internationalization
  328. GitWand uses a zero-dependency type-safe i18n system across five languages — English (`en`, default), French (`fr`), Spanish (`es`), Brazilian Portuguese (`pt-BR`), and Simplified Chinese (`zh-CN`). `en.ts` is the canonical reference, defined with `as const`; the `Locale` and `LocaleKey` types are derived from it, so every other locale must match its 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.
  329. ---
  330. ## Roadmap
  331. See [ROADMAP.md](./ROADMAP.md) for the full phased plan — upcoming features, competitive analysis, and shipped version history.
  332. ---
  333. ## Code signing policy
  334. Windows builds of GitWand are code-signed. Free code signing provided by [SignPath.io](https://about.signpath.io), certificate by [SignPath Foundation](https://signpath.org).
  335. | Role | Member |
  336. |------|--------|
  337. | Committers / Reviewers | [Laurent Guitton](https://github.com/devlint) |
  338. | Approvers | [Laurent Guitton](https://github.com/devlint) |
  339. This program will not transfer any information to other networked systems unless specifically requested by the user.
  340. ---
  341. ## License
  342. MIT — [Laurent Guitton](https://github.com/devlint)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.