@rethunk/mcp-multi-root-git 3.1.0 → 4.0.0

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

@@ -1,7 +1,8 @@
 import { matchesGlob } from "node:path";
 import { z } from "zod";
 import { ERROR_CODES } from "./error-codes.js";
-import { isSafeGitUpstreamToken, spawnGitAsync } from "./git.js";
+import { spawnGitAsync } from "./git.js";
+import { isSafeGitRangeToken } from "./git-refs.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
@@ -27,6 +28,8 @@ const DEFAULT_EXCLUDE_PATTERNS = [
 /**
  * Parse `git diff --numstat` output into exact per-file counts.
  * Format per line: "<additions>\t<deletions>\t<path>"
+ * Renames emit "<additions>\t<deletions>\told => new" — keyed by the new path
+ * so lookups from extractFileInfo (which uses the destination path) succeed.
  * Binary files emit "-\t-\t<path>" and are recorded as 0/0.
  */
 export function parseNumstatOutput(numstat) {
@@ -36,9 +39,15 @@ export function parseNumstatOutput(numstat) {
         if (parts.length < 3)
             continue;
         const [addStr, delStr, ...pathParts] = parts;
-        const filePath = pathParts.join("\t");
+        let filePath = pathParts.join("\t");
         if (!filePath)
             continue;
+        // Rename numstat: "old/path => new/path" — index under the new path.
+        const renameSep = " => ";
+        const renameIdx = filePath.indexOf(renameSep);
+        if (renameIdx >= 0) {
+            filePath = filePath.slice(renameIdx + renameSep.length);
+        }
         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)) {
@@ -51,7 +60,7 @@ export function parseNumstatOutput(numstat) {
  * Parse `git diff` output into per-file chunks.
  * Splits on "diff --git a/..." lines.
  */
-function parseDiffOutput(diff) {
+export function parseDiffOutput(diff) {
     const chunks = [];
     // Each file section starts with "diff --git"
     const parts = diff.split(/(?=^diff --git )/m);
@@ -70,7 +79,7 @@ function parseDiffOutput(diff) {
  * Header: "diff --git a/old b/new"
  * Body may contain "rename from", "rename to", "new file mode", "deleted file mode".
  */
-function extractFileInfo(header, body) {
+export function extractFileInfo(header, body) {
     // 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/";
@@ -114,10 +123,11 @@ function extractFileInfo(header, body) {
     return { path, oldPath, status };
 }
 /**
- * Truncate diff body to at most `maxLines` lines (counting only hunk content lines).
+ * Truncate diff body to at most `maxLines` lines of the raw body text
+ * (includes index/---/+++/@@ headers — coarser than hunk-content-only counting).
  * Returns { text, truncated }.
  */
-function truncateDiffBody(body, maxLines) {
+export function truncateDiffBody(body, maxLines) {
     const lines = body.split("\n");
     if (lines.length <= maxLines) {
         return { text: body, truncated: false };
@@ -125,7 +135,7 @@ function truncateDiffBody(body, maxLines) {
     return { text: lines.slice(0, maxLines).join("\n"), truncated: true };
 }
 /** Check whether a file path matches any of the given glob patterns. */
-function matchesAnyPattern(filePath, patterns) {
+export function matchesAnyPattern(filePath, patterns) {
     const normalized = filePath.replace(/\\/g, "/");
     for (const pattern of patterns) {
         if (matchesGlob(normalized, pattern))
@@ -138,7 +148,7 @@ function matchesAnyPattern(filePath, patterns) {
     return false;
 }
 /** Build the diff args array from the `range` parameter. */
-function buildDiffArgs(range) {
+export function buildDiffArgs(range) {
     if (range === undefined || range === "") {
         return { ok: true, args: [] };
     }
@@ -149,21 +159,13 @@ function buildDiffArgs(range) {
     if (normalized === "head") {
         return { ok: true, args: ["HEAD"] };
     }
-    // Range like "A..B", "A...B", or a single ref
-    // Split on ".." or "..." separators to validate each token
-    const separatorMatch = /^(.+?)(\.{2,3})(.+)$/.exec(range.trim());
-    if (separatorMatch) {
-        const [, left, sep, right] = separatorMatch;
-        if (!isSafeGitUpstreamToken(left ?? "") || !isSafeGitUpstreamToken(right ?? "")) {
-            return { ok: false, error: `unsafe_range_token: ${range}` };
-        }
-        return { ok: true, args: [`${left}${sep}${right}`] };
-    }
-    // Single ref
-    if (!isSafeGitUpstreamToken(range.trim())) {
-        return { ok: false, error: `unsafe_range_token: ${range}` };
+    // "A..B", "A...B", or a single ref (ancestor notation like "HEAD~3" accepted
+    // on any endpoint) — delegates to the shared range validator.
+    const trimmed = range.trim();
+    if (!isSafeGitRangeToken(trimmed)) {
+        return { ok: false, error: ERROR_CODES.UNSAFE_RANGE_TOKEN };
     }
-    return { ok: true, args: [range.trim()] };
+    return { ok: true, args: [trimmed] };
 }
 /** Human-readable label for the range. */
 function rangeLabel(range, diffArgs) {
@@ -245,8 +247,9 @@ export function registerGitDiffSummaryTool(server) {
             }
             // --- Parse diff chunks ---
             const chunks = parseDiffOutput(diffResult.stdout);
-            const totalFiles = chunks.length;
             // --- Apply excludePatterns and fileFilter ---
+            // totalFiles / totals count the post-filter set (before maxFiles truncation)
+            // so they stay consistent with each other; truncatedFiles covers display caps.
             const excludePatterns = args.excludePatterns !== undefined ? args.excludePatterns : DEFAULT_EXCLUDE_PATTERNS;
             const excludedFiles = [];
             const includedChunks = [];
@@ -257,24 +260,32 @@ export function registerGitDiffSummaryTool(server) {
                     continue;
                 }
                 if (args.fileFilter && !matchesAnyPattern(filePath, [args.fileFilter])) {
+                    excludedFiles.push(filePath);
                     continue;
                 }
                 includedChunks.push(chunk);
             }
+            const totalFiles = includedChunks.length;
             // --- Truncate to maxFiles ---
             const maxFiles = args.maxFiles ?? 30;
             const maxLinesPerFile = args.maxLinesPerFile ?? 50;
             const truncatedFileCount = includedChunks.length > maxFiles ? includedChunks.length - maxFiles : 0;
             const processedChunks = includedChunks.slice(0, maxFiles);
             // --- Build FileDiff entries ---
+            // Sum stats over the full filtered set (includedChunks), not only the
+            // maxFiles-truncated display slice, so totals match totalFiles.
             let totalAdditions = 0;
             let totalDeletions = 0;
+            for (const chunk of includedChunks) {
+                const { path: filePath } = extractFileInfo(chunk.header, chunk.body);
+                const stat = statMap.get(filePath) ?? { additions: 0, deletions: 0 };
+                totalAdditions += stat.additions;
+                totalDeletions += stat.deletions;
+            }
             const files = [];
             for (const chunk of processedChunks) {
                 const { path: filePath, oldPath, status } = extractFileInfo(chunk.header, chunk.body);
                 const stat = statMap.get(filePath) ?? { additions: 0, deletions: 0 };
-                totalAdditions += stat.additions;
-                totalDeletions += stat.deletions;
                 const { text: diffText, truncated } = truncateDiffBody(chunk.body, maxLinesPerFile);
                 files.push({
                     path: filePath,

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

@@ -1,31 +1,36 @@
 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 { spawnGitAsync } from "./git.js";
+import { isSafeGitCommitIsh } from "./git-refs.js";
+import { jsonRespond, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
 // ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** Default byte cap on raw diff stdout to keep agent context bounded. */
+export const GIT_DIFF_DEFAULT_MAX_BYTES = 512_000;
+// ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 /** Build the diff args array from parameters. */
-function buildDiffArgs(opts) {
+export function buildDiffArgs(opts) {
     const args = ["diff"];
-    // Handle staged flag first
-    if (opts.staged === true) {
-        args.push("--staged");
-    }
-    else if (opts.base || opts.head) {
-        // Range-based diff: base..head or base...head
-        // If only base is given, use base~0..HEAD (implicit HEAD)
-        const baseStr = opts.base?.trim() ?? "HEAD";
-        const headStr = opts.head?.trim() ?? "HEAD";
-        if (!isSafeGitUpstreamToken(baseStr) || !isSafeGitUpstreamToken(headStr)) {
+    // Docs: `staged` is ignored when `base` is provided; `head` is used only
+    // when `base` is set. Prefer base..head over --staged whenever base is set.
+    if (opts.base) {
+        const baseStr = opts.base.trim();
+        const headStr = opts.head?.trim() || "HEAD";
+        if (!isSafeGitCommitIsh(baseStr) || !isSafeGitCommitIsh(headStr)) {
             return { ok: false, error: ERROR_CODES.UNSAFE_RANGE_TOKEN };
         }
-        // Use two-dot range: base..head
         args.push(`${baseStr}..${headStr}`);
     }
+    else if (opts.staged === true) {
+        args.push("--staged");
+    }
+    // head without base is ignored (matches docs: head used only when base is set)
     // Apply unified context width if specified
     if (typeof opts.unified === "number") {
         args.push(`-U${opts.unified}`);
@@ -37,16 +42,16 @@ function buildDiffArgs(opts) {
     return { ok: true, args };
 }
 /** Human-readable label for the range. */
-function rangeLabel(opts) {
+export function rangeLabel(opts) {
     let label = "";
-    if (opts.staged === true) {
-        label = "staged changes";
-    }
-    else if (opts.base || opts.head) {
-        const baseStr = opts.base?.trim() ?? "HEAD";
-        const headStr = opts.head?.trim() ?? "HEAD";
+    if (opts.base) {
+        const baseStr = opts.base.trim();
+        const headStr = opts.head?.trim() || "HEAD";
         label = `${baseStr}..${headStr}`;
     }
+    else if (opts.staged === true) {
+        label = "staged changes";
+    }
     else {
         label = "unstaged changes";
     }
@@ -55,6 +60,14 @@ function rangeLabel(opts) {
     }
     return label;
 }
+/** Cap diff text at maxBytes; UTF-8 safe via Buffer slice. */
+export function truncateDiffOutput(diff, maxBytes) {
+    const buf = Buffer.from(diff, "utf8");
+    if (buf.length <= maxBytes) {
+        return { text: diff, truncated: false };
+    }
+    return { text: buf.subarray(0, maxBytes).toString("utf8"), truncated: true };
+}
 // ---------------------------------------------------------------------------
 // Tool registration
 // ---------------------------------------------------------------------------
@@ -62,7 +75,8 @@ export function registerGitDiffTool(server) {
     server.addTool({
         name: "git_diff",
         description: "Raw diff text for scoped file(s) or range. `staged: true` for staged changes, " +
-            "`base`/`head` for revision ranges, `path`/`paths` to scope, `unified` for context lines.",
+            "`base`/`head` for revision ranges, `path`/`paths` to scope, `unified` for context lines. " +
+            "Output is capped by `maxBytes` (default 512000) to bound agent context.",
         annotations: {
             readOnlyHint: true,
         },
@@ -70,11 +84,11 @@ export function registerGitDiffTool(server) {
             base: z
                 .string()
                 .optional()
-                .describe('Base ref (e.g. "main", "HEAD~3"). Omit for unstaged changes.'),
+                .describe('Base ref (e.g. "main"). Ancestor notation is accepted (e.g. "HEAD~3", "main^2"). Omit for unstaged changes.'),
             head: z
                 .string()
                 .optional()
-                .describe('Head ref (e.g. "feature-branch"). Defaults to HEAD. Used only when `base` is set.'),
+                .describe('Head ref (e.g. "feature-branch"). Ancestor notation is accepted (e.g. "HEAD~3", "main^2"). Defaults to HEAD. Used only when `base` is set.'),
             path: z
                 .string()
                 .optional()
@@ -95,6 +109,14 @@ export function registerGitDiffTool(server) {
                 .max(100)
                 .optional()
                 .describe("Context lines around each change (`-U<n>`). Default: 3. Use 0 for no context."),
+            maxBytes: z
+                .number()
+                .int()
+                .min(1024)
+                .max(10_000_000)
+                .optional()
+                .default(GIT_DIFF_DEFAULT_MAX_BYTES)
+                .describe(`Max UTF-8 bytes of diff text to return (default ${GIT_DIFF_DEFAULT_MAX_BYTES}). Oversized output is truncated with truncated:true.`),
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
@@ -141,6 +163,8 @@ export function registerGitDiffTool(server) {
                     detail: (result.stderr || result.stdout).trim(),
                 });
             }
+            const maxBytes = typeof args.maxBytes === "number" ? args.maxBytes : GIT_DIFF_DEFAULT_MAX_BYTES;
+            const { text: diffText, truncated } = truncateDiffOutput(result.stdout, maxBytes);
             const label = rangeLabel({
                 base: args.base,
                 head: args.head,
@@ -150,18 +174,22 @@ export function registerGitDiffTool(server) {
             if (args.format === "json") {
                 return jsonRespond({
                     range: label,
-                    diff: result.stdout,
+                    diff: diffText,
+                    ...spreadWhen(truncated, { truncated: true }),
                 });
             }
             // Markdown output
             const lines = [];
             lines.push(`# Diff: ${label}`, "");
-            if (result.stdout.trim()) {
-                lines.push("```diff", result.stdout.trimEnd(), "```");
+            if (diffText.trim()) {
+                lines.push("```diff", diffText.trimEnd(), "```");
             }
             else {
                 lines.push("_(no changes)_");
             }
+            if (truncated) {
+                lines.push("", `_(diff truncated at ${maxBytes} bytes)_`);
+            }
             return lines.join("\n");
         },
     });

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

@@ -0,0 +1,188 @@
+import { basename } from "node:path";
+import { z } from "zod";
+import { assertRelativePathUnderTop, resolvePathForRepo } from "../repo-paths.js";
+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, spreadWhen } from "./json.js";
+import { requireGitAndRoots } from "./roots.js";
+import { RootPickSchema } from "./schemas.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const MAX_MATCHES_HARD_CAP = 1000;
+const DEFAULT_MAX_MATCHES = 200;
+/** Run `git log -S` / `-G` pickaxe history search for a single repo root. */
+async function runPickaxe(opts) {
+    const { top, mode, term, ref, paths, ignoreCase, maxMatches } = opts;
+    const args = [
+        "log",
+        "--pretty=format:%H%x01%s",
+        "-n",
+        String(maxMatches + 1),
+        mode === "S" ? "-S" : "-G",
+        term,
+    ];
+    // `-i` / `--regexp-ignore-case` affects `-G` (and `--grep`); harmless on `-S`.
+    if (ignoreCase)
+        args.push("-i");
+    if (ref)
+        args.push(ref);
+    if (paths.length > 0)
+        args.push("--", ...paths);
+    const r = await spawnGitAsync(top, args);
+    if (!r.ok) {
+        return {
+            error: ERROR_CODES.GIT_GREP_FAILED,
+            detail: r.stderr.trim() || r.stdout.trim(),
+        };
+    }
+    const commits = [];
+    for (const line of r.stdout.split("\n")) {
+        if (!line.trim())
+            continue;
+        const sep = line.indexOf("\x01");
+        if (sep < 0)
+            continue;
+        const sha = line.slice(0, sep).trim();
+        const subject = line.slice(sep + 1).trim();
+        if (sha)
+            commits.push({ sha, subject });
+    }
+    const truncated = commits.length > maxMatches;
+    return {
+        commits: truncated ? commits.slice(0, maxMatches) : commits,
+        truncated,
+    };
+}
+// ---------------------------------------------------------------------------
+// Markdown rendering
+// ---------------------------------------------------------------------------
+function renderGrepMarkdown(group) {
+    const lines = [`### ${group.repo}`, `_root: ${group.root}_`, ""];
+    if (group.error) {
+        lines.push(`_error: ${group.error}${group.detail ? ` — ${group.detail}` : ""}_`);
+        return lines.join("\n");
+    }
+    const commits = group.commits ?? [];
+    if (commits.length === 0) {
+        lines.push("_(no pickaxe hits)_");
+    }
+    else {
+        for (const c of commits) {
+            lines.push(`- \`${c.sha.slice(0, 7)}\`  ${c.subject}`);
+        }
+    }
+    if (group.truncated) {
+        lines.push("", "_(truncated — raise `maxMatches` for the full result set)_");
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGitGrepTool(server) {
+    server.addTool({
+        name: "git_grep",
+        description: "Pickaxe history search across one or more roots: which commits added or removed a term " +
+            '(`git log -S`) or changed lines matching a regex (`git log -G`), via `pickaxe: { mode: "S"|"G", term }`. ' +
+            "Returns `commits[]` (sha + subject) per root. Set `ref` to limit history to that tip. " +
+            "For working-tree content search use the client's native grep/rg tooling instead — " +
+            "content mode was removed in v6.",
+        annotations: {
+            readOnlyHint: true,
+        },
+        parameters: RootPickSchema.extend({
+            pickaxe: z
+                .object({
+                mode: z
+                    .enum(["S", "G"])
+                    .describe("`S` = pickaxe string (`git log -S`); `G` = pickaxe regex (`git log -G`)."),
+                term: z.string().min(1).max(500).describe("Search term / regex for pickaxe history."),
+            })
+                .describe("Pickaxe history search. Returns `commits[]` (sha + subject) per root."),
+            ref: z
+                .string()
+                .optional()
+                .describe("Commit/branch/tag to use as the history tip. Must be a safe ref token."),
+            paths: z
+                .array(z.string())
+                .optional()
+                .describe("Limit history to these paths (must resolve within the repo root)."),
+            ignoreCase: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Case-insensitive match (`-i`; affects `G` mode regexes)."),
+            maxMatches: z
+                .number()
+                .int()
+                .min(1)
+                .max(MAX_MATCHES_HARD_CAP)
+                .optional()
+                .default(DEFAULT_MAX_MATCHES)
+                .describe(`Max commits per root (hard cap ${MAX_MATCHES_HARD_CAP}, default ${DEFAULT_MAX_MATCHES}).`),
+        }),
+        execute: async (args) => {
+            const pre = requireGitAndRoots(server, args, undefined);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const pickaxe = args.pickaxe;
+            if (args.ref !== undefined && !isSafeGitAncestorRef(args.ref)) {
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: args.ref });
+            }
+            const ref = args.ref?.trim() || undefined;
+            const rawPaths = Array.isArray(args.paths) ? args.paths : [];
+            const ignoreCase = args.ignoreCase ?? false;
+            const maxMatches = Math.min(args.maxMatches ?? DEFAULT_MAX_MATCHES, MAX_MATCHES_HARD_CAP);
+            // Fan out across roots. Path confinement is per-root since each root has
+            // its own git toplevel.
+            const jobs = pre.roots.map((rootInput) => ({ rootInput }));
+            const groups = await asyncPool(jobs, GIT_SUBPROCESS_PARALLELISM, async ({ rootInput }) => {
+                const top = gitTopLevel(rootInput);
+                if (!top) {
+                    return {
+                        root: rootInput,
+                        repo: basename(rootInput),
+                        error: ERROR_CODES.NOT_A_GIT_REPOSITORY,
+                        detail: rootInput,
+                    };
+                }
+                for (const p of rawPaths) {
+                    const resolved = resolvePathForRepo(p, top);
+                    if (!assertRelativePathUnderTop(p, resolved, top)) {
+                        return {
+                            root: top,
+                            repo: basename(top),
+                            error: ERROR_CODES.PATH_ESCAPES_REPO,
+                            detail: p,
+                        };
+                    }
+                }
+                const result = await runPickaxe({
+                    top,
+                    mode: pickaxe.mode,
+                    term: pickaxe.term,
+                    ref,
+                    paths: rawPaths,
+                    ignoreCase,
+                    maxMatches,
+                });
+                if ("error" in result) {
+                    return { root: top, repo: basename(top), error: result.error, detail: result.detail };
+                }
+                return {
+                    root: top,
+                    repo: basename(top),
+                    commits: result.commits,
+                    ...spreadWhen(result.truncated, { truncated: true }),
+                };
+            });
+            if (args.format === "json") {
+                return jsonRespond({ results: groups });
+            }
+            const mdChunks = ["# git grep", ...groups.map((g) => renderGrepMarkdown(g))];
+            return mdChunks.join("\n\n");
+        },
+    });
+}

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { ERROR_CODES } from "./error-codes.js";
 import { asyncPool, GIT_SUBPROCESS_PARALLELISM, gitRevParseGitDir, gitTopLevel, isSafeGitUpstreamToken, } from "./git.js";
+import { isSafeGitAncestorRef } from "./git-refs.js";
 import { buildInventorySectionMarkdown, collectInventoryEntry, makeSkipEntry, validateRepoPath, } from "./inventory.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
 import { applyPresetNestedRoots } from "./presets.js";
@@ -9,7 +10,7 @@ import { MAX_INVENTORY_ROOTS_DEFAULT, RootPickSchema } from "./schemas.js";
 export function registerGitInventoryTool(server) {
     server.addTool({
         name: "git_inventory",
-        description: "Read-only status + ahead/behind per root.",
+        description: "Read-only status + ahead/behind per root. Optional `compareRefs` adds ahead/behind between two local refs (independent of upstream).",
         annotations: {
             readOnlyHint: true,
         },
@@ -23,6 +24,13 @@ export function registerGitInventoryTool(server) {
                 .describe("Merge with preset instead of replacing."),
             remote: z.string().optional().describe("Pair with `branch`."),
             branch: z.string().optional().describe("Pair with `remote`."),
+            compareRefs: z
+                .object({
+                left: z.string().describe("Base ref (ahead = commits in right not in left)."),
+                right: z.string().describe("Other ref (behind = commits in left not in right)."),
+            })
+                .optional()
+                .describe("Ahead/behind between two local refs (e.g. main vs a feature branch), independent of upstream tracking."),
             maxRoots: z.number().int().min(1).max(256).optional().default(MAX_INVENTORY_ROOTS_DEFAULT),
         }),
         execute: async (args) => {
@@ -49,24 +57,36 @@ export function registerGitInventoryTool(server) {
                 }
                 upstream = { mode: "fixed", remote: rawRemote, branch: rawBranch };
             }
+            let compareRefs;
+            if (args.compareRefs) {
+                const left = args.compareRefs.left.trim();
+                const right = args.compareRefs.right.trim();
+                if (!isSafeGitAncestorRef(left) || !isSafeGitAncestorRef(right)) {
+                    return jsonRespond({
+                        error: ERROR_CODES.UNSAFE_REF_TOKEN,
+                        left: args.compareRefs.left,
+                        right: args.compareRefs.right,
+                    });
+                }
+                compareRefs = { left, right };
+            }
             const useFixed = upstream.mode === "fixed";
             const allJson = [];
             const mdChunks = [];
             for (const workspaceRoot of pre.roots) {
                 const top = gitTopLevel(workspaceRoot);
                 if (!top) {
-                    const err = { error: ERROR_CODES.NOT_A_GIT_REPOSITORY, path: workspaceRoot };
                     if (args.format === "json") {
                         allJson.push({
                             workspaceRoot: workspaceRoot,
                             ...(upstream.mode === "fixed" ? { upstream } : {}),
                             entries: [
-                                makeSkipEntry(workspaceRoot, workspaceRoot, upstream.mode, JSON.stringify(err)),
+                                makeSkipEntry(workspaceRoot, workspaceRoot, upstream.mode, "(not a git repository)"),
                             ],
                         });
                     }
                     else {
-                        mdChunks.push(`### ${workspaceRoot}\n${jsonRespond(err)}`);
+                        mdChunks.push(`### ${workspaceRoot}\n(not a git repository)`);
                     }
                     continue;
                 }
@@ -106,14 +126,14 @@ export function registerGitInventoryTool(server) {
                         }
                         jobs.push({ label: rel, abs });
                     }
-                    const computed = await asyncPool(jobs, GIT_SUBPROCESS_PARALLELISM, (j) => collectInventoryEntry(j.label, j.abs, upstream.remote, upstream.branch));
+                    const computed = await asyncPool(jobs, GIT_SUBPROCESS_PARALLELISM, (j) => collectInventoryEntry(j.label, j.abs, upstream.remote, upstream.branch, compareRefs));
                     entries.push(...computed);
                 }
                 else if (!gitRevParseGitDir(top)) {
                     entries.push(makeSkipEntry(".", top, upstream.mode, "(not a git work tree — unexpected)"));
                 }
                 else {
-                    const one = await collectInventoryEntry(".", top, upstream.remote, upstream.branch);
+                    const one = await collectInventoryEntry(".", top, upstream.remote, upstream.branch, compareRefs);
                     entries.push(one);
                 }
                 if (args.format === "json") {