@davesheffer/hunch 1.43.0 → 1.44.0

package/dist/integrations/hooks.d.ts

@@ -144,6 +144,21 @@ export declare function hookStatus(root: string): {
     postMerge: boolean;
     postCheckout: boolean;
 };
+/** One git hook file `hunch uninstall` would change. `next === null` deletes the
+ *  file (only a shebang was left); a `reason` means nothing is edited and the
+ *  user removes the block by hand. */
+export interface HookRemoval {
+    path: string;
+    hookName: string;
+    next?: string | null;
+    reason?: string;
+}
+/** Plan the removal of every Hunch-managed block from the hooks git runs (#449).
+ *  Read-only. Only a hook file Hunch itself writes (manager "none", or an
+ *  exec/exit file whose block it appended) is edited, and only a block with both
+ *  markers; a hook manager's file, a tracked hooks dir, or an unclosed block is
+ *  reported instead — the same lines Hunch refuses to write on install. */
+export declare function planHookRemoval(root: string): HookRemoval[];
 /** Doctor lines for where each installed/stale hook points (issue #315): hooks
  *  sharing one invocation share one line, and a line whose invocation is not the
  *  Hunch currently running says so. Informational — a hook may legitimately

package/dist/integrations/hooks.js

@@ -20,7 +20,7 @@ import { homedir } from "node:os";
 import { hooksDir, gitCommonDir, isLinkedWorktree, mainWorktreeRoot } from "../extractors/git.js";
 import { initiatorChildEnv } from "../synthesis/initiator.js";
 import { HUNCH_NPX_PACKAGE_SPEC, HUNCH_PACKAGE_NAME } from "../core/version.js";
-import { normalizeEol } from "../core/eol.js";
+import { eolLengthAt, normalizeEol } from "../core/eol.js";
 const MARK = "# >>> hunch post-commit >>>";
 const ENDMARK = "# <<< hunch post-commit <<<";
 const GIT_CONTEXT = { checkoutType: "$3", portable: false };
@@ -942,6 +942,54 @@ export function hookStatus(root) {
         postCheckout: r.postCheckout.state === "installed",
     };
 }
+/** Plan the removal of every Hunch-managed block from the hooks git runs (#449).
+ *  Read-only. Only a hook file Hunch itself writes (manager "none", or an
+ *  exec/exit file whose block it appended) is edited, and only a block with both
+ *  markers; a hook manager's file, a tracked hooks dir, or an unclosed block is
+ *  reported instead — the same lines Hunch refuses to write on install. */
+export function planHookRemoval(root) {
+    const ends = {
+        [MARK]: ENDMARK, [PRE_MARK]: PRE_END, [GROUNDING_MERGE_MARK]: GROUNDING_MERGE_END,
+        [REPAIR_MERGE_MARK]: REPAIR_MERGE_END, [CHECKOUT_MARK]: CHECKOUT_END,
+    };
+    const byHook = new Map();
+    for (const [hookName, mark] of managedBlocks())
+        byHook.set(hookName, [...(byHook.get(hookName) ?? []), mark]);
+    const out = [];
+    for (const [hookName, marks] of byHook) {
+        const t = resolveHookTarget(root, hookName, marks[0]);
+        if (t.manager !== "none" && t.manager !== "exec-exit") {
+            const owner = readText(t.ownerFile);
+            if (owner !== null && marks.some((m) => owner.includes(m))) {
+                out.push({ path: t.ownerFile, hookName, reason: `${t.manager} owns this hook; remove the Hunch block from it by hand` });
+            }
+            continue;
+        }
+        const cur = readText(t.hookPath);
+        if (cur === null || !marks.some((m) => cur.includes(m)))
+            continue;
+        let next = cur;
+        let damaged = false;
+        for (const mark of marks) {
+            if (!next.includes(mark))
+                continue;
+            const m = new RegExp(`${escapeRe(mark)}[\\s\\S]*?${escapeRe(ends[mark])}`).exec(next);
+            if (!m) {
+                damaged = true;
+                continue;
+            }
+            const end = m.index + m[0].length;
+            next = next.slice(0, m.index) + next.slice(end + eolLengthAt(next, end));
+        }
+        if (damaged) {
+            out.push({ path: t.hookPath, hookName, reason: "a Hunch block here has no closing marker; remove it by hand" });
+            continue;
+        }
+        const body = normalizeEol(next).split("\n").filter((l, i) => !(i === 0 && l.startsWith("#!")));
+        out.push({ path: t.hookPath, hookName, next: body.every((l) => l.trim() === "") ? null : next });
+    }
+    return out;
+}
 /** Doctor lines for where each installed/stale hook points (issue #315): hooks
  *  sharing one invocation share one line, and a line whose invocation is not the
  *  Hunch currently running says so. Informational — a hook may legitimately

package/dist/integrations/mergeDriver.d.ts

@@ -1,3 +1,5 @@
+export declare const ATTR_LINES: readonly string[];
+export declare function targetRepositoryEnv(): NodeJS.ProcessEnv;
 export declare function installMergeDriver(root: string, invShell: string): {
     action: string;
 };

package/dist/integrations/mergeDriver.js

@@ -20,12 +20,12 @@ import { GROUNDING_DOC_PATHS } from "./providers.js";
 //
 // The five generated grounding docs get the OTHER driver — narrower in scope
 // (it only ever touches a hard conflict confined to the counts sentence).
-const ATTR_LINES = [
+export const ATTR_LINES = [
     ".hunch/**/*.json merge=hunch",
     ".hunch/manifest.json merge=text",
     ...GROUNDING_DOC_PATHS.map((f) => `${f} merge=hunch-grounding`),
 ];
