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

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

@@ -1,6 +1,8 @@
 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";
 import { requireGitAndRoots } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
@@ -81,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,
         };
     }
@@ -221,23 +223,31 @@ 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: 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.
             const jobs = pre.roots.map((rootInput) => ({ rootInput }));
             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,11 +34,11 @@ 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({
-                            workspace_root: workspaceRoot,
+                            workspaceRoot: workspaceRoot,
                             status: "MISMATCH",
                             pairs: [{ label: "—", leftPath: "", rightPath: "", match: false, error: err }],
                         });
@@ -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 = [];
@@ -114,7 +115,7 @@ export function registerGitParityTool(server) {
                     }
                 }
                 results.push({
-                    workspace_root: top,
+                    workspaceRoot: top,
                     ...spreadDefined("presetSchemaVersion", parityPresetSchemaVersion),
                     status: allOk ? "OK" : "MISMATCH",
                     pairs: 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(),
                 });
             }

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

@@ -0,0 +1,126 @@
+import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
+import { spawnGitAsync } from "./git.js";
+import { isSafeGitRefToken } from "./git-refs.js";
+import { jsonRespond } from "./json.js";
+import { requireSingleRepo } from "./roots.js";
+import { WorkspacePickSchema } from "./schemas.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const MAX_ENTRIES_HARD_CAP = 200;
+const DEFAULT_MAX_ENTRIES = 30;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Run git reflog for a single ref and return structured data.
+ * Uses NUL-delimited fields within each line for robust parsing.
+ */
+async function runGitReflog(opts) {
+    const { top, ref, maxEntries } = opts;
+    // %h = short sha, %H = full sha, %gd = selector (HEAD@{0}), %gs = reflog subject
+    const reflogArgs = [
+        "reflog",
+        "show",
+        ref,
+        "--format=%h%x00%H%x00%gd%x00%gs",
+        `-n`,
+        String(maxEntries),
+    ];
+    const r = await spawnGitAsync(top, reflogArgs);
+    if (!r.ok) {
+        return {
+            error: ERROR_CODES.REFLOG_FAILED,
+            detail: (r.stderr || r.stdout || "git reflog failed").trim(),
+        };
+    }
+    const entries = [];
+    const lines = r.stdout.split("\n");
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        const parts = line.split("\x00");
+        // Expect 4 fields: shaShort, shaFull, selector, message
+        if (parts.length < 4)
+            continue;
+        const [, shaFull, selector, message] = parts;
+        if (!shaFull)
+            continue;
+        entries.push({
+            sha: shaFull.trim(),
+            selector: (selector ?? "").trim(),
+            message: (message ?? "").trim(),
+        });
+    }
+    return { ref, entries };
+}
+// ---------------------------------------------------------------------------
+// Markdown rendering
+// ---------------------------------------------------------------------------
+function renderReflogMarkdown(result) {
+    const lines = [];
+    lines.push(`## Reflog (${result.ref})`);
+    lines.push("");
+    if (result.entries.length === 0) {
+        lines.push("_(no reflog entries)_");
+    }
+    else {
+        for (const entry of result.entries) {
+            lines.push(`${entry.selector}  ${entry.sha.slice(0, 7)}  ${entry.message}`);
+        }
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGitReflogTool(server) {
+    server.addTool({
+        name: "git_reflog",
+        description: "Show the reflog for a ref (default HEAD). Returns a list of recent HEAD movements with selector (e.g. HEAD@{0}), full SHA, and message. Useful for recovering lost commits or inspecting reset/checkout history.",
+        annotations: {
+            readOnlyHint: true,
+        },
+        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true, allWorkspaceRoots: true })
+            .pick({
+            workspaceRoot: true,
+            rootIndex: true,
+            format: true,
+        })
+            .extend({
+            ref: z
+                .string()
+                .optional()
+                .default("HEAD")
+                .describe("Ref whose reflog to show (branch name, HEAD, etc.). Default: HEAD."),
+            maxEntries: z
+                .number()
+                .int()
+                .min(1)
+                .max(MAX_ENTRIES_HARD_CAP)
+                .optional()
+                .default(DEFAULT_MAX_ENTRIES)
+                .describe(`Maximum reflog entries to return (hard cap ${MAX_ENTRIES_HARD_CAP}). Default ${DEFAULT_MAX_ENTRIES}.`),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const top = pre.gitTop;
+            const ref = args.ref ?? "HEAD";
+            if (!isSafeGitRefToken(ref)) {
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref });
+            }
+            const maxEntries = Math.min(args.maxEntries ?? DEFAULT_MAX_ENTRIES, MAX_ENTRIES_HARD_CAP);
+            const result = await runGitReflog({ top, ref, maxEntries });
+            if ("error" in result) {
+                return jsonRespond(result);
+            }
+            if (args.format === "json") {
+                return jsonRespond(result);
+            }
+            return renderReflogMarkdown(result);
+        },
+    });
+}

package/dist/server/git-refs.js

