@rethunk/mcp-multi-root-git 2.9.1 → 4.0.0

package/dist/server/presets-resource.js

@@ -10,39 +10,56 @@ export function registerPresetsResource(server) {
         name: "git-mcp-presets",
         mimeType: "application/json",
         async load() {
-            const pre = requireGitAndRoots(server, {}, undefined);
+            const pre = requireGitAndRoots(server, { root: "*" }, undefined);
             if (!pre.ok) {
                 return { text: jsonRespond(pre.error) };
             }
-            const ws = pre.roots[0];
-            if (!ws) {
+            if (pre.roots.length === 0) {
                 return { text: jsonRespond({ error: ERROR_CODES.NO_WORKSPACE_ROOT }) };
             }
-            const top = gitTopLevel(ws);
-            if (!top) {
-                return { text: jsonRespond({ error: ERROR_CODES.NOT_A_GIT_REPOSITORY, path: ws }) };
-            }
-            const loaded = loadPresetsFromGitTop(top);
-            if (!loaded.ok) {
-                if (loaded.reason === "missing") {
+            const roots = pre.roots.map((ws) => {
+                const top = gitTopLevel(ws);
+                const presetFile = top ? join(top, PRESET_FILE_PATH) : join(ws, PRESET_FILE_PATH);
+                if (!top) {
                     return {
-                        text: jsonRespond({
-                            presetFile: join(top, PRESET_FILE_PATH),
+                        workspaceRoot: ws,
+                        gitTop: null,
+                        presetFile,
+                        fileExists: false,
+                        presets: {},
+                        error: { error: ERROR_CODES.NOT_A_GIT_REPOSITORY, path: ws },
+                    };
+                }
+                const loaded = loadPresetsFromGitTop(top);
+                if (!loaded.ok) {
+                    if (loaded.reason === "missing") {
+                        return {
+                            workspaceRoot: ws,
+                            gitTop: top,
+                            presetFile,
                             fileExists: false,
                             presets: {},
-                        }),
+                        };
+                    }
+                    return {
+                        workspaceRoot: ws,
+                        gitTop: top,
+                        presetFile,
+                        fileExists: true,
+                        presets: {},
+                        error: presetLoadErrorPayload(top, loaded),
                     };
                 }
-                return { text: jsonRespond(presetLoadErrorPayload(top, loaded)) };
-            }
-            return {
-                text: jsonRespond({
-                    presetFile: join(top, PRESET_FILE_PATH),
+                return {
+                    workspaceRoot: ws,
+                    gitTop: top,
+                    presetFile,
                     fileExists: true,
                     ...spreadDefined("presetSchemaVersion", loaded.schemaVersion),
                     presets: loaded.data,
-                }),
-            };
+                };
+            });
+            return { text: jsonRespond({ roots }) };
         },
     });
 }

package/dist/server/presets.js

@@ -5,21 +5,56 @@ import { ERROR_CODES } from "./error-codes.js";
 /**
  * Schema for `.rethunk/git-mcp-presets.json` at the workspace root.
  * Each named entry defines roots for `git_inventory` and/or pairs for `git_parity`.
+ * Must stay aligned with `git-mcp-presets.schema.json`.
  */
-const PresetEntrySchema = z.object({
+const ParityPairSchema = z
+    .object({
+    left: z.string(),
+    right: z.string(),
+    label: z.string().optional(),
+})
+    .strict();
+const PresetEntrySchema = z
+    .object({
     nestedRoots: z.array(z.string()).optional(),
-    parityPairs: z
-        .array(z.object({
-        left: z.string(),
-        right: z.string(),
-        label: z.string().optional(),
-    }))
-        .optional(),
+    parityPairs: z.array(ParityPairSchema).optional(),
     /** When multiple MCP file roots exist, prefer one whose path basename or suffix matches this hint. */
     workspaceRootHint: z.string().optional(),
-});
+})
+    .strict();
 const PresetFileSchema = z.record(z.string(), PresetEntrySchema);
 export const PRESET_FILE_PATH = ".rethunk/git-mcp-presets.json";
