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

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

@@ -94,6 +94,8 @@ export function registerGitPushTool(server) {
                 "@{u}",
             ]);
             const upstream = upstreamProbe.ok ? upstreamProbe.stdout.trim() : `${remote}/${branch}`;
+            // Append git output (stdout/stderr) if non-empty
+            const gitOutput = (pushResult.stdout || pushResult.stderr).trim();
             if (args.format === "json") {
                 return jsonRespond({
                     ok: true,
@@ -101,9 +103,14 @@ export function registerGitPushTool(server) {
                     remote,
                     upstream,
                     ...spreadDefined("setUpstream", args.setUpstream || undefined),
+                    ...spreadDefined("output", gitOutput || undefined),
                 });
             }
-            return `# Push\n✓ ${branch} → ${upstream}`;
+            let result = `# Push\n✓ ${branch} → ${upstream}`;
+            if (gitOutput) {
+                result += `\n\n${gitOutput}`;
+            }
+            return result;
         },
     });
 }

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

@@ -0,0 +1,148 @@
+import { z } from "zod";
+import { spawnGitAsync } from "./git.js";
+import { jsonRespond } from "./json.js";
+import { requireSingleRepo } from "./roots.js";
+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).
+ */
+async function runGitShow(opts) {
+    const { top, ref, path } = opts;
+    // Build git show args. Start with --no-patch to get just the commit message.
+    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 r = await spawnGitAsync(top, showArgs);
+    if (!r.ok) {
+        return {
+            error: "git_show_failed",
+        };
+    }
+    // Parse the output. For a commit, git show outputs:
+    // - Header (commit, Author, Date, etc.)
+    // - 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
+    const output = r.stdout;
+    let message = "";
+    let diff = "";
+    const lines = output.split("\n");
+    let inHeader = true;
+    let inMessage = false;
+    const messageLines = [];
+    const contentLines = [];
+    for (const line of lines) {
+        if (line === undefined)
+            continue;
+        // End header when we see a blank line
+        if (inHeader && line.trim() === "") {
+            inHeader = false;
+            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")) {
+                inMessage = false;
+                contentLines.push(line);
+            }
+            else {
+                messageLines.push(line);
+            }
+        }
+        else if (!inHeader) {
+            // In diff/content section
+            contentLines.push(line);
+        }
+    }
+    message = messageLines.join("\n").trim();
+    diff = contentLines.join("\n").trim();
+    const result = {
+        ref,
+        message,
+    };
+    if (path) {
+        result.path = path;
+    }
+    if (diff) {
+        result.diff = diff;
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Markdown rendering
+// ---------------------------------------------------------------------------
+function renderShowMarkdown(result) {
+    const lines = [];
+    lines.push(`# git show ${result.ref}`);
+    if (result.path) {
+        lines.push(`_path: ${result.path}_`);
+    }
+    lines.push("");
+    lines.push("## Commit message");
+    lines.push("");
+    lines.push("```");
+    lines.push(result.message);
+    lines.push("```");
+    if (result.diff) {
+        lines.push("");
+        lines.push("## Diff");
+        lines.push("");
+        lines.push("```diff");
+        lines.push(result.diff);
+        lines.push("```");
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+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).",
+        annotations: {
+            readOnlyHint: true,
+        },
+        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true, allWorkspaceRoots: true })
+            .pick({
+            workspaceRoot: true,
+            rootIndex: true,
+            format: true,
+        })
+            .extend({
+            ref: z.string().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."),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const top = pre.gitTop;
+            const result = await runGitShow({
+                top,
+                ref: args.ref,
+                path: args.path,
+            });
+            if ("error" in result) {
+                return jsonRespond(result);
+            }
+            if (args.format === "json") {
+                return jsonRespond(result);
+            }
+            // Markdown
+            return renderShowMarkdown(result);
+        },
+    });
+}

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

