@rethunk/mcp-multi-root-git 2.0.1 → 2.2.0

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

@@ -0,0 +1,393 @@
+import { z } from "zod";
+import { gitTopLevel, spawnGitAsync } from "./git.js";
+import { getCurrentBranch, isFullyMergedInto, isProtectedBranch, isSafeGitRefToken, isWorkingTreeClean, resolveRef, worktreeForBranch, } from "./git-refs.js";
+import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
+import { requireGitAndRoots } from "./roots.js";
+import { WorkspacePickSchema } from "./schemas.js";
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+const StrategySchema = z
+    .enum(["auto", "ff-only", "rebase", "merge"])
+    .optional()
+    .default("auto")
+    .describe("`auto` (default): cascade fast-forward → rebase → merge-commit per source. " +
+    "`ff-only`: only fast-forward, fail if diverged. " +
+    "`rebase`: rebase source onto destination, then fast-forward (no merge-commit fallback). " +
+    "`merge`: always create a merge commit (no fast-forward).");
+// ---------------------------------------------------------------------------
+// Conflict helpers
+// ---------------------------------------------------------------------------
+async function conflictPaths(gitTop) {
+    const r = await spawnGitAsync(gitTop, ["diff", "--name-only", "--diff-filter=U"]);
+    if (!r.ok)
+        return [];
+    return r.stdout
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+}
+async function abortMerge(gitTop) {
+    await spawnGitAsync(gitTop, ["merge", "--abort"]);
+}
+async function abortRebase(gitTop) {
+    await spawnGitAsync(gitTop, ["rebase", "--abort"]);
+}
+// ---------------------------------------------------------------------------
+// Per-source merge logic
+// ---------------------------------------------------------------------------
+/**
+ * Attempt to land `source` on `into`. Caller must ensure `into` is checked out.
+ * On conflict the repo state is cleaned (merge/rebase aborted, HEAD restored to `into`).
+ */
+async function mergeOneSource(gitTop, into, source, strategy, mergeMessage) {
+    // --- Classify state via merge-base ---
+    const intoSha = await resolveRef(gitTop, into);
+    const sourceSha = await resolveRef(gitTop, source);
+    if (!sourceSha) {
+        return { source, ok: false, error: "source_not_found" };
+    }
+    if (!intoSha) {
+        return { source, ok: false, error: "destination_not_found" };
+    }
+    const mb = await spawnGitAsync(gitTop, ["merge-base", into, source]);
+    if (!mb.ok) {
+        return {
+            source,
+            ok: false,
+            error: "merge_base_failed",
+            detail: (mb.stderr || mb.stdout).trim(),
+        };
+    }
+    const mergeBase = mb.stdout.trim();
+    // source fully contained in into → noop
+    if (mergeBase === sourceSha) {
+        return { source, ok: true, outcome: "up_to_date", mergedSha: intoSha };
+    }
+    // into fully contained in source → fast-forward is the right move
+    const canFastForward = mergeBase === intoSha;
+    // --- ff-only strategy ---
+    if (strategy === "ff-only") {
+        if (!canFastForward) {
+            return {
+                source,
+                ok: false,
+                error: "cannot_fast_forward",
+                detail: "destination and source have diverged; retry with strategy: rebase, merge, or auto",
+            };
+        }
+        return fastForward(gitTop, source);
+    }
+    // --- Fast-forward path for auto/rebase when applicable ---
+    if (canFastForward && (strategy === "auto" || strategy === "rebase")) {
+        return fastForward(gitTop, source);
+    }
+    // --- merge strategy: always merge commit ---
+    if (strategy === "merge") {
+        return mergeCommit(gitTop, source, mergeMessage, into);
+    }
+    // --- rebase or auto (diverged case) ---
+    const rebased = await rebaseSourceOntoInto(gitTop, into, source);
+    if (rebased.ok) {
+        // Rebase succeeded; FF destination up to the now-rebased source tip.
+        const ff = await fastForward(gitTop, source);
+        if (!ff.ok)
+            return ff;
+        return { ...ff, outcome: "rebase_then_ff" };
+    }
+    if (strategy === "rebase") {
+        return rebased; // caller opted out of merge-commit fallback
+    }
+    // auto: fall through to merge commit
+    return mergeCommit(gitTop, source, mergeMessage, into);
+}
+async function fastForward(gitTop, source) {
+    const r = await spawnGitAsync(gitTop, ["merge", "--ff-only", source]);
+    if (!r.ok) {
+        await abortMerge(gitTop);
+        return {
+            source,
+            ok: false,
+            outcome: "conflicts",
+            conflictStage: "merge",
+            conflictPaths: [],
+            error: "merge_failed",
+            detail: (r.stderr || r.stdout).trim(),
+        };
+    }
+    const head = await spawnGitAsync(gitTop, ["rev-parse", "HEAD"]);
+    return {
+        source,
+        ok: true,
+        outcome: "fast_forward",
+        mergedSha: head.ok ? head.stdout.trim() : undefined,
+    };
+}
+async function mergeCommit(gitTop, source, message, into) {
+    const msg = message?.trim() || `Merge branch '${source}' into ${into}`;
+    const r = await spawnGitAsync(gitTop, ["merge", "--no-ff", "--no-edit", "-m", msg, source]);
+    if (!r.ok) {
+        const paths = await conflictPaths(gitTop);
+        await abortMerge(gitTop);
+        return {
+            source,
+            ok: false,
+            outcome: "conflicts",
+            conflictStage: "merge",
+            conflictPaths: paths,
+            error: "merge_conflicts",
+            detail: (r.stderr || r.stdout).trim(),
+        };
+    }
+    const head = await spawnGitAsync(gitTop, ["rev-parse", "HEAD"]);
+    return {
+        source,
+        ok: true,
+        outcome: "merge_commit",
+        mergedSha: head.ok ? head.stdout.trim() : undefined,
+    };
+}
+/**
+ * Rebase `source` onto `into`, then return to `into`.
+ * On failure: abort rebase, check out `into` again, return structured conflict.
+ */
+async function rebaseSourceOntoInto(gitTop, into, source) {
+    // `git rebase <upstream> <branch>` first switches to <branch>.
+    const r = await spawnGitAsync(gitTop, ["rebase", into, source]);
+    if (!r.ok) {
+        const paths = await conflictPaths(gitTop);
+        await abortRebase(gitTop);
+        // Ensure we're back on `into` regardless of rebase state.
+        await spawnGitAsync(gitTop, ["checkout", into]);
+        return {
+            source,
+            ok: false,
+            outcome: "conflicts",
+            conflictStage: "rebase",
+            conflictPaths: paths,
+            error: "rebase_conflicts",
+            detail: (r.stderr || r.stdout).trim(),
+        };
+    }
+    // Rebase succeeded; switch back to destination so the caller can FF.
+    const co = await spawnGitAsync(gitTop, ["checkout", into]);
+    if (!co.ok) {
+        return {
+            source,
+            ok: false,
+            error: "checkout_failed",
+            detail: (co.stderr || co.stdout).trim(),
+        };
+    }
+    return { source, ok: true }; // caller FFs
+}
+// ---------------------------------------------------------------------------
+// Cleanup helpers
+// ---------------------------------------------------------------------------
+async function maybeRemoveWorktree(gitTop, source, enabled) {
+    if (!enabled)
+        return undefined;
+    const path = await worktreeForBranch(gitTop, source);
+    if (!path)
+        return undefined;
+    // Re-check protected names against the worktree path's trailing segment too.
+    const tail = path.split("/").pop() ?? "";
+    if (isProtectedBranch(tail))
+        return undefined;
+    const r = await spawnGitAsync(gitTop, ["worktree", "remove", path]);
+    return r.ok ? path : undefined;
+}
+async function maybeDeleteBranch(gitTop, source, enabled, into) {
+    if (!enabled)
+        return false;
+    if (isProtectedBranch(source))
+        return false;
+    // Safety double-check: source must be fully merged into destination.
+    const merged = await isFullyMergedInto(gitTop, source, into);
+    if (!merged)
+        return false;
+    const r = await spawnGitAsync(gitTop, ["branch", "-d", source]);
+    return r.ok;
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGitMergeTool(server) {
+    server.addTool({
+        name: "git_merge",
+        description: "Merge one or more source branches into a destination. Default strategy `auto` " +
+            "cascades fast-forward → rebase → merge-commit per source, preferring linear history. " +
+            "Refuses if the working tree is dirty. Stops on the first conflict and reports " +
+            "the affected paths. Optional flags auto-delete merged branches and worktrees, " +
+            "skipping protected names (main, master, dev, develop, stable, trunk, prod, " +
+            "production, release/*, hotfix/*). See docs/mcp-tools.md.",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+        },
+        parameters: WorkspacePickSchema.extend({
+            sources: z
+                .array(z.string().min(1))
+                .min(1)
+                .max(20)
+                .describe("Branches to merge into the destination, in order."),
+            into: z
+                .string()
+                .optional()
+                .describe("Destination branch. Defaults to the currently checked-out branch."),
+            strategy: StrategySchema,
+            message: z
+                .string()
+                .optional()
+                .describe("Merge commit message (used only when a merge commit is created)."),
+            deleteMergedBranches: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("After all sources merge cleanly, delete each source branch locally (`git branch -d`). " +
+                "Protected names (main, master, dev, develop, stable, trunk, prod, production, " +
+                "release/*, hotfix/*) are always skipped. Never affects remote branches."),
+            deleteMergedWorktrees: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("After all sources merge cleanly, remove any local worktree currently checked out " +
+                "on a source branch (`git worktree remove`). Protected tails always skipped."),
+        }),
+        execute: async (args) => {
+            const pre = requireGitAndRoots(server, args, undefined);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const rootInput = pre.roots[0];
+            if (!rootInput)
+                return jsonRespond({ error: "no_workspace_root" });
+            const gitTop = gitTopLevel(rootInput);
+            if (!gitTop)
+                return jsonRespond({ error: "not_a_git_repository", path: rootInput });
+            // --- Validate ref tokens early ---
+            for (const s of args.sources) {
+                if (!isSafeGitRefToken(s)) {
+                    return jsonRespond({ error: "unsafe_ref_token", ref: s });
+                }
+            }
+            if (args.into !== undefined && !isSafeGitRefToken(args.into)) {
+                return jsonRespond({ error: "unsafe_ref_token", ref: args.into });
+            }
+            // --- Resolve destination ---
+            const startBranch = await getCurrentBranch(gitTop);
+            const into = args.into?.trim() || startBranch;
+            if (!into) {
+                return jsonRespond({ error: "into_detached_head" });
+            }
+            // --- Refuse dirty tree ---
+            if (!(await isWorkingTreeClean(gitTop))) {
+                return jsonRespond({ error: "working_tree_dirty" });
+            }
+            // --- Ensure destination is checked out ---
+            if (into !== startBranch) {
+                const co = await spawnGitAsync(gitTop, ["checkout", into]);
+                if (!co.ok) {
+                    return jsonRespond({
+                        error: "checkout_failed",
+                        detail: (co.stderr || co.stdout).trim(),
+                    });
+                }
+            }
+            // Verify destination exists after checkout.
+            const intoShaProbe = await resolveRef(gitTop, into);
+            if (!intoShaProbe) {
+                return jsonRespond({ error: "destination_not_found", ref: into });
+            }
+            // --- Merge each source sequentially ---
+            const strategy = args.strategy ?? "auto";
+            const results = [];
+            let firstConflict = false;
+            for (const source of args.sources) {
+                const r = await mergeOneSource(gitTop, into, source, strategy, args.message);
+                results.push(r);
+                if (!r.ok) {
+                    firstConflict = true;
+                    break;
+                }
+            }
+            const allOk = !firstConflict && results.every((r) => r.ok);
+            // --- Cleanup (only on full success) ---
+            if (allOk) {
+                for (let i = 0; i < results.length; i++) {
+                    const r = results[i];
+                    if (!r || r.outcome === "up_to_date")
+                        continue;
+                    const worktreeRemoved = await maybeRemoveWorktree(gitTop, r.source, args.deleteMergedWorktrees ?? false);
+                    const branchDeleted = await maybeDeleteBranch(gitTop, r.source, args.deleteMergedBranches ?? false, into);
+                    results[i] = {
+                        ...r,
+                        ...spreadDefined("worktreeRemoved", worktreeRemoved),
+                        ...spreadWhen(branchDeleted, { branchDeleted: true }),
+                    };
+                }
+            }
+            const headProbe = await spawnGitAsync(gitTop, ["rev-parse", "HEAD"]);
+            const headSha = headProbe.ok ? headProbe.stdout.trim() : undefined;
+            if (args.format === "json") {
+                return jsonRespond({
+                    ok: allOk,
+                    into,
+                    strategy,
+                    ...spreadDefined("headSha", headSha),
+                    applied: results.filter((r) => r.ok).length,
+                    total: args.sources.length,
+                    results: results.map((r) => ({
+                        source: r.source,
+                        ok: r.ok,
+                        ...spreadDefined("outcome", r.outcome),
+                        ...spreadDefined("mergedSha", r.mergedSha),
+                        ...spreadDefined("conflictStage", r.conflictStage),
+                        ...spreadWhen((r.conflictPaths?.length ?? 0) > 0, {
+                            conflictPaths: r.conflictPaths,
+                        }),
+                        ...spreadWhen(r.branchDeleted === true, { branchDeleted: true }),
+                        ...spreadDefined("worktreeRemoved", r.worktreeRemoved),
+                        ...spreadDefined("skipReason", r.skipReason),
+                        ...spreadDefined("error", r.error),
+                        ...spreadDefined("detail", r.detail),
+                    })),
+                });
+            }
+            // --- Markdown ---
+            const lines = [];
+            const applied = results.filter((r) => r.ok).length;
+            const header = allOk
+                ? `# Merge into \`${into}\`: ${applied}/${args.sources.length} sources applied`
+                : `# Merge into \`${into}\`: ${applied}/${args.sources.length} sources applied (stopped on conflict)`;
+            lines.push(header, "");
+            for (const r of results) {
+                const icon = r.ok ? "✓" : "✗";
+                const tail = [];
+                if (r.outcome)
+                    tail.push(r.outcome);
+                if (r.mergedSha)
+                    tail.push(`\`${r.mergedSha.slice(0, 7)}\``);
+                if (r.branchDeleted)
+                    tail.push("branch deleted");
+                if (r.worktreeRemoved)
+                    tail.push(`worktree removed: ${r.worktreeRemoved}`);
+                lines.push(`${icon} ${r.source}${tail.length ? `  —  ${tail.join(", ")}` : ""}`);
+                if (!r.ok) {
+                    if (r.conflictPaths?.length) {
+                        for (const p of r.conflictPaths)
+                            lines.push(`  conflict: ${p}`);
+                    }
+                    if (r.error)
+                        lines.push(`  Error: ${r.error}${r.detail ? ` — ${r.detail}` : ""}`);
+                }
+            }
+            if (!allOk) {
+                const skipped = args.sources.length - results.length;
+                if (skipped > 0)
+                    lines.push("", `${skipped} remaining source(s) skipped.`);
+            }
+            return lines.join("\n");
+        },
+    });
+}

