@rethunk/mcp-multi-root-git 2.3.4 → 2.5.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-log-tool.js

@@ -133,6 +133,22 @@ async function runGitLog(opts) {
 // ---------------------------------------------------------------------------
 // Markdown rendering
 // ---------------------------------------------------------------------------
+function renderLogOneline(group, multiRoot) {
+    const lines = [];
+    if (multiRoot) {
+        lines.push(`### ${group.repo} (${group.branch})`);
+    }
+    for (const c of group.commits) {
+        lines.push(`${c.sha.slice(0, 7)} ${c.subject}`);
+    }
+    if (group.commits.length === 0) {
+        lines.push("(no commits)");
+    }
+    if (group.truncated) {
+        lines.push(`(+${group.omittedCount} more)`);
+    }
+    return lines.join("\n");
+}
 function renderLogMarkdown(group, filterSummary) {
     const lines = [];
     lines.push(`### ${group.repo} (${group.branch})${filterSummary ? `  —  ${filterSummary}` : ""}`);
@@ -164,6 +180,13 @@ export function registerGitLogTool(server) {
             readOnlyHint: true,
         },
         parameters: WorkspacePickSchema.extend({
+            format: z
+                .enum(["markdown", "json", "oneline"])
+                .optional()
+                .default("markdown")
+                .describe("`markdown` (default): headed sections per root. " +
+                "`json`: structured groups array. " +
+                "`oneline`: `<sha7> <subject>` per line, no headers (single-root) or `### repo (branch)` separator per group (multi-root). Lowest-token option for post-commit verification."),
             since: z
                 .string()
                 .optional()
@@ -258,6 +281,20 @@ export function registerGitLogTool(server) {
                 });
                 return jsonRespond({ groups });
             }
+            // Oneline
+            if (args.format === "oneline") {
+                const multiRoot = results.length > 1;
+                const chunks = [];
+                for (const r of results) {
+                    if (r._error) {
+                        chunks.push(multiRoot ? `### ${r.workspaceRoot}\n(error: ${r.error})` : `(error: ${r.error})`);
+                        continue;
+                    }
+                    const { _error: _e, ...group } = r;
+                    chunks.push(renderLogOneline(group, multiRoot));
+                }
+                return chunks.join("\n\n");
+            }
             // Markdown
             const mdChunks = ["# Git log"];
             for (const r of results) {

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-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)
@@ -124,6 +125,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

@@ -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. 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 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);
+        },
+    });
+}