@rethunk/mcp-multi-root-git 2.6.0 → 2.8.0

package/dist/server/git-diff-tool.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { assertRelativePathUnderTop, resolvePathForRepo } from "../repo-paths.js";
+import { ERROR_CODES } from "./error-codes.js";
 import { isSafeGitUpstreamToken, spawnGitAsync } from "./git.js";
 import { jsonRespond } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
@@ -19,14 +21,18 @@ function buildDiffArgs(opts) {
         const baseStr = opts.base?.trim() ?? "HEAD";
         const headStr = opts.head?.trim() ?? "HEAD";
         if (!isSafeGitUpstreamToken(baseStr) || !isSafeGitUpstreamToken(headStr)) {
-            return { ok: false, error: "unsafe_range_token" };
+            return { ok: false, error: ERROR_CODES.UNSAFE_RANGE_TOKEN };
         }
         // Use two-dot range: base..head
         args.push(`${baseStr}..${headStr}`);
     }
-    // Scope to path if provided
-    if (opts.path?.trim()) {
-        args.push("--", opts.path.trim());
+    // Apply unified context width if specified
+    if (typeof opts.unified === "number") {
+        args.push(`-U${opts.unified}`);
+    }
+    // Scope to paths if provided
+    if (opts.paths && opts.paths.length > 0) {
+        args.push("--", ...opts.paths);
     }
     return { ok: true, args };
 }