@@ -0,0 +1,131 @@
+import { z } from "zod";
+import { spawnGitAsync } from "./git.js";
+import { jsonRespond, spreadDefined } from "./json.js";
+import { requireSingleRepo } from "./roots.js";
+import { WorkspacePickSchema } from "./schemas.js";
+// ---------------------------------------------------------------------------
+// git_stash_list
+// ---------------------------------------------------------------------------
+export function registerGitStashListTool(server) {
+    server.addTool({
+        name: "git_stash_list",
+        description: "List all git stashes. Returns array of `{ index: number, message: string, sha: string }`.",
+        annotations: {
+            readOnlyHint: true,
+        },
+        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true, allWorkspaceRoots: true }).pick({
+            workspaceRoot: true,
+            rootIndex: true,
+            format: true,
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                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)",
+            ]);
+            if (!r.ok) {
+                // If there are no stashes, git still returns ok=true with empty output
+                // Only treat as error if git itself failed
+                return jsonRespond({
+                    error: "stash_list_failed",
+                    detail: (r.stderr || r.stdout).trim(),
+                });
+            }
+            const stashes = [];
+            const lines = (r.stdout || "")
+                .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],
+                        });
+                    }
+                }
+            }
+            if (args.format === "json") {
+                return jsonRespond({ stashes });
+            }
+            if (stashes.length === 0) {
+                return "# Stashes\n_(none)_";
+            }
+            const lines_out = ["# Stashes", ""];
+            for (const s of stashes) {
+                lines_out.push(`- **stash@{${s.index}}** — ${s.message}  (\`${s.sha}\`)`);
+            }
+            return lines_out.join("\n");
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// git_stash_apply
+// ---------------------------------------------------------------------------
+export function registerGitStashApplyTool(server) {
+    server.addTool({
+        name: "git_stash_apply",
+        description: "Apply or pop a git stash. `index` defaults to 0 (stash@{0}). " +
+            "Set `pop: true` to run `git stash pop` instead of `git stash apply` (removes stash after applying). " +
+            "Returns `{ applied: boolean, stashIndex: number, popped: boolean, output: string }`.",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+        },
+        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true, allWorkspaceRoots: true })
+            .pick({
+            workspaceRoot: true,
+            rootIndex: true,
+            format: true,
+        })
+            .extend({
+            index: z
+                .number()
+                .int()
+                .min(0)
+                .optional()
+                .default(0)
+                .describe("Stash index (defaults to 0 for stash@{0})."),
+            pop: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("If true, runs `git stash pop` instead of `git stash apply` (removes stash after applying)."),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const { gitTop } = pre;
+            const stashRef = `stash@{${args.index}}`;
+            const cmd = args.pop ? "pop" : "apply";
+            const r = await spawnGitAsync(gitTop, ["stash", cmd, stashRef]);
+            const applied = r.ok;
+            const output = (r.stdout || r.stderr).trim();
+            if (args.format === "json") {
+                return jsonRespond({
+                    applied,
+                    stashIndex: args.index,
+                    popped: args.pop,
+                    ...spreadDefined("output", output),
+                });
+            }
+            const verb = args.pop ? "popped" : "applied";
+            if (applied) {
+                return `# Stash ${verb}\n✓ ${stashRef}  → ${verb}`;
+            }
+            return `# Stash ${verb} (failed)\n✗ ${stashRef}\n\n\`\`\`\n${output}\n\`\`\``;
+        },
+    });
+}

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

