@rethunk/mcp-multi-root-git 2.6.0 → 2.8.0

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

@@ -0,0 +1,126 @@
+import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
+import { spawnGitAsync } from "./git.js";
+import { isSafeGitRefToken } from "./git-refs.js";
+import { jsonRespond } from "./json.js";
+import { requireSingleRepo } from "./roots.js";
+import { WorkspacePickSchema } from "./schemas.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const MAX_ENTRIES_HARD_CAP = 200;
+const DEFAULT_MAX_ENTRIES = 30;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Run git reflog for a single ref and return structured data.
+ * Uses NUL-delimited fields within each line for robust parsing.
+ */
+async function runGitReflog(opts) {
+    const { top, ref, maxEntries } = opts;
+    // %h = short sha, %H = full sha, %gd = selector (HEAD@{0}), %gs = reflog subject
+    const reflogArgs = [
+        "reflog",
+        "show",
+        ref,
+        "--format=%h%x00%H%x00%gd%x00%gs",
+        `-n`,
+        String(maxEntries),
+    ];
+    const r = await spawnGitAsync(top, reflogArgs);
+    if (!r.ok) {
+        return {
+            error: ERROR_CODES.REFLOG_FAILED,
+            detail: (r.stderr || r.stdout || "git reflog failed").trim(),
+        };
+    }
+    const entries = [];
+    const lines = r.stdout.split("\n");
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        const parts = line.split("\x00");
+        // Expect 4 fields: shaShort, shaFull, selector, message
+        if (parts.length < 4)
+            continue;
+        const [, shaFull, selector, message] = parts;
+        if (!shaFull)
+            continue;
+        entries.push({
+            sha: shaFull.trim(),
+            selector: (selector ?? "").trim(),
+            message: (message ?? "").trim(),
+        });
+    }
+    return { ref, entries };
+}
+// ---------------------------------------------------------------------------
+// Markdown rendering
+// ---------------------------------------------------------------------------
+function renderReflogMarkdown(result) {
+    const lines = [];
+    lines.push(`## Reflog (${result.ref})`);
+    lines.push("");
+    if (result.entries.length === 0) {
+        lines.push("_(no reflog entries)_");
+    }
+    else {
+        for (const entry of result.entries) {
+            lines.push(`${entry.selector}  ${entry.sha.slice(0, 7)}  ${entry.message}`);
+        }
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGitReflogTool(server) {
+    server.addTool({
+        name: "git_reflog",
+        description: "Show the reflog for a ref (default HEAD). Returns a list of recent HEAD movements with selector (e.g. HEAD@{0}), full SHA, and message. Useful for recovering lost commits or inspecting reset/checkout history.",
+        annotations: {
+            readOnlyHint: true,
+        },
+        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true, allWorkspaceRoots: true })
+            .pick({
+            workspaceRoot: true,
+            rootIndex: true,
+            format: true,
+        })
+            .extend({
+            ref: z
+                .string()
+                .optional()
+                .default("HEAD")
+                .describe("Ref whose reflog to show (branch name, HEAD, etc.). Default: HEAD."),
+            maxEntries: z
+                .number()
+                .int()
+                .min(1)
+                .max(MAX_ENTRIES_HARD_CAP)
+                .optional()
+                .default(DEFAULT_MAX_ENTRIES)
+                .describe(`Maximum reflog entries to return (hard cap ${MAX_ENTRIES_HARD_CAP}). Default ${DEFAULT_MAX_ENTRIES}.`),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const top = pre.gitTop;
+            const ref = args.ref ?? "HEAD";
+            if (!isSafeGitRefToken(ref)) {
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref });
+            }
+            const maxEntries = Math.min(args.maxEntries ?? DEFAULT_MAX_ENTRIES, MAX_ENTRIES_HARD_CAP);
+            const result = await runGitReflog({ top, ref, maxEntries });
+            if ("error" in result) {
+                return jsonRespond(result);
+            }
+            if (args.format === "json") {
+                return jsonRespond(result);
+            }
+            return renderReflogMarkdown(result);
+        },
+    });
+}