-function targetRepositoryEnv() {
+export function targetRepositoryEnv() {
     const env = { ...process.env };
     for (const key of [
         "GIT_ALTERNATE_OBJECT_DIRECTORIES", "GIT_CONFIG", "GIT_CONFIG_PARAMETERS", "GIT_CONFIG_COUNT",

package/dist/integrations/providers.d.ts

@@ -1,5 +1,10 @@
 import type { HunchStore } from "../store/hunchStore.js";
 import type { Invocation } from "./scaffold.js";
+/** Read a JSON/JSONC object. Returns {} only for an ABSENT or empty file. A
+ *  non-empty file we cannot parse THROWS — overwriting it would silently wipe the
+ *  user's other MCP servers. */
+export declare function readJsonObj(file: string): Record<string, unknown>;
+export declare function isHunchProviderHook(entry: unknown): boolean;
 /** Cursor: .cursor/mcp.json — same `mcpServers` shape as Claude Desktop/Code. */
 export declare function writeCursorMcp(root: string, inv: Invocation): string;
 /** VS Code (Copilot agent mode): .vscode/mcp.json — root key is `servers`, and
@@ -20,6 +25,8 @@ export declare function writeAntigravityMcp(inv: Invocation, home?: string): str
  * committed with the repository, so every clone gets the same private/local
  * Hunch server without touching a user's home directory. */
 export declare function writeAntigravityWorkspaceMcp(root: string, inv: Invocation): string;
+export declare const TOML_START = "# >>> hunch mcp (managed) >>>";
+export declare const TOML_END = "# <<< hunch mcp <<<";
 /** Codex CLI: .codex/config.toml — `[mcp_servers.hunch]` stdio entry. We own only
  *  a marker-delimited block; any other TOML the user has is preserved. Paths use
  *  TOML single-quote LITERAL strings so Windows backslashes need no escaping. */

package/dist/integrations/providers.js

@@ -50,7 +50,7 @@ function hasJsoncComments(raw) {
 /** Read a JSON/JSONC object. Returns {} only for an ABSENT or empty file. A
  *  non-empty file we cannot parse THROWS — overwriting it would silently wipe the
  *  user's other MCP servers. */
-function readJsonObj(file) {
+export function readJsonObj(file) {
     if (!existsSync(file))
         return {};
     const raw = readFileSync(file, "utf8");
@@ -128,7 +128,7 @@ function shellToken(part) {
 function hookCommand(inv, provider) {
     return [inv.command, ...inv.args, "hook", "--provider", provider].map(shellToken).join(" ");
 }
-function isHunchProviderHook(entry) {
+export function isHunchProviderHook(entry) {
     const e = entry && typeof entry === "object" ? entry : null;
     // Codex (like Claude Code) nests commands under a matcher entry: an entry
     // whose every nested hook is ours is ours; a mixed entry stays foreign.
@@ -210,8 +210,8 @@ export function writeAntigravityWorkspaceMcp(root, inv) {
     json.mcpServers.hunch = { command: inv.command, args: [...inv.args, "mcp"] };
     return writeJson(file, json);
 }
-const TOML_START = "# >>> hunch mcp (managed) >>>";
-const TOML_END = "# <<< hunch mcp <<<";
+export const TOML_START = "# >>> hunch mcp (managed) >>>";
+export const TOML_END = "# <<< hunch mcp <<<";
 /** Codex CLI: .codex/config.toml — `[mcp_servers.hunch]` stdio entry. We own only
  *  a marker-delimited block; any other TOML the user has is preserved. Paths use
  *  TOML single-quote LITERAL strings so Windows backslashes need no escaping. */

package/dist/integrations/scaffold.d.ts

@@ -23,6 +23,11 @@ export interface ClaudeHookInstall {
  * non-empty file we cannot parse THROWS rather than clobbering the user's config.
  */
 export declare function installClaudeHooks(root: string, hookCmd: string): ClaudeHookInstall;
+/** Ownership marker for generated slash commands: its presence means Hunch may
+ *  refresh the file; deleting the line hands the file to the user for good. */
+export declare const CMD_MARKER = "<!-- hunch:generated \u2014 refreshed by hunch init; delete this line to take ownership -->";
+/** File names `writeSlashCommands` writes under .claude/commands/. */
+export declare const SLASH_COMMAND_FILES: readonly string[];
 export declare function writeSlashCommands(root: string): {
     written: string[];
     skipped: string[];

package/dist/integrations/scaffold.js

@@ -233,13 +233,9 @@ export function installClaudeHooks(root, hookCmd) {
 }
 /** Ownership marker for generated slash commands: its presence means Hunch may
  *  refresh the file; deleting the line hands the file to the user for good. */
-const CMD_MARKER = "<!-- hunch:generated — refreshed by hunch init; delete this line to take ownership -->";
-export function writeSlashCommands(root) {
-    const dir = join(root, ".claude", "commands");
-    mkdirSync(dir, { recursive: true });
-    const written = [];
-    const skipped = [];
-    const files = [
+export const CMD_MARKER = "<!-- hunch:generated — refreshed by hunch init; delete this line to take ownership -->";
+function slashCommandFiles() {
+    return [
         ["hunch-why.md", WHY_CMD],
         ["hunch-fix.md", FIX_CMD],
         ["hunch-fragile.md", FRAGILE_CMD],
@@ -248,6 +244,15 @@ export function writeSlashCommands(root) {
         ["audit.md", AUDIT_CMD],
         ["worktrees.md", WORKTREES_CMD],
     ];
+}
+/** File names `writeSlashCommands` writes under .claude/commands/. */
+export const SLASH_COMMAND_FILES = Object.freeze(slashCommandFiles().map(([name]) => name));
+export function writeSlashCommands(root) {
+    const dir = join(root, ".claude", "commands");
+    mkdirSync(dir, { recursive: true });
+    const written = [];
+    const skipped = [];
+    const files = slashCommandFiles();
     for (const [name, body] of files) {
         const p = join(dir, name);
         // Generic names (capture/heal/audit) are plausibly the USER'S OWN commands;

package/dist/integrations/uninstall.d.ts

@@ -0,0 +1,40 @@
+/** The opt-out marker, at the repository root. Commit it so every clone stays opted out. */
+export declare const OPT_OUT_FILE = ".hunch-removed";
+export declare function isOptedOut(root: string): boolean;
+export declare function optOutMessage(): string;
+export interface UninstallStep {
+    /** Repo-relative (POSIX) where possible, else absolute. */
+    path: string;
+    kind: "edit" | "delete" | "create" | "keep";
+    note: string;
+    run?: () => void;
+}
+export interface UninstallPlan {
+    root: string;
+    purge: boolean;
+    steps: UninstallStep[];
+    refused: Array<{
+        path: string;
+        reason: string;
+    }>;
+}
+/** Read-only: everything `hunch uninstall` would do in `root`. */
+export declare function planUninstall(root: string, opts?: {
+    purge?: boolean;
+}): UninstallPlan;
+/** Apply a plan with no refusals. The opt-out marker goes first, so an interrupted
+ *  run is already opted out. A step that fails at write time (a file held open by a
+ *  running `hunch mcp`/`hunch serve` on Windows, a permission) does not stop the
+ *  others; the failures are returned so the caller can say what is left and that a
+ *  re-run — idempotent — finishes the job. */
+/** What applyUninstall actually did: the steps that ran (so output never
+ *  claims a step that was skipped), and the ones that failed. */
+export interface UninstallResult {
+    applied: UninstallStep[];
+    failed: Array<{
+        path: string;
+        error: string;
+    }>;
+}
+export declare function applyUninstall(plan: UninstallPlan): UninstallResult;
+export declare function formatUninstallPlan(plan: UninstallPlan, dryRun: boolean): string[];