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

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

@@ -0,0 +1,132 @@
+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
+// ---------------------------------------------------------------------------
+/** Build the diff args array from parameters. */
+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)) {
+            return { ok: false, error: "unsafe_range_token" };
+        }
+        // Use two-dot range: base..head
+        args.push(`${baseStr}..${headStr}`);
+    }
+    // Scope to path if provided
+    if (opts.path?.trim()) {
+        args.push("--", opts.path.trim());
+    }
+    return { ok: true, args };
+}
+/** Human-readable label for the range. */
+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";
+        label = `${baseStr}..${headStr}`;
+    }
+    else {
+        label = "unstaged changes";
+    }
+    if (opts.path?.trim()) {
+        label += ` (${opts.path.trim()})`;
+    }
+    return label;
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGitDiffTool(server) {
+    server.addTool({
+        name: "git_diff",
+        description: "Get diff text for scoped file or range. Returns the raw diff output. " +
+            "Use `staged: true` for staged changes, `base`/`head` for revision ranges, " +
+            "and `path` to scope to a specific file.",
+        annotations: {
+            readOnlyHint: true,
+        },
+        parameters: WorkspacePickSchema.extend({
+            base: z
+                .string()
+                .optional()
+                .describe('Base ref (e.g. "main", "HEAD~3"). Required for range diffs. ' +
+                "If omitted and `staged: false`, shows unstaged changes."),
+            head: z
+                .string()
+                .optional()
+                .describe('Head ref (e.g. "feature-branch"). If omitted, defaults to HEAD. ' +
+                "Only used if `base` is provided."),
+            path: z
+                .string()
+                .optional()
+                .describe('Scope diff to a single file path (e.g. "src/main.ts").'),
+            staged: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("If true, show staged changes (git diff --staged). " + "Ignored if `base` is provided."),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const gitTop = pre.gitTop;
+            // Build git diff args
+            const diffArgsResult = buildDiffArgs({
+                base: args.base,
+                head: args.head,
+                path: args.path,
+                staged: args.staged,
+            });
+            if (!diffArgsResult.ok) {
+                return jsonRespond({ error: diffArgsResult.error });
+            }
+            // Run git diff
+            const result = await spawnGitAsync(gitTop, diffArgsResult.args);
+            if (!result.ok) {
+                return jsonRespond({
+                    error: "git_diff_failed",
+                    detail: (result.stderr || result.stdout).trim(),
+                });
+            }
+            const label = rangeLabel({
+                base: args.base,
+                head: args.head,
+                path: args.path,
+                staged: args.staged,
+            });
+            if (args.format === "json") {
+                return jsonRespond({
+                    range: label,
+                    diff: result.stdout,
+                });
+            }
+            // Markdown output
+            const lines = [];
+            lines.push(`# Diff: ${label}`, "");
+            if (result.stdout.trim()) {
+                lines.push("```diff", result.stdout.trimEnd(), "```");
+            }
+            else {
+                lines.push("_(no changes)_");
+            }
+            return lines.join("\n");
+        },
+    });
+}

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

@@ -0,0 +1,131 @@
+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
+// ---------------------------------------------------------------------------
+/**
+ * Parse `git fetch` output to extract updated and new refs.
+ * Lines containing "[new" indicate new refs (new branch, new tag, new ref).
+ * Lines with " -> " but not containing "[new" indicate updated refs.
+ */
+function parseGitFetchOutput(output) {
+    const lines = output.split("\n");
+    const updatedRefs = [];
+    const newRefs = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Lines containing "[new" indicate new refs (e.g. "[new branch]", "[new tag]", "[new ref]")
+        if (trimmed.includes("[new")) {
+            newRefs.push(trimmed);
+        }
+        // Lines with " -> " that don't contain "[new" indicate ref updates
+        else if (trimmed.includes(" -> ")) {
+            updatedRefs.push(trimmed);
+        }
+    }
+    return { updatedRefs, newRefs };
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGitFetchTool(server) {
+    server.addTool({
+        name: "git_fetch",
+        description: "Fetch updates from a remote repository without modifying the working tree. " +
+            "Returns structured output distinguishing updated refs from new refs.",
+        annotations: {
+            readOnlyHint: false, // Fetch modifies refs but not working tree; not strictly read-only but safe
+        },
+        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true, allWorkspaceRoots: true })
+            .pick({
+            workspaceRoot: true,
+            rootIndex: true,
+            format: true,
+        })
+            .extend({
+            remote: z
+                .string()
+                .optional()
+                .default("origin")
+                .describe("Remote to fetch from (default: origin)."),
+            branch: z
+                .string()
+                .optional()
+                .describe("If specified: fetch only this branch (e.g. 'main')."),
+            prune: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Pass --prune to remove deleted remote branches (default: false)."),
+            tags: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Pass --tags to also fetch all tags (default: false)."),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok) {
+                return jsonRespond(pre.error);
+            }
+            const gitTop = pre.gitTop;
+            const remote = (args.remote ?? "origin").trim();
+            const branch = args.branch?.trim();
+            const prune = args.prune === true;
+            const tags = args.tags === true;
+            // Build git fetch command
+            const fetchArgs = ["fetch"];
+            if (prune) {
+                fetchArgs.push("--prune");
+            }
+            if (tags) {
+                fetchArgs.push("--tags");
+            }
+            fetchArgs.push(remote);
+            if (branch) {
+                fetchArgs.push(branch);
+            }
+            const result = await spawnGitAsync(gitTop, fetchArgs);
+            const { updatedRefs, newRefs } = parseGitFetchOutput(result.stdout + result.stderr);
+            const fetchResult = {
+                ok: result.ok,
+                remote,
+                updatedRefs,
+                newRefs,
+                output: (result.stdout + result.stderr).trim(),
+            };
+            if (args.format === "json") {
+                return jsonRespond(fetchResult);
+            }
+            // Markdown output
+            const lines = [`# Git fetch from '${remote}'`];
+            if (!result.ok) {
+                lines.push("", "**Status**: Failed", "");
+                lines.push("```", result.stdout || result.stderr || "(no output)", "```");
+                return lines.join("\n");
+            }
+            lines.push("", "**Status**: Success", "");
+            if (updatedRefs.length > 0) {
+                lines.push("## Updated refs", "");
+                for (const ref of updatedRefs) {
+                    lines.push(`- ${ref}`);
+                }
+            }
+            if (newRefs.length > 0) {
+                lines.push("", "## New refs", "");
+                for (const ref of newRefs) {
+                    lines.push(`- ${ref}`);
+                }
+            }
+            if (updatedRefs.length === 0 && newRefs.length === 0 && result.stdout.trim()) {
+                lines.push("", "## Output", "", "```", result.stdout.trim(), "```");
+            }
+            return lines.join("\n");
+        },
+    });
+}

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\`\`\``;
+        },
+    });
+}