@@ -0,0 +1,162 @@
+import { z } from "zod";
+import { isSafeGitUpstreamToken, spawnGitAsync } from "./git.js";
+import { jsonRespond } from "./json.js";
+import { requireSingleRepo } from "./roots.js";
+import { WorkspacePickSchema } from "./schemas.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Get the SHA of a given ref (tag, commit, branch, etc).
+ */
+async function getRefSha(gitTop, ref) {
+    const result = await spawnGitAsync(gitTop, ["rev-parse", ref]);
+    if (!result.ok)
+        return null;
+    return result.stdout.trim();
+}
+/**
+ * Check if a tag is annotated or lightweight.
+ */
+async function getTagType(gitTop, tag) {
+    // For annotated tags, `git cat-file -t <tag>` returns "tag"
+    // For lightweight tags, it returns "commit"
+    const result = await spawnGitAsync(gitTop, ["cat-file", "-t", tag]);
+    if (!result.ok)
+        return null;
+    const type = result.stdout.trim();
+    if (type === "tag")
+        return "annotated";
+    if (type === "commit")
+        return "lightweight";
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGitTagTool(server) {
+    server.addTool({
+        name: "git_tag",
+        description: "Create, delete, or inspect git tags. Create annotated tags (with message) or lightweight tags (ref only). " +
+            "Returns tag name, type, and SHA.",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+        },
+        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true, allWorkspaceRoots: true })
+            .pick({
+            workspaceRoot: true,
+            rootIndex: true,
+            format: true,
+        })
+            .extend({
+            tag: z.string().min(1).describe("Tag name (e.g. 'v1.2.3')."),
+            message: z
+                .string()
+                .optional()
+                .describe("If provided, create an annotated tag with this message. If absent, create a lightweight tag."),
+            ref: z
+                .string()
+                .optional()
+                .describe("Commit/ref to tag (default: HEAD). Ignored if `delete` is true."),
+            delete: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("If true, delete the named tag instead of creating it."),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const gitTop = pre.gitTop;
+            const tag = args.tag.trim();
+            if (!tag) {
+                return jsonRespond({ error: "tag_empty" });
+            }
+            // Validate tag name: no shell metacharacters
+            if (!isSafeGitUpstreamToken(tag)) {
+                return jsonRespond({ error: "tag_unsafe", tag });
+            }
+            // Handle deletion
+            if (args.delete === true) {
+                const delResult = await spawnGitAsync(gitTop, ["tag", "-d", tag]);
+                if (!delResult.ok) {
+                    return jsonRespond({
+                        error: "tag_delete_failed",
+                        detail: (delResult.stderr || delResult.stdout).trim(),
+                    });
+                }
+                if (args.format === "json") {
+                    return jsonRespond({
+                        tag,
+                        type: "deleted",
+                        sha: "", // Deleted tags have no SHA
+                    });
+                }
+                return `Deleted tag: ${tag}`;
+            }
+            // Determine the ref to tag (default HEAD)
+            const ref = (args.ref ?? "HEAD").trim();
+            if (!isSafeGitUpstreamToken(ref)) {
+                return jsonRespond({ error: "ref_unsafe", ref });
+            }
+            // Get the SHA of the ref to tag
+            const sha = await getRefSha(gitTop, ref);
+            if (!sha) {
+                return jsonRespond({
+                    error: "ref_not_found",
+                    ref,
+                });
+            }
+            // Create tag (annotated or lightweight)
+            const tagArgs = ["tag"];
+            if (args.message) {
+                // Annotated tag
+                tagArgs.push("-a", "-m", args.message);
+            }
+            else {
+                // Lightweight tag (just the tag name and ref)
+            }
+            tagArgs.push(tag, ref);
+            const createResult = await spawnGitAsync(gitTop, tagArgs);
+            if (!createResult.ok) {
+                return jsonRespond({
+                    error: "tag_create_failed",
+                    detail: (createResult.stderr || createResult.stdout).trim(),
+                });
+            }
+            // Verify the tag was created and get its type
+            const tagType = await getTagType(gitTop, tag);
+            if (!tagType) {
+                return jsonRespond({
+                    error: "tag_verification_failed",
+                    tag,
+                });
+            }
+            const result = {
+                tag,
+                type: tagType,
+                sha,
+            };
+            if (args.format === "json") {
+                return jsonRespond(result);
+            }
+            // Markdown output
+            const lines = [];
+            lines.push(`# Tag: ${tag}`);
+            lines.push("");
+            lines.push(`**Type:** ${tagType}`);
+            lines.push(`**SHA:** \`${sha}\``);
+            if (args.message) {
+                lines.push("");
+                lines.push("**Message:**");
+                lines.push("");
+                lines.push("```");
+                lines.push(args.message);
+                lines.push("```");
+            }
+            return lines.join("\n");
+        },
+    });
+}

package/dist/server/git.js

@@ -1,8 +1,24 @@
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
+import { cpus } from "node:os";
 import { join } from "node:path";