+const PRESET_ENTRY_FIELD_NAMES = new Set(["nestedRoots", "parityPairs", "workspaceRootHint"]);
+const WRAPPED_META_KEYS = new Set(["$schema", "schemaVersion", "presets"]);
+const PRESET_SCHEMA_VERSION = "1";
+function looksLikePresetEntryObject(obj) {
+    const keys = Object.keys(obj);
+    if (keys.length === 0)
+        return true;
+    return keys.every((k) => PRESET_ENTRY_FIELD_NAMES.has(k));
+}
+function isWrappedLayout(o) {
+    if (!("presets" in o))
+        return false;
+    const inner = o.presets;
+    if (inner === null || typeof inner !== "object" || Array.isArray(inner)) {
+        return false;
+    }
+    const innerObj = inner;
+    // Non-empty inner with only PresetEntry field names → legacy preset named "presets".
+    if (looksLikePresetEntryObject(innerObj) && Object.keys(innerObj).length > 0) {
+        return false;
+    }
+    // Empty inner: wrapped when top level has only metadata + presets.
+    if (Object.keys(innerObj).length === 0) {
+        const topKeys = Object.keys(o);
+        return topKeys.every((k) => WRAPPED_META_KEYS.has(k));
+    }
+    return true;
+}
+function schemaIssue(message, path = []) {
+    return { code: "custom", path, message };
+}
 /**
  * Supports:
  * - Wrapped: `{ "schemaVersion": "1", "presets": { "name": { ... } } }`
@@ -30,10 +65,12 @@ function splitPresetFileRaw(raw) {
         throw new Error("invalid_root");
     }
     const o = raw;
-    if ("presets" in o &&
-        o.presets !== null &&
-        typeof o.presets === "object" &&
-        !Array.isArray(o.presets)) {
+    if (isWrappedLayout(o)) {
+        for (const key of Object.keys(o)) {
+            if (!WRAPPED_META_KEYS.has(key)) {
+                throw new Error("wrapped_extra_keys");
+            }
+        }
         const sv = o.schemaVersion;
         return {
             mapRaw: o.presets,
@@ -69,13 +106,39 @@ export function loadPresetsFromGitTop(gitTop) {
         mapRaw = s.mapRaw;
         schemaVersion = s.schemaVersion;
     }
-    catch {
+    catch (e) {
+        if (e instanceof Error && e.message === "wrapped_extra_keys") {
+            return {
+                ok: false,
+                reason: "schema",
+                issues: [
+                    schemaIssue("Wrapped preset files allow only $schema, schemaVersion, and presets"),
+                ],
+            };
+        }
         return {
             ok: false,
             reason: "invalid_json",
             message: "Preset file root must be a JSON object",
         };
     }
+    if (schemaVersion !== undefined && schemaVersion !== PRESET_SCHEMA_VERSION) {
+        return {
+            ok: false,
+            reason: "schema",
+            issues: [schemaIssue(`schemaVersion must be "${PRESET_SCHEMA_VERSION}"`, ["schemaVersion"])],
+        };
+    }
+    if (mapRaw === null ||
+        typeof mapRaw !== "object" ||
+        Array.isArray(mapRaw) ||
+        Object.keys(mapRaw).length === 0) {
+        return {
+            ok: false,
+            reason: "schema",
+            issues: [schemaIssue("Preset file must contain at least one preset")],
+        };
+    }
     const parsed = PresetFileSchema.safeParse(mapRaw);
     if (!parsed.success) {
         return { ok: false, reason: "schema", issues: parsed.error.issues };
@@ -150,7 +213,16 @@ function mergePairs(preset, inline) {
     const b = inline ?? [];
     if (a.length === 0 && b.length === 0)
         return undefined;
-    return [...a, ...b];
+    const seen = new Set();
+    const out = [];
+    for (const pair of [...a, ...b]) {
+        const key = `${pair.left}\0${pair.right}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            out.push(pair);
+        }
+    }
+    return out;
 }
 export function applyPresetNestedRoots(gitTop, presetName, presetMerge, inlineNestedRoots) {
     const got = getPresetEntry(gitTop, presetName);

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,58 @@ 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 } };
+            return { ok: false, error: { error: ERROR_CODES.ROOT_LIST_PRESET_CONFLICT } };
         }
-        if (hasExclusiveWorkspacePick(args)) {
-            return { ok: false, error: { error: ERROR_CODES.ABSOLUTE_GIT_ROOTS_EXCLUSIVE } };
+        return resolveRootPathList(root);
+    }
+    const trimmed = root?.trim();
+    if (trimmed === "*") {
+        const fileRoots = listFileRoots(server);
+        if (fileRoots.length === 0)
+            return defaultRoots(fileRoots);
+        if (fileRoots.length > MAX_ROOT_PATHS) {
+            return {
+                ok: false,
+                error: {
+                    error: ERROR_CODES.ROOT_LIST_TOO_MANY,
+                    max: MAX_ROOT_PATHS,
+                    count: fileRoots.length,
+                },
+            };
         }
-        return resolveAbsoluteGitRootsList(abs);
+        return { ok: true, roots: fileRoots };
+    }
+    if (trimmed) {
+        return { ok: true, roots: [resolve(trimmed)] };
     }
-    const rootsRes = presetName
-        ? resolveRootsForPreset(server, args, presetName)
-        : resolveWorkspaceRoots(server, args);
-    if (!rootsRes.ok) {
-        return { ok: false, error: rootsRes.error };
+    if (presetName) {
+        return resolveRootsForPreset(server, presetName);
     }
-    return { ok: true, roots: rootsRes.roots };
+    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,26 @@
 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.
+ *
+ * Array length is intentionally uncapped here so `resolveRootPathList` can
+ * return the structured `{ error: root_list_too_many, max, count }` JSON
+ * payload. Zod `.max(MAX_ROOT_PATHS)` would reject with `too_big` before execute.
+ * The `"*"` sentinel is a plain string (no redundant `z.literal("*")`).
+ */
+export const RootPickSchema = z.object({
+    root: z
+        .union([z.string(), z.array(z.string())])
         .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/test-harness.js

@@ -16,6 +16,7 @@
  *   const result = await tool({ workspaceRoot: dir, commits: [...] });
  *   // result is string (markdown) or JSON-parseable string
  */
+import { afterEach } from "bun:test";
 import { execFileSync } from "node:child_process";
 import { appendFileSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -33,12 +34,18 @@ const STUB_CONTEXT = {
 };
 // ---------------------------------------------------------------------------
 // Tmp-dir lifecycle — prevents accumulating thousands of leaked test dirs.
-// Each test file must register the hook itself:
-//   afterEach(cleanupTmpPaths);
-// Module-scope afterEach(...) would only register once (first-importer wins)
-// because the module is cached across test files in the same bun test run.
+// Each test file that calls mkTmpDir / makeRepo / trackTmpPath must register
+// cleanup once at module scope:
+//   registerTmpCleanup();
+// (equivalent to afterEach(cleanupTmpPaths) but documents the contract.)
+// Module-scope afterEach(...) in this file would only register once
+// (first-importer wins) because the module is cached across test files.
 // ---------------------------------------------------------------------------
 const tmpPaths = [];
+/** Register afterEach cleanup for dirs created via mkTmpDir / makeRepo. Call once per test file. */
+export function registerTmpCleanup() {
+    afterEach(cleanupTmpPaths);
+}
 export function mkTmpDir(prefix) {
     const dir = mkdtempSync(join(tmpdir(), prefix));
     tmpPaths.push(dir);

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

@@ -1,95 +1,84 @@
 import { z } from "zod";
-import { registerBatchCommitTool } from "./batch-commit-tool.js";
-import { registerGitBlameTool } from "./git-blame-tool.js";
-import { registerGitBranchListTool } from "./git-branch-list-tool.js";
-import { registerGitCherryPickTool } from "./git-cherry-pick-tool.js";
-import { registerGitDiffSummaryTool } from "./git-diff-summary-tool.js";
-import { registerGitDiffTool } from "./git-diff-tool.js";
-import { registerGitFetchTool } from "./git-fetch-tool.js";
-import { registerGitInventoryTool } from "./git-inventory-tool.js";
-import { registerGitLogTool } from "./git-log-tool.js";
-import { registerGitMergeTool } from "./git-merge-tool.js";
-import { registerGitParityTool } from "./git-parity-tool.js";
-import { registerGitPushTool } from "./git-push-tool.js";
-import { registerGitReflogTool } from "./git-reflog-tool.js";
-import { registerGitResetSoftTool } from "./git-reset-soft-tool.js";
-import { registerGitShowTool } from "./git-show-tool.js";
-import { registerGitStashApplyTool, registerGitStashListTool } from "./git-stash-tool.js";
-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 = [
+import { registerRethunkGitTools } from "./tools.js";
+/**
+ * Fan-out read tools: polymorphic `root` routing (string | string[] | "*").
+ * Must stay in sync with the tools that use RootPickSchema — asserted against
+ * live `registerRethunkGitTools` capture in tests.
+ */
+export const FAN_OUT_ROOT_TOOLS = [
     "git_status",
     "git_inventory",
     "git_parity",
     "list_presets",
     "git_log",
-    "git_diff_summary",
+    "git_grep",
 ];
+/**
+ * Read-only single-repo tools: `workspaceRoot` routing only.
+ */
 export const READ_ONLY_SINGLE_REPO_TOOLS = [
+    "git_diff_summary",
     "git_diff",
     "git_show",
-    "git_worktree_list",
-    "git_stash_list",
+    "git_conflicts",
     "git_blame",
-    "git_branch_list",
-    "git_reflog",
 ];
+/**
+ * Mutating tools: `workspaceRoot` routing only.
+ */
 export const MUTATING_TOOLS = [
-    "git_fetch",
     "batch_commit",
     "git_push",
     "git_merge",
     "git_cherry_pick",
+    "git_cherry_pick_continue",
     "git_reset_soft",
+    "git_revert",
     "git_tag",
+    "git_branch",
     "git_worktree_add",
     "git_worktree_remove",
     "git_stash_apply",
+    "git_stash_push",
 ];
+/** Category union used for routing assertions; must equal live registrar names. */
 export const ALL_PARAMETER_SCHEMA_TOOLS = [
-    ...READ_ONLY_ABSOLUTE_ROOT_TOOLS,
+    ...FAN_OUT_ROOT_TOOLS,
     ...READ_ONLY_SINGLE_REPO_TOOLS,
     ...MUTATING_TOOLS,
 ];
-function captureParameterTools(register) {
+/**
+ * Capture parameter Zod schemas by driving the same registrar path as the live
+ * server (`registerRethunkGitTools`), so adding a tool only in `tools.ts` is
+ * enough for schema capture — no parallel register* list here.
+ *
+ * Clears `RETHUNK_GIT_TOOLS` for the duration so allowlist filtering cannot
+ * silently omit tools from published artifacts.
+ */
+export function captureToolParameterSchemas() {
     const tools = [];
     const server = {
         sessions: [],
         addTool(tool) {
             tools.push({ name: tool.name, parameters: tool.parameters });
         },
+        addResource() {
+            // Presets resource is always registered; capture only needs tools.
+        },
     };
-    register(server);
-    return tools;
-}
-export function captureToolParameterSchemas() {
-    const tools = captureParameterTools((server) => {
-        registerGitStatusTool(server);
-        registerGitInventoryTool(server);
-        registerGitParityTool(server);
-        registerListPresetsTool(server);
-        registerGitLogTool(server);
-        registerGitDiffSummaryTool(server);
-        registerGitDiffTool(server);
-        registerGitShowTool(server);
-        registerGitWorktreeListTool(server);
-        registerGitStashListTool(server);
-        registerGitFetchTool(server);
-        registerGitBlameTool(server);
-        registerGitBranchListTool(server);
-        registerGitReflogTool(server);
-        registerBatchCommitTool(server);
-        registerGitPushTool(server);
-        registerGitMergeTool(server);
-        registerGitCherryPickTool(server);
-        registerGitResetSoftTool(server);
-        registerGitTagTool(server);
-        registerGitWorktreeAddTool(server);
-        registerGitWorktreeRemoveTool(server);
-        registerGitStashApplyTool(server);
-    });
+    const prev = process.env.RETHUNK_GIT_TOOLS;
+    delete process.env.RETHUNK_GIT_TOOLS;
+    try {
+        registerRethunkGitTools(server);
+    }
+    finally {
+        if (prev === undefined) {
+            delete process.env.RETHUNK_GIT_TOOLS;
+        }
+        else {
+            process.env.RETHUNK_GIT_TOOLS = prev;
+        }
+    }
     return Object.fromEntries(tools.map((tool) => [tool.name, z.toJSONSchema(tool.parameters)]));
 }
 export function buildToolParameterSchemaDocument() {