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

package/dist/server/batch-commit-tool.js

@@ -1,3 +1,4 @@
+import { existsSync } from "node:fs";
 import { z } from "zod";
 import { isStrictlyUnderGitTop, resolvePathForRepo } from "../repo-paths.js";
 import { spawnGitAsync } from "./git.js";
@@ -5,9 +6,26 @@ import { getCurrentBranch, inferRemoteFromUpstream } from "./git-refs.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
+const FileEntrySchema = z.union([
+    z.string().min(1),
+    z.object({
+        path: z.string().min(1).describe("File path relative to git root."),
+        lines: z
+            .object({
+            from: z.number().int().min(1).describe("Start line number (1-indexed)."),
+            to: z.number().int().min(1).describe("End line number (1-indexed, inclusive)."),
+        })
+            .describe("Line range to stage. Only hunks overlapping [from, to] are staged."),
+    }),
+]);
 const CommitEntrySchema = z.object({
     message: z.string().min(1).describe("Commit message."),
-    files: z.array(z.string().min(1)).min(1).describe("Paths to stage, relative to the git root."),
+    files: z
+        .array(FileEntrySchema)
+        .min(1)
+        .describe("Paths to stage, relative to the git root. Each can be a string path or { path, lines } for hunk-level staging. " +
+        "Deleted files (missing on disk but tracked in HEAD) are staged as removals via `git rm --cached`. " +
+        "Combining { path, lines } with a deleted file is an error."),
 });
 const PushModeSchema = z
     .enum(["never", "after"])
@@ -16,6 +34,151 @@ const PushModeSchema = z
     .describe("`never` (default): no push. `after`: push the current branch to its upstream once all commits succeed; " +
     "fails with `push_no_upstream` if the branch has no upstream (commits are NOT rolled back). " +
     "Enum reserved for future modes such as `force-with-lease`.");
