@stupify/cli 0.0.3 → 0.0.4

package/src/command.ts

@@ -1,26 +1,35 @@
 import { DEFAULT_MODEL_ID, MODEL_REGISTRY } from "./constants.ts";
-import type { AuditContextMode, AuditPromptName, Command, Engine, ModelId, ScoutMode } from "./types.ts";
+import type { Command, HookAction, ModelId, SearchSource } from "./types.ts";
 
 const DEFAULT_SINCE = "2 weeks ago";
 const DEFAULT_MAX_CANDIDATES = 10;
-const DEFAULT_SCOUT_MODE: ScoutMode = "counter";
-const DEFAULT_AUDIT_CONTEXT: AuditContextMode = "repomix";
-const DEFAULT_AUDIT_PROMPT: AuditPromptName = "high_bar";
-const DEFAULT_AUDIT_BATCH_SIZE = 25;
-const DEFAULT_MAX_AUDIT_INPUT_TOKENS = 20_000;
-const DEFAULT_AUDIT_CONCURRENCY = 2;
+const DEFAULT_MAX_SEARCH_INPUT_TOKENS = 12_000;
+
 type InputMode =
-  | Readonly<{ kind: "since"; since: string }>
-  | Readonly<{ kind: "stdin" }>
-  | Readonly<{ kind: "commit"; commit: string }>
-  | Readonly<{ kind: "commits"; count: number }>;
+  | Readonly<{ kind: "since"; since: string; source: "since" }>
+  | Readonly<{ kind: "stdin"; source: "stdin" }>
+  | Readonly<{ kind: "commit"; commit: string; source: "commit" }>
+  | Readonly<{ kind: "commits"; count: number; source: "commits" }>
+  | Readonly<{ kind: "staged"; source: "staged" }>;
 
 export function parseCommand(argv: readonly string[]): Command {
   if (argv.length === 1 && isHelp(argv[0])) return { kind: "help" };
-  if (argv[0] === "experiment") {
-    const configPath = argv[1];
-    if (!configPath || argv.length > 2) throw new Error("Usage: stupify experiment <config.json>");
-    return { kind: "experiment", configPath };
+  if (argv[0] === "bench") {
+    if (argv[1] !== "search" || !argv[2] || argv.length > 3) {
+      throw new Error("Usage: stupify bench search <config.json>");
+    }
+    return { kind: "bench-search", configPath: argv[2] };
+  }
+  if (argv[0] === "hook") {
+    const action = argv[1];
+    if (!action || !isHookAction(action) || argv.length > 2) {
+      throw new Error("Usage: stupify hook install|uninstall|status");
+    }
+    return { kind: "hook", action };
+  }
+  if (argv[0] === "doctor") {
+    if (argv.length > 1) throw new Error("Usage: stupify doctor");
+    return { kind: "doctor" };
   }
 
   type ParseState = Readonly<{
@@ -29,52 +38,38 @@ export function parseCommand(argv: readonly string[]): Command {
     checkIds: readonly string[] | null;
     json: boolean;
     model: ModelId;
-    engine: Engine;
-    scout: ScoutMode;
-    auditContext: AuditContextMode;
-    auditPrompt: AuditPromptName;
     debugSem: boolean;
-    debugTargets: boolean;
     maxCandidates: number;
-    auditBatchSize: number;
-    maxAuditInputTokens: number;
-    auditConcurrency: number;
+    maxSearchInputTokens: number;
+    searchProfilePath: string | null;
+    includeCounterReasonInPrompt: boolean;
   }>;
 
   const initialState: ParseState = {
-    inputMode: { kind: "since", since: DEFAULT_SINCE },
+    inputMode: { kind: "since", since: DEFAULT_SINCE, source: "since" },
     explicitInputMode: false,
     checkIds: null,
     json: false,
     model: DEFAULT_MODEL_ID,
-    engine: "raw-diff",
-    scout: DEFAULT_SCOUT_MODE,
-    auditContext: DEFAULT_AUDIT_CONTEXT,
-    auditPrompt: DEFAULT_AUDIT_PROMPT,
     debugSem: false,
-    debugTargets: false,
     maxCandidates: DEFAULT_MAX_CANDIDATES,
-    auditBatchSize: DEFAULT_AUDIT_BATCH_SIZE,
-    maxAuditInputTokens: DEFAULT_MAX_AUDIT_INPUT_TOKENS,
-    auditConcurrency: DEFAULT_AUDIT_CONCURRENCY,
+    maxSearchInputTokens: DEFAULT_MAX_SEARCH_INPUT_TOKENS,
+    searchProfilePath: null,
+    includeCounterReasonInPrompt: false,
   };
 
   const finalState = parseFrom(0, initialState);
   return {
     ...finalState.inputMode,
+    mode: "search",
     checkIds: finalState.checkIds,
     json: finalState.json,
     model: finalState.model,
-    engine: finalState.engine,
-    scout: finalState.scout,
-    auditContext: finalState.auditContext,
-    auditPrompt: finalState.auditPrompt,
     debugSem: finalState.debugSem,
-    debugTargets: finalState.debugTargets,
     maxCandidates: finalState.maxCandidates,
-    auditBatchSize: finalState.auditBatchSize,
-    maxAuditInputTokens: finalState.maxAuditInputTokens,
-    auditConcurrency: finalState.auditConcurrency,
+    maxSearchInputTokens: finalState.maxSearchInputTokens,
+    searchProfilePath: finalState.searchProfilePath,
+    includeCounterReasonInPrompt: finalState.includeCounterReasonInPrompt,
   };
 
   function parseFrom(index: number, state: ParseState): ParseState {
@@ -82,28 +77,42 @@ export function parseCommand(argv: readonly string[]): Command {
 
     const arg = argv[index];
 
-    if (arg === "--stdin") return parseFrom(index + 1, setInputMode(state, { kind: "stdin" }));
+    if (arg === "--mode") {
+      const value = argv[index + 1];
+      if (value !== "search") throw new Error("--mode only supports search.");
+      return parseFrom(index + 2, state);
+    }
+    if (arg === "--staged") return parseFrom(index + 1, setInputMode(state, { kind: "staged", source: "staged" }));
+    if (arg === "--stdin") return parseFrom(index + 1, setInputMode(state, { kind: "stdin", source: "stdin" }));
     if (arg === "--json") return parseFrom(index + 1, { ...state, json: true });
     if (arg === "--debug-sem") return parseFrom(index + 1, { ...state, debugSem: true });
-    if (arg === "--debug-targets") return parseFrom(index + 1, { ...state, debugTargets: true });
+    if (arg === "--include-counter-reason-in-prompt") {
+      return parseFrom(index + 1, { ...state, includeCounterReasonInPrompt: true });
+    }
+
+    if (arg === "--search-profile") {
+      const value = argv[index + 1];
+      if (!value || value.startsWith("-")) throw new Error("--search-profile requires a JSON profile path.");
+      return parseFrom(index + 2, { ...state, searchProfilePath: value });
+    }
 
     if (arg === "--since") {
       const value = argv[index + 1];
       if (!value || value.startsWith("-")) throw new Error("--since requires a git date, such as \"2 weeks ago\".");
-      return parseFrom(index + 2, setInputMode(state, { kind: "since", since: value }));
+      return parseFrom(index + 2, setInputMode(state, { kind: "since", since: value, source: "since" }));
     }
 
     if (arg === "--commit") {
       const value = argv[index + 1];
       if (!value || !isSafeCommitArg(value)) throw new Error("Invalid commit.");
-      return parseFrom(index + 2, setInputMode(state, { kind: "commit", commit: value }));
+      return parseFrom(index + 2, setInputMode(state, { kind: "commit", commit: value, source: "commit" }));
     }
 
     if (arg === "--commits") {
       const value = argv[index + 1];
       const count = Number(value);
       if (!Number.isInteger(count) || count < 1) throw new Error("--commits requires a positive integer.");
-      return parseFrom(index + 2, setInputMode(state, { kind: "commits", count }));
+      return parseFrom(index + 2, setInputMode(state, { kind: "commits", count, source: "commits" }));
     }
 
     if (arg === "--checks") {
@@ -120,30 +129,6 @@ export function parseCommand(argv: readonly string[]): Command {
       return parseFrom(index + 2, { ...state, model: value });
     }
 
-    if (arg === "--engine") {
-      const value = argv[index + 1];
-      if (!value || !isEngine(value)) throw new Error("--engine must be raw-diff or sem.");
-      return parseFrom(index + 2, { ...state, engine: value });
-    }
-
-    if (arg === "--scout") {
-      const value = argv[index + 1];
-      if (!value || !isScoutMode(value)) throw new Error("--scout must be counter or llm.");
-      return parseFrom(index + 2, { ...state, scout: value });
-    }
-
-    if (arg === "--audit-context") {
-      const value = argv[index + 1];
-      if (!value || !isAuditContextMode(value)) throw new Error("--audit-context must be none or repomix.");
-      return parseFrom(index + 2, { ...state, auditContext: value });
-    }
-
-    if (arg === "--audit-prompt") {
-      const value = argv[index + 1];
-      if (!value || !isAuditPromptName(value)) throw new Error("--audit-prompt must be strict or high_bar.");
-      return parseFrom(index + 2, { ...state, auditPrompt: value });
-    }
-
     if (arg === "--max-candidates") {
       const value = argv[index + 1];
       const maxCandidates = Number(value);
@@ -153,38 +138,20 @@ export function parseCommand(argv: readonly string[]): Command {
       return parseFrom(index + 2, { ...state, maxCandidates });
     }
 
-    if (arg === "--audit-batch-size") {
-      const value = argv[index + 1];
-      const auditBatchSize = Number(value);
-      if (!Number.isInteger(auditBatchSize) || auditBatchSize < 1) {
-        throw new Error("--audit-batch-size requires a positive integer.");
-      }
-      return parseFrom(index + 2, { ...state, auditBatchSize });
-    }
-
-    if (arg === "--max-audit-input-tokens") {
-      const value = argv[index + 1];
-      const maxAuditInputTokens = Number(value);
-      if (!Number.isInteger(maxAuditInputTokens) || maxAuditInputTokens < 1) {
-        throw new Error("--max-audit-input-tokens requires a positive integer.");
-      }
-      return parseFrom(index + 2, { ...state, maxAuditInputTokens });
-    }
-
-    if (arg === "--audit-concurrency") {
+    if (arg === "--max-search-input-tokens") {
       const value = argv[index + 1];
-      const auditConcurrency = Number(value);
-      if (!Number.isInteger(auditConcurrency) || auditConcurrency < 1) {
-        throw new Error("--audit-concurrency requires a positive integer.");
+      const maxSearchInputTokens = Number(value);
+      if (!Number.isInteger(maxSearchInputTokens) || maxSearchInputTokens < 1) {
+        throw new Error("--max-search-input-tokens requires a positive integer.");
       }
-      return parseFrom(index + 2, { ...state, auditConcurrency });
+      return parseFrom(index + 2, { ...state, maxSearchInputTokens });
     }
 
     throw new Error(`Unknown option: ${arg}`);
   }
 
   function setInputMode(state: ParseState, next: InputMode): ParseState {
-    if (state.explicitInputMode) throw new Error("Choose only one input mode: --since, --stdin, --commit, or --commits.");
+    if (state.explicitInputMode) throw new Error("Choose only one input mode: --since, --stdin, --commit, --commits, or --staged.");
     return { ...state, inputMode: next, explicitInputMode: true };
   }
 }
@@ -201,18 +168,6 @@ function isModelId(value: string): value is ModelId {
   return value in MODEL_REGISTRY;
 }
 
-function isEngine(value: string): value is Engine {
-  return value === "raw-diff" || value === "sem";
-}
-
-function isScoutMode(value: string): value is ScoutMode {
-  return value === "counter" || value === "llm";
-}
-
-function isAuditContextMode(value: string): value is AuditContextMode {
-  return value === "none" || value === "repomix";
-}
-
-function isAuditPromptName(value: string): value is AuditPromptName {
-  return value === "strict" || value === "high_bar";
+function isHookAction(value: string): value is HookAction {
+  return value === "install" || value === "uninstall" || value === "status";
 }

package/src/constants.ts

@@ -1,4 +1,4 @@
-export const VERSION = "0.0.3";
+export const VERSION = "0.0.4";
 import type { ModelConfig, ModelId } from "./types.ts";
 
 export const DEFAULT_MODEL_ID: ModelId = "gemma-4-e2b";

package/src/counter-scout.ts

@@ -60,13 +60,15 @@ export function runSignalCounters(
 }
 
 function reasonForCheck(checkId: CheckId, change: SemChange): string | null {
+  if (!isSearchableSourceChange(change)) return null;
+
   const haystack = `${change.entityName}\n${change.entityType}\n${change.filePath}\n${change.afterContent ?? ""}`.toLowerCase();
   const changed = change.changeType === "added" || change.changeType === "modified";
   if (!changed) return null;
 
   switch (checkId as string) {
     case "duplicated_schema":
-      return isSchemaish(change, haystack) ? "schemaish_type_or_payload" : null;
+      return isDuplicatedSchemaCandidate(change) ? "local_schemaish_copy" : null;
     case "unnecessary_complexity":
       return /\b(helper|wrapper|service|provider|manager|factory|adapter|resolver|coordinator)\b/i.test(change.entityName)
         ? "new_abstraction_name"
@@ -84,11 +86,11 @@ function reasonForCheck(checkId: CheckId, change: SemChange): string | null {
         ? "large_changed_chunk"
         : null;
     case "over_commenting":
-      return commentLines(change.afterContent) > commentLines(change.beforeContent) + 3
+      return overCommentingSignal(change)
         ? "comment_lines_increased"
         : null;
     case "lint_bypass":
-      return /(eslint-disable|biome-ignore|@ts-ignore|@ts-expect-error|\bas unknown as\b|\bany\b)/i.test(change.afterContent ?? "")
+      return lintBypassSignal(change.afterContent ?? "")
         ? "lint_or_type_bypass_text"
         : null;
     case "inconsistent_patterns":
@@ -96,7 +98,7 @@ function reasonForCheck(checkId: CheckId, change: SemChange): string | null {
         ? "pattern_abstraction_name"
         : null;
     case "reinvented_utils":
-      return /^(format|parse|normalize|group|sort|filter|find|has|get|set|is|resolve|clamp|slug)/i.test(change.entityName)
+      return reinventedUtilitySignal(change)
         ? "generic_utility_name"
         : null;
     case "operator_style_mismatch":
@@ -108,12 +110,66 @@ function reasonForCheck(checkId: CheckId, change: SemChange): string | null {
   }
 }
 
-function isSchemaish(change: SemChange, haystack: string): boolean {
-  if (/^(interface|type|class)$/i.test(change.entityType)) return true;
-  return /\b(payload|dto|schema|response|request|input|output|result|context|asset|job|node|edge|generation)\b/i.test(haystack);
+function isDuplicatedSchemaCandidate(change: SemChange): boolean {
+  if (!/^(interface|type)$/i.test(change.entityType)) return false;
+  if (/^(public|external|internal|payment|.+client$)/i.test(change.entityName)) return false;
+  return /\b(local|payload|schema)\b/i.test(words(change.entityName));
+}
+
+function overCommentingSignal(change: SemChange): boolean {
+  const before = commentLines(change.beforeContent);
+  const after = commentLines(change.afterContent);
+  if (after <= before + 3) return false;
+  const comments = commentText(change.afterContent);
+  if (/\b(because|why|constraint|provider|external|api|quirk|edge case|timezone|utc|ledger|finance|reconciliation|rejects|mirrors|keep this)\b/i.test(comments)) {
+    return false;
+  }
+  return true;
+}
+
+function lintBypassSignal(value: string): boolean {
+  return value.split(/\r?\n/).some((line) => {
+    const trimmed = line.trim();
+    const comment = /^(\/\/|\/\*|\*)/.test(trimmed);
+    if (comment && /@ts-ignore\s*$/i.test(trimmed)) return true;
+    if (comment && /@ts-expect-error\s*$/i.test(trimmed)) return true;
+    if (comment && /(eslint-disable|biome-ignore)/i.test(trimmed) && !/\s--\s*\S/.test(trimmed)) return true;
+    return /\bas unknown as\b|\bas any\b|:\s*any\b/i.test(trimmed);
+  });
+}
+
+function reinventedUtilitySignal(change: SemChange): boolean {
+  const name = change.entityName;
+  if (!/^(clamp|debounce|throttle|slug|slugify|group|sort|shuffle|memoize|pick|omit|uniq)/i.test(name)) return false;
+  const content = change.afterContent ?? "";
+  if (/currency|invoice|refund|subscription|tier|domain/i.test(`${name}\n${content}`)) return false;
+  return true;
+}
+
+function isSearchableSourceChange(change: SemChange): boolean {
+  const filePath = change.filePath.toLowerCase();
+  if (/(^|\/)(bun|package-lock|pnpm-lock|yarn)\.lock$/.test(filePath)) return false;
+  if (/(^|\/)(dist|build|coverage|generated|vendor|fixtures?|snapshots?)(\/|$)/.test(filePath)) return false;
+  if (/\.(md|mdx|txt|json|jsonc|ya?ml|toml|lock|csv|svg|png|jpe?g|gif|webp)$/i.test(filePath)) return false;
+  if (/\.(test|spec|fixture)\.[cm]?[jt]sx?$/i.test(filePath)) return false;
+  return /\.(ts|tsx|js|jsx|mjs|cjs|mts|cts)$/i.test(filePath);
 }
 
 function commentLines(value: string | null): number {
   if (!value) return 0;
   return value.split(/\r?\n/).filter((line) => /^\s*(\/\/|\/\*|\*|#)/.test(line)).length;
 }
+
+function commentText(value: string | null): string {
+  if (!value) return "";
+  return value
+    .split(/\r?\n/)
+    .filter((line) => /^\s*(\/\/|\/\*|\*|#)/.test(line))
+    .join("\n");
+}
+
+function words(value: string): string {
+  return value
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/[_-]+/g, " ");
+}

package/src/doctor.ts

@@ -0,0 +1,140 @@
+import { execFile } from "node:child_process";
+import { createRequire } from "node:module";
+import { homedir, platform } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { DEFAULT_MODEL_ID, MODEL_REGISTRY } from "./constants.ts";
+import { runHookCommand } from "./hooks.ts";
+
+const execFileAsync = promisify(execFile);
+
+type CheckStatus = "ok" | "missing" | "info";
+
+type DoctorCheck = Readonly<{
+  label: string;
+  status: CheckStatus;
+  detail: string;
+  required?: boolean;
+}>;
+
+export async function runDoctor(): Promise<Readonly<{ exitCode: number; text: string }>> {
+  const checks = await Promise.all([
+    gitCheck(),
+    hookCheck(),
+    semCheck(),
+    repomixCheck(),
+    llamaServerCheck(),
+    modelCacheCheck(),
+  ]);
+  const requiredMissing = checks.some((check) => check.required && check.status === "missing");
+  return {
+    exitCode: requiredMissing ? 1 : 0,
+    text: renderDoctor(checks),
+  };
+}
+
+async function gitCheck(): Promise<DoctorCheck> {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], { maxBuffer: 1024 * 1024 });
+    return { label: "git repo", status: "ok", detail: stdout.trim(), required: true };
+  } catch {
+    return { label: "git repo", status: "missing", detail: "not inside a git repository", required: true };
+  }
+}
+
+async function hookCheck(): Promise<DoctorCheck> {
+  try {
+    const status = await runHookCommand("status");
+    return { label: "pre-commit hook", status: "info", detail: status.replace(/^Stupify hook:\s*/, "") };
+  } catch (error) {
+    return { label: "pre-commit hook", status: "info", detail: errorMessage(error) };
+  }
+}
+
+async function semCheck(): Promise<DoctorCheck> {
+  const packageBin = resolvePackage("@ataraxy-labs/sem/bin/sem.js");
+  if (packageBin) return { label: "sem", status: "ok", detail: "@ataraxy-labs/sem package binary found", required: true };
+  if (await commandExists("sem")) return { label: "sem", status: "ok", detail: "sem found on PATH", required: true };
+  return { label: "sem", status: "missing", detail: "install @ataraxy-labs/sem or put sem on PATH", required: true };
+}
+
+async function repomixCheck(): Promise<DoctorCheck> {
+  if (resolvePackage("repomix")) return { label: "Repomix", status: "ok", detail: "repomix package found", required: true };
+  return { label: "Repomix", status: "missing", detail: "repomix package is not installed", required: true };
+}
+
+async function llamaServerCheck(): Promise<DoctorCheck> {
+  if (await commandExists("llama-server")) return { label: "llama-server", status: "ok", detail: "llama-server found on PATH", required: true };
+  return { label: "llama-server", status: "missing", detail: "install llama.cpp, for example `brew install llama.cpp`", required: true };
+}
+
+async function modelCacheCheck(): Promise<DoctorCheck> {
+  const model = MODEL_REGISTRY[DEFAULT_MODEL_ID];
+  const modelPath = path.join(cacheDir(), "models", model.file);
+  if (await fileExists(modelPath)) return { label: "default model", status: "ok", detail: `${model.name} cached` };
+  return {
+    label: "default model",
+    status: "info",
+    detail: `${model.name} not cached yet; first interactive search can download it locally`,
+  };
+}
+
+function renderDoctor(checks: readonly DoctorCheck[]): string {
+  const lines = [
+    "Stupify doctor",
+    "",
+    ...checks.map((check) => `${icon(check.status)} ${check.label}: ${check.detail}`),
+    "",
+    "Privacy: local-only. Stupify does not upload source, diffs, filenames, repo URLs, commit messages, author names, or private package names.",
+  ];
+  return lines.join("\n");
+}
+
+function icon(status: CheckStatus): string {
+  if (status === "ok") return "OK";
+  if (status === "missing") return "MISSING";
+  return "INFO";
+}
+
+function resolvePackage(specifier: string): string | null {
+  try {
+    const require = createRequire(import.meta.url);
+    return require.resolve(specifier);
+  } catch {
+    return null;
+  }
+}
+
+async function commandExists(command: string): Promise<boolean> {
+  try {
+    await execFileAsync("sh", ["-c", `command -v ${shellQuote(command)}`], { maxBuffer: 1024 * 1024 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    const { stat } = await import("node:fs/promises");
+    return (await stat(filePath)).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function cacheDir(): string {
+  if (process.env.STUPIFY_CACHE_DIR) return process.env.STUPIFY_CACHE_DIR;
+  if (process.env.XDG_CACHE_HOME) return path.join(process.env.XDG_CACHE_HOME, "stupify");
+  if (platform() === "darwin") return path.join(homedir(), "Library", "Caches", "stupify");
+  if (platform() === "win32" && process.env.LOCALAPPDATA) return path.join(process.env.LOCALAPPDATA, "stupify", "Cache");
+  return path.join(homedir(), ".cache", "stupify");
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/git.ts

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { sourceId, type NetDiff, type NetDiffStats, type SourceRange } from "./types.ts";
+import { sourceId, type NetDiff, type NetDiffStats, type SourceRange, type StagedDiff } from "./types.ts";
 
 const execFileAsync = promisify(execFile);
 
@@ -62,6 +62,40 @@ export async function netDiffFromStdin(text: string): Promise<NetDiff> {
   };
 }
 
+export async function stagedDiff(): Promise<StagedDiff> {
+  try {
+    const { stdout } = await execFileAsync("git", [
+      "diff",
+      "--cached",
+      "--no-ext-diff",
+      "--no-color",
+      "--unified=3",
+      "--",
+    ], { maxBuffer: 64 * 1024 * 1024 });
+    return { text: stdout, stats: statsFromDiff(stdout) };
+  } catch {
+    throw new Error("Could not read staged changes. Run stupify inside a git repository.");
+  }
+}
+
+export async function gitRoot(): Promise<string> {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"]);
+    return stdout.trim();
+  } catch {
+    throw new Error("Could not find a git repository.");
+  }
+}
+
+export async function gitPath(pathspec: string): Promise<string> {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--git-path", pathspec]);
+    return stdout.trim();
+  } catch {
+    throw new Error(`Could not resolve git path: ${pathspec}`);
+  }
+}
+
 async function netDiff(base: string, target: string, label: string, id?: NetDiff["id"]): Promise<NetDiff> {
   const [text, stats, shortBase, shortTarget] = await Promise.all([
     diff(base, target),