@stupify/cli 0.0.3 → 0.0.5

package/dist/command.js

@@ -1,85 +1,98 @@
 import { DEFAULT_MODEL_ID, MODEL_REGISTRY } from "./constants.js";
 const DEFAULT_SINCE = "2 weeks ago";
 const DEFAULT_MAX_CANDIDATES = 10;
-const DEFAULT_SCOUT_MODE = "counter";
-const DEFAULT_AUDIT_CONTEXT = "repomix";
-const DEFAULT_AUDIT_PROMPT = "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;
 export function parseCommand(argv) {
     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" };
     }
     const initialState = {
-        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, state) {
         if (index >= argv.length)
             return state;
         const arg = argv[index];
+        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" }));
+            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") {
             const value = argv[index + 1];
@@ -96,30 +109,6 @@ export function parseCommand(argv) {
                 throw new Error(`--model must be one of: ${Object.keys(MODEL_REGISTRY).join(", ")}`);
             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);
@@ -128,35 +117,19 @@ export function parseCommand(argv) {
             }
             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") {
+        if (arg === "--max-search-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.");
+            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, maxAuditInputTokens });
-        }
-        if (arg === "--audit-concurrency") {
-            const value = argv[index + 1];
-            const auditConcurrency = Number(value);
-            if (!Number.isInteger(auditConcurrency) || auditConcurrency < 1) {
-                throw new Error("--audit-concurrency 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, next) {
         if (state.explicitInputMode)
-            throw new Error("Choose only one input mode: --since, --stdin, --commit, or --commits.");
+            throw new Error("Choose only one input mode: --since, --stdin, --commit, --commits, or --staged.");
         return { ...state, inputMode: next, explicitInputMode: true };
     }
 }
@@ -169,15 +142,6 @@ function isHelp(value) {
 function isModelId(value) {
     return value in MODEL_REGISTRY;
 }
-function isEngine(value) {
-    return value === "raw-diff" || value === "sem";
-}
-function isScoutMode(value) {
-    return value === "counter" || value === "llm";
-}
-function isAuditContextMode(value) {
-    return value === "none" || value === "repomix";
-}
-function isAuditPromptName(value) {
-    return value === "strict" || value === "high_bar";
+function isHookAction(value) {
+    return value === "install" || value === "uninstall" || value === "status";
 }

package/dist/constants.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "0.0.3";
+export declare const VERSION = "0.0.5";
 import type { ModelConfig, ModelId } from "./types.ts";
 export declare const DEFAULT_MODEL_ID: ModelId;
 export declare const MODEL_REGISTRY: Record<ModelId, ModelConfig>;

package/dist/constants.js

@@ -1,4 +1,4 @@
-export const VERSION = "0.0.3";
+export const VERSION = "0.0.5";
 export const DEFAULT_MODEL_ID = "gemma-4-e2b";
 export const MODEL_REGISTRY = {
     "gemma-4-e2b": {

package/dist/counter-scout.js

@@ -38,13 +38,15 @@ export function runSignalCounters(changeSet, checks) {
         .filter((bucket) => bucket.total > 0);
 }
 function reasonForCheck(checkId, change) {
+    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) {
         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"
@@ -62,11 +64,11 @@ function reasonForCheck(checkId, change) {
                 ? "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":
@@ -74,7 +76,7 @@ function reasonForCheck(checkId, change) {
                 ? "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":
@@ -85,13 +87,73 @@ function reasonForCheck(checkId, change) {
             return null;
     }
 }
-function isSchemaish(change, haystack) {
-    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
     if (!value)
         return 0;
     return value.split(/\r?\n/).filter((line) => /^\s*(\/\/|\/\*|\*|#)/.test(line)).length;
 }
+function commentText(value) {
+    if (!value)
+        return "";
+    return value
+        .split(/\r?\n/)
+        .filter((line) => /^\s*(\/\/|\/\*|\*|#)/.test(line))
+        .join("\n");
+}
+function words(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[_-]+/g, " ");
+}

package/dist/doctor.d.ts

@@ -0,0 +1,4 @@
+export declare function runDoctor(): Promise<Readonly<{
+    exitCode: number;
+    text: string;
+}>>;

package/dist/doctor.js

@@ -0,0 +1,131 @@
+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.js";
+import { runHookCommand } from "./hooks.js";
+const execFileAsync = promisify(execFile);
+export async function runDoctor() {
+    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() {
+    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() {
+    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() {
+    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() {
+    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() {
+    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() {
+    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) {
+    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) {
+    if (status === "ok")
+        return "OK";
+    if (status === "missing")
+        return "MISSING";
+    return "INFO";
+}
+function resolvePackage(specifier) {
+    try {
+        const require = createRequire(import.meta.url);
+        return require.resolve(specifier);
+    }
+    catch {
+        return null;
+    }
+}
+async function commandExists(command) {
+    try {
+        await execFileAsync("sh", ["-c", `command -v ${shellQuote(command)}`], { maxBuffer: 1024 * 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function fileExists(filePath) {
+    try {
+        const { stat } = await import("node:fs/promises");
+        return (await stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function cacheDir() {
+    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) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/git.d.ts

@@ -1,4 +1,4 @@
-import { type NetDiff, type SourceRange } from "./types.ts";
+import { type NetDiff, type SourceRange, type StagedDiff } from "./types.ts";
 export declare function netDiffSince(since: string): Promise<NetDiff>;
 export declare function netDiffForCommit(commit: string): Promise<NetDiff>;
 export declare function netDiffForRecentCommits(count: number): Promise<NetDiff>;
@@ -6,3 +6,6 @@ export declare function sourceRangeSince(since: string): Promise<SourceRange>;
 export declare function sourceRangeForCommit(commit: string): Promise<SourceRange>;
 export declare function sourceRangeForRecentCommits(count: number): Promise<SourceRange>;
 export declare function netDiffFromStdin(text: string): Promise<NetDiff>;
+export declare function stagedDiff(): Promise<StagedDiff>;
+export declare function gitRoot(): Promise<string>;
+export declare function gitPath(pathspec: string): Promise<string>;

package/dist/git.js

@@ -53,6 +53,40 @@ export async function netDiffFromStdin(text) {
         stats: statsFromDiff(text),
     };
 }
+export async function 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() {
+    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) {
+    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, target, label, id) {
     const [text, stats, shortBase, shortTarget] = await Promise.all([
         diff(base, target),

package/dist/hooks.d.ts

@@ -0,0 +1,3 @@
+import type { HookAction } from "./types.ts";
+export declare function runHookCommand(action: HookAction): Promise<string>;
+export declare function hookSnippet(): string;

package/dist/hooks.js

@@ -0,0 +1,117 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { chmod, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { gitPath, gitRoot } from "./git.js";
+const execFileAsync = promisify(execFile);
+const START = "# stupify hook start";
+const END = "# stupify hook end";
+export async function runHookCommand(action) {
+    if (action === "status")
+        return hookStatus();
+    if (action === "install")
+        return installHook();
+    return uninstallHook();
+}
+export function hookSnippet() {
+    return managedBlock("stupify --staged");
+}
+async function hookStatus() {
+    const hookPath = await preCommitHookPath();
+    if (!existsSync(hookPath))
+        return "Stupify hook: not installed";
+    const content = await readFile(hookPath, "utf8");
+    if (hasManagedBlock(content))
+        return "Stupify hook: installed";
+    return "Stupify hook: existing non-Stupify pre-commit hook found";
+}
+async function installHook() {
+    const hookPath = await preCommitHookPath();
+    const block = await managedBlockForInstall();
+    if (!existsSync(hookPath)) {
+        await writeFile(hookPath, `#!/bin/sh\n${block}\n`, "utf8");
+        await chmod(hookPath, 0o755);
+        return "Stupify hook: installed";
+    }
+    const content = await readFile(hookPath, "utf8");
+    if (hasManagedBlock(content)) {
+        await writeFile(hookPath, `${replaceManagedBlock(content, block).trimEnd()}\n`, "utf8");
+        await chmod(hookPath, 0o755);
+        return "Stupify hook: updated";
+    }
+    if (isEffectivelyEmptyHook(content)) {
+        await writeFile(hookPath, `#!/bin/sh\n${block}\n`, "utf8");
+        await chmod(hookPath, 0o755);
+        return "Stupify hook: installed";
+    }
+    return `Stupify hook: existing non-Stupify pre-commit hook found; not modified.
+Add this snippet manually if you want Stupify in that hook:
+${block}`;
+}
+async function uninstallHook() {
+    const hookPath = await preCommitHookPath();
+    if (!existsSync(hookPath))
+        return "Stupify hook: not installed";
+    const content = await readFile(hookPath, "utf8");
+    if (!hasManagedBlock(content))
+        return "Stupify hook: not installed";
+    const next = replaceManagedBlock(content, "").trim();
+    if (isEffectivelyEmptyHook(next)) {
+        await rm(hookPath, { force: true });
+        return "Stupify hook: uninstalled";
+    }
+    await writeFile(hookPath, `${next}\n`, "utf8");
+    await chmod(hookPath, 0o755);
+    return "Stupify hook: uninstalled";
+}
+async function preCommitHookPath() {
+    const [root, hook] = await Promise.all([gitRoot(), gitPath("hooks/pre-commit")]);
+    return path.isAbsolute(hook) ? hook : path.join(root, hook);
+}
+function hasManagedBlock(content) {
+    return content.includes(START) && content.includes(END);
+}
+async function managedBlockForInstall() {
+    if (await commandExists("stupify"))
+        return managedBlock("stupify --staged");
+    const root = await gitRoot();
+    const localEntrypoint = path.join(root, "packages", "cli", "src", "stupify.ts");
+    if (existsSync(localEntrypoint) && await commandExists("bun")) {
+        return managedBlock(`bun ${shellQuote(localEntrypoint)} --staged`);
+    }
+    return managedBlock("stupify --staged");
+}
+function managedBlock(command) {
+    return `${START}
+${command} || true
+${END}`;
+}
+function replaceManagedBlock(content, replacement) {
+    const pattern = new RegExp(`${escapeRegExp(START)}[\\s\\S]*?${escapeRegExp(END)}`);
+    return content.replace(pattern, replacement);
+}
+function isEffectivelyEmptyHook(content) {
+    return content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && line !== "#!/bin/sh" && line !== "#!/usr/bin/env sh")
+        .length === 0;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function commandExists(command) {
+    try {
+        await execFileAsync("sh", ["-c", `command -v ${shellQuote(command)}`], {
+            maxBuffer: 1024 * 1024,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}