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

package/dist/server/git-refs.js

@@ -1,3 +1,4 @@
+import { execFileSync } from "node:child_process";
 import { spawnGitAsync } from "./git.js";
 // ---------------------------------------------------------------------------
 // Merge conflict helpers (shared between git_merge and git_cherry_pick)
@@ -24,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)
@@ -124,6 +132,77 @@ export async function isFullyMergedInto(cwd, branch, target) {
     const r = await spawnGitAsync(cwd, ["merge-base", "--is-ancestor", branch, target]);
     return r.ok;
 }
+/**
+ * Returns the git patch-id for a single commit, or undefined on failure.
+ * Uses execFileSync to pipe `git diff-tree --patch -r <sha>` into `git patch-id --stable`.
+ */
+function commitPatchId(cwd, sha) {
+    try {
+        const diff = execFileSync("git", ["diff-tree", "--patch", "-r", sha], {
+            cwd,
+            encoding: "utf8",
+        });
+        const out = execFileSync("git", ["patch-id", "--stable"], {
+            cwd,
+            encoding: "utf8",
+            input: diff,
+        });
+        return out.trim().split(" ")[0] || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Returns true when every commit reachable from `branch` but not from `target` has a
+ * patch-equivalent commit already in `target` (content-equivalent merge check for
+ * cherry-pick workflows where SHA differs but diff is identical).
+ *
+ * Falls back to ref-equality (`isFullyMergedInto`) when patch-id comparison fails.
+ */
+export async function isContentEquivalentlyMergedInto(cwd, branch, target) {
+    if (!isSafeGitRefToken(branch) || !isSafeGitRefToken(target))
+        return false;
+    // Fast path: ref equality (normal merge).
+    const refMerged = await spawnGitAsync(cwd, ["merge-base", "--is-ancestor", branch, target]);
+    if (refMerged.ok)
+        return true;
+    // Collect commits in branch not reachable from target.
+    const srcList = await spawnGitAsync(cwd, ["rev-list", "--no-merges", `${branch}`, `^${target}`]);
+    if (!srcList.ok)
+        return false;
+    const srcShas = srcList.stdout
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+    if (srcShas.length === 0)
+        return true; // nothing to check
+    // Build patch-id set for target commits since merge-base.
+    const base = await spawnGitAsync(cwd, ["merge-base", branch, target]);
+    if (!base.ok)
+        return false;
+    const baseSha = base.stdout.trim();
+    const destList = await spawnGitAsync(cwd, ["rev-list", "--no-merges", `${baseSha}..${target}`]);
+    if (!destList.ok)
+        return false;
+    const destShas = destList.stdout
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+    const destPatchIds = new Set();
+    for (const sha of destShas) {
+        const patchId = commitPatchId(cwd, sha);
+        if (patchId)
+            destPatchIds.add(patchId);
+    }
+    // Every source commit must have its patch-id present in destination.
+    for (const sha of srcShas) {
+        const patchId = commitPatchId(cwd, sha);
+        if (!patchId || !destPatchIds.has(patchId))
+            return false;
+    }
+    return true;
+}
 /**
  * SHAs of commits in `exclude..include`, oldest-first (cherry-pick feed order).
  * Returns `null` on git failure.

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

@@ -1,5 +1,7 @@
 import { z } from "zod";
+import { assertRelativePathUnderTop, resolvePathForRepo } from "../repo-paths.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";
@@ -12,7 +14,7 @@ import { WorkspacePickSchema } from "./schemas.js";
  */
 async function runGitShow(opts) {
     const { top, ref, path } = opts;
-    // Build git show args. Start with --no-patch to get just the commit message.
+    // 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
@@ -119,7 +121,10 @@ 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()
@@ -130,6 +135,15 @@ export function registerGitShowTool(server) {
             if (!pre.ok)
                 return jsonRespond(pre.error);
             const top = pre.gitTop;
+            if (!isSafeGitAncestorRef(args.ref)) {
+                return jsonRespond({ error: "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: "path_escapes_repo", path: args.path });
+                }
+            }
             const result = await runGitShow({
                 top,
                 ref: args.ref,

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

@@ -24,11 +24,8 @@ export function registerGitStashListTool(server) {
                 return jsonRespond(pre.error);
             const { gitTop } = pre;
             // List all stashes: git stash list --format='%(refname:short)|%(subject)|%(objectname:short)'
-            const r = await spawnGitAsync(gitTop, [
-                "stash",
-                "list",
-                "--format=%(refname:short)|%(subject)|%(objectname:short)",
-            ]);
+            // git stash list uses git-log format (%s, %h) not for-each-ref format %(subject).
+            const r = await spawnGitAsync(gitTop, ["stash", "list", "--format=%gd|%s|%h"]);
             if (!r.ok) {
                 // If there are no stashes, git still returns ok=true with empty output
                 // Only treat as error if git itself failed
@@ -42,18 +39,22 @@ export function registerGitStashListTool(server) {
                 .split("\n")
                 .map((l) => l.trim())
                 .filter((l) => l.length > 0);
-            for (let i = 0; i < lines.length; i++) {
-                const line = lines[i];
-                if (line) {
-                    const parts = line.split("|");
-                    if (parts.length >= 3 && parts[1] && parts[2]) {
-                        stashes.push({
-                            index: i,
-                            message: parts[1],
-                            sha: parts[2],
-                        });
-                    }
+            for (const line of lines) {
+                const parts = line.split("|");
+                // parts[0] = stash@{N}, last part = short SHA, middle = message (may contain "|")
+                const sha = parts[parts.length - 1];
+                const message = parts.slice(1, -1).join("|");
+                // Parse the real stash index from the canonical stash@{N} ref in parts[0].
+                const indexMatch = parts[0] ? /stash@\{(\d+)\}/.exec(parts[0]) : null;
+                if (!indexMatch || parts.length < 3 || !message || !sha) {
+                    // Malformed line — skip without affecting index tracking.
+                    continue;
                 }
+                stashes.push({
+                    index: Number(indexMatch[1]),
+                    message,
+                    sha,
+                });
             }
             if (args.format === "json") {
                 return jsonRespond({ stashes });

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

@@ -72,11 +72,11 @@ export function registerGitTagTool(server) {
             const gitTop = pre.gitTop;
             const tag = args.tag.trim();
             if (!tag) {
-                return jsonRespond({ error: "tag_empty" });
+                return jsonRespond({ error: "empty_tag_name" });
             }
             // Validate tag name: no shell metacharacters
             if (!isSafeGitUpstreamToken(tag)) {
-                return jsonRespond({ error: "tag_unsafe", tag });
+                return jsonRespond({ error: "unsafe_tag_token", tag });
             }
             // Handle deletion
             if (args.delete === true) {
@@ -99,7 +99,7 @@ export function registerGitTagTool(server) {
             // Determine the ref to tag (default HEAD)
             const ref = (args.ref ?? "HEAD").trim();
             if (!isSafeGitUpstreamToken(ref)) {
-                return jsonRespond({ error: "ref_unsafe", ref });
+                return jsonRespond({ error: "unsafe_ref_token", ref });
             }
             // Get the SHA of the ref to tag
             const sha = await getRefSha(gitTop, ref);

package/dist/server/git.js

@@ -1,5 +1,5 @@
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, lstatSync, readFileSync } from "node:fs";
 import { cpus } from "node:os";
 import { join } from "node:path";
 /**
@@ -77,12 +77,40 @@ export function parseGitSubmodulePaths(gitRoot) {
     const f = join(gitRoot, ".gitmodules");
     if (!existsSync(f))
         return [];
-    const text = readFileSync(f, "utf8");
+    // Skip non-regular files (character devices, sockets, etc.) — common in
+    // Claude Code sandbox environments where stub device files shadow paths.
+    try {
+        if (!lstatSync(f).isFile())
+            return [];
+    }
+    catch {
+        return [];
+    }
+    let text;
+    try {
+        text = readFileSync(f, "utf8");
+    }
+    catch {
+        return [];
+    }
     const paths = [];
-    for (const line of text.split("\n")) {
-        const m = /^\s*path\s*=\s*(.+)\s*$/.exec(line);
+    let inSubmoduleSection = false;
+    for (const rawLine of text.split("\n")) {
+        // Strip inline and whole-line comments (; and #)
+        const commentIdx = rawLine.search(/\s*[;#]/);
+        const line = commentIdx >= 0 ? rawLine.slice(0, commentIdx) : rawLine;
+        // Track INI section header
+        const sectionMatch = /^\s*\[(.+)\]\s*$/.exec(line);
+        if (sectionMatch) {
+            inSubmoduleSection = /^submodule\s+"/.test(sectionMatch[1] ?? "");
+            continue;
+        }
+        // Only collect path = lines inside a [submodule "..."] section
+        if (!inSubmoduleSection)
+            continue;
+        const m = /^\s*path\s*=\s*(.+?)\s*$/.exec(line);
         if (m?.[1])
-            paths.push(m[1].trim());
+            paths.push(m[1]);
     }
     return paths;
 }

package/dist/server.js

@@ -2,9 +2,16 @@
 import { FastMCP } from "fastmcp";
 import { readMcpServerVersion } from "./server/json.js";
 import { registerRethunkGitTools } from "./server/tools.js";
+/**
+ * JSON payload contract version. Bump on incompatible JSON output changes
+ * (renamed/nested/omitted fields). Surfaced via the FastMCP `instructions`
+ * field below, so it is discoverable in the MCP `initialize` response.
+ */
+export const MCP_JSON_FORMAT_VERSION = "3";
 const server = new FastMCP({
     name: "rethunk-git",
     version: readMcpServerVersion(),
+    instructions: `rethunk-git MCP server. JSON payload contract: format version ${MCP_JSON_FORMAT_VERSION} (minified, no envelope; optional fields omitted when empty/null/false).`,
     roots: { enabled: true },
 });
 registerRethunkGitTools(server);