@rethunk/mcp-multi-root-git 1.0.0 → 2.1.0

package/dist/server/inventory.js

@@ -6,48 +6,52 @@ export function validateRepoPath(rel, gitTop) {
     return { abs, underTop: assertRelativePathUnderTop(rel, abs, gitTop) };
 }
 export function makeSkipEntry(label, abs, upstreamMode, skipReason) {
-    return {
-        label,
-        path: abs,
-        branchStatus: "",
-        shortStatus: "",
-        detached: false,
-        headAbbrev: "",
-        upstreamMode,
-        upstreamRef: null,
-        ahead: null,
-        behind: null,
-        upstreamNote: "",
-        skipReason,
-    };
+    return { label, path: abs, upstreamMode, skipReason };
 }
 export function buildInventorySectionMarkdown(e) {
+    const header = `## ${e.label} — ${e.path}`;
     if (e.skipReason) {
-        return [`## ${e.label}`, `path: ${e.path}`, "```text", e.skipReason, "```", ``];
-    }
-    const lines = [];
-    lines.push(e.branchStatus);
-    lines.push("");
-    lines.push("short:");
-    lines.push(e.shortStatus || "(clean)");
-    lines.push("");
-    if (e.detached) {
-        lines.push("branch: (detached HEAD)");
-        lines.push("");
+        return ["", header, e.skipReason];
     }
-    if (e.ahead != null && e.behind != null && e.upstreamRef) {
-        lines.push(`ahead_of_${e.upstreamRef.replace(/\//g, "_")}: ${e.ahead}`);
-        lines.push(`behind_${e.upstreamRef.replace(/\//g, "_")}: ${e.behind}`);
+    const lines = [e.branchStatus || "(clean)"];
+    if (e.detached)
+        lines.push("detached HEAD");
+    if (e.ahead !== undefined && e.behind !== undefined && e.upstreamRef) {
+        lines.push(`${e.upstreamRef}: ahead ${e.ahead}, behind ${e.behind}`);
     }
-    else {
+    else if (e.upstreamNote) {
         lines.push(`upstream: ${e.upstreamNote}`);
     }
-    return [`## ${e.label}`, `path: ${e.path}`, "```text", lines.join("\n"), "```", ``];
+    const single = lines.length === 1 ? lines[0] : undefined;
+    if (single !== undefined && !single.includes("\n")) {
+        return ["", header, single];
+    }
+    return ["", header, "```text", lines.join("\n"), "```"];
 }
-function upstreamNoteFor(ref, ahead, behind) {
-    return ahead != null && behind != null
-        ? `tracking ${ref}`
-        : `upstream ${ref} (counts unreadable)`;
+function upstreamNoteFor(ref, hasCounts) {
+    return hasCounts ? `tracking ${ref}` : `upstream ${ref} (counts unreadable)`;
+}
+function buildEntry(params) {
+    const out = {
+        label: params.label,
+        path: params.absPath,
+        upstreamMode: params.upstreamMode,
+    };
+    if (params.branchStatus)
+        out.branchStatus = params.branchStatus;
+    if (params.detached)
+        out.detached = true;
+    if (params.headAbbrev)
+        out.headAbbrev = params.headAbbrev;
+    if (params.upstreamRef !== null)
+        out.upstreamRef = params.upstreamRef;
+    if (params.ahead !== null)
+        out.ahead = params.ahead;
+    if (params.behind !== null)
+        out.behind = params.behind;
+    if (params.upstreamNote)
+        out.upstreamNote = params.upstreamNote;
+    return out;
 }
 export async function collectInventoryEntry(label, absPath, fixedRemote, fixedBranch) {
     const [snap, headR] = await Promise.all([
@@ -55,79 +59,52 @@ export async function collectInventoryEntry(label, absPath, fixedRemote, fixedBr
         spawnGitAsync(absPath, ["rev-parse", "--abbrev-ref", "HEAD"]),
     ]);
     const branchStatus = snap.branchLine;
-    const shortStatus = snap.shortLine;
     const headAbbrev = headR.ok ? headR.stdout.trim() : "";
     const detached = !headR.ok || headAbbrev === "HEAD" || headAbbrev.endsWith("/HEAD");
-    const useFixed = fixedRemote !== undefined && fixedBranch !== undefined;
-    if (useFixed) {
-        const remote = fixedRemote;
-        const branch = fixedBranch;
-        const verify = await spawnGitAsync(absPath, ["rev-parse", "--verify", `${remote}/${branch}`]);
+    const base = { label, absPath, branchStatus, detached, headAbbrev };
+    if (fixedRemote !== undefined && fixedBranch !== undefined) {
+        const ref = `${fixedRemote}/${fixedBranch}`;
+        const verify = await spawnGitAsync(absPath, ["rev-parse", "--verify", ref]);
         if (!verify.ok) {
-            return {
-                label,
-                path: absPath,
-                branchStatus,
-                shortStatus,
-                detached,
-                headAbbrev: headAbbrev || "(unknown)",
+            return buildEntry({
+                ...base,
                 upstreamMode: "fixed",
-                upstreamRef: `${remote}/${branch}`,
+                upstreamRef: ref,
                 ahead: null,
                 behind: null,
-                upstreamNote: `(no local ref ${remote}/${branch} or unreadable)`,
-            };
+                upstreamNote: `(no local ref ${ref} or unreadable)`,
+            });
         }
-        const ref = `${remote}/${branch}`;
         const { ahead, behind } = await fetchAheadBehind(absPath, ref);
-        return {
-            label,
-            path: absPath,
-            branchStatus,
-            shortStatus,
-            detached,
-            headAbbrev: headAbbrev || "(unknown)",
+        return buildEntry({
+            ...base,
             upstreamMode: "fixed",
             upstreamRef: ref,
             ahead,
             behind,
-            upstreamNote: upstreamNoteFor(ref, ahead, behind),
-        };
+            upstreamNote: upstreamNoteFor(ref, ahead != null && behind != null),
+        });
     }
     const upVerify = await spawnGitAsync(absPath, ["rev-parse", "--verify", "@{u}"]);
     if (!upVerify.ok) {
-        let note = "no upstream configured";
-        if (detached) {
-            note = "detached HEAD — no upstream";
-        }
-        return {
-            label,
-            path: absPath,
-            branchStatus,
-            shortStatus,
-            detached,
-            headAbbrev: headAbbrev || "(unknown)",
+        return buildEntry({
+            ...base,
             upstreamMode: "auto",
             upstreamRef: null,
             ahead: null,
             behind: null,
-            upstreamNote: note,
-        };
+            upstreamNote: detached ? "detached HEAD — no upstream" : "no upstream configured",
+        });
     }
     const abbrevR = await spawnGitAsync(absPath, ["rev-parse", "--abbrev-ref", "@{u}"]);
     const upstreamRef = abbrevR.ok ? abbrevR.stdout.trim() : "@{u}";
     const { ahead, behind } = await fetchAheadBehind(absPath, "@{u}");
-    return {
-        label,
-        path: absPath,
-        branchStatus,
-        shortStatus,
-        detached,
-        headAbbrev: headAbbrev || "(unknown)",
+    return buildEntry({
+        ...base,
         upstreamMode: "auto",
         upstreamRef,
         ahead,
         behind,
-        upstreamNote: upstreamNoteFor(upstreamRef, ahead, behind),
-    };
+        upstreamNote: upstreamNoteFor(upstreamRef, ahead != null && behind != null),
+    });
 }

package/dist/server/json.js

@@ -1,8 +1,7 @@
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-export const MCP_JSON_FORMAT_VERSION = "1";
-export function readPackageVersion() {
+function readPackageVersion() {
     const here = dirname(fileURLToPath(import.meta.url));
     const pkgPath = join(here, "..", "..", "package.json");
     try {
@@ -23,13 +22,7 @@ export function readMcpServerVersion() {
     return "0.0.0";
 }
 export function jsonRespond(body) {
-    return JSON.stringify({
-        ...body,
-        rethunkGitMcp: {
-            jsonFormatVersion: MCP_JSON_FORMAT_VERSION,
-            packageVersion: readPackageVersion(),
-        },
-    }, null, 2);
+    return JSON.stringify(body);
 }
 /** Spread into an object literal only when `cond` is true; otherwise `{}`. */
 export function spreadWhen(cond, fields) {

package/dist/server/list-presets-tool.js

@@ -7,7 +7,7 @@ import { WorkspacePickSchema } from "./schemas.js";
 export function registerListPresetsTool(server) {
     server.addTool({
         name: "list_presets",
-        description: "List named entries from `.rethunk/git-mcp-presets.json` at the git toplevel for the resolved workspace root.",
+        description: "List presets from .rethunk/git-mcp-presets.json. See docs/mcp-tools.md.",
         parameters: WorkspacePickSchema.pick({
             workspaceRoot: true,
             rootIndex: true,

package/dist/server/presets.js

@@ -24,7 +24,7 @@ export const PRESET_FILE_PATH = ".rethunk/git-mcp-presets.json";
  * - Wrapped: `{ "schemaVersion": "1", "presets": { "name": { ... } } }`
  * - Legacy: `{ "name": { ... }, ... }` with optional top-level `schemaVersion` / `$schema` (editor hints).
  */
-export function splitPresetFileRaw(raw) {
+function splitPresetFileRaw(raw) {
     if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
         throw new Error("invalid_root");
     }
@@ -96,24 +96,25 @@ export function presetLoadErrorPayload(gitTop, fail) {
     }
     return { error: "preset_file_invalid", presetFile };
 }
-export function getPresetEntry(gitTop, presetName) {
+function getPresetEntry(gitTop, presetName) {
     const loaded = loadPresetsFromGitTop(gitTop);
     if (!loaded.ok) {
         if (loaded.reason === "missing") {
             return {
+                ok: false,
                 error: {
                     error: "preset_not_found",
                     preset: presetName,
                     presetFile: join(gitTop, PRESET_FILE_PATH),
-                    message: "Preset file missing",
                 },
             };
         }
-        return { error: presetLoadErrorPayload(gitTop, loaded) };
+        return { ok: false, error: presetLoadErrorPayload(gitTop, loaded) };
     }
     const entry = loaded.data[presetName];
     if (!entry) {
         return {
+            ok: false,
             error: {
                 error: "preset_not_found",
                 preset: presetName,
@@ -121,9 +122,9 @@ export function getPresetEntry(gitTop, presetName) {
             },
         };
     }
-    return { entry, presetSchemaVersion: loaded.schemaVersion };
+    return { ok: true, entry, presetSchemaVersion: loaded.schemaVersion };
 }
-export function mergeNestedRoots(preset, inline) {
+function mergeNestedRoots(preset, inline) {
     const a = preset ?? [];
     const b = inline ?? [];
     if (a.length === 0 && b.length === 0)
@@ -138,7 +139,7 @@ export function mergeNestedRoots(preset, inline) {
     }
     return out;
 }
-export function mergePairs(preset, inline) {
+function mergePairs(preset, inline) {
     const a = preset ?? [];
     const b = inline ?? [];
     if (a.length === 0 && b.length === 0)
@@ -147,7 +148,7 @@ export function mergePairs(preset, inline) {
 }
 export function applyPresetNestedRoots(gitTop, presetName, presetMerge, inlineNestedRoots) {
     const got = getPresetEntry(gitTop, presetName);
-    if ("error" in got)
+    if (!got.ok)
         return { ok: false, error: got.error };
     const fromPreset = got.entry.nestedRoots;
     let nestedRoots = inlineNestedRoots;
@@ -161,7 +162,7 @@ export function applyPresetNestedRoots(gitTop, presetName, presetMerge, inlineNe
 }
 export function applyPresetParityPairs(gitTop, presetName, presetMerge, inlinePairs) {
     const got = getPresetEntry(gitTop, presetName);
-    if ("error" in got)
+    if (!got.ok)
         return { ok: false, error: got.error };
     const fromPreset = got.entry.parityPairs;
     let pairs = inlinePairs;

package/dist/server/roots.js

@@ -1,8 +1,8 @@
-import { basename, isAbsolute, resolve } from "node:path";
+import { basename, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gateGit, gitTopLevel } from "./git.js";
 import { loadPresetsFromGitTop, presetLoadErrorPayload } from "./presets.js";
-export function uriToPath(uri) {
+function uriToPath(uri) {
     if (!uri.startsWith("file://"))
         return null;
     try {
@@ -12,7 +12,7 @@ export function uriToPath(uri) {
         return null;
     }
 }
-export function listFileRoots(server) {
+function listFileRoots(server) {
     const sessions = server.sessions;
     const roots = sessions[0]?.roots ?? [];
     const paths = [];
@@ -24,40 +24,29 @@ export function listFileRoots(server) {
     return paths;
 }
 /** Basename or trailing path segment; compares using normalized slashes so Windows backslashes match. */
-export function pathMatchesWorkspaceRootHint(rootPath, hint) {
+function pathMatchesWorkspaceRootHint(rootPath, hint) {
     const h = hint.trim();
     if (!h)
         return true;
-    if (basename(rootPath) === h)
-        return true;
     const absRoot = resolve(rootPath);
-    if (absRoot === h)
-        return true;
-    try {
-        if (isAbsolute(h) && resolve(h) === absRoot)
-            return true;
-    }
-    catch {
-        /* invalid absolute hint */
-    }
     const normRoot = absRoot.replace(/\\/g, "/").replace(/\/+$/, "");
     const normHint = h.replace(/\\/g, "/").replace(/\/+$/, "").replace(/^\/+/, "");
     if (!normHint)
         return true;
     if (normRoot === normHint)
         return true;
-    return normRoot.endsWith(`/${normHint}`);
+    if (normRoot.endsWith(`/${normHint}`))
+        return true;
+    return basename(rootPath) === h;
 }
-export function resolveWorkspaceRoots(server, args) {
+function resolveWorkspaceRoots(server, args) {
     if (args.workspaceRoot?.trim()) {
         return { ok: true, roots: [resolve(args.workspaceRoot.trim())] };
     }
     const fileRoots = listFileRoots(server);
+    const fallback = { ok: true, roots: [process.cwd()] };
     if (args.allWorkspaceRoots) {
-        if (fileRoots.length === 0) {
-            return { ok: true, roots: [process.cwd()] };
-        }
-        return { ok: true, roots: fileRoots };
+        return fileRoots.length === 0 ? fallback : { ok: true, roots: fileRoots };
     }
     if (args.rootIndex != null) {
         const r = fileRoots[args.rootIndex];
@@ -74,16 +63,13 @@ export function resolveWorkspaceRoots(server, args) {
         return { ok: true, roots: [r] };
     }
     const primary = fileRoots[0];
-    if (primary !== undefined) {
-        return { ok: true, roots: [primary] };
-    }
-    return { ok: true, roots: [process.cwd()] };
+    return primary !== undefined ? { ok: true, roots: [primary] } : fallback;
 }
 /**
  * When a preset name is requested and multiple MCP roots exist, pick the first root
  * whose git toplevel loads a preset file containing that name.
  */
-export function resolveRootsForPreset(server, args, presetName) {
+function resolveRootsForPreset(server, args, presetName) {
     if (args.workspaceRoot?.trim() || args.allWorkspaceRoots || args.rootIndex != null) {
         return resolveWorkspaceRoots(server, args);
     }

package/dist/server/schemas.js

@@ -2,21 +2,9 @@ import { z } from "zod";
 import { MAX_INVENTORY_ROOTS_DEFAULT } from "./inventory.js";
 const FormatSchema = z.enum(["markdown", "json"]).optional().default("markdown");
 export const WorkspacePickSchema = z.object({
-    workspaceRoot: z
-        .string()
-        .optional()
-        .describe("Override workspace path. Wins over MCP roots, rootIndex, and allWorkspaceRoots."),
-    rootIndex: z
-        .number()
-        .int()
-        .min(0)
-        .optional()
-        .describe("Use the Nth file:// MCP root (0-based) when multiple workspace roots exist."),
-    allWorkspaceRoots: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Run against every file:// MCP root and aggregate results."),
-    format: FormatSchema.describe('Return "markdown" (default) or structured "json".'),
+    workspaceRoot: z.string().optional().describe("Highest-priority override."),
+    rootIndex: z.number().int().min(0).optional(),
+    allWorkspaceRoots: z.boolean().optional().default(false),
+    format: FormatSchema,
 });
 export { MAX_INVENTORY_ROOTS_DEFAULT };

package/dist/server/test-harness.js

@@ -0,0 +1,64 @@
+/**
+ * Lightweight test harness for MCP tool execute handlers.
+ *
+ * FastMCP does not expose a way to inject a custom transport, so the full
+ * MCP client/server stack cannot be wired up in tests without stdio or HTTP.
+ * Instead, we use a duck-typed fake server that satisfies the FastMCP interface
+ * just enough for tool registration: it has `sessions` (empty — tools use
+ * `workspaceRoot` arg which bypasses session root detection) and `addTool`
+ * which captures the tool definition so we can call `execute` directly.
+ *
+ * Context passed to execute is a no-op stub — none of the current tools
+ * use the context object (logging, progress, etc.).
+ *
+ * Usage:
+ *   const tool = captureTool(registerBatchCommitTool);
+ *   const result = await tool({ workspaceRoot: dir, commits: [...] });
+ *   // result is string (markdown) or JSON-parseable string
+ */
+// Stub context — no tool currently uses context
+const STUB_CONTEXT = {
+    log: {
+        debug: () => undefined,
+        error: () => undefined,
+        info: () => undefined,
+        warn: () => undefined,
+    },
+    reportProgress: async () => undefined,
+    session: undefined,
+};
+// ---------------------------------------------------------------------------
+// Fake server
+// ---------------------------------------------------------------------------
+function makeFakeServer() {
+    const tools = [];
+    const server = {
+        sessions: [],
+        addTool(tool) {
+            tools.push({ name: tool.name, execute: tool.execute });
+        },
+    };
+    return { server, tools };
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Register one tool and return a caller that invokes its execute handler.
+ * 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();
+    register(server);
+    const pick = toolName ? tools.find((t) => t.name === toolName) : tools[0];
+    if (!pick) {
+        throw new Error(`captureTool: no tool captured${toolName ? ` named "${toolName}"` : ""}. Did you forget to call register?`);
+    }
+    return async (args) => {
+        const result = await pick.execute(args, STUB_CONTEXT);
+        if (typeof result === "string")
+            return result;
+        return JSON.stringify(result);
+    };
+}

package/dist/server/tools.js

@@ -1,4 +1,7 @@
+import { registerBatchCommitTool } from "./batch-commit-tool.js";
+import { registerGitDiffSummaryTool } from "./git-diff-summary-tool.js";
 import { registerGitInventoryTool } from "./git-inventory-tool.js";
+import { registerGitLogTool } from "./git-log-tool.js";
 import { registerGitParityTool } from "./git-parity-tool.js";
 import { registerGitStatusTool } from "./git-status-tool.js";
 import { registerListPresetsTool } from "./list-presets-tool.js";
@@ -8,5 +11,8 @@ export function registerRethunkGitTools(server) {
     registerGitInventoryTool(server);
     registerGitParityTool(server);
     registerListPresetsTool(server);
+    registerBatchCommitTool(server);
+    registerGitDiffSummaryTool(server);
+    registerGitLogTool(server);
     registerPresetsResource(server);
 }