@@ -44,8 +50,8 @@ function rangeLabel(opts) {
     else {
         label = "unstaged changes";
     }
-    if (opts.path?.trim()) {
-        label += ` (${opts.path.trim()})`;
+    if (opts.paths && opts.paths.length > 0) {
+        label += ` (${opts.paths.join(", ")})`;
     }
     return label;
 }
@@ -55,9 +61,10 @@ function rangeLabel(opts) {
 export function registerGitDiffTool(server) {
     server.addTool({
         name: "git_diff",
-        description: "Get diff text for scoped file or range. Returns the raw diff output. " +
+        description: "Get diff text for scoped file(s) or range. Returns the raw diff output. " +
             "Use `staged: true` for staged changes, `base`/`head` for revision ranges, " +
-            "and `path` to scope to a specific file.",
+            "`path` to scope to a single file, `paths` to scope to multiple files, " +
+            "and `unified` to control the number of context lines.",
         annotations: {
             readOnlyHint: true,
         },
@@ -78,23 +85,60 @@ export function registerGitDiffTool(server) {
             path: z
                 .string()
                 .optional()
-                .describe('Scope diff to a single file path (e.g. "src/main.ts").'),
+                .describe('Scope diff to a single file path (e.g. "src/main.ts"). ' +
+                "For multiple files, prefer `paths`. If both `path` and `paths` are given, they are unioned."),
+            paths: z
+                .array(z.string())
+                .optional()
+                .describe('Scope diff to multiple file paths (e.g. ["src/a.ts", "src/b.ts"]). ' +
+                "Each path is validated and must lie within the repository root. " +
+                "If both `path` and `paths` are given, they are unioned."),
             staged: z
                 .boolean()
                 .optional()
                 .default(false)
                 .describe("If true, show staged changes (git diff --staged). " + "Ignored if `base` is provided."),
+            unified: z
+                .number()
+                .int()
+                .min(0)
+                .max(100)
+                .optional()
+                .describe("Number of context lines to show around each change (passed as -U<n> to git diff). " +
+                "Defaults to git's built-in default (3). Use 0 for no context."),
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
             if (!pre.ok)
                 return jsonRespond(pre.error);
             const gitTop = pre.gitTop;
+            // Union path + paths, trim, dedup
+            const rawPaths = [];
+            if (args.path && typeof args.path === "string" && args.path.trim()) {
+                rawPaths.push(args.path.trim());
+            }
+            if (Array.isArray(args.paths)) {
+                for (const p of args.paths) {
+                    if (typeof p === "string" && p.trim()) {
+                        rawPaths.push(p.trim());
+                    }
+                }
+            }
+            // Dedup preserving order
+            const dedupedPaths = [...new Set(rawPaths)];
+            // Confine each path within the repo
+            for (const p of dedupedPaths) {
+                const resolved = resolvePathForRepo(p, gitTop);
+                if (!assertRelativePathUnderTop(p, resolved, gitTop)) {
+                    return jsonRespond({ error: ERROR_CODES.PATH_ESCAPES_REPO, path: p });
+                }
+            }
             // Build git diff args
             const diffArgsResult = buildDiffArgs({
                 base: args.base,
                 head: args.head,
-                path: args.path,
+                paths: dedupedPaths.length > 0 ? dedupedPaths : undefined,
+                unified: typeof args.unified === "number" ? args.unified : undefined,
                 staged: args.staged,
             });
             if (!diffArgsResult.ok) {
@@ -104,14 +148,14 @@ export function registerGitDiffTool(server) {
             const result = await spawnGitAsync(gitTop, diffArgsResult.args);
             if (!result.ok) {
                 return jsonRespond({
-                    error: "git_diff_failed",
+                    error: ERROR_CODES.GIT_DIFF_FAILED,
                     detail: (result.stderr || result.stdout).trim(),
                 });
             }
             const label = rangeLabel({
                 base: args.base,
                 head: args.head,
-                path: args.path,
+                paths: dedupedPaths.length > 0 ? dedupedPaths : undefined,
                 staged: args.staged,
             });
             if (args.format === "json") {

package/dist/server/git-fetch-tool.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
 import { isSafeGitUpstreamToken, spawnGitAsync } from "./git.js";
-import { jsonRespond } from "./json.js";
+import { jsonRespond, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
 // ---------------------------------------------------------------------------
@@ -30,6 +31,61 @@ function parseGitFetchOutput(output) {
     }
     return { updatedRefs, newRefs };
 }
+const ZEROS_SHA = "0000000000000000000000000000000000000000";
+/**
+ * Parse `git fetch --porcelain` stdout.
+ *
+ * Machine-readable lines have the form:
+ *   <flag><SP><old-sha><SP><new-sha><SP><local-ref>
+ *
+ * Flags:
+ *   ' ' = fast-forward update
+ *   '+' = forced update
+ *   '*' = new ref
+ *   '-' = pruned (deleted)
+ *   '!' = rejected
+ *   '=' = up-to-date (no change)
+ *   't' = tag update
+ */
+function parsePorcelainOutput(stdout) {
+    const updated = [];
+    const created = [];
+    const pruned = [];
+    for (const line of stdout.split("\n")) {
+        if (!line)
+            continue;
+        // Porcelain lines: flag(1) + space(1) + old-sha + space + new-sha + space + ref
+        // Minimum viable line: 1 flag + 1 space + at least some content
+        if (line.length < 3)
+            continue;
+        const flag = line[0];
+        const rest = line.slice(2); // skip "flag " prefix
+        const parts = rest.split(" ");
+        // Expected: [old-sha, new-sha, ref...]
+        if (parts.length < 3)
+            continue;
+        const oldSha = parts[0] ?? "";
+        const newSha = parts[1] ?? "";
+        const ref = parts.slice(2).join(" ");
+        if (!ref)
+            continue;
+        if (flag === "-") {
+            pruned.push({ ref });
+        }
+        else if (flag === "*" || oldSha === ZEROS_SHA) {
+            // New ref: flag is '*' OR old-sha is all-zeros
+            created.push({ ref, newSha, flag: flag ?? "*" });
+        }
+        else if (flag === " " || flag === "+" || flag === "t") {
+            // Update: old and new differ
+            if (oldSha !== newSha) {
+                updated.push({ ref, oldSha, newSha, flag: flag ?? " " });
+            }
+        }
+        // '!' (rejected) and '=' (up-to-date) are intentionally ignored
+    }
+    return { updated, created, pruned };
+}
 // ---------------------------------------------------------------------------
 // Tool registration
 // ---------------------------------------------------------------------------
@@ -80,31 +136,80 @@ export function registerGitFetchTool(server) {
             const tags = args.tags === true;
             // Validate remote and branch to prevent argument injection.
             if (!isSafeGitUpstreamToken(remote)) {
-                return jsonRespond({ error: "unsafe_remote_token", remote });
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REMOTE_TOKEN, remote });
             }
             if (branch && !isSafeGitUpstreamToken(branch)) {
-                return jsonRespond({ error: "unsafe_ref_token", branch });
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, branch });
             }
-            // Build git fetch command
-            const fetchArgs = ["fetch"];
+            // Build base fetch args (without --porcelain for now)
+            const baseArgs = ["fetch"];
             if (prune) {
-                fetchArgs.push("--prune");
+                baseArgs.push("--prune");
             }
             if (tags) {
-                fetchArgs.push("--tags");
+                baseArgs.push("--tags");
             }
-            fetchArgs.push(remote);
+            baseArgs.push(remote);
             if (branch) {
-                fetchArgs.push(branch);
+                baseArgs.push(branch);
+            }
+            // --- Attempt structured fetch with --porcelain (requires git >= 2.41) ---
+            let structured = null;
+            let result;
+            const porcelainArgs = ["fetch", "--porcelain"];
+            if (prune)
+                porcelainArgs.push("--prune");
+            if (tags)
+                porcelainArgs.push("--tags");
+            porcelainArgs.push(remote);
+            if (branch)
+                porcelainArgs.push(branch);
+            const porcelainResult = await spawnGitAsync(gitTop, porcelainArgs);
+            if (!porcelainResult.ok &&
+                (porcelainResult.stderr.includes("unknown option") ||
+                    porcelainResult.stderr.includes("unknown switch") ||
+                    porcelainResult.stderr.includes("invalid option"))) {
+                // --porcelain not supported: fall back to plain fetch
+                result = await spawnGitAsync(gitTop, baseArgs);
+                structured = null;
+            }
+            else {
+                // Use porcelain result (ok or actual fetch error)
+                result = porcelainResult;
+                if (porcelainResult.ok || !porcelainResult.stderr.includes("unknown option")) {
+                    structured = parsePorcelainOutput(porcelainResult.stdout);
+                }
+            }
+            // Legacy string-line parse: use combined output when porcelain is unavailable.
+            // When porcelain succeeded, derive legacy fields from structured data so
+            // that callers who rely on updatedRefs/newRefs still get useful values.
+            let updatedRefs;
+            let newRefs;
+            if (structured !== null) {
+                // Derive legacy string arrays from structured deltas
+                updatedRefs = structured.updated.map((d) => `${d.oldSha.slice(0, 7)}..${d.newSha.slice(0, 7)}  ${d.ref}`);
+                newRefs = structured.created.map((d) => `[new ref] ${d.ref} -> ${d.newSha.slice(0, 7)}`);
+            }
+            else {
+                const parsed = parseGitFetchOutput(result.stdout + result.stderr);
+                updatedRefs = parsed.updatedRefs;
+                newRefs = parsed.newRefs;
             }
-            const result = await spawnGitAsync(gitTop, fetchArgs);
-            const { updatedRefs, newRefs } = parseGitFetchOutput(result.stdout + result.stderr);
             const fetchResult = {
                 ok: result.ok,
                 remote,
                 updatedRefs,
                 newRefs,
                 output: (result.stdout + result.stderr).trim(),
+                ...spreadWhen(structured !== null && structured.updated.length > 0, {
+                    updated: structured?.updated ?? [],
+                }),
+                ...spreadWhen(structured !== null && structured.created.length > 0, {
+                    created: structured?.created ?? [],
+                }),
+                ...spreadWhen(structured !== null && structured.pruned.length > 0, {
+                    pruned: structured?.pruned ?? [],
+                }),
             };
             if (args.format === "json") {
                 return jsonRespond(fetchResult);
@@ -117,19 +222,42 @@ export function registerGitFetchTool(server) {
                 return lines.join("\n");
             }
             lines.push("", "**Status**: Success", "");
-            if (updatedRefs.length > 0) {
+            // Prefer structured deltas in markdown when available
+            if (structured !== null && structured.updated.length > 0) {
+                lines.push("## Updated refs", "");
+                for (const d of structured.updated) {
+                    lines.push(`- \`${d.ref}\` ${d.oldSha.slice(0, 7)}→${d.newSha.slice(0, 7)}`);
+                }
+            }
+            else if (updatedRefs.length > 0) {
                 lines.push("## Updated refs", "");
                 for (const ref of updatedRefs) {
                     lines.push(`- ${ref}`);
                 }
             }
-            if (newRefs.length > 0) {
+            if (structured !== null && structured.created.length > 0) {
+                lines.push("", "## New refs", "");
+                for (const d of structured.created) {
+                    lines.push(`- \`${d.ref}\` (new, ${d.newSha.slice(0, 7)})`);
+                }
+            }
+            else if (newRefs.length > 0) {
                 lines.push("", "## New refs", "");
                 for (const ref of newRefs) {
                     lines.push(`- ${ref}`);
                 }
             }
-            if (updatedRefs.length === 0 && newRefs.length === 0 && result.stdout.trim()) {
+            if (structured !== null && structured.pruned.length > 0) {
+                lines.push("", "## Pruned refs", "");
+                for (const d of structured.pruned) {
+                    lines.push(`- \`${d.ref}\` (deleted)`);
+                }
+            }
+            if (updatedRefs.length === 0 &&
+                newRefs.length === 0 &&
+                (structured === null ||
+                    (structured.updated.length === 0 && structured.created.length === 0)) &&
+                result.stdout.trim()) {
                 lines.push("", "## Output", "", "```", result.stdout.trim(), "```");
             }
             return lines.join("\n");

package/dist/server/git-inventory-tool.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
 import { asyncPool, GIT_SUBPROCESS_PARALLELISM, gitRevParseGitDir, gitTopLevel, isSafeGitUpstreamToken, } from "./git.js";
 import { buildInventorySectionMarkdown, collectInventoryEntry, makeSkipEntry, validateRepoPath, } from "./inventory.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
@@ -27,7 +28,7 @@ export function registerGitInventoryTool(server) {
         execute: async (args) => {
             if (args.absoluteGitRoots != null && args.absoluteGitRoots.length > 0) {
                 if (args.preset || (args.nestedRoots?.length ?? 0) > 0) {
-                    return jsonRespond({ error: "absolute_git_roots_nested_or_preset_conflict" });
+                    return jsonRespond({ error: ERROR_CODES.ABSOLUTE_GIT_ROOTS_NESTED_OR_PRESET_CONFLICT });
                 }
             }
             const pre = requireGitAndRoots(server, args, args.preset);
@@ -39,12 +40,12 @@ export function registerGitInventoryTool(server) {
             const hasRemote = rawRemote !== undefined && rawRemote !== "";
             const hasBranch = rawBranch !== undefined && rawBranch !== "";
             if (hasRemote !== hasBranch) {
-                return jsonRespond({ error: "remote_branch_mismatch" });
+                return jsonRespond({ error: ERROR_CODES.REMOTE_BRANCH_MISMATCH });
             }
             let upstream = { mode: "auto" };
             if (hasRemote && hasBranch && rawRemote && rawBranch) {
                 if (!isSafeGitUpstreamToken(rawRemote) || !isSafeGitUpstreamToken(rawBranch)) {
-                    return jsonRespond({ error: "invalid_remote_or_branch" });
+                    return jsonRespond({ error: ERROR_CODES.INVALID_REMOTE_OR_BRANCH });
                 }
                 upstream = { mode: "fixed", remote: rawRemote, branch: rawBranch };
             }
@@ -54,7 +55,7 @@ export function registerGitInventoryTool(server) {
             for (const workspaceRoot of pre.roots) {
                 const top = gitTopLevel(workspaceRoot);
                 if (!top) {
-                    const err = { error: "not_a_git_repository", path: workspaceRoot };
+                    const err = { error: ERROR_CODES.NOT_A_GIT_REPOSITORY, path: workspaceRoot };
                     if (args.format === "json") {
                         allJson.push({
                             workspaceRoot: workspaceRoot,

package/dist/server/git-log-tool.js

@@ -1,5 +1,6 @@
 import { basename } from "node:path";
 import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
 import { asyncPool, GIT_SUBPROCESS_PARALLELISM, gitTopLevel, spawnGitAsync } from "./git.js";
 import { isSafeGitAncestorRef } from "./git-refs.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
@@ -82,7 +83,7 @@ async function runGitLog(opts) {
     const r = await spawnGitAsync(top, logArgs);
     if (!r.ok) {
         return {
-            error: "git_log_failed",
+            error: ERROR_CODES.GIT_LOG_FAILED,
             path: top,
         };
     }
@@ -222,19 +223,19 @@ export function registerGitLogTool(server) {
             // Validate `since` — reject obvious injection attempts (newlines, semicolons, shell chars).
             const rawSince = (args.since?.trim() ?? DEFAULT_SINCE) || DEFAULT_SINCE;
             if (/[\n\r;|&`$<>]/.test(rawSince)) {
-                return jsonRespond({ error: "invalid_since", since: rawSince });
+                return jsonRespond({ error: ERROR_CODES.INVALID_SINCE, since: rawSince });
             }
             // Validate paths — reject anything with null bytes or shell meta.
             // Use charCodeAt(0) === 0 for the null byte to avoid a biome lint on control chars in regex.
             const rawPaths = args.paths ?? [];
             for (const p of rawPaths) {
                 if (p.split("").some((c) => c.charCodeAt(0) === 0) || /[\n\r;|&`$<>]/.test(p)) {
-                    return jsonRespond({ error: "invalid_paths", path: p });
+                    return jsonRespond({ error: ERROR_CODES.INVALID_PATHS, path: p });
                 }
             }
             // Validate branch — reject leading-dash and other injection attempts.
             if (args.branch && !isSafeGitAncestorRef(args.branch)) {
-                return jsonRespond({ error: "unsafe_ref_token", branch: args.branch });
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, branch: args.branch });
             }
             const maxCommits = Math.min(args.maxCommits ?? DEFAULT_MAX_COMMITS, MAX_COMMITS_HARD_CAP);
             // Fan out across roots.
@@ -242,7 +243,11 @@ export function registerGitLogTool(server) {
             const results = await asyncPool(jobs, GIT_SUBPROCESS_PARALLELISM, async ({ rootInput }) => {
                 const top = gitTopLevel(rootInput);
                 if (!top) {
-                    return { _error: true, workspaceRoot: rootInput, error: "not_a_git_repository" };
+                    return {
+                        _error: true,
+                        workspaceRoot: rootInput,
+                        error: ERROR_CODES.NOT_A_GIT_REPOSITORY,
+                    };
                 }
                 const r = await runGitLog({
                     top,

package/dist/server/git-merge-tool.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
 import { spawnGitAsync } from "./git.js";
 import { conflictPaths, getCurrentBranch, isFullyMergedInto, isProtectedBranch, isSafeGitRefToken, isWorkingTreeClean, resolveRef, worktreeForBranch, } from "./git-refs.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
@@ -36,17 +37,17 @@ async function mergeOneSource(gitTop, into, source, strategy, mergeMessage) {
     const intoSha = await resolveRef(gitTop, into);
     const sourceSha = await resolveRef(gitTop, source);
     if (!sourceSha) {
-        return { source, ok: false, error: "source_not_found" };
+        return { source, ok: false, error: ERROR_CODES.SOURCE_NOT_FOUND };
     }
     if (!intoSha) {
-        return { source, ok: false, error: "destination_not_found" };
+        return { source, ok: false, error: ERROR_CODES.DESTINATION_NOT_FOUND };
     }
     const mb = await spawnGitAsync(gitTop, ["merge-base", into, source]);
     if (!mb.ok) {
         return {
             source,
             ok: false,
-            error: "merge_base_failed",
+            error: ERROR_CODES.MERGE_BASE_FAILED,
             detail: (mb.stderr || mb.stdout).trim(),
         };
     }
@@ -63,7 +64,7 @@ async function mergeOneSource(gitTop, into, source, strategy, mergeMessage) {
             return {
                 source,
                 ok: false,
-                error: "cannot_fast_forward",
+                error: ERROR_CODES.CANNOT_FAST_FORWARD,
                 detail: "destination and source have diverged; retry with strategy: rebase, merge, or auto",
             };
         }
@@ -102,7 +103,7 @@ async function fastForward(gitTop, source) {
             outcome: "conflicts",
             conflictStage: "merge",
             conflictPaths: [],
-            error: "merge_failed",
+            error: ERROR_CODES.MERGE_FAILED,
             detail: (r.stderr || r.stdout).trim(),
         };
     }
@@ -126,7 +127,7 @@ async function mergeCommit(gitTop, source, message, into) {
             outcome: "conflicts",
             conflictStage: "merge",
             conflictPaths: paths,
-            error: "merge_conflicts",
+            error: ERROR_CODES.MERGE_CONFLICTS,
             detail: (r.stderr || r.stdout).trim(),
         };
     }
@@ -156,7 +157,7 @@ async function rebaseSourceOntoInto(gitTop, into, source) {
             outcome: "conflicts",
             conflictStage: "rebase",
             conflictPaths: paths,
-            error: "rebase_conflicts",
+            error: ERROR_CODES.REBASE_CONFLICTS,
             detail: (r.stderr || r.stdout).trim(),
         };
     }
@@ -166,7 +167,7 @@ async function rebaseSourceOntoInto(gitTop, into, source) {
         return {
             source,
             ok: false,
-            error: "checkout_failed",
+            error: ERROR_CODES.CHECKOUT_FAILED,
             detail: (co.stderr || co.stdout).trim(),
         };
     }
@@ -253,28 +254,28 @@ export function registerGitMergeTool(server) {
             // --- Validate ref tokens early ---
             for (const s of args.sources) {
                 if (!isSafeGitRefToken(s)) {
-                    return jsonRespond({ error: "unsafe_ref_token", ref: s });
+                    return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: s });
                 }
             }
             if (args.into !== undefined && !isSafeGitRefToken(args.into)) {
-                return jsonRespond({ error: "unsafe_ref_token", ref: args.into });
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: args.into });
             }
             // --- Resolve destination ---
             const startBranch = await getCurrentBranch(gitTop);
             const into = args.into?.trim() || startBranch;
             if (!into) {
-                return jsonRespond({ error: "into_detached_head" });
+                return jsonRespond({ error: ERROR_CODES.INTO_DETACHED_HEAD });
             }
             // --- Refuse dirty tree ---
             if (!(await isWorkingTreeClean(gitTop))) {
-                return jsonRespond({ error: "working_tree_dirty" });
+                return jsonRespond({ error: ERROR_CODES.WORKING_TREE_DIRTY });
             }
             // --- Ensure destination is checked out ---
             if (into !== startBranch) {
                 const co = await spawnGitAsync(gitTop, ["checkout", into]);
                 if (!co.ok) {
                     return jsonRespond({
-                        error: "checkout_failed",
+                        error: ERROR_CODES.CHECKOUT_FAILED,
                         detail: (co.stderr || co.stdout).trim(),
                     });
                 }
@@ -282,7 +283,7 @@ export function registerGitMergeTool(server) {
             // Verify destination exists after checkout.
             const intoShaProbe = await resolveRef(gitTop, into);
             if (!intoShaProbe) {
-                return jsonRespond({ error: "destination_not_found", ref: into });
+                return jsonRespond({ error: ERROR_CODES.DESTINATION_NOT_FOUND, ref: into });
             }
             // --- Merge each source sequentially ---
             const strategy = args.strategy ?? "auto";

package/dist/server/git-parity-tool.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
 import { gitRevParseHead, gitTopLevel } from "./git.js";
 import { validateRepoPath } from "./inventory.js";
 import { jsonRespond, spreadDefined } from "./json.js";
@@ -33,7 +34,7 @@ export function registerGitParityTool(server) {
             for (const workspaceRoot of pre.roots) {
                 const top = gitTopLevel(workspaceRoot);
                 if (!top) {
-                    const errPayload = { error: "not_a_git_repository", path: workspaceRoot };
+                    const errPayload = { error: ERROR_CODES.NOT_A_GIT_REPOSITORY, path: workspaceRoot };
                     const err = jsonRespond(errPayload);
                     if (args.format === "json") {
                         results.push({
@@ -58,7 +59,7 @@ export function registerGitParityTool(server) {
                     parityPresetSchemaVersion = applied.presetSchemaVersion;
                 }
                 if (!pairs?.length) {
-                    return jsonRespond({ error: "no_pairs" });
+                    return jsonRespond({ error: ERROR_CODES.NO_PAIRS });
                 }
                 let allOk = true;
                 const pairResults = [];

package/dist/server/git-push-tool.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
 import { isSafeGitUpstreamToken, spawnGitAsync } from "./git.js";
 import { getCurrentBranch, inferRemoteFromUpstream, isSafeGitRefToken } from "./git-refs.js";
 import { jsonRespond, spreadDefined } from "./json.js";
@@ -42,16 +43,19 @@ export function registerGitPushTool(server) {
             const currentBranch = await getCurrentBranch(gitTop);
             const branch = args.branch?.trim() || currentBranch;
             if (!branch) {
-                return jsonRespond({ error: "push_detached_head" });
+                return jsonRespond({ error: ERROR_CODES.PUSH_DETACHED_HEAD });
             }
             if (!isSafeGitRefToken(branch)) {
-                return jsonRespond({ error: "unsafe_ref_token", ref: branch });
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: branch });
             }
             // --- Resolve remote ---
             let remote;
             if (args.remote?.trim()) {
                 if (!isSafeGitUpstreamToken(args.remote.trim())) {
-                    return jsonRespond({ error: "unsafe_remote_token", remote: args.remote.trim() });
+                    return jsonRespond({
+                        error: ERROR_CODES.UNSAFE_REMOTE_TOKEN,
+                        remote: args.remote.trim(),
+                    });
                 }
                 remote = args.remote.trim();
             }
@@ -64,7 +68,7 @@ export function registerGitPushTool(server) {
                 const t = await inferRemoteFromUpstream(gitTop);
                 if (!t.ok) {
                     return jsonRespond({
-                        error: "push_no_upstream",
+                        error: ERROR_CODES.PUSH_NO_UPSTREAM,
                         branch,
                         detail: t.detail,
                     });
@@ -82,7 +86,7 @@ export function registerGitPushTool(server) {
                     ok: false,
                     branch,
                     remote,
-                    error: "push_failed",
+                    error: ERROR_CODES.PUSH_FAILED,
                     detail: (pushResult.stderr || pushResult.stdout).trim(),
                 });
             }