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

package/dist/server/git-branch-list-tool.js

@@ -0,0 +1,140 @@
+import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
+import { spawnGitAsync } from "./git.js";
+import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
+import { requireSingleRepo } from "./roots.js";
+import { WorkspacePickSchema } from "./schemas.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+async function runBranchList(opts) {
+    const { top, includeRemotes } = opts;
+    // Local branches: name, full SHA, upstream (may be empty), HEAD marker (* or space)
+    const localR = await spawnGitAsync(top, [
+        "for-each-ref",
+        "--format=%(refname:short)%00%(objectname)%00%(upstream:short)%00%(HEAD)",
+        "refs/heads",
+    ]);
+    if (!localR.ok) {
+        return {
+            error: ERROR_CODES.BRANCH_LIST_FAILED,
+            detail: (localR.stderr || localR.stdout).trim(),
+        };
+    }
+    const branches = [];
+    const localLines = (localR.stdout || "").split("\n").filter((l) => l.length > 0);
+    for (const line of localLines) {
+        const parts = line.split("\x00");
+        const name = parts[0] ?? "";
+        const sha = parts[1] ?? "";
+        const upstream = parts[2] ?? "";
+        const headMarker = parts[3] ?? "";
+        if (!name || !sha)
+            continue;
+        branches.push({
+            name,
+            sha,
+            current: headMarker === "*",
+            ...spreadDefined("upstream", upstream || undefined),
+        });
+    }
+    if (!includeRemotes) {
+        return { branches };
+    }
+    // Remote branches: name, full SHA — skip symbolic origin/HEAD refs
+    const remoteR = await spawnGitAsync(top, [
+        "for-each-ref",
+        "--format=%(refname:short)%00%(objectname)",
+        "refs/remotes",
+    ]);
+    if (!remoteR.ok) {
+        return {
+            error: ERROR_CODES.BRANCH_LIST_FAILED,
+            detail: (remoteR.stderr || remoteR.stdout).trim(),
+        };
+    }
+    const remotes = [];
+    const remoteLines = (remoteR.stdout || "").split("\n").filter((l) => l.length > 0);
+    for (const line of remoteLines) {
+        const parts = line.split("\x00");
+        const name = parts[0] ?? "";
+        const sha = parts[1] ?? "";
+        // Skip symbolic origin/HEAD
+        if (!name || !sha || name.endsWith("/HEAD"))
+            continue;
+        remotes.push({ name, sha });
+    }
+    return {
+        branches,
+        ...spreadWhen(remotes.length > 0, { remotes }),
+    };
+}
+// ---------------------------------------------------------------------------
+// Markdown rendering
+// ---------------------------------------------------------------------------
+function renderBranchListMarkdown(result) {
+    const lines = ["## Branches", ""];
+    if (result.branches.length === 0) {
+        lines.push("_(none)_");
+    }
+    else {
+        for (const b of result.branches) {
+            const prefix = b.current ? "* " : "  ";
+            const upstream = b.upstream ? ` → ${b.upstream}` : "";
+            lines.push(`${prefix}**${b.name}**${upstream}  (\`${b.sha}\`)`);
+        }
+    }
+    if (result.remotes && result.remotes.length > 0) {
+        lines.push("");
+        lines.push("## Remote branches");
+        lines.push("");
+        for (const r of result.remotes) {
+            lines.push(`- **${r.name}**  (\`${r.sha}\`)`);
+        }
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGitBranchListTool(server) {
+    server.addTool({
+        name: "git_branch_list",
+        description: "List local branches (and optionally remote-tracking branches) for a single git repository. " +
+            "Returns `{ branches: [{ name, sha, current, upstream? }], remotes?: [{ name, sha }] }`. " +
+            "The current branch is marked with `current: true`. Remote branches are included when `includeRemotes: true`.",
+        annotations: {
+            readOnlyHint: true,
+        },
+        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true, allWorkspaceRoots: true })
+            .pick({
+            workspaceRoot: true,
+            rootIndex: true,
+            format: true,
+        })
+            .extend({
+            includeRemotes: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("When true, also return remote-tracking branches from refs/remotes (excluding symbolic origin/HEAD)."),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const { gitTop } = pre;
+            const result = await runBranchList({
+                top: gitTop,
+                includeRemotes: args.includeRemotes ?? false,
+            });
+            if ("error" in result) {
+                return jsonRespond(result);
+            }
+            if (args.format === "json") {
+                return jsonRespond(result);
+            }
+            return renderBranchListMarkdown(result);
+        },
+    });
+}

package/dist/server/git-cherry-pick-tool.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
 import { spawnGitAsync } from "./git.js";
 import { commitListBetween, conflictPaths, getCurrentBranch, isContentEquivalentlyMergedInto, isFullyMergedInto, isProtectedBranch, isSafeGitRangeToken, isSafeGitRefToken, isWorkingTreeClean, resolveRef, worktreeForBranch, } from "./git-refs.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
@@ -30,12 +31,12 @@ async function branchExists(gitTop, name) {
 async function resolveSource(gitTop, onto, raw) {
     if (raw.includes("..")) {
         if (!isSafeGitRangeToken(raw)) {
-            return { error: "unsafe_ref_token", raw };
+            return { error: ERROR_CODES.UNSAFE_REF_TOKEN, raw };
         }
         const r = await spawnGitAsync(gitTop, ["rev-list", "--reverse", raw]);
         if (!r.ok) {
             return {
-                error: "range_resolution_failed",
+                error: ERROR_CODES.RANGE_RESOLUTION_FAILED,
                 detail: (r.stderr || r.stdout).trim(),
                 raw,
             };
@@ -47,18 +48,18 @@ async function resolveSource(gitTop, onto, raw) {
         return { raw, kind: "range", commits };
     }
     if (!isSafeGitRefToken(raw)) {
-        return { error: "unsafe_ref_token", raw };
+        return { error: ERROR_CODES.UNSAFE_REF_TOKEN, raw };
     }
     if (await branchExists(gitTop, raw)) {
         const commits = await commitListBetween(gitTop, onto, raw);
         if (commits === null) {
-            return { error: "range_resolution_failed", raw };
+            return { error: ERROR_CODES.RANGE_RESOLUTION_FAILED, raw };
         }
         return { raw, kind: "branch", commits };
     }
     const sha = await resolveRef(gitTop, raw);
     if (!sha) {
-        return { error: "source_not_found", raw };
+        return { error: ERROR_CODES.SOURCE_NOT_FOUND, raw };
     }
     return { raw, kind: "sha", commits: [sha] };
 }
@@ -149,26 +150,26 @@ export function registerGitCherryPickTool(server) {
             const startBranch = await getCurrentBranch(gitTop);
             const onto = args.onto?.trim() || startBranch;
             if (!onto)
-                return jsonRespond({ error: "onto_detached_head" });
+                return jsonRespond({ error: ERROR_CODES.ONTO_DETACHED_HEAD });
             if (args.onto !== undefined && !isSafeGitRefToken(args.onto)) {
-                return jsonRespond({ error: "unsafe_ref_token", ref: args.onto });
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: args.onto });
             }
             // --- 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 (onto !== startBranch) {
                 const co = await spawnGitAsync(gitTop, ["checkout", onto]);
                 if (!co.ok) {
                     return jsonRespond({
-                        error: "checkout_failed",
+                        error: ERROR_CODES.CHECKOUT_FAILED,
                         detail: (co.stderr || co.stdout).trim(),
                     });
                 }
             }
             if (!(await resolveRef(gitTop, onto))) {
-                return jsonRespond({ error: "destination_not_found", ref: onto });
+                return jsonRespond({ error: ERROR_CODES.DESTINATION_NOT_FOUND, ref: onto });
             }
             // --- Resolve each source ---
             const resolved = [];

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

@@ -1,5 +1,6 @@
 import { matchesGlob } from "node:path";
 import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
 import { isSafeGitUpstreamToken, spawnGitAsync } from "./git.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
@@ -102,6 +103,12 @@ function extractFileInfo(header, body) {
         status = "renamed";
         const fromMatch = /^rename from (.+)$/m.exec(body);
         oldPath = fromMatch?.[1];
+        // Prefer the authoritative "rename to <path>" body line over the greedy
+        // header regex split, which mis-parses paths containing the literal " b/".
+        const toMatch = /^rename to (.+)$/m.exec(body);
+        if (toMatch?.[1]) {
+            bPath = toMatch[1];
+        }
     }
     const path = status === "deleted" ? aPath : bPath;
     return { path, oldPath, status };
@@ -178,7 +185,7 @@ export function registerGitDiffSummaryTool(server) {
         annotations: {
             readOnlyHint: true,
         },
-        parameters: WorkspacePickSchema.extend({
+        parameters: WorkspacePickSchema.omit({ allWorkspaceRoots: true }).extend({
             range: z
                 .string()
                 .optional()
@@ -224,7 +231,7 @@ export function registerGitDiffSummaryTool(server) {
             const statResult = await spawnGitAsync(gitTop, ["diff", "--numstat", ...diffArgs]);
             if (!statResult.ok) {
                 return jsonRespond({
-                    error: "git_diff_failed",
+                    error: ERROR_CODES.GIT_DIFF_FAILED,
                     detail: (statResult.stderr || statResult.stdout).trim(),
                 });
             }
@@ -233,7 +240,7 @@ export function registerGitDiffSummaryTool(server) {
             const diffResult = await spawnGitAsync(gitTop, ["diff", ...diffArgs]);
             if (!diffResult.ok) {
                 return jsonRespond({
-                    error: "git_diff_failed",
+                    error: ERROR_CODES.GIT_DIFF_FAILED,
                     detail: (diffResult.stderr || diffResult.stdout).trim(),
                 });
             }

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,13 +61,17 @@ 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,
         },
-        parameters: WorkspacePickSchema.extend({
+        parameters: WorkspacePickSchema.omit({
+            absoluteGitRoots: true,
+            allWorkspaceRoots: true,
+        }).extend({
             base: z
                 .string()
                 .optional()
@@ -75,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) {
@@ -101,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 { spawnGitAsync } from "./git.js";
-import { jsonRespond } from "./json.js";
+import { ERROR_CODES } from "./error-codes.js";
+import { isSafeGitUpstreamToken, spawnGitAsync } from "./git.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
 // ---------------------------------------------------------------------------
@@ -78,26 +134,82 @@ export function registerGitFetchTool(server) {
             const branch = args.branch?.trim();
             const prune = args.prune === true;
             const tags = args.tags === true;
-            // Build git fetch command
-            const fetchArgs = ["fetch"];
+            // Validate remote and branch to prevent argument injection.
+            if (!isSafeGitUpstreamToken(remote)) {
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REMOTE_TOKEN, remote });
+            }
+            if (branch && !isSafeGitUpstreamToken(branch)) {
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, branch });
+            }
+            // 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);
@@ -110,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,10 +55,10 @@ 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({
-                            workspace_root: workspaceRoot,
+                            workspaceRoot: workspaceRoot,
                             ...(upstream.mode === "fixed" ? { upstream } : {}),
                             entries: [
                                 makeSkipEntry(workspaceRoot, workspaceRoot, upstream.mode, JSON.stringify(err)),
@@ -117,7 +118,7 @@ export function registerGitInventoryTool(server) {
                 }
                 if (args.format === "json") {
                     allJson.push({
-                        workspace_root: top,
+                        workspaceRoot: top,
                         ...spreadDefined("presetSchemaVersion", presetSchemaVersion),
                         ...spreadWhen(nestedRootsTruncated, {
                             nestedRootsTruncated: true,