@rethunk/mcp-multi-root-git 2.9.0 → 3.1.0

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

@@ -156,17 +156,8 @@ export function registerGitShowTool(server) {
         annotations: {
             readOnlyHint: true,
         },
-        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true, allWorkspaceRoots: true })
-            .pick({
-            workspaceRoot: true,
-            rootIndex: true,
-            format: true,
-        })
-            .extend({
-            ref: z
-                .string()
-                .min(1)
-                .describe("Commit reference (SHA, branch, tag, or any git rev-spec)."),
+        parameters: WorkspacePickSchema.extend({
+            ref: z.string().min(1).describe("Commit reference (SHA, branch, tag, or any git rev-spec)."),
             path: z
                 .string()
                 .optional()

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

@@ -14,11 +14,7 @@ export function registerGitStashListTool(server) {
         annotations: {
             readOnlyHint: true,
         },
-        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true, allWorkspaceRoots: true }).pick({
-            workspaceRoot: true,
-            rootIndex: true,
-            format: true,
-        }),
+        parameters: WorkspacePickSchema,
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
             if (!pre.ok)
@@ -83,17 +79,12 @@ export function registerGitStashApplyTool(server) {
             destructiveHint: false,
             idempotentHint: false,
         },
-        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true, allWorkspaceRoots: true })
-            .pick({
-            workspaceRoot: true,
-            rootIndex: true,
-            format: true,
-        })
-            .extend({
+        parameters: WorkspacePickSchema.extend({
             index: z
                 .number()
                 .int()
                 .min(0)
+                .max(10000)
                 .optional()
                 .default(0)
                 .describe("Stash index (defaults to 0 for stash@{0})."),

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

@@ -4,7 +4,7 @@ import { isStrictlyUnderGitTop } from "../repo-paths.js";
 import { asyncPool, GIT_SUBPROCESS_PARALLELISM, gitStatusShortBranchAsync, gitTopLevel, hasGitMetadata, parseGitSubmodulePaths, } from "./git.js";
 import { jsonRespond } from "./json.js";
 import { requireGitAndRoots } from "./roots.js";
-import { WorkspacePickSchema } from "./schemas.js";
+import { RootPickSchema } from "./schemas.js";
 export function registerGitStatusTool(server) {
     server.addTool({
         name: "git_status",
@@ -12,7 +12,7 @@ export function registerGitStatusTool(server) {
         annotations: {
             readOnlyHint: true,
         },
-        parameters: WorkspacePickSchema.extend({
+        parameters: RootPickSchema.extend({
             includeSubmodules: z.boolean().optional().default(true),
         }),
         execute: async (args) => {

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

@@ -44,13 +44,7 @@ export function registerGitTagTool(server) {
             readOnlyHint: false,
             destructiveHint: true,
         },
-        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true, allWorkspaceRoots: true })
-            .pick({
-            workspaceRoot: true,
-            rootIndex: true,
-            format: true,
-        })
-            .extend({
+        parameters: WorkspacePickSchema.extend({
             tag: z.string().min(1).describe("Tag name (e.g. 'v1.2.3')."),
             message: z
                 .string()

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

@@ -16,11 +16,7 @@ export function registerGitWorktreeListTool(server) {
         annotations: {
             readOnlyHint: true,
         },
-        parameters: WorkspacePickSchema.pick({
-            workspaceRoot: true,
-            rootIndex: true,
-            format: true,
-        }),
+        parameters: WorkspacePickSchema,
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
             if (!pre.ok)
@@ -55,7 +51,7 @@ export function registerGitWorktreeAddTool(server) {
             destructiveHint: false,
             idempotentHint: false,
         },
-        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true }).extend({
+        parameters: WorkspacePickSchema.extend({
             path: z
                 .string()
                 .min(1)
@@ -137,7 +133,7 @@ export function registerGitWorktreeRemoveTool(server) {
             destructiveHint: true,
             idempotentHint: false,
         },
-        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true }).extend({
+        parameters: WorkspacePickSchema.extend({
             path: z
                 .string()
                 .min(1)

package/dist/server/git.js

@@ -95,19 +95,13 @@ export function gitRevParseHead(cwd) {
 }
 export function parseGitSubmodulePaths(gitRoot) {
     const f = join(gitRoot, ".gitmodules");
-    if (!existsSync(f))
-        return [];
     // Skip non-regular files (character devices, sockets, etc.) — common in
     // Claude Code sandbox environments where stub device files shadow paths.
+    // Use a single try/catch to avoid TOCTOU between existence check and open.
+    let text;
     try {
         if (!lstatSync(f).isFile())
             return [];
-    }
-    catch {
-        return [];
-    }
-    let text;
-    try {
         text = readFileSync(f, "utf8");
     }
     catch {

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

@@ -4,7 +4,7 @@ import { gitTopLevel } from "./git.js";
 import { jsonRespond, spreadDefined } from "./json.js";
 import { loadPresetsFromGitTop, PRESET_FILE_PATH, presetLoadErrorPayload } from "./presets.js";
 import { requireGitAndRoots } from "./roots.js";
-import { WorkspacePickSchema } from "./schemas.js";
+import { RootPickSchema } from "./schemas.js";
 export function registerListPresetsTool(server) {
     server.addTool({
         name: "list_presets",
@@ -12,13 +12,7 @@ export function registerListPresetsTool(server) {
         annotations: {
             readOnlyHint: true,
         },
-        parameters: WorkspacePickSchema.pick({
-            workspaceRoot: true,
-            rootIndex: true,
-            allWorkspaceRoots: true,
-            absoluteGitRoots: true,
-            format: true,
-        }),
+        parameters: RootPickSchema,
         execute: async (args) => {
             const pre = requireGitAndRoots(server, args, undefined);
             if (!pre.ok) {

package/dist/server/roots.js

@@ -3,7 +3,7 @@ import { fileURLToPath } from "node:url";
 import { ERROR_CODES } from "./error-codes.js";
 import { gateGit, gitTopLevel } from "./git.js";
 import { loadPresetsFromGitTop, presetLoadErrorPayload } from "./presets.js";
-import { MAX_ABSOLUTE_GIT_ROOTS } from "./schemas.js";
+import { MAX_ROOT_PATHS } from "./schemas.js";
 function uriToPath(uri) {
     if (!uri.startsWith("file://"))
         return null;
@@ -45,25 +45,17 @@ function pathMatchesWorkspaceRootHint(rootPath, hint) {
         return true;
     return basename(rootPath) === h;
 }
-function hasExclusiveWorkspacePick(args) {
-    if (args.workspaceRoot?.trim())
-        return true;
-    if (args.rootIndex != null)
-        return true;
-    if (args.allWorkspaceRoots === true)
-        return true;
-    return false;
-}
 /**
- * Resolve `absoluteGitRoots` to unique git toplevels (stable order, first occurrence wins).
+ * Resolve an explicit `root` path array to unique git toplevels
+ * (stable order, first occurrence wins).
  */
-export function resolveAbsoluteGitRootsList(raw) {
-    if (raw.length > MAX_ABSOLUTE_GIT_ROOTS) {
+export function resolveRootPathList(raw) {
+    if (raw.length > MAX_ROOT_PATHS) {
         return {
             ok: false,
             error: {
-                error: ERROR_CODES.ABSOLUTE_GIT_ROOTS_TOO_MANY,
-                max: MAX_ABSOLUTE_GIT_ROOTS,
+                error: ERROR_CODES.ROOT_LIST_TOO_MANY,
+                max: MAX_ROOT_PATHS,
                 count: raw.length,
             },
         };
@@ -73,12 +65,12 @@ export function resolveAbsoluteGitRootsList(raw) {
     for (const item of raw) {
         const trimmed = item.trim();
         if (trimmed.length === 0) {
-            return { ok: false, error: { error: ERROR_CODES.INVALID_ABSOLUTE_GIT_ROOT, path: item } };
+            return { ok: false, error: { error: ERROR_CODES.INVALID_ROOT_PATH, path: item } };
         }
         const abs = resolve(trimmed);
         const top = gitTopLevel(abs);
         if (!top) {
-            return { ok: false, error: { error: ERROR_CODES.INVALID_ABSOLUTE_GIT_ROOT, path: abs } };
+            return { ok: false, error: { error: ERROR_CODES.INVALID_ROOT_PATH, path: abs } };
         }
         if (seen.has(top))
             continue;
@@ -86,47 +78,23 @@ export function resolveAbsoluteGitRootsList(raw) {
         tops.push(top);
     }
     if (tops.length === 0) {
-        return { ok: false, error: { error: ERROR_CODES.ABSOLUTE_GIT_ROOTS_EMPTY } };
+        return { ok: false, error: { error: ERROR_CODES.ROOT_LIST_EMPTY } };
     }
     return { ok: true, roots: tops };
 }
-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) {
-        return fileRoots.length === 0 ? fallback : { ok: true, roots: fileRoots };
-    }
-    if (args.rootIndex != null) {
-        const r = fileRoots[args.rootIndex];
-        if (!r) {
-            return {
-                ok: false,
-                error: {
-                    error: ERROR_CODES.ROOT_INDEX_OUT_OF_RANGE,
-                    rootIndex: args.rootIndex,
-                    rootCount: fileRoots.length,
-                },
-            };
-        }
-        return { ok: true, roots: [r] };
-    }
+/** Default when `root` is omitted: first MCP file root, else cwd. */
+function defaultRoots(fileRoots) {
     const primary = fileRoots[0];
-    return primary !== undefined ? { ok: true, roots: [primary] } : fallback;
+    return { ok: true, roots: [primary ?? process.cwd()] };
 }
 /**
  * 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.
  */
-function resolveRootsForPreset(server, args, presetName) {
-    if (args.workspaceRoot?.trim() || args.allWorkspaceRoots || args.rootIndex != null) {
-        return resolveWorkspaceRoots(server, args);
-    }
+function resolveRootsForPreset(server, presetName) {
     const fileRoots = listFileRoots(server);
     if (fileRoots.length <= 1) {
-        return resolveWorkspaceRoots(server, args);
+        return defaultRoots(fileRoots);
     }
     const matches = [];
     for (const r of fileRoots) {
@@ -153,53 +121,46 @@ function resolveRootsForPreset(server, args, presetName) {
     if (pick !== undefined) {
         return { ok: true, roots: [pick] };
     }
-    return resolveWorkspaceRoots(server, args);
+    return defaultRoots(fileRoots);
 }
-/** `gateGit` plus workspace / preset root resolution; shared tool and resource prelude. */
+/** `gateGit` plus `root` resolution; shared fan-out tool and resource prelude. */
 export function requireGitAndRoots(server, args, presetName) {
     const gg = gateGit();
     if (!gg.ok) {
         return { ok: false, error: gg.body };
     }
-    const abs = args.absoluteGitRoots;
-    if (abs != null && abs.length > 0) {
+    const root = args.root;
+    if (Array.isArray(root)) {
         if (presetName) {
-            return { ok: false, error: { error: ERROR_CODES.ABSOLUTE_GIT_ROOTS_PRESET_CONFLICT } };
-        }
-        if (hasExclusiveWorkspacePick(args)) {
-            return { ok: false, error: { error: ERROR_CODES.ABSOLUTE_GIT_ROOTS_EXCLUSIVE } };
+            return { ok: false, error: { error: ERROR_CODES.ROOT_LIST_PRESET_CONFLICT } };
         }
-        return resolveAbsoluteGitRootsList(abs);
+        return resolveRootPathList(root);
     }
-    const rootsRes = presetName
-        ? resolveRootsForPreset(server, args, presetName)
-        : resolveWorkspaceRoots(server, args);
-    if (!rootsRes.ok) {
-        return { ok: false, error: rootsRes.error };
+    const trimmed = root?.trim();
+    if (trimmed === "*") {
+        const fileRoots = listFileRoots(server);
+        return fileRoots.length === 0 ? defaultRoots(fileRoots) : { ok: true, roots: fileRoots };
     }
-    return { ok: true, roots: rootsRes.roots };
+    if (trimmed) {
+        return { ok: true, roots: [resolve(trimmed)] };
+    }
+    if (presetName) {
+        return resolveRootsForPreset(server, presetName);
+    }
+    return defaultRoots(listFileRoots(server));
 }
 /**
- * Convenience wrapper for single-repo tools: gate git, resolve roots, pick the first
- * root, and resolve its git toplevel. Returns `{ ok: true, gitTop }` or a structured
- * error payload ready for `jsonRespond`.
+ * Prelude for single-repo tools: gate git, resolve `workspaceRoot` (or the first
+ * MCP root / cwd), and resolve its git toplevel. Returns `{ ok: true, gitTop }`
+ * or a structured error payload ready for `jsonRespond`.
  */
-export function requireSingleRepo(server, args, presetName = undefined) {
-    const pre = requireGitAndRoots(server, args, presetName);
-    if (!pre.ok)
-        return pre;
-    if (args.absoluteGitRoots != null && args.absoluteGitRoots.length > 0 && pre.roots.length !== 1) {
-        return {
-            ok: false,
-            error: {
-                error: ERROR_CODES.ABSOLUTE_GIT_ROOTS_SINGLE_REPO_ONLY,
-                rootCount: pre.roots.length,
-            },
-        };
+export function requireSingleRepo(server, args) {
+    const gg = gateGit();
+    if (!gg.ok) {
+        return { ok: false, error: gg.body };
     }
-    const rootInput = pre.roots[0];
-    if (!rootInput)
-        return { ok: false, error: { error: ERROR_CODES.NO_WORKSPACE_ROOT } };
+    const ws = args.workspaceRoot?.trim();
+    const rootInput = ws ? resolve(ws) : (listFileRoots(server)[0] ?? process.cwd());
     const top = gitTopLevel(rootInput);
     if (!top)
         return { ok: false, error: { error: ERROR_CODES.NOT_A_GIT_REPOSITORY, path: rootInput } };

package/dist/server/schemas.js

@@ -1,27 +1,19 @@
 import { z } from "zod";
 import { MAX_INVENTORY_ROOTS_DEFAULT } from "./inventory.js";
 const FormatSchema = z.enum(["markdown", "json"]).optional().default("markdown");
-/** Max paths in `absoluteGitRoots` (matches `git_inventory` `maxRoots` hard cap). */
-export const MAX_ABSOLUTE_GIT_ROOTS = 256;
+/** Max entries when `root` is an array (matches `git_inventory` `maxRoots` hard cap). */
+export const MAX_ROOT_PATHS = 256;
+/** Single-repo tools: one optional repo-path override plus output format. */
 export const WorkspacePickSchema = z.object({
-    workspaceRoot: z.string().optional().describe("Highest-priority root override."),
-    rootIndex: z
-        .number()
-        .int()
-        .min(0)
-        .optional()
-        .describe("0-based index into MCP roots; ignored if workspaceRoot set."),
-    allWorkspaceRoots: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Fan out across all MCP roots."),
-    /** Independent git worktrees (sibling clones). Mutually exclusive with workspaceRoot, rootIndex, allWorkspaceRoots, and (git_inventory) preset/nestedRoots. */
-    absoluteGitRoots: z
-        .array(z.string())
-        .max(MAX_ABSOLUTE_GIT_ROOTS)
+    workspaceRoot: z.string().optional().describe("Repo path. Default: first MCP root / cwd."),
+    format: FormatSchema,
+});
+/** Fan-out tools: one polymorphic routing param plus output format. */
+export const RootPickSchema = z.object({
+    root: z
+        .union([z.string(), z.array(z.string()).max(MAX_ROOT_PATHS), z.literal("*")])
         .optional()
-        .describe("Absolute paths to git repo roots; use for sibling clones under a non-git parent."),
+        .describe('Repo path, array of paths, or "*" for all MCP roots.'),
     format: FormatSchema,
 });
 export { MAX_INVENTORY_ROOTS_DEFAULT };

package/dist/server/tool-parameter-schemas.js

@@ -19,15 +19,15 @@ import { registerGitStatusTool } from "./git-status-tool.js";
 import { registerGitTagTool } from "./git-tag-tool.js";
 import { registerGitWorktreeAddTool, registerGitWorktreeListTool, registerGitWorktreeRemoveTool, } from "./git-worktree-tool.js";
 import { registerListPresetsTool } from "./list-presets-tool.js";
-export const READ_ONLY_ABSOLUTE_ROOT_TOOLS = [
+export const FAN_OUT_ROOT_TOOLS = [
     "git_status",
     "git_inventory",
     "git_parity",
     "list_presets",
     "git_log",
-    "git_diff_summary",
 ];
 export const READ_ONLY_SINGLE_REPO_TOOLS = [
+    "git_diff_summary",
     "git_diff",
     "git_show",
     "git_worktree_list",
@@ -49,7 +49,7 @@ export const MUTATING_TOOLS = [
     "git_stash_apply",
 ];
 export const ALL_PARAMETER_SCHEMA_TOOLS = [
-    ...READ_ONLY_ABSOLUTE_ROOT_TOOLS,
+    ...FAN_OUT_ROOT_TOOLS,
     ...READ_ONLY_SINGLE_REPO_TOOLS,
     ...MUTATING_TOOLS,
 ];

package/dist/server.js

@@ -7,7 +7,7 @@ import { registerRethunkGitTools } from "./server/tools.js";
  * (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";
+export const MCP_JSON_FORMAT_VERSION = "5";
 const server = new FastMCP({
     name: "rethunk-git",
     version: readMcpServerVersion(),