@@ -25,17 +25,24 @@ const PROTECTED_EXACT = new Set([
     "trunk",
     "prod",
     "production",
-    "HEAD",
+    "head",
 ]);
 const PROTECTED_PATTERN = /^(release|hotfix)[-/].+$/i;
 /** True when a branch name is on the protected list and must not be auto-deleted. */
 export function isProtectedBranch(name) {
-    const t = name.trim();
-    if (t === "")
+    // Normalize: trim whitespace, strip leading refs/heads/ prefix, then lowercase.
+    const trimmed = name.trim();
+    if (trimmed === "")
         return true;
-    if (PROTECTED_EXACT.has(t))
+    const stripped = trimmed.startsWith("refs/heads/")
+        ? trimmed.slice("refs/heads/".length)
+        : trimmed;
+    const normalized = stripped.toLowerCase();
+    if (normalized === "")
         return true;
-    return PROTECTED_PATTERN.test(t);
+    if (PROTECTED_EXACT.has(normalized))
+        return true;
+    return PROTECTED_PATTERN.test(normalized);
 }
 // ---------------------------------------------------------------------------
 // Ref/branch name validation (argv-safe subset of git's ref-format rules)

package/dist/server/git-reset-soft-tool.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
 import { spawnGitAsync } from "./git.js";
 import { isSafeGitAncestorRef, isWorkingTreeClean } from "./git-refs.js";
 import { jsonRespond, spreadDefined } from "./json.js";