package/dist/server/git-refs.js

@@ -0,0 +1,151 @@
+import { spawnGitAsync } from "./git.js";
+// ---------------------------------------------------------------------------
+// Protected branch names — never auto-delete, never cascade destructive ops onto
+// ---------------------------------------------------------------------------
+const PROTECTED_EXACT = new Set([
+    "main",
+    "master",
+    "dev",
+    "develop",
+    "stable",
+    "trunk",
+    "prod",
+    "production",
+    "HEAD",
+]);
+const PROTECTED_PATTERN = /^(release|hotfix)[-/].+$/i;
+/** True when a branch name is on the protected list and must not be auto-deleted. */
+export function isProtectedBranch(name) {
+    const t = name.trim();
+    if (t === "")
+        return true;
+    if (PROTECTED_EXACT.has(t))
+        return true;
+    return PROTECTED_PATTERN.test(t);
+}
+// ---------------------------------------------------------------------------
+// Ref/branch name validation (argv-safe subset of git's ref-format rules)
+// ---------------------------------------------------------------------------
+/**
+ * Conservative check for branch/ref names passed to git argv.
+ * Rejects anything outside the ASCII subset `A-Z a-z 0-9 _ . / + -`,
+ * sequences git itself rejects (`..`, `@{`, leading `-`, trailing `.lock`/`/`),
+ * and pathological tokens.
+ */
+export function isSafeGitRefToken(s) {
+    const t = s.trim();
+    if (t.length === 0 || t.length > 256)
+        return false;
+    if (t.startsWith("-"))
+        return false;
+    if (t.endsWith("/") || t.endsWith(".lock") || t.endsWith("."))
+        return false;
+    if (t.includes(".."))
+        return false;
+    if (t.includes("@{"))
+        return false;
+    if (t.includes("//"))
+        return false;
+    return /^[A-Za-z0-9_./+-]+$/.test(t);
+}
+/**
+ * Same as `isSafeGitRefToken` but also allows the `A..B` / `A...B` range forms
+ * used by `git log` / `git cherry-pick`. Splits once and validates each side.
+ */
+export function isSafeGitRangeToken(s) {
+    const t = s.trim();
+    if (t.includes("...")) {
+        const parts = t.split("...");
+        return parts.length === 2 && parts.every((p) => isSafeGitRefToken(p));
+    }
+    if (t.includes("..")) {
+        const parts = t.split("..");
+        return parts.length === 2 && parts.every((p) => isSafeGitRefToken(p));
+    }
+    return isSafeGitRefToken(t);
+}
+// ---------------------------------------------------------------------------
+// Async helpers
+// ---------------------------------------------------------------------------
+/** Current branch name; `null` if detached HEAD. */
+export async function getCurrentBranch(cwd) {
+    const r = await spawnGitAsync(cwd, ["symbolic-ref", "--short", "-q", "HEAD"]);
+    if (!r.ok)
+        return null;
+    const name = r.stdout.trim();
+    return name === "" ? null : name;
+}
+/** Resolve a ref to its full SHA; `null` if unknown. */
+export async function resolveRef(cwd, ref) {
+    if (!isSafeGitRefToken(ref))
+        return null;
+    const r = await spawnGitAsync(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]);
+    if (!r.ok)
+        return null;
+    const sha = r.stdout.trim();
+    return sha === "" ? null : sha;
+}
+/** Working tree clean (no staged, no unstaged, no untracked). */
+export async function isWorkingTreeClean(cwd) {
+    const r = await spawnGitAsync(cwd, ["status", "--porcelain"]);
+    if (!r.ok)
+        return false;
+    return r.stdout.trim() === "";
+}
+/** True when every commit on `branch` is reachable from `target`. */
+export async function isFullyMergedInto(cwd, branch, target) {
+    if (!isSafeGitRefToken(branch) || !isSafeGitRefToken(target))
+        return false;
+    const r = await spawnGitAsync(cwd, ["merge-base", "--is-ancestor", branch, target]);
+    return r.ok;
+}
+/**
+ * SHAs of commits in `exclude..include`, oldest-first (cherry-pick feed order).
+ * Returns `null` on git failure.
+ */
+export async function commitListBetween(cwd, excludeRef, includeRef) {
+    if (!isSafeGitRefToken(excludeRef) || !isSafeGitRefToken(includeRef))
+        return null;
+    const r = await spawnGitAsync(cwd, ["rev-list", "--reverse", `${excludeRef}..${includeRef}`]);
+    if (!r.ok)
+        return null;
+    return r.stdout
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+}
+/** Parse `git worktree list --porcelain` into structured entries. */
+export async function listWorktrees(cwd) {
+    const r = await spawnGitAsync(cwd, ["worktree", "list", "--porcelain"]);
+    if (!r.ok)
+        return [];
+    const out = [];
+    let cur = {};
+    for (const line of r.stdout.split("\n")) {
+        if (line.startsWith("worktree ")) {
+            if (cur.path)
+                out.push({ path: cur.path, branch: cur.branch ?? null, head: cur.head ?? null });
+            cur = { path: line.slice("worktree ".length).trim() };
+        }
+        else if (line.startsWith("HEAD ")) {
+            cur.head = line.slice("HEAD ".length).trim();
+        }
+        else if (line.startsWith("branch ")) {
+            // e.g. `branch refs/heads/foo`
+            const ref = line.slice("branch ".length).trim();
+            cur.branch = ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : ref;
+        }
+        else if (line === "detached") {
+            cur.branch = null;
+        }
+    }
+    if (cur.path)
+        out.push({ path: cur.path, branch: cur.branch ?? null, head: cur.head ?? null });
+    return out;
+}
+/** Path of the worktree currently checked out on `branch`; `null` if none. */
+export async function worktreeForBranch(cwd, branch) {
+    const trees = await listWorktrees(cwd);
+    const hit = trees.find((t) => t.branch === branch);
+    return hit?.path ?? 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 = "2";
-export function readPackageVersion() {
+function readPackageVersion() {
     const here = dirname(fileURLToPath(import.meta.url));
     const pkgPath = join(here, "..", "..", "package.json");
     try {

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,7 +96,7 @@ 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") {
@@ -124,7 +124,7 @@ export function getPresetEntry(gitTop, presetName) {
     }
     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)
@@ -139,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)

package/dist/server/roots.js

@@ -2,7 +2,7 @@ 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,7 +24,7 @@ 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;
@@ -39,7 +39,7 @@ export function pathMatchesWorkspaceRootHint(rootPath, hint) {
         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())] };
     }
@@ -69,7 +69,7 @@ export function resolveWorkspaceRoots(server, args) {
  * 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);
     }