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

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

@@ -1,4 +1,4 @@
-import { resolve } from "node:path";
+import { basename, resolve } from "node:path";
 import { z } from "zod";
 import { ERROR_CODES } from "./error-codes.js";
 import { spawnGitAsync } from "./git.js";
@@ -6,42 +6,29 @@ import { isProtectedBranch, isSafeGitRefToken, listWorktrees, } from "./git-refs
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
-// ---------------------------------------------------------------------------
-// git_worktree_list
-// ---------------------------------------------------------------------------
-export function registerGitWorktreeListTool(server) {
-    server.addTool({
-        name: "git_worktree_list",
-        description: "List all git worktrees for the repository (`git worktree list --porcelain`).",
-        annotations: {
-            readOnlyHint: true,
-        },
-        parameters: WorkspacePickSchema.pick({
-            workspaceRoot: true,
-            rootIndex: true,
-            format: true,
-        }),
-        execute: async (args) => {
-            const pre = requireSingleRepo(server, args);
-            if (!pre.ok)
-                return jsonRespond(pre.error);
-            const { gitTop } = pre;
-            const trees = await listWorktrees(gitTop);
-            if (args.format === "json") {
-                return jsonRespond({ worktrees: trees });
-            }
-            if (trees.length === 0) {
-                return "# Worktrees\n_(none)_";
-            }
-            const lines = ["# Worktrees", ""];
-            for (const t of trees) {
-                const branchPart = t.branch ?? "(detached)";
-                const headPart = t.head ? ` @ ${t.head.slice(0, 7)}` : "";
-                lines.push(`- \`${t.path}\`  ${branchPart}${headPart}`);
-            }
-            return lines.join("\n");
-        },
-    });
+/**
+ * Resolve a worktree path for add/remove.
+ *
+ * Sibling worktrees outside `gitTop` are intentional (absolute or relative).
+ * Still refuse empty/whitespace, NUL bytes, and leading-dash / option-like
+ * path tokens so git does not treat the operand as a flag. Callers must pass
+ * the resolved path after `--` in argv.
+ */
+function resolveWorktreePath(gitTop, rawPath) {
+    const trimmed = rawPath.trim();
+    if (trimmed.length === 0 || trimmed.includes("\0")) {
+        return { ok: false, error: ERROR_CODES.INVALID_PATHS, path: rawPath };
+    }
+    // Reject option-like tokens before resolve (relative "-foo") and after
+    // (absolute paths whose basename still starts with `-`, e.g. "/tmp/-evil").
+    if (trimmed.startsWith("-") || basename(trimmed).startsWith("-")) {
+        return { ok: false, error: ERROR_CODES.INVALID_PATHS, path: rawPath };
+    }
+    const wtPath = resolve(gitTop, trimmed);
+    if (basename(wtPath).startsWith("-")) {
+        return { ok: false, error: ERROR_CODES.INVALID_PATHS, path: rawPath };
+    }
+    return { ok: true, path: wtPath };
 }
 // ---------------------------------------------------------------------------
 // git_worktree_add
@@ -55,11 +42,12 @@ export function registerGitWorktreeAddTool(server) {
             destructiveHint: false,
             idempotentHint: false,
         },
-        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true }).extend({
+        parameters: WorkspacePickSchema.extend({
             path: z
                 .string()
                 .min(1)
-                .describe("Filesystem path for the new worktree (relative paths resolved from git toplevel)."),
+                .describe("Filesystem path for the new worktree (relative paths resolved from git toplevel). " +
+                "Sibling directories outside the repo toplevel are allowed; leading `-` and NUL are rejected."),
             branch: z
                 .string()
                 .min(1)
@@ -74,34 +62,40 @@ export function registerGitWorktreeAddTool(server) {
             if (!pre.ok)
                 return jsonRespond(pre.error);
             const { gitTop } = pre;
+            const branch = args.branch.trim();
+            const baseRef = args.baseRef !== undefined ? args.baseRef.trim() : undefined;
             // Validate branch
-            if (!isSafeGitRefToken(args.branch)) {
+            if (!isSafeGitRefToken(branch)) {
                 return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: args.branch });
             }
-            if (isProtectedBranch(args.branch)) {
-                return jsonRespond({ error: ERROR_CODES.PROTECTED_BRANCH, branch: args.branch });
+            if (isProtectedBranch(branch)) {
+                return jsonRespond({ error: ERROR_CODES.PROTECTED_BRANCH, branch });
             }
-            if (args.baseRef !== undefined && !isSafeGitRefToken(args.baseRef)) {
+            if (baseRef !== undefined && !isSafeGitRefToken(baseRef)) {
                 return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: args.baseRef });
             }
-            // Resolve path
-            const wtPath = resolve(gitTop, args.path);
+            const resolved = resolveWorktreePath(gitTop, args.path);
+            if (!resolved.ok) {
+                return jsonRespond({ error: resolved.error, path: resolved.path });
+            }
+            const wtPath = resolved.path;
             // Check if branch already exists
             const branchCheck = await spawnGitAsync(gitTop, [
                 "show-ref",
                 "--verify",
                 "--quiet",
-                `refs/heads/${args.branch}`,
+                `refs/heads/${branch}`,
             ]);
             const branchExists = branchCheck.ok;
+            // Path must follow `--` so a leading-dash path cannot be parsed as an option.
             let gitArgs;
             if (branchExists) {
-                gitArgs = ["worktree", "add", wtPath, args.branch];
+                gitArgs = ["worktree", "add", "--", wtPath, branch];
             }
             else {
-                gitArgs = ["worktree", "add", "-b", args.branch, wtPath];
-                if (args.baseRef)
-                    gitArgs.push(args.baseRef);
+                gitArgs = ["worktree", "add", "-b", branch, "--", wtPath];
+                if (baseRef)
+                    gitArgs.push(baseRef);
             }
             const r = await spawnGitAsync(gitTop, gitArgs);
             if (!r.ok) {
@@ -115,13 +109,13 @@ export function registerGitWorktreeAddTool(server) {
                 return jsonRespond({
                     ok: true,
                     path: wtPath,
-                    branch: args.branch,
+                    branch,
                     created: !branchExists,
-                    ...spreadDefined("baseRef", !branchExists ? (args.baseRef ?? "HEAD") : undefined),
+                    ...spreadDefined("baseRef", !branchExists ? (baseRef ?? "HEAD") : undefined),
                 });
             }
-            const createdNote = branchExists ? "" : ` (new branch from ${args.baseRef ?? "HEAD"})`;
-            return `# Worktree added\n✓ ${wtPath}  →  ${args.branch}${createdNote}`;
+            const createdNote = branchExists ? "" : ` (new branch from ${baseRef ?? "HEAD"})`;
+            return `# Worktree added\n✓ ${wtPath}  →  ${branch}${createdNote}`;
         },
     });
 }
@@ -137,11 +131,12 @@ export function registerGitWorktreeRemoveTool(server) {
             destructiveHint: true,
             idempotentHint: false,
         },
-        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true }).extend({
+        parameters: WorkspacePickSchema.extend({
             path: z
                 .string()
                 .min(1)
-                .describe("Path of the worktree to remove. Must not be the main worktree."),
+                .describe("Path of the worktree to remove. Must not be the main worktree. " +
+                "Sibling paths outside the repo toplevel are allowed; leading `-` and NUL are rejected."),
             force: z
                 .boolean()
                 .optional()
@@ -153,20 +148,33 @@ export function registerGitWorktreeRemoveTool(server) {
             if (!pre.ok)
                 return jsonRespond(pre.error);
             const { gitTop } = pre;
+            const resolved = resolveWorktreePath(gitTop, args.path);
+            if (!resolved.ok) {
+                return jsonRespond({ error: resolved.error, path: resolved.path });
+            }
+            const wtPath = resolved.path;
             // Refuse to remove the main worktree
-            const wtPath = resolve(gitTop, args.path);
             if (wtPath === gitTop) {
                 return jsonRespond({ error: ERROR_CODES.CANNOT_REMOVE_MAIN_WORKTREE, path: wtPath });
             }
             // Verify it exists in the worktree list
-            const trees = await listWorktrees(gitTop);
+            const listed = await listWorktrees(gitTop);
+            if (!listed.ok) {
+                return jsonRespond({
+                    ok: false,
+                    error: ERROR_CODES.WORKTREE_REMOVE_FAILED,
+                    detail: listed.detail,
+                });
+            }
+            const trees = listed.worktrees;
             const isRegistered = trees.some((t) => t.path === wtPath || t.path === args.path);
             if (!isRegistered) {
                 return jsonRespond({ error: ERROR_CODES.WORKTREE_NOT_FOUND, path: args.path });
             }
-            const removeArgs = ["worktree", "remove", wtPath];
+            const removeArgs = ["worktree", "remove"];
             if (args.force)
                 removeArgs.push("--force");
+            removeArgs.push("--", wtPath);
             const r = await spawnGitAsync(gitTop, removeArgs);
             if (!r.ok) {
                 return jsonRespond({

package/dist/server/git.js

@@ -7,13 +7,11 @@ import { ERROR_CODES } from "./error-codes.js";
  * Parallel git subprocesses for inventory rows and git_status submodule rows.
  * Reads from GIT_SUBPROCESS_PARALLELISM env var (default 4), clamped to [1, 2×CPU_COUNT].
  */
-function resolveGitSubprocessParallelism() {
-    const env = process.env.GIT_SUBPROCESS_PARALLELISM;
-    if (env) {
-        const n = Number.parseInt(env, 10);
+export function resolveGitSubprocessParallelism(envValue = process.env.GIT_SUBPROCESS_PARALLELISM, cpuCount = cpus().length) {
+    if (envValue) {
+        const n = Number.parseInt(envValue, 10);
         if (!Number.isNaN(n) && n >= 1) {
-            const cpuCount = cpus().length;
-            const maxParallel = cpuCount * 2;
+            const maxParallel = Math.max(1, cpuCount * 2);
             return Math.min(n, maxParallel);
         }
     }
@@ -26,10 +24,9 @@ export const GIT_SUBPROCESS_PARALLELISM = resolveGitSubprocessParallelism();
  * A value of 0 (or negative/NaN) disables the timeout — use for operations
  * like large clones where unbounded wait is intentional.
  */
-function resolveGitSubprocessTimeoutMs() {
-    const env = process.env.GIT_SUBPROCESS_TIMEOUT_MS;
-    if (env) {
-        const n = Number.parseInt(env, 10);
+export function resolveGitSubprocessTimeoutMs(envValue = process.env.GIT_SUBPROCESS_TIMEOUT_MS) {
+    if (envValue) {
+        const n = Number.parseInt(envValue, 10);
         if (!Number.isNaN(n) && n > 0)
             return n;
         // 0 or negative → disabled
@@ -39,10 +36,31 @@ function resolveGitSubprocessTimeoutMs() {
     return 120_000;
 }
 export const GIT_SUBPROCESS_TIMEOUT_MS = resolveGitSubprocessTimeoutMs();
+/**
+ * Max combined stdout+stderr bytes retained from spawnGitAsync.
+ * Env: GIT_SUBPROCESS_MAX_BUFFER_BYTES (default 16 MiB). Exceeding kills the child.
+ */
+export function resolveGitSubprocessMaxBufferBytes(envValue = process.env.GIT_SUBPROCESS_MAX_BUFFER_BYTES) {
+    if (envValue) {
+        const n = Number.parseInt(envValue, 10);
+        if (!Number.isNaN(n) && n >= 1024)
+            return n;
+    }
+    return 16 * 1024 * 1024;
+}
+export const GIT_SUBPROCESS_MAX_BUFFER_BYTES = resolveGitSubprocessMaxBufferBytes();
+/** Delay after SIGTERM before escalating to SIGKILL (spawnGitAsync timeout/abort/overflow). */
+export const GIT_SUBPROCESS_SIGKILL_ESCALATION_MS = 2_000;
+/** Timeout for sync spawnSync helpers (gateGit, rev-parse). */
+export const GIT_SYNC_TIMEOUT_MS = 30_000;
 let gitPathState = "unknown";
 const GIT_NOT_FOUND_BODY = {
     error: ERROR_CODES.GIT_NOT_FOUND,
 };
+/** Test-only: reset the cached git-on-PATH probe. */
+export function resetGitPathStateForTests() {
+    gitPathState = "unknown";
+}
 export function gateGit() {
     if (gitPathState === "ok") {
         return { ok: true };
@@ -53,9 +71,16 @@ export function gateGit() {
             body: GIT_NOT_FOUND_BODY,
         };
     }
-    const r = spawnSync("git", ["--version"], { encoding: "utf8" });
-    if (r.status !== 0) {
-        gitPathState = "missing";
+    const r = spawnSync("git", ["--version"], {
+        encoding: "utf8",
+        timeout: GIT_SYNC_TIMEOUT_MS,
+    });
+    if (r.error || r.status !== 0) {
+        // Do not cache "missing" on timeout — a wedged git may recover.
+        const timedOut = r.error !== undefined && r.error.code === "ETIMEDOUT";
+        if (!timedOut) {
+            gitPathState = "missing";
+        }
         return {
             ok: false,
             body: GIT_NOT_FOUND_BODY,
@@ -71,8 +96,9 @@ export function gitTopLevel(cwd) {
     const r = spawnSync("git", ["rev-parse", "--show-toplevel"], {
         cwd,
         encoding: "utf8",
+        timeout: GIT_SYNC_TIMEOUT_MS,
     });
-    if (r.status !== 0)
+    if (r.error || r.status !== 0)
         return null;
     return r.stdout.trim();
 }
@@ -80,15 +106,17 @@ export function gitRevParseGitDir(cwd) {
     const r = spawnSync("git", ["rev-parse", "--git-dir"], {
         cwd,
         encoding: "utf8",
+        timeout: GIT_SYNC_TIMEOUT_MS,
     });
-    return r.status === 0;
+    return !r.error && r.status === 0;
 }
 export function gitRevParseHead(cwd) {
     const r = spawnSync("git", ["rev-parse", "HEAD"], {
         cwd,
         encoding: "utf8",
+        timeout: GIT_SYNC_TIMEOUT_MS,
     });
-    if (r.status !== 0) {
+    if (r.error || r.status !== 0) {
         return { ok: false, text: (r.stderr || r.stdout || "git rev-parse HEAD failed").trim() };
     }
     return { ok: true, sha: r.stdout.trim(), text: r.stdout.trim() };
@@ -163,17 +191,70 @@ export async function asyncPool(items, concurrency, fn) {
 }
 export function spawnGitAsync(cwd, args, opts) {
     return new Promise((resolveP) => {
-        const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        const child = spawn("git", args, { cwd, stdio: ["pipe", "pipe", "pipe"] });
         let stdout = "";
         let stderr = "";
         let settled = false;
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
+        let sigkillTimer;
+        const maxBuffer = opts?.maxBufferBytes ?? GIT_SUBPROCESS_MAX_BUFFER_BYTES;
+        const sigkillAfter = opts?.sigkillAfterMs ?? GIT_SUBPROCESS_SIGKILL_ESCALATION_MS;
+        if (!opts?.holdStdin) {
+            child.stdin?.end();
+        }
         child.stdout?.setEncoding("utf8");
         child.stderr?.setEncoding("utf8");
+        function escalateKill() {
+            try {
+                child.kill("SIGTERM");
+            }
+            catch {
+                /* already dead */
+            }
+            if (sigkillTimer !== undefined)
+                return;
+            sigkillTimer = setTimeout(() => {
+                sigkillTimer = undefined;
+                try {
+                    if (!settled && child.exitCode === null && child.signalCode === null) {
+                        child.kill("SIGKILL");
+                    }
+                }
+                catch {
+                    /* already dead */
+                }
+            }, sigkillAfter);
+            // Do not keep the process alive solely for SIGKILL escalation.
+            if (typeof sigkillTimer === "object" && "unref" in sigkillTimer) {
+                sigkillTimer.unref();
+            }
+        }
+        function onChunk(stream, chunk) {
+            const byteLen = Buffer.byteLength(chunk, "utf8");
+            if (stream === "stdout") {
+                stdoutBytes += byteLen;
+                stdout += chunk;
+            }
+            else {
+                stderrBytes += byteLen;
+                stderr += chunk;
+            }
+            if (stdoutBytes + stderrBytes > maxBuffer) {
+                escalateKill();
+                settle({
+                    ok: false,
+                    stdout,
+                    stderr: `${stderr}\n<git output exceeded ${maxBuffer} bytes>`,
+                    truncated: true,
+                });
+            }
+        }
         child.stdout?.on("data", (c) => {
-            stdout += c;
+            onChunk("stdout", c);
         });
         child.stderr?.on("data", (c) => {
-            stderr += c;
+            onChunk("stderr", c);
         });
         const effectiveTimeout = opts?.timeoutMs ?? GIT_SUBPROCESS_TIMEOUT_MS;
         let timer;
@@ -183,10 +264,20 @@ export function spawnGitAsync(cwd, args, opts) {
                 clearTimeout(timer);
                 timer = undefined;
             }
+            if (sigkillTimer !== undefined) {
+                clearTimeout(sigkillTimer);
+                sigkillTimer = undefined;
+            }
             if (abortListener !== undefined && opts?.signal) {
                 opts.signal.removeEventListener("abort", abortListener);
                 abortListener = undefined;
             }
+            try {
+                child.stdin?.destroy();
+            }
+            catch {
+                /* ignore */
+            }
         }
         function settle(result) {
             if (settled)
@@ -195,15 +286,18 @@ export function spawnGitAsync(cwd, args, opts) {
             cleanup();
             resolveP(result);
         }
+        // Register lifecycle handlers before any early kill so close/error are observed.
+        child.on("error", () => settle({ ok: false, stdout, stderr }));
+        child.on("close", (code) => settle({ ok: code === 0, stdout, stderr }));
         // AbortSignal: kill immediately if already aborted, else listen
         if (opts?.signal) {
             if (opts.signal.aborted) {
-                child.kill("SIGTERM");
+                escalateKill();
                 settle({ ok: false, stdout, stderr, aborted: true });
                 return;
             }
             abortListener = () => {
-                child.kill("SIGTERM");
+                escalateKill();
                 settle({ ok: false, stdout, stderr, aborted: true });
             };
             opts.signal.addEventListener("abort", abortListener, { once: true });
@@ -211,7 +305,7 @@ export function spawnGitAsync(cwd, args, opts) {
         // Timeout: set timer if effectiveTimeout > 0
         if (effectiveTimeout > 0) {
             timer = setTimeout(() => {
-                child.kill("SIGTERM");
+                escalateKill();
                 settle({
                     ok: false,
                     stdout,
@@ -220,8 +314,6 @@ export function spawnGitAsync(cwd, args, opts) {
                 });
             }, effectiveTimeout);
         }
-        child.on("error", () => settle({ ok: false, stdout, stderr }));
-        child.on("close", (code) => settle({ ok: code === 0, stdout, stderr }));
     });
 }
 function gitStatusFailText(r) {

package/dist/server/inventory.js

@@ -22,6 +22,15 @@ export function buildInventorySectionMarkdown(e) {
     else if (e.upstreamNote) {
         lines.push(`upstream: ${e.upstreamNote}`);
     }
+    if (e.compareRefs) {
+        const cr = e.compareRefs;
+        if (cr.ahead !== undefined && cr.behind !== undefined) {
+            lines.push(`${cr.left}...${cr.right}: ahead ${cr.ahead}, behind ${cr.behind}`);
+        }
+        else if (cr.note) {
+            lines.push(`compareRefs ${cr.left}...${cr.right}: ${cr.note}`);
+        }
+    }
     const single = lines.length === 1 ? lines[0] : undefined;
     if (single !== undefined && !single.includes("\n")) {
         return ["", header, single];
@@ -53,7 +62,48 @@ function buildEntry(params) {
         out.upstreamNote = params.upstreamNote;
     return out;
 }
-export async function collectInventoryEntry(label, absPath, fixedRemote, fixedBranch) {
+/**
+ * Ahead = commits reachable from `right` but not `left` (`left..right`).
+ * Behind = commits reachable from `left` but not `right` (`right..left`).
+ */
+async function fetchCompareAheadBehind(absPath, left, right) {
+    const [aheadR, behindR] = await Promise.all([
+        spawnGitAsync(absPath, ["rev-list", "--count", `${left}..${right}`]),
+        spawnGitAsync(absPath, ["rev-list", "--count", `${right}..${left}`]),
+    ]);
+    return {
+        ahead: aheadR.ok ? aheadR.stdout.trim() : null,
+        behind: behindR.ok ? behindR.stdout.trim() : null,
+    };
+}
+async function attachCompareRefs(entry, absPath, compareRefs) {
+    if (!compareRefs)
+        return entry;
+    const left = compareRefs.left;
+    const right = compareRefs.right;
+    const [leftOk, rightOk] = await Promise.all([
+        spawnGitAsync(absPath, ["rev-parse", "--verify", left]),
+        spawnGitAsync(absPath, ["rev-parse", "--verify", right]),
+    ]);
+    if (!leftOk.ok || !rightOk.ok) {
+        entry.compareRefs = {
+            left,
+            right,
+            note: `(ref unreadable: ${[!leftOk.ok ? left : "", !rightOk.ok ? right : ""].filter(Boolean).join(", ")})`,
+        };
+        return entry;
+    }
+    const { ahead, behind } = await fetchCompareAheadBehind(absPath, left, right);
+    entry.compareRefs = {
+        left,
+        right,
+        ...(ahead != null ? { ahead } : {}),
+        ...(behind != null ? { behind } : {}),
+        ...(ahead == null || behind == null ? { note: "(counts unreadable)" } : {}),
+    };
+    return entry;
+}
+export async function collectInventoryEntry(label, absPath, fixedRemote, fixedBranch, compareRefs) {
     const [snap, headR] = await Promise.all([
         gitStatusSnapshotAsync(absPath),
         spawnGitAsync(absPath, ["rev-parse", "--abbrev-ref", "HEAD"]),
@@ -62,11 +112,12 @@ export async function collectInventoryEntry(label, absPath, fixedRemote, fixedBr
     const headAbbrev = headR.ok ? headR.stdout.trim() : "";
     const detached = !headR.ok || headAbbrev === "HEAD" || headAbbrev.endsWith("/HEAD");
     const base = { label, absPath, branchStatus, detached, headAbbrev };
+    let entry;
     if (fixedRemote !== undefined && fixedBranch !== undefined) {
         const ref = `${fixedRemote}/${fixedBranch}`;
         const verify = await spawnGitAsync(absPath, ["rev-parse", "--verify", ref]);
         if (!verify.ok) {
-            return buildEntry({
+            entry = buildEntry({
                 ...base,
                 upstreamMode: "fixed",
                 upstreamRef: ref,
@@ -75,36 +126,43 @@ export async function collectInventoryEntry(label, absPath, fixedRemote, fixedBr
                 upstreamNote: `(no local ref ${ref} or unreadable)`,
             });
         }
-        const { ahead, behind } = await fetchAheadBehind(absPath, ref);
-        return buildEntry({
-            ...base,
-            upstreamMode: "fixed",
-            upstreamRef: ref,
-            ahead,
-            behind,
-            upstreamNote: upstreamNoteFor(ref, ahead != null && behind != null),
-        });
+        else {
+            const { ahead, behind } = await fetchAheadBehind(absPath, ref);
+            entry = buildEntry({
+                ...base,
+                upstreamMode: "fixed",
+                upstreamRef: ref,
+                ahead,
+                behind,
+                upstreamNote: upstreamNoteFor(ref, ahead != null && behind != null),
+            });
+        }
     }
-    const upVerify = await spawnGitAsync(absPath, ["rev-parse", "--verify", "@{u}"]);
-    if (!upVerify.ok) {
-        return buildEntry({
-            ...base,
-            upstreamMode: "auto",
-            upstreamRef: null,
-            ahead: null,
-            behind: null,
-            upstreamNote: detached ? "detached HEAD — no upstream" : "no upstream configured",
-        });
+    else {
+        const upVerify = await spawnGitAsync(absPath, ["rev-parse", "--verify", "@{u}"]);
+        if (!upVerify.ok) {
+            entry = buildEntry({
+                ...base,
+                upstreamMode: "auto",
+                upstreamRef: null,
+                ahead: null,
+                behind: null,
+                upstreamNote: detached ? "detached HEAD — no upstream" : "no upstream configured",
+            });
+        }
+        else {
+            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}");
+            entry = buildEntry({
+                ...base,
+                upstreamMode: "auto",
+                upstreamRef,
+                ahead,
+                behind,
+                upstreamNote: upstreamNoteFor(upstreamRef, ahead != null && behind != null),
+            });
+        }
     }
-    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 buildEntry({
-        ...base,
-        upstreamMode: "auto",
-        upstreamRef,
-        ahead,
-        behind,
-        upstreamNote: upstreamNoteFor(upstreamRef, ahead != null && behind != null),
-    });
+    return attachCompareRefs(entry, absPath, compareRefs);
 }

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) {