@@ -30,12 +31,12 @@ export function registerGitResetSoftTool(server) {
             const { gitTop } = pre;
             // Validate ref — allow ancestor notation (~N, ^N).
             if (!isSafeGitAncestorRef(args.ref)) {
-                return jsonRespond({ error: "unsafe_ref_token", ref: args.ref });
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: args.ref });
             }
             // Refuse when the working tree is dirty (unstaged or untracked changes).
             if (!(await isWorkingTreeClean(gitTop))) {
                 return jsonRespond({
-                    error: "working_tree_dirty",
+                    error: ERROR_CODES.WORKING_TREE_DIRTY,
                     detail: "git_reset_soft requires a clean working tree. " +
                         "Commit or stash pending changes first.",
                 });
@@ -47,7 +48,7 @@ export function registerGitResetSoftTool(server) {
             const r = await spawnGitAsync(gitTop, ["reset", "--soft", args.ref]);
             if (!r.ok) {
                 return jsonRespond({
-                    error: "reset_failed",
+                    error: ERROR_CODES.RESET_FAILED,
                     detail: (r.stderr || r.stdout).trim(),
                 });
             }

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

@@ -1,5 +1,8 @@
 import { z } from "zod";
+import { assertRelativePathUnderTop, resolvePathForRepo } from "../repo-paths.js";
+import { ERROR_CODES } from "./error-codes.js";
 import { spawnGitAsync } from "./git.js";
+import { isSafeGitAncestorRef } from "./git-refs.js";
 import { jsonRespond } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
@@ -7,22 +10,35 @@ import { WorkspacePickSchema } from "./schemas.js";
 // Helpers
 // ---------------------------------------------------------------------------
 /**
- * Run git show for a single ref, optionally limiting to a specific path.
- * Returns commit message and diff (or file content if path is specified).
+ * Run git show for a single ref, optionally limiting to specific paths and/or
+ * showing only the --stat diffstat rather than the full patch.
+ * Returns commit message and diff/stat output.
  */
 async function runGitShow(opts) {
-    const { top, ref, path } = opts;
-    // Build git show args. Shows commit message + full diff (or file content when path given).
-    const showArgs = ["show", ref];
-    if (path) {
-        // When path is specified, show that path at the ref without --no-patch
-        // to get the full content at that ref
-        showArgs.push("--", path);
+    const { top, ref, path, paths, stat } = opts;
+    // Merge single path + paths array into a unified list (deduped, order preserved).
+    const effectivePaths = [];
+    if (path)
+        effectivePaths.push(path);
+    if (paths) {
+        for (const p of paths) {
+            if (!effectivePaths.includes(p))
+                effectivePaths.push(p);
+        }
+    }
+    // Build git show args. Shows commit message + full diff (or --stat diffstat).
+    const showArgs = ["show"];
+    if (stat) {
+        showArgs.push("--stat");
+    }
+    showArgs.push(ref);
+    if (effectivePaths.length > 0) {
+        showArgs.push("--", ...effectivePaths);
     }
     const r = await spawnGitAsync(top, showArgs);
     if (!r.ok) {
         return {
-            error: "git_show_failed",
+            error: ERROR_CODES.GIT_SHOW_FAILED,
         };
     }
     // Parse the output. For a commit, git show outputs:
@@ -30,10 +46,9 @@ async function runGitShow(opts) {
     // - Blank line
     // - Commit message (may contain multiple lines and blank lines)
     // - Blank line (separator before diff)
-    // - Diff (if --no-patch not used) or file content
+    // - Diff or --stat diffstat section
     const output = r.stdout;
     let message = "";
-    let diff = "";
     const lines = output.split("\n");
     let inHeader = true;
     let inMessage = false;
@@ -48,9 +63,14 @@ async function runGitShow(opts) {
             inMessage = true;
             continue;
         }
-        // In message: collect until we see "diff --git" which marks the start of the diff section
         if (inMessage) {
-            if (line.startsWith("diff --git")) {
+            // In stat mode: content starts at the first line that looks like a stat entry
+            // (indented file path) or the summary line "N files changed".
+            // In diff mode: content starts at "diff --git".
+            const isStatLine = stat &&
+                (line.match(/^\s+\S.*\|/) !== null || line.match(/^\s*\d+ files? changed/) !== null);
+            const isDiffLine = !stat && line.startsWith("diff --git");
+            if (isStatLine || isDiffLine) {
                 inMessage = false;
                 contentLines.push(line);
             }
@@ -64,16 +84,26 @@ async function runGitShow(opts) {
         }
     }
     message = messageLines.join("\n").trim();
-    diff = contentLines.join("\n").trim();
+    const contentStr = contentLines.join("\n").trim();
     const result = {
         ref,
         message,
     };
-    if (path) {
+    // Reflect single legacy path (for backward-compat) and new paths[] in result.
+    if (path && !paths) {
         result.path = path;
     }
-    if (diff) {
-        result.diff = diff;
+    else if (effectivePaths.length > 0) {
+        result.paths = effectivePaths;
+    }
+    if (stat) {
+        result.stat = true;
+        if (contentStr) {
+            result.statOutput = contentStr;
+        }
+    }
+    else if (contentStr) {
+        result.diff = contentStr;
     }
     return result;
 }
@@ -86,13 +116,27 @@ function renderShowMarkdown(result) {
     if (result.path) {
         lines.push(`_path: ${result.path}_`);
     }
+    else if (result.paths && result.paths.length > 0) {
+        lines.push(`_paths: ${result.paths.join(", ")}_`);
+    }
+    if (result.stat) {
+        lines.push("_mode: stat_");
+    }
     lines.push("");
     lines.push("## Commit message");
     lines.push("");
     lines.push("```");
     lines.push(result.message);
     lines.push("```");
-    if (result.diff) {
+    if (result.stat && result.statOutput) {
+        lines.push("");
+        lines.push("## Stat");
+        lines.push("");
+        lines.push("```");
+        lines.push(result.statOutput);
+        lines.push("```");
+    }
+    else if (result.diff) {
         lines.push("");
         lines.push("## Diff");
         lines.push("");
@@ -108,7 +152,7 @@ function renderShowMarkdown(result) {
 export function registerGitShowTool(server) {
     server.addTool({
         name: "git_show",
-        description: "Inspect commit content by ref/SHA. Returns commit message and diff (or file content at a specific path).",
+        description: "Inspect commit content by ref/SHA. Returns commit message and diff (or --stat diffstat when stat:true). Optionally filter to specific paths via path or paths[].",
         annotations: {
             readOnlyHint: true,
         },
@@ -119,21 +163,51 @@ export function registerGitShowTool(server) {
             format: true,
         })
             .extend({
-            ref: z.string().describe("Commit reference (SHA, branch, tag, or any git rev-spec)."),
+            ref: z
+                .string()
+                .min(1)
+                .describe("Commit reference (SHA, branch, tag, or any git rev-spec)."),
             path: z
                 .string()
                 .optional()
-                .describe("Optional file path to inspect at the ref. If provided, shows that path's content at the ref instead of the diff."),
+                .describe("Optional single file path to inspect at the ref. Merged with `paths` when both are provided."),
+            paths: z
+                .array(z.string())
+                .optional()
+                .describe("Optional list of file paths to filter the shown diff/stat. Merged with `path` when both are provided."),
+            stat: z
+                .boolean()
+                .optional()
+                .describe("When true, show --stat diffstat (files changed summary) instead of the full patch."),
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
             if (!pre.ok)
                 return jsonRespond(pre.error);
             const top = pre.gitTop;
+            if (!isSafeGitAncestorRef(args.ref)) {
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: args.ref });
+            }
+            if (args.path !== undefined) {
+                const resolved = resolvePathForRepo(args.path, top);
+                if (!assertRelativePathUnderTop(args.path, resolved, top)) {
+                    return jsonRespond({ error: ERROR_CODES.PATH_ESCAPES_REPO, path: args.path });
+                }
+            }
+            if (Array.isArray(args.paths)) {
+                for (const p of args.paths) {
+                    const resolved = resolvePathForRepo(p, top);
+                    if (!assertRelativePathUnderTop(p, resolved, top)) {
+                        return jsonRespond({ error: ERROR_CODES.PATH_ESCAPES_REPO, path: p });
+                    }
+                }
+            }
             const result = await runGitShow({
                 top,
                 ref: args.ref,
                 path: args.path,
+                paths: args.paths,
+                stat: args.stat,
             });
             if ("error" in result) {
                 return jsonRespond(result);