+const DryRunSchema = z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe("When true, stage files, collect preview (files staged, commit messages), return preview response without writing commits. " +
+    "Unstages any files that were staged for the preview. Response indicates DRY RUN mode.");
+/**
+ * Parses a unified diff to extract hunks that overlap with a given line range.
+ * Returns a partial patch containing only the overlapping hunks, including header lines.
+ * Uses new file line numbers (after @@) to determine overlap.
+ */
+function extractOverlappingHunks(diffContent, fromLine, toLine) {
+    const lines = diffContent.split("\n");
+    // Find file header lines (index, ---, +++)
+    const fileHeaderLines = [];
+    let firstHunkIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line === undefined)
+            continue;
+        if (line.startsWith("@@")) {
+            firstHunkIdx = i;
+            break;
+        }
+        fileHeaderLines.push(line);
+    }
+    if (firstHunkIdx === -1) {
+        // No hunks found
+        return null;
+    }
+    const result = [...fileHeaderLines];
+    let i = firstHunkIdx;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line === undefined) {
+            i++;
+            continue;
+        }
+        // Match hunk header: @@ -oldStart,oldCount +newStart,newCount @@
+        const hunkMatch = /^@@\s+-\d+(?:,\d+)?\s+\+(\d+)(?:,(\d+))?\s+@@/.exec(line);
+        if (hunkMatch) {
+            const newStart = Number.parseInt(hunkMatch[1] || "0", 10);
+            const newCount = Number.parseInt(hunkMatch[2] || "1", 10);
+            // newCount=0 means pure deletion; hunkEnd must equal newStart so ranges
+            // that include newStart correctly capture the deletion.
+            const hunkEnd = newCount === 0 ? newStart : newStart + newCount - 1;
+            // Check if hunk overlaps with requested line range
+            const hasOverlap = !(hunkEnd < fromLine || newStart > toLine);
+            if (hasOverlap) {
+                // Add hunk header
+                result.push(line);
+                i++;
+                // Add hunk content until next hunk or EOF
+                while (i < lines.length) {
+                    const contentLine = lines[i];
+                    if (contentLine === undefined) {
+                        i++;
+                        continue;
+                    }
+                    // Stop at next hunk header
+                    if (contentLine.startsWith("@@")) {
+                        break;
+                    }
+                    result.push(contentLine);
+                    i++;
+                }
+            }
+            else {
+                // Skip hunk
+                i++;
+                while (i < lines.length) {
+                    const contentLine = lines[i];
+                    if (contentLine === undefined) {
+                        i++;
+                        continue;
+                    }
+                    if (contentLine.startsWith("@@")) {
+                        break;
+                    }
+                    i++;
+                }
+            }
+        }
+        else {
+            i++;
+        }
+    }
+    return result.length > fileHeaderLines.length ? result.join("\n") : null;
+}
+/**
+ * Stages a file with optional line range. If lines are provided, only hunks
+ * overlapping the range are staged via a partial patch. Otherwise, stages the whole file.
+ */
+async function stageFile(gitTop, filePath, lines) {
+    const absPath = resolvePathForRepo(filePath, gitTop);
+    const fileOnDisk = existsSync(absPath);
+    if (!fileOnDisk) {
+        if (lines) {
+            return { ok: false, error: "cannot stage line range for deleted file" };
+        }
+        // File missing on disk — stage as removal if tracked in HEAD
+        const lsResult = await spawnGitAsync(gitTop, ["ls-files", "--error-unmatch", "--", filePath]);
+        if (!lsResult.ok) {
+            return { ok: false, error: `pathspec '${filePath}' did not match any files` };
+        }
+        const rmResult = await spawnGitAsync(gitTop, ["rm", "--cached", "--", filePath]);
+        return {
+            ok: rmResult.ok,
+            error: rmResult.ok ? undefined : (rmResult.stderr || rmResult.stdout).trim(),
+        };
+    }
+    if (!lines) {
+        // Simple case: stage the whole file
+        const addResult = await spawnGitAsync(gitTop, ["add", "--", filePath]);
+        return {
+            ok: addResult.ok,
+            error: addResult.ok ? undefined : (addResult.stderr || addResult.stdout).trim(),
+        };
+    }
+    // Line range case: extract overlapping hunks and apply patch
+    const diffResult = await spawnGitAsync(gitTop, ["diff", filePath]);
+    if (!diffResult.ok) {
+        return { ok: false, error: (diffResult.stderr || diffResult.stdout).trim() };
+    }
+    const partialPatch = extractOverlappingHunks(diffResult.stdout, lines.from, lines.to);
+    if (!partialPatch) {
+        return { ok: false, error: "No hunks found in line range" };
+    }
+    // Write partial patch to temp file in the git repo and apply it to the index
+    const tempPatchFile = `${gitTop}/.git/.mcp-patch-${Date.now()}-${Math.random().toString(36).slice(2)}.patch`;
+    const { writeFileSync, unlinkSync } = await import("node:fs");
+    writeFileSync(tempPatchFile, partialPatch, "utf8");
+    const applyResult = await spawnGitAsync(gitTop, ["apply", "--cached", tempPatchFile]);
+    // Clean up temp file
+    try {
+        unlinkSync(tempPatchFile);
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+    return {
+        ok: applyResult.ok,
+        error: applyResult.ok ? undefined : (applyResult.stderr || applyResult.stdout).trim(),
+    };
+}
 /**
  * After all commits succeed, push the current branch to its upstream.
  * Commits are already applied at this point — do NOT attempt rollback on push failure.
@@ -39,7 +202,13 @@ export async function runPushAfter(gitTop) {
             detail: (pushResult.stderr || pushResult.stdout).trim(),
         };
     }
-    return { ok: true, branch, upstream: t.upstream };
+    const gitOutput = (pushResult.stdout || pushResult.stderr).trim();
+    return {
+        ok: true,
+        branch,
+        upstream: t.upstream,
+        ...spreadDefined("output", gitOutput || undefined),
+    };
 }
 export function registerBatchCommitTool(server) {
     server.addTool({
@@ -47,7 +216,8 @@ export function registerBatchCommitTool(server) {
         description: "Create multiple sequential git commits in a single call. " +
             "Each entry stages the listed files then commits with the given message. " +
             'Stops on first failure. Optional `push: "after"` pushes the current branch ' +
-            "to its upstream once all commits succeed.",
+            "to its upstream once all commits succeed. " +
+            "Optional `dryRun: true` previews what would be staged/committed without writing commits.",
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
@@ -60,6 +230,7 @@ export function registerBatchCommitTool(server) {
                 .max(50)
                 .describe("Commits to create, applied in order."),
             push: PushModeSchema,
+            dryRun: DryRunSchema,
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
@@ -67,16 +238,30 @@ export function registerBatchCommitTool(server) {
                 return jsonRespond(pre.error);
             const gitTop = pre.gitTop;
             const results = [];
+            const stagedFilesForCleanup = new Set();
             for (let i = 0; i < args.commits.length; i++) {
                 const entry = args.commits[i];
                 if (!entry)
                     break;
+                // Normalize file entries to { path, lines? } format
+                const fileEntries = [];
+                const filePaths = [];
+                for (const fileEntry of entry.files) {
+                    if (typeof fileEntry === "string") {
+                        fileEntries.push({ path: fileEntry });
+                        filePaths.push(fileEntry);
+                    }
+                    else {
+                        fileEntries.push(fileEntry);
+                        filePaths.push(fileEntry.path);
+                    }
+                }
                 // --- Validate all paths are under the git toplevel ---
                 const escapedPaths = [];
-                for (const rel of entry.files) {
-                    const abs = resolvePathForRepo(rel, gitTop);
+                for (const path of filePaths) {
+                    const abs = resolvePathForRepo(path, gitTop);
                     if (!isStrictlyUnderGitTop(abs, gitTop)) {
-                        escapedPaths.push(rel);
+                        escapedPaths.push(path);
                     }
                 }
                 if (escapedPaths.length > 0) {
@@ -84,53 +269,94 @@ export function registerBatchCommitTool(server) {
                         index: i,
                         ok: false,
                         message: entry.message,
-                        files: entry.files,
+                        files: filePaths,
                         error: "path_escapes_repository",
                         detail: escapedPaths.join(", "),
                     });
                     break;
                 }
-                // --- Stage files ---
-                const addResult = await spawnGitAsync(gitTop, ["add", "--", ...entry.files]);
-                if (!addResult.ok) {
+                // --- Stage files (with optional line ranges) ---
+                let stagingFailed = false;
+                let stagingError = "";
+                for (const fileEntry of fileEntries) {
+                    const stageResult = await stageFile(gitTop, fileEntry.path, fileEntry.lines);
+                    if (!stageResult.ok) {
+                        stagingFailed = true;
+                        stagingError = stageResult.error || "Unknown error";
+                        break;
+                    }
+                }
+                if (stagingFailed) {
                     results.push({
                         index: i,
                         ok: false,
                         message: entry.message,
-                        files: entry.files,
+                        files: filePaths,
                         error: "stage_failed",
-                        detail: (addResult.stderr || addResult.stdout).trim(),
+                        detail: stagingError,
+                        ...spreadDefined("output", stagingError || undefined),
                     });
                     break;
                 }
+                // Track staged files for cleanup in dry-run
+                if (args.dryRun) {
+                    for (const path of filePaths) {
+                        stagedFilesForCleanup.add(path);
+                    }
+                }
+                // --- Dry-run mode: collect preview and unstage ---
+                if (args.dryRun) {
+                    // Get diff stat for this staged entry
+                    const diffStatResult = await spawnGitAsync(gitTop, ["diff", "--staged", "--stat"]);
+                    const diffStat = diffStatResult.ok ? (diffStatResult.stdout || "").trim() : undefined;
+                    results.push({
+                        index: i,
+                        ok: true,
+                        message: entry.message,
+                        files: filePaths,
+                        staged: filePaths,
+                        ...spreadDefined("diffStat", diffStat || undefined),
+                    });
+                    continue; // Skip actual commit in dry-run mode
+                }
                 // --- Commit ---
                 const commitResult = await spawnGitAsync(gitTop, ["commit", "-m", entry.message]);
                 if (!commitResult.ok) {
+                    const gitOutput = (commitResult.stderr || commitResult.stdout).trim();
                     results.push({
                         index: i,
                         ok: false,
                         message: entry.message,
-                        files: entry.files,
+                        files: filePaths,
                         error: "commit_failed",
-                        detail: (commitResult.stderr || commitResult.stdout).trim(),
+                        detail: gitOutput,
+                        ...spreadDefined("output", gitOutput || undefined),
                     });
                     break;
                 }
                 // --- Extract SHA from commit output ---
                 const shaMatch = /\[[\w/.-]+\s+([0-9a-f]+)\]/.exec(commitResult.stdout);
+                const gitOutput = (commitResult.stdout || commitResult.stderr).trim();
                 results.push({
                     index: i,
                     ok: true,
                     sha: shaMatch?.[1],
                     message: entry.message,
-                    files: entry.files,
+                    files: filePaths,
+                    ...spreadDefined("output", gitOutput || undefined),
                 });
             }
+            // --- In dry-run mode, unstage all files ---
+            if (args.dryRun && stagedFilesForCleanup.size > 0) {
+                const filesToReset = Array.from(stagedFilesForCleanup);
+                await spawnGitAsync(gitTop, ["reset", "HEAD", "--", ...filesToReset]);
+            }
             const allOk = results.length === args.commits.length && results.every((r) => r.ok);
-            // --- Optional push after all commits succeed ---
-            const push = allOk && args.push === "after" ? await runPushAfter(gitTop) : undefined;
+            // --- Optional push after all commits succeed (not in dry-run mode) ---
+            const push = !args.dryRun && allOk && args.push === "after" ? await runPushAfter(gitTop) : undefined;
             if (args.format === "json") {
                 return jsonRespond({
+                    ...spreadWhen(args.dryRun, { dryRun: true }),
                     ok: allOk,
                     committed: results.filter((r) => r.ok).length,
                     total: args.commits.length,
@@ -140,8 +366,11 @@ export function registerBatchCommitTool(server) {
                         ...spreadDefined("sha", r.sha),
                         message: r.message,
                         files: r.files,
+                        ...spreadDefined("staged", r.staged),
+                        ...spreadDefined("diffStat", r.diffStat),
                         ...spreadDefined("error", r.error),
                         ...spreadDefined("detail", r.detail),
+                        ...spreadDefined("output", r.output),
                     })),
                     ...spreadWhen(push !== undefined, {
                         push: {
@@ -150,15 +379,17 @@ export function registerBatchCommitTool(server) {
                             ...spreadDefined("upstream", push?.upstream),
                             ...spreadDefined("error", push?.error),
                             ...spreadDefined("detail", push?.detail),
+                            ...spreadDefined("output", push?.output),
                         },
                     }),
                 });
             }
             // --- Markdown ---
             const lines = [];
+            const dryRunPrefix = args.dryRun ? "DRY RUN — " : "";
             const header = allOk
-                ? `# Batch commit: ${results.length}/${args.commits.length} committed`
-                : `# Batch commit: ${results.filter((r) => r.ok).length}/${args.commits.length} committed (stopped on error)`;
+                ? `# Batch commit: ${dryRunPrefix}${results.length}/${args.commits.length} committed`
+                : `# Batch commit: ${dryRunPrefix}${results.filter((r) => r.ok).length}/${args.commits.length} committed (stopped on error)`;
             lines.push(header, "");
             for (const r of results) {
                 const icon = r.ok ? "✓" : "✗";
@@ -167,11 +398,24 @@ export function registerBatchCommitTool(server) {
                 if (!r.ok && r.detail) {
                     lines.push(`  Error: ${r.error} — ${r.detail}`);
                 }
+                if (args.dryRun && r.staged) {
+                    lines.push(`  Staged: ${r.staged.join(", ")}`);
+                }
+                if (args.dryRun && r.diffStat) {
+                    lines.push(`  Diff stat:`);
+                    lines.push(`  ${r.diffStat.replace(/\n/g, "\n  ")}`);
+                }
+                if (r.output) {
+                    lines.push(`  Output: ${r.output.replace(/\n/g, "\n  ")}`);
+                }
             }
             if (!allOk && results.length < args.commits.length) {
                 const skipped = args.commits.length - results.length;
                 lines.push("", `${skipped} remaining commit(s) skipped.`);
             }
+            if (args.dryRun) {
+                lines.push("", "**DRY RUN — no commits written. All staged files have been unstaged.**");
+            }
             if (push) {
                 lines.push("");
                 if (push.ok) {
@@ -180,6 +424,9 @@ export function registerBatchCommitTool(server) {
                 else {
                     lines.push(`Push: ✗ ${push.error}${push.detail ? ` — ${push.detail}` : ""}`);
                 }
+                if (push.output) {
+                    lines.push(`  Output: ${push.output.replace(/\n/g, "\n  ")}`);
+                }
             }
             return lines.join("\n");
         },

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { spawnGitAsync } from "./git.js";
-import { commitListBetween, conflictPaths, getCurrentBranch, isFullyMergedInto, isProtectedBranch, isSafeGitRangeToken, isSafeGitRefToken, isWorkingTreeClean, resolveRef, worktreeForBranch, } from "./git-refs.js";
+import { commitListBetween, conflictPaths, getCurrentBranch, isContentEquivalentlyMergedInto, isFullyMergedInto, isProtectedBranch, isSafeGitRangeToken, isSafeGitRefToken, isWorkingTreeClean, resolveRef, worktreeForBranch, } from "./git-refs.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
@@ -96,8 +96,11 @@ export function registerGitCherryPickTool(server) {
         description: "Play commits from one or more sources onto a destination. Sources may be SHAs, " +
             "`A..B` ranges, or branch names (expanded to `onto..<branch>`, oldest-first). " +
             "Commits already reachable from the destination are skipped. Refuses on dirty tree; " +
-            "stops on the first conflict and reports paths. Optional flags auto-delete fully " +
-            "merged source branches and their worktrees, skipping protected names.",
+            "stops on the first conflict and reports paths. Optional flags auto-delete source " +
+            "branches and worktrees after success; deletion uses patch-id equivalence by default " +
+            "(content-identical commits with different SHAs are treated as merged, which is the " +
+            "normal cherry-pick outcome). Pass `strictMergedRefEquality: true` for strict `git branch -d` " +
+            "ancestry semantics. Protected branch names always skipped.",
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
@@ -127,6 +130,15 @@ export function registerGitCherryPickTool(server) {
                 .default(false)
                 .describe("After success, remove any local worktree attached to a branch-kind source " +
                 "(`git worktree remove`). Protected tails always skipped."),
+            strictMergedRefEquality: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("When false (default), branch deletion uses patch-id equivalence: a source branch " +
+                "is deleted when every commit it contains has a content-equivalent commit on the " +
+                "destination (same diff, different SHA — the normal cherry-pick outcome). " +
+                "Set to true to require strict ref ancestry (`git branch -d` semantics), which " +
+                "will refuse deletion after a cherry-pick because the SHA differs."),
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
@@ -221,11 +233,23 @@ export function registerGitCherryPickTool(server) {
                         }
                     }
                     if (args.deleteMergedBranches) {
-                        const merged = await isFullyMergedInto(gitTop, src.raw, onto);
-                        if (merged) {
-                            const r = await spawnGitAsync(gitTop, ["branch", "-d", src.raw]);
-                            if (r.ok)
-                                src.branchDeleted = true;
+                        if (args.strictMergedRefEquality) {
+                            const merged = await isFullyMergedInto(gitTop, src.raw, onto);
+                            if (merged) {
+                                const r = await spawnGitAsync(gitTop, ["branch", "-d", src.raw]);
+                                if (r.ok)
+                                    src.branchDeleted = true;
+                            }
+                        }
+                        else {
+                            const merged = await isContentEquivalentlyMergedInto(gitTop, src.raw, onto);
+                            if (merged) {
+                                // -D required: git branch -d checks ref ancestry (fails after cherry-pick),
+                                // but we've already verified content equivalence via patch-id.
+                                const r = await spawnGitAsync(gitTop, ["branch", "-D", src.raw]);
+                                if (r.ok)
+                                    src.branchDeleted = true;
+                            }
                         }
                     }
                 }

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

@@ -24,23 +24,25 @@ const DEFAULT_EXCLUDE_PATTERNS = [
 // Helpers
 // ---------------------------------------------------------------------------
 /**
- * Parse `git diff --stat` output into per-file stats.
- * Format: " path/to/file | N ++++---"
- * Final line: " N files changed, N insertions(+), N deletions(-)"
+ * Parse `git diff --numstat` output into exact per-file counts.
+ * Format per line: "<additions>\t<deletions>\t<path>"
+ * Binary files emit "-\t-\t<path>" and are recorded as 0/0.
  */
-function parseStatOutput(stat) {
+function parseNumstatOutput(numstat) {
     const result = new Map();
-    for (const line of stat.split("\n")) {
-        // Skip the summary line and blank lines
-        if (!line.includes("|"))
+    for (const line of numstat.split("\n")) {
+        const parts = line.split("\t");
+        if (parts.length < 3)
             continue;
-        const pipeIdx = line.indexOf("|");
-        const filePart = line.slice(0, pipeIdx).trim();
-        const statPart = line.slice(pipeIdx + 1).trim();
-        // statPart looks like "5 ++---" or "3 +++", count + and -
-        const additions = (statPart.match(/\+/g) ?? []).length;
-        const deletions = (statPart.match(/-/g) ?? []).length;
-        result.set(filePart, { additions, deletions });
+        const [addStr, delStr, ...pathParts] = parts;
+        const filePath = pathParts.join("\t");
+        if (!filePath)
+            continue;
+        const additions = addStr === "-" ? 0 : Number.parseInt(addStr ?? "0", 10);
+        const deletions = delStr === "-" ? 0 : Number.parseInt(delStr ?? "0", 10);
+        if (!Number.isNaN(additions) && !Number.isNaN(deletions)) {
+            result.set(filePath, { additions, deletions });
+        }
     }
     return result;
 }
@@ -68,10 +70,26 @@ function parseDiffOutput(diff) {
  * Body may contain "rename from", "rename to", "new file mode", "deleted file mode".
  */
 function extractFileInfo(header, body) {
-    // Parse "diff --git a/X b/Y"
-    const headerMatch = /^diff --git a\/(.+) b\/(.+)$/.exec(header);
-    const aPath = headerMatch?.[1] ?? "";
-    const bPath = headerMatch?.[2] ?? aPath;
+    // Parse "diff --git a/X b/Y". For non-renames X === Y; use midpoint split so
+    // paths containing " b/" (e.g. "src/b/file.ts") are not mis-parsed by a greedy regex.
+    const prefix = "diff --git a/";
+    const raw = header.startsWith(prefix) ? header.slice(prefix.length) : "";
+    const midLen = (raw.length - " b/".length) / 2;
+    let aPath = "";
+    let bPath = "";
+    if (Number.isInteger(midLen) && midLen > 0) {
+        const candidate = raw.slice(0, midLen);
+        if (raw.slice(midLen) === ` b/${candidate}`) {
+            aPath = candidate;
+            bPath = candidate;
+        }
+    }
+    if (!aPath) {
+        // Fall back for renames (aPath ≠ bPath); rename paths also come from body lines.
+        const headerMatch = /^diff --git a\/(.+) b\/(.+)$/.exec(header);
+        aPath = headerMatch?.[1] ?? "";
+        bPath = headerMatch?.[2] ?? aPath;
+    }
     let status = "modified";
     let oldPath;
     if (/^new file mode/m.test(body)) {
@@ -202,15 +220,15 @@ export function registerGitDiffSummaryTool(server) {
                 return jsonRespond({ error: diffArgsResult.error });
             }
             const diffArgs = diffArgsResult.args;
-            // --- Run git diff --stat ---
-            const statResult = await spawnGitAsync(gitTop, ["diff", "--stat", ...diffArgs]);
+            // --- Run git diff --numstat for exact addition/deletion counts ---
+            const statResult = await spawnGitAsync(gitTop, ["diff", "--numstat", ...diffArgs]);
             if (!statResult.ok) {
                 return jsonRespond({
                     error: "git_diff_failed",
                     detail: (statResult.stderr || statResult.stdout).trim(),
                 });
             }
-            const statMap = parseStatOutput(statResult.stdout);
+            const statMap = parseNumstatOutput(statResult.stdout);
             // --- Run git diff ---
             const diffResult = await spawnGitAsync(gitTop, ["diff", ...diffArgs]);
             if (!diffResult.ok) {