package/dist/server/git-reset-soft-tool.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
 import { spawnGitAsync } from "./git.js";
 import { isSafeGitAncestorRef, isWorkingTreeClean } from "./git-refs.js";
 import { jsonRespond, spreadDefined } from "./json.js";
@@ -30,12 +31,12 @@ export function registerGitResetSoftTool(server) {
             const { gitTop } = pre;
             // Validate ref — allow ancestor notation (~N, ^N).
             if (!isSafeGitAncestorRef(args.ref)) {
-                return jsonRespond({ error: "unsafe_ref_token", ref: args.ref });
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: args.ref });
             }
             // Refuse when the working tree is dirty (unstaged or untracked changes).
             if (!(await isWorkingTreeClean(gitTop))) {
                 return jsonRespond({
-                    error: "working_tree_dirty",
+                    error: ERROR_CODES.WORKING_TREE_DIRTY,
                     detail: "git_reset_soft requires a clean working tree. " +
                         "Commit or stash pending changes first.",
                 });
@@ -47,7 +48,7 @@ export function registerGitResetSoftTool(server) {
             const r = await spawnGitAsync(gitTop, ["reset", "--soft", args.ref]);
             if (!r.ok) {
                 return jsonRespond({
-                    error: "reset_failed",
+                    error: ERROR_CODES.RESET_FAILED,
                     detail: (r.stderr || r.stdout).trim(),
                 });
             }

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

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { assertRelativePathUnderTop, resolvePathForRepo } from "../repo-paths.js";
+import { ERROR_CODES } from "./error-codes.js";
 import { spawnGitAsync } from "./git.js";
 import { isSafeGitAncestorRef } from "./git-refs.js";
 import { jsonRespond } from "./json.js";
@@ -9,22 +10,35 @@ import { WorkspacePickSchema } from "./schemas.js";
 // Helpers
 // ---------------------------------------------------------------------------
 /**
- * Run git show for a single ref, optionally limiting to a specific path.
- * Returns commit message and diff (or file content if path is specified).
+ * Run git show for a single ref, optionally limiting to specific paths and/or
+ * showing only the --stat diffstat rather than the full patch.
+ * Returns commit message and diff/stat output.
  */
 async function runGitShow(opts) {
-    const { top, ref, path } = opts;
-    // Build git show args. Shows commit message + full diff (or file content when path given).
-    const showArgs = ["show", ref];
-    if (path) {
-        // When path is specified, show that path at the ref without --no-patch
-        // to get the full content at that ref
-        showArgs.push("--", path);
+    const { top, ref, path, paths, stat } = opts;
+    // Merge single path + paths array into a unified list (deduped, order preserved).
+    const effectivePaths = [];
+    if (path)
+        effectivePaths.push(path);
+    if (paths) {
+        for (const p of paths) {
+            if (!effectivePaths.includes(p))
+                effectivePaths.push(p);
+        }
+    }
+    // Build git show args. Shows commit message + full diff (or --stat diffstat).
+    const showArgs = ["show"];
+    if (stat) {
+        showArgs.push("--stat");
+    }
+    showArgs.push(ref);
+    if (effectivePaths.length > 0) {
+        showArgs.push("--", ...effectivePaths);
     }
     const r = await spawnGitAsync(top, showArgs);
     if (!r.ok) {
         return {
-            error: "git_show_failed",
+            error: ERROR_CODES.GIT_SHOW_FAILED,
         };
     }
     // Parse the output. For a commit, git show outputs:
@@ -32,10 +46,9 @@ async function runGitShow(opts) {
     // - Blank line
     // - Commit message (may contain multiple lines and blank lines)
     // - Blank line (separator before diff)
-    // - Diff (if --no-patch not used) or file content
+    // - Diff or --stat diffstat section
     const output = r.stdout;
     let message = "";
-    let diff = "";
     const lines = output.split("\n");
     let inHeader = true;
     let inMessage = false;
@@ -50,9 +63,14 @@ async function runGitShow(opts) {
             inMessage = true;
             continue;
         }
-        // In message: collect until we see "diff --git" which marks the start of the diff section
         if (inMessage) {
-            if (line.startsWith("diff --git")) {
+            // In stat mode: content starts at the first line that looks like a stat entry
+            // (indented file path) or the summary line "N files changed".
+            // In diff mode: content starts at "diff --git".
+            const isStatLine = stat &&
+                (line.match(/^\s+\S.*\|/) !== null || line.match(/^\s*\d+ files? changed/) !== null);
+            const isDiffLine = !stat && line.startsWith("diff --git");
+            if (isStatLine || isDiffLine) {
                 inMessage = false;
                 contentLines.push(line);
             }
@@ -66,16 +84,26 @@ async function runGitShow(opts) {
         }
     }
     message = messageLines.join("\n").trim();
-    diff = contentLines.join("\n").trim();
+    const contentStr = contentLines.join("\n").trim();
     const result = {
         ref,
         message,
     };
-    if (path) {
+    // Reflect single legacy path (for backward-compat) and new paths[] in result.
+    if (path && !paths) {
         result.path = path;
     }
-    if (diff) {
-        result.diff = diff;
+    else if (effectivePaths.length > 0) {
+        result.paths = effectivePaths;
+    }
+    if (stat) {
+        result.stat = true;
+        if (contentStr) {
+            result.statOutput = contentStr;
+        }
+    }
+    else if (contentStr) {
+        result.diff = contentStr;
     }
     return result;
 }
@@ -88,13 +116,27 @@ function renderShowMarkdown(result) {
     if (result.path) {
         lines.push(`_path: ${result.path}_`);
     }
+    else if (result.paths && result.paths.length > 0) {
+        lines.push(`_paths: ${result.paths.join(", ")}_`);
+    }
+    if (result.stat) {
+        lines.push("_mode: stat_");
+    }
     lines.push("");
     lines.push("## Commit message");
     lines.push("");
     lines.push("```");
     lines.push(result.message);
     lines.push("```");
-    if (result.diff) {
+    if (result.stat && result.statOutput) {
+        lines.push("");
+        lines.push("## Stat");
+        lines.push("");
+        lines.push("```");
+        lines.push(result.statOutput);
+        lines.push("```");
+    }
+    else if (result.diff) {
         lines.push("");
         lines.push("## Diff");
         lines.push("");
@@ -110,7 +152,7 @@ function renderShowMarkdown(result) {
 export function registerGitShowTool(server) {
     server.addTool({
         name: "git_show",
-        description: "Inspect commit content by ref/SHA. Returns commit message and diff (or file content at a specific path).",
+        description: "Inspect commit content by ref/SHA. Returns commit message and diff (or --stat diffstat when stat:true). Optionally filter to specific paths via path or paths[].",
         annotations: {
             readOnlyHint: true,
         },
@@ -128,7 +170,15 @@ export function registerGitShowTool(server) {
             path: z
                 .string()
                 .optional()
-                .describe("Optional file path to inspect at the ref. If provided, shows that path's content at the ref instead of the diff."),
+                .describe("Optional single file path to inspect at the ref. Merged with `paths` when both are provided."),
+            paths: z
+                .array(z.string())
+                .optional()
+                .describe("Optional list of file paths to filter the shown diff/stat. Merged with `path` when both are provided."),
+            stat: z
+                .boolean()
+                .optional()
+                .describe("When true, show --stat diffstat (files changed summary) instead of the full patch."),
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
@@ -136,18 +186,28 @@ export function registerGitShowTool(server) {
                 return jsonRespond(pre.error);
             const top = pre.gitTop;
             if (!isSafeGitAncestorRef(args.ref)) {
-                return jsonRespond({ error: "unsafe_ref_token", ref: args.ref });
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: args.ref });
             }
             if (args.path !== undefined) {
                 const resolved = resolvePathForRepo(args.path, top);
                 if (!assertRelativePathUnderTop(args.path, resolved, top)) {
-                    return jsonRespond({ error: "path_escapes_repo", path: args.path });
+                    return jsonRespond({ error: ERROR_CODES.PATH_ESCAPES_REPO, path: args.path });
+                }
+            }
+            if (Array.isArray(args.paths)) {
+                for (const p of args.paths) {
+                    const resolved = resolvePathForRepo(p, top);
+                    if (!assertRelativePathUnderTop(p, resolved, top)) {
+                        return jsonRespond({ error: ERROR_CODES.PATH_ESCAPES_REPO, path: p });
+                    }
                 }
             }
             const result = await runGitShow({
                 top,
                 ref: args.ref,
                 path: args.path,
+                paths: args.paths,
+                stat: args.stat,
             });
             if ("error" in result) {
                 return jsonRespond(result);

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

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
 import { spawnGitAsync } from "./git.js";
 import { jsonRespond, spreadDefined } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
@@ -30,7 +31,7 @@ export function registerGitStashListTool(server) {
                 // If there are no stashes, git still returns ok=true with empty output
                 // Only treat as error if git itself failed
                 return jsonRespond({
-                    error: "stash_list_failed",
+                    error: ERROR_CODES.STASH_LIST_FAILED,
                     detail: (r.stderr || r.stdout).trim(),
                 });
             }

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

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
 import { isSafeGitUpstreamToken, spawnGitAsync } from "./git.js";
 import { jsonRespond } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
@@ -72,18 +73,18 @@ export function registerGitTagTool(server) {
             const gitTop = pre.gitTop;
             const tag = args.tag.trim();
             if (!tag) {
-                return jsonRespond({ error: "empty_tag_name" });
+                return jsonRespond({ error: ERROR_CODES.EMPTY_TAG_NAME });
             }
             // Validate tag name: no shell metacharacters
             if (!isSafeGitUpstreamToken(tag)) {
-                return jsonRespond({ error: "unsafe_tag_token", tag });
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_TAG_TOKEN, tag });
             }
             // Handle deletion
             if (args.delete === true) {
                 const delResult = await spawnGitAsync(gitTop, ["tag", "-d", tag]);
                 if (!delResult.ok) {
                     return jsonRespond({
-                        error: "tag_delete_failed",
+                        error: ERROR_CODES.TAG_DELETE_FAILED,
                         detail: (delResult.stderr || delResult.stdout).trim(),
                     });
                 }
@@ -99,13 +100,13 @@ export function registerGitTagTool(server) {
             // Determine the ref to tag (default HEAD)
             const ref = (args.ref ?? "HEAD").trim();
             if (!isSafeGitUpstreamToken(ref)) {
-                return jsonRespond({ error: "unsafe_ref_token", ref });
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref });
             }
             // Get the SHA of the ref to tag
             const sha = await getRefSha(gitTop, ref);
             if (!sha) {
                 return jsonRespond({
-                    error: "ref_not_found",
+                    error: ERROR_CODES.REF_NOT_FOUND,
                     ref,
                 });
             }
@@ -122,7 +123,7 @@ export function registerGitTagTool(server) {
             const createResult = await spawnGitAsync(gitTop, tagArgs);
             if (!createResult.ok) {
                 return jsonRespond({
-                    error: "tag_create_failed",
+                    error: ERROR_CODES.TAG_CREATE_FAILED,
                     detail: (createResult.stderr || createResult.stdout).trim(),
                 });
             }
@@ -130,7 +131,7 @@ export function registerGitTagTool(server) {
             const tagType = await getTagType(gitTop, tag);
             if (!tagType) {
                 return jsonRespond({
-                    error: "tag_verification_failed",
+                    error: ERROR_CODES.TAG_VERIFICATION_FAILED,
                     tag,
                 });
             }

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

@@ -1,5 +1,6 @@
 import { resolve } from "node:path";
 import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
 import { spawnGitAsync } from "./git.js";
 import { isProtectedBranch, isSafeGitRefToken, listWorktrees, } from "./git-refs.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
@@ -76,13 +77,13 @@ export function registerGitWorktreeAddTool(server) {
             const { gitTop } = pre;
             // Validate branch
             if (!isSafeGitRefToken(args.branch)) {
-                return jsonRespond({ error: "unsafe_ref_token", ref: args.branch });
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: args.branch });
             }
             if (isProtectedBranch(args.branch)) {
-                return jsonRespond({ error: "protected_branch", branch: args.branch });
+                return jsonRespond({ error: ERROR_CODES.PROTECTED_BRANCH, branch: args.branch });
             }
             if (args.baseRef !== undefined && !isSafeGitRefToken(args.baseRef)) {
-                return jsonRespond({ error: "unsafe_ref_token", ref: args.baseRef });
+                return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: args.baseRef });
             }
             // Resolve path
             const wtPath = resolve(gitTop, args.path);
@@ -107,7 +108,7 @@ export function registerGitWorktreeAddTool(server) {
             if (!r.ok) {
                 return jsonRespond({
                     ok: false,
-                    error: "worktree_add_failed",
+                    error: ERROR_CODES.WORKTREE_ADD_FAILED,
                     detail: (r.stderr || r.stdout).trim(),
                 });
             }
@@ -158,13 +159,13 @@ export function registerGitWorktreeRemoveTool(server) {
             // Refuse to remove the main worktree
             const wtPath = resolve(gitTop, args.path);
             if (wtPath === gitTop) {
-                return jsonRespond({ error: "cannot_remove_main_worktree", path: wtPath });
+                return jsonRespond({ error: ERROR_CODES.CANNOT_REMOVE_MAIN_WORKTREE, path: wtPath });
             }
             // Verify it exists in the worktree list
             const trees = await listWorktrees(gitTop);
             const isRegistered = trees.some((t) => t.path === wtPath || t.path === args.path);
             if (!isRegistered) {
-                return jsonRespond({ error: "worktree_not_found", path: args.path });
+                return jsonRespond({ error: ERROR_CODES.WORKTREE_NOT_FOUND, path: args.path });
             }
             const removeArgs = ["worktree", "remove", wtPath];
             if (args.force)
@@ -173,7 +174,7 @@ export function registerGitWorktreeRemoveTool(server) {
             if (!r.ok) {
                 return jsonRespond({
                     ok: false,
-                    error: "worktree_remove_failed",
+                    error: ERROR_CODES.WORKTREE_REMOVE_FAILED,
                     detail: (r.stderr || r.stdout).trim(),
                     ...spreadWhen((r.stderr || r.stdout).includes("contains modified") ||
                         (r.stderr || r.stdout).includes("is not empty"), { hint: "Pass force: true to remove a worktree with uncommitted changes." }),

package/dist/server/git.js

@@ -2,6 +2,7 @@ import { spawn, spawnSync } from "node:child_process";
 import { existsSync, lstatSync, readFileSync } from "node:fs";
 import { cpus } from "node:os";
 import { join } from "node:path";
+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].
@@ -19,9 +20,28 @@ function resolveGitSubprocessParallelism() {
     return 4;
 }
 export const GIT_SUBPROCESS_PARALLELISM = resolveGitSubprocessParallelism();
+/**
+ * Default timeout for git subprocesses spawned by spawnGitAsync.
+ * Reads from GIT_SUBPROCESS_TIMEOUT_MS env var (default 120000 ms = 2 min).
+ * 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);
+        if (!Number.isNaN(n) && n > 0)
+            return n;
+        // 0 or negative → disabled
+        if (!Number.isNaN(n))
+            return 0;
+    }
+    return 120_000;
+}
+export const GIT_SUBPROCESS_TIMEOUT_MS = resolveGitSubprocessTimeoutMs();
 let gitPathState = "unknown";
 const GIT_NOT_FOUND_BODY = {
-    error: "git_not_found",
+    error: ERROR_CODES.GIT_NOT_FOUND,
 };
 export function gateGit() {
     if (gitPathState === "ok") {
@@ -147,11 +167,12 @@ export async function asyncPool(items, concurrency, fn) {
     await Promise.all(Array.from({ length: n }, () => worker()));
     return results;
 }
-export function spawnGitAsync(cwd, args) {
+export function spawnGitAsync(cwd, args, opts) {
     return new Promise((resolveP) => {
         const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
         let stdout = "";
         let stderr = "";
+        let settled = false;
         child.stdout?.setEncoding("utf8");
         child.stderr?.setEncoding("utf8");
         child.stdout?.on("data", (c) => {
@@ -160,8 +181,53 @@ export function spawnGitAsync(cwd, args) {
         child.stderr?.on("data", (c) => {
             stderr += c;
         });
-        child.on("error", () => resolveP({ ok: false, stdout, stderr }));
-        child.on("close", (code) => resolveP({ ok: code === 0, stdout, stderr }));
+        const effectiveTimeout = opts?.timeoutMs ?? GIT_SUBPROCESS_TIMEOUT_MS;
+        let timer;
+        let abortListener;
+        function cleanup() {
+            if (timer !== undefined) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+            if (abortListener !== undefined && opts?.signal) {
+                opts.signal.removeEventListener("abort", abortListener);
+                abortListener = undefined;
+            }
+        }
+        function settle(result) {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolveP(result);
+        }
+        // AbortSignal: kill immediately if already aborted, else listen
+        if (opts?.signal) {
+            if (opts.signal.aborted) {
+                child.kill("SIGTERM");
+                settle({ ok: false, stdout, stderr, aborted: true });
+                return;
+            }
+            abortListener = () => {
+                child.kill("SIGTERM");
+                settle({ ok: false, stdout, stderr, aborted: true });
+            };
+            opts.signal.addEventListener("abort", abortListener, { once: true });
+        }
+        // Timeout: set timer if effectiveTimeout > 0
+        if (effectiveTimeout > 0) {
+            timer = setTimeout(() => {
+                child.kill("SIGTERM");
+                settle({
+                    ok: false,
+                    stdout,
+                    stderr: `${stderr}\n<git timed out after ${effectiveTimeout}ms>`,
+                    timedOut: true,
+                });
+            }, 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/list-presets-tool.js

@@ -1,4 +1,5 @@
 import { join } from "node:path";
+import { ERROR_CODES } from "./error-codes.js";
 import { gitTopLevel } from "./git.js";
 import { jsonRespond, spreadDefined } from "./json.js";
 import { loadPresetsFromGitTop, PRESET_FILE_PATH, presetLoadErrorPayload } from "./presets.js";
@@ -34,7 +35,7 @@ export function registerListPresetsTool(server) {
                         presetFile,
                         fileExists: false,
                         presets: [],
-                        error: { error: "not_a_git_repository", path: ws },
+                        error: { error: ERROR_CODES.NOT_A_GIT_REPOSITORY, path: ws },
                     });
                     continue;
                 }

package/dist/server/presets-resource.js

@@ -1,4 +1,5 @@
 import { join } from "node:path";
+import { ERROR_CODES } from "./error-codes.js";
 import { gitTopLevel } from "./git.js";
 import { jsonRespond, spreadDefined } from "./json.js";
 import { loadPresetsFromGitTop, PRESET_FILE_PATH, presetLoadErrorPayload } from "./presets.js";
@@ -15,11 +16,11 @@ export function registerPresetsResource(server) {
             }
             const ws = pre.roots[0];
             if (!ws) {
-                return { text: jsonRespond({ error: "no_workspace_root" }) };
+                return { text: jsonRespond({ error: ERROR_CODES.NO_WORKSPACE_ROOT }) };
             }
             const top = gitTopLevel(ws);
             if (!top) {
-                return { text: jsonRespond({ error: "not_a_git_repository", path: ws }) };
+                return { text: jsonRespond({ error: ERROR_CODES.NOT_A_GIT_REPOSITORY, path: ws }) };
             }
             const loaded = loadPresetsFromGitTop(top);
             if (!loaded.ok) {