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

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";
@@ -9,7 +10,7 @@ import { WorkspacePickSchema } from "./schemas.js";
 export function registerGitStashListTool(server) {
     server.addTool({
         name: "git_stash_list",
-        description: "List all git stashes. Returns array of `{ index: number, message: string, sha: string }`.",
+        description: "List all git stashes.",
         annotations: {
             readOnlyHint: true,
         },
@@ -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(),
                 });
             }
@@ -76,9 +77,7 @@ export function registerGitStashListTool(server) {
 export function registerGitStashApplyTool(server) {
     server.addTool({
         name: "git_stash_apply",
-        description: "Apply or pop a git stash. `index` defaults to 0 (stash@{0}). " +
-            "Set `pop: true` to run `git stash pop` instead of `git stash apply` (removes stash after applying). " +
-            "Returns `{ applied: boolean, stashIndex: number, popped: boolean, output: string }`.",
+        description: "Apply or pop a git stash. `index` defaults to 0. `pop: true` removes stash after applying.",
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
@@ -102,7 +101,7 @@ export function registerGitStashApplyTool(server) {
                 .boolean()
                 .optional()
                 .default(false)
-                .describe("If true, runs `git stash pop` instead of `git stash apply` (removes stash after applying)."),
+                .describe("Run `git stash pop` instead of `git stash apply` (removes stash after applying)."),
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);

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";
@@ -48,8 +49,7 @@ export function registerGitWorktreeListTool(server) {
 export function registerGitWorktreeAddTool(server) {
     server.addTool({
         name: "git_worktree_add",
-        description: "Add a new git worktree. If `branch` does not exist it is created from `baseRef` " +
-            "(defaults to HEAD). Refuses to create on a protected branch name.",
+        description: "Add a new git worktree. Creates `branch` from `baseRef` (default: HEAD) if it doesn't exist. Refuses protected branch names.",
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
@@ -59,15 +59,15 @@ export function registerGitWorktreeAddTool(server) {
             path: z
                 .string()
                 .min(1)
-                .describe("Filesystem path for the new worktree. Relative paths are resolved from the git toplevel."),
+                .describe("Filesystem path for the new worktree (relative paths resolved from git toplevel)."),
             branch: z
                 .string()
                 .min(1)
-                .describe("Branch to check out in the new worktree. Created from `baseRef` if absent."),
+                .describe("Branch to check out; created from `baseRef` if it doesn't exist."),
             baseRef: z
                 .string()
                 .optional()
-                .describe("Commit-ish to base the new branch on when it does not yet exist. Default: HEAD."),
+                .describe("Commit-ish to base the new branch on. Default: HEAD."),
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
@@ -76,13 +76,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 +107,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(),
                 });
             }
@@ -131,9 +131,7 @@ export function registerGitWorktreeAddTool(server) {
 export function registerGitWorktreeRemoveTool(server) {
     server.addTool({
         name: "git_worktree_remove",
-        description: "Remove a git worktree (`git worktree remove`). " +
-            "Pass `force: true` to remove a worktree with uncommitted changes. " +
-            "Refuses to remove the main worktree.",
+        description: "Remove a git worktree. Pass `force: true` to remove with uncommitted changes. Refuses to remove the main worktree.",
         annotations: {
             readOnlyHint: false,
             destructiveHint: true,
@@ -148,7 +146,7 @@ export function registerGitWorktreeRemoveTool(server) {
                 .boolean()
                 .optional()
                 .default(false)
-                .describe("Pass `--force` to allow removal of worktrees with uncommitted changes."),
+                .describe("Allow removal of worktrees with uncommitted changes (`--force`)."),
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
@@ -158,13 +156,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 +171,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) {

package/dist/server/presets.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
+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`.
@@ -85,16 +86,21 @@ export function presetLoadErrorPayload(gitTop, fail) {
     const presetFile = join(gitTop, PRESET_FILE_PATH);
     if (fail.reason === "invalid_json") {
         return {
-            error: "preset_file_invalid",
+            error: ERROR_CODES.PRESET_FILE_INVALID,
             kind: "invalid_json",
             presetFile,
             message: fail.message,
         };
     }
     if (fail.reason === "schema") {
-        return { error: "preset_file_invalid", kind: "schema", presetFile, issues: fail.issues };
+        return {
+            error: ERROR_CODES.PRESET_FILE_INVALID,
+            kind: "schema",
+            presetFile,
+            issues: fail.issues,
+        };
     }
-    return { error: "preset_file_invalid", presetFile };
+    return { error: ERROR_CODES.PRESET_FILE_INVALID, presetFile };
 }
 function getPresetEntry(gitTop, presetName) {
     const loaded = loadPresetsFromGitTop(gitTop);
@@ -103,7 +109,7 @@ function getPresetEntry(gitTop, presetName) {
             return {
                 ok: false,
                 error: {
-                    error: "preset_not_found",
+                    error: ERROR_CODES.PRESET_NOT_FOUND,
                     preset: presetName,
                     presetFile: join(gitTop, PRESET_FILE_PATH),
                 },
@@ -116,7 +122,7 @@ function getPresetEntry(gitTop, presetName) {
         return {
             ok: false,
             error: {
-                error: "preset_not_found",
+                error: ERROR_CODES.PRESET_NOT_FOUND,
                 preset: presetName,
                 presetFile: join(gitTop, PRESET_FILE_PATH),
             },