-/** Parallel git subprocesses for inventory rows and git_status submodule rows. */
-export const GIT_SUBPROCESS_PARALLELISM = 4;
+/**
+ * Parallel git subprocesses for inventory rows and git_status submodule rows.
+ * Reads from GIT_SUBPROCESS_PARALLELISM env var (default 4), clamped to [1, 2×CPU_COUNT].
+ */
+function resolveGitSubprocessParallelism() {
+    const env = process.env.GIT_SUBPROCESS_PARALLELISM;
+    if (env) {
+        const n = Number.parseInt(env, 10);
+        if (!Number.isNaN(n) && n >= 1) {
+            const cpuCount = cpus().length;
+            const maxParallel = cpuCount * 2;
+            return Math.min(n, maxParallel);
+        }
+    }
+    return 4;
+}
+export const GIT_SUBPROCESS_PARALLELISM = resolveGitSubprocessParallelism();
 let gitPathState = "unknown";
 const GIT_NOT_FOUND_BODY = {
     error: "git_not_found",

package/dist/server/roots.js

@@ -15,12 +15,16 @@ function uriToPath(uri) {
 }
 function listFileRoots(server) {
     const sessions = server.sessions;
-    const roots = sessions[0]?.roots ?? [];
     const paths = [];
-    for (const root of roots) {
-        const p = uriToPath(root.uri);
-        if (p)
+    const seen = new Set();
+    for (const session of sessions) {
+        for (const root of session.roots ?? []) {
+            const p = uriToPath(root.uri);
+            if (!p || seen.has(p))
+                continue;
+            seen.add(p);
             paths.push(p);
+        }
     }
     return paths;
 }

package/dist/server/test-harness.js

@@ -16,7 +16,8 @@
  *   const result = await tool({ workspaceRoot: dir, commits: [...] });
  *   // result is string (markdown) or JSON-parseable string
  */
-import { mkdtempSync, rmSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { appendFileSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 // Stub context — no tool currently uses context
@@ -54,15 +55,25 @@ export function cleanupTmpPaths() {
             rmSync(p, { recursive: true, force: true });
     }
 }
+export function writeTestGitConfig(repo) {
+    appendFileSync(join(repo, ".git", "config"), "\n[user]\n\temail = test@example.com\n\tname = Test User\n[commit]\n\tgpgsign = false\n");
+}
 // ---------------------------------------------------------------------------
 // Fake server
 // ---------------------------------------------------------------------------
-function makeFakeServer() {
+function makeFakeServer(roots = []) {
     const tools = [];
     const server = {
-        sessions: [],
+        sessions: [
+            {
+                roots: roots.map((uri) => ({ uri })),
+            },
+        ],
         addTool(tool) {
-            tools.push({ name: tool.name, execute: tool.execute });
+            tools.push({ name: tool.name, parameters: tool.parameters, execute: tool.execute });
+        },
+        addResource() {
+            // Resource tests do not need transport behavior; tool-surface tests only need registration to complete.
         },
     };
     return { server, tools };
@@ -75,8 +86,8 @@ function makeFakeServer() {
  * The returned function accepts tool args (always include `workspaceRoot`)
  * and returns the raw result as a string.
  */
-export function captureTool(register, toolName) {
-    const { server, tools } = makeFakeServer();
+export function captureTool(register, toolName, roots = []) {
+    const { server, tools } = makeFakeServer(roots);
     register(server);
     const pick = toolName ? tools.find((t) => t.name === toolName) : tools[0];
     if (!pick) {
@@ -89,3 +100,63 @@ export function captureTool(register, toolName) {
         return JSON.stringify(result);
     };
 }
+export function captureToolDefinitions(register) {
+    const { server, tools } = makeFakeServer();
+    register(server);
+    return tools;
+}
+// ---------------------------------------------------------------------------
+// Shared git test helpers (extracted from per-file duplication)
+// ---------------------------------------------------------------------------
+/** Execute git command with standard test environment and encoding. */
+export function gitCmd(cwd, ...args) {
+    const opts = {
+        cwd,
+        encoding: "utf8",
+        env: {
+            ...process.env,
+            GIT_AUTHOR_NAME: "Test User",
+            GIT_AUTHOR_EMAIL: "test@example.com",
+            GIT_COMMITTER_NAME: "Test User",
+            GIT_COMMITTER_EMAIL: "test@example.com",
+            GIT_AUTHOR_DATE: "2025-01-01T00:00:00Z",
+            GIT_COMMITTER_DATE: "2025-01-01T00:00:00Z",
+        },
+    };
+    return execFileSync("git", args, opts);
+}
+/** Initialize a basic git repo with test config. */
+export function makeRepo(prefix = "mcp-test-repo-") {
+    const dir = mkTmpDir(prefix);
+    gitCmd(dir, "init", "-b", "main");
+    writeTestGitConfig(dir);
+    return dir;
+}
+/** Initialize a repo with a seed commit (useful for branch/cherry-pick tests). */
+export function makeRepoWithSeed(prefix = "mcp-test-repo-") {
+    const dir = makeRepo(prefix);
+    writeFileSync(join(dir, "seed.txt"), "seed\n");
+    gitCmd(dir, "add", "seed.txt");
+    gitCmd(dir, "commit", "-m", "chore: seed");
+    return dir;
+}
+/** Initialize work repo + bare remote with tracking set up. */
+export function makeRepoWithUpstream(workPrefix = "mcp-work-", remotePrefix = "mcp-remote-") {
+    const remote = mkTmpDir(remotePrefix);
+    gitCmd(remote, "init", "--bare", "-b", "main");
+    const work = makeRepoWithSeed(workPrefix);
+    gitCmd(work, "remote", "add", "origin", remote);
+    gitCmd(work, "push", "-u", "origin", "main");
+    return { work, remote };
+}
+/** Initialize a git repo with main branch and test config. */
+export function gitInitMain(dir) {
+    gitCmd(dir, "init", "-b", "main");
+    writeTestGitConfig(dir);
+}
+/** Add a commit to a repo with specified file content. */
+export function addCommit(dir, file, content, message) {
+    writeFileSync(join(dir, file), content);
+    gitCmd(dir, "add", file);
+    gitCmd(dir, "commit", "-m", message);
+}