@davesheffer/hunch 1.45.2 → 1.47.0

package/dist/integrations/mergeDriver.js

@@ -1,29 +1,29 @@
 /**
  * Wires up two independent git merge drivers:
- *   - `merge=hunch` — the structured `.hunch/` JSON driver (store/merge.ts):
- *     resolves concurrent edits by record id.
- *   - `merge=hunch-grounding` — the generated grounding docs (core/groundingMerge.ts):
- *     auto-resolves a hard conflict confined to the record-counts sentence,
- *     leaving any other conflict untouched (dec_ba5b0dfa22).
- * Both routes live in `.gitattributes` (committed, travels with the repo);
- * both drivers are registered in LOCAL git config only (per-clone, since each
- * references this machine's node + cli path — teammates re-run `hunch init`).
+ *  - `merge=hunch`: the structured `.hunch/` JSON driver (store/merge.ts), which
+ *    resolves concurrent edits by record id;
+ *  - `merge=hunch-grounding`: the generated grounding docs driver
+ *    (core/groundingMerge.ts), which auto-resolves only a hard conflict confined
+ *    to the record-counts sentence.
+ * Both routes live in the committed `.gitattributes`. Both drivers are
+ * registered only in local, per-clone git config, because each references this
+ * machine's node and CLI path; teammates re-run `hunch init`.
  */
 import { execFileSync } from "node:child_process";
 import { readFileSync, existsSync } from "node:fs";
 import { writeFileAtomic } from "../core/io.js";
 import { assertSafeTopLevelConfigFile } from "./gitignore.js";
 import { GROUNDING_DOC_PATHS } from "./providers.js";
+import { mergeDriverShell } from "../cli/invocation.js";
 // Route the .hunch JSON records through the structured driver — but NOT the
 // manifest (an id-less `{schema_version}` object the driver can't merge by id; a
 // normal text merge with conflict markers is the right behavior for it).
-//
-// The five generated grounding docs get the OTHER driver — narrower in scope
-// (it only ever touches a hard conflict confined to the counts sentence).
+// The five generated grounding docs go to the other driver, which is narrower:
+// it only ever touches a hard conflict confined to the counts sentence.
 export const ATTR_LINES = [
     ".hunch/**/*.json merge=hunch",
     ".hunch/manifest.json merge=text",
-    ...GROUNDING_DOC_PATHS.map((f) => `${f} merge=hunch-grounding`),
+    ...GROUNDING_DOC_PATHS.map((p) => `${p} merge=hunch-grounding`),
 ];
 export function targetRepositoryEnv() {
     const env = { ...process.env };
@@ -56,11 +56,12 @@ export function installMergeDriver(root, invShell) {
         assertSafeTopLevelConfigFile(root, ".gitattributes");
         writeFileAtomic(attrPath, text);
     }
-    // 2. Local git config — the driver definitions are per-clone (they reference
-    //    this machine's node + cli path), so they are NOT committed; teammates
-    //    re-run init.
-    const driver = `${invShell} merge-driver "%O" "%A" "%B" "%P"`;
-    const groundingDriver = `${invShell} merge-driver-grounding "%O" "%A" "%B" "%P"`;
+    // 2. The driver definitions go into local git config. They are per-clone (they
+    //    reference this machine's node and CLI path), so they are never committed; teammates
+    //    re-run init. Dev mode swaps `npx tsx` for Hunch's own loader (#492).
+    const shell = mergeDriverShell(invShell);
+    const driver = `${shell} merge-driver "%O" "%A" "%B" "%P"`;
+    const groundingDriver = `${shell} merge-driver-grounding "%O" "%A" "%B" "%P"`;
     const env = targetRepositoryEnv();
     try {
         execFileSync("git", ["config", "merge.hunch.name", "hunch structured JSON merge"], { cwd: root, env });

package/dist/integrations/optout.d.ts

@@ -0,0 +1,3 @@
+/** 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;

package/dist/integrations/optout.js

@@ -0,0 +1,17 @@
+/**
+ * The opt-out marker `hunch uninstall` leaves (#449), apart from uninstall.ts so the
+ * hook installers can honor it without an import cycle (uninstall.ts imports hooks.ts).
+ */
+import { lstatSync } from "node:fs";
+import { join } from "node:path";
+/** The opt-out marker, at the repository root. Commit it so every clone stays opted out. */
+export const OPT_OUT_FILE = ".hunch-removed";
+export function isOptedOut(root) {
+    try {
+        return lstatSync(join(root, OPT_OUT_FILE)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=optout.js.map

package/dist/integrations/providers.d.ts

@@ -73,8 +73,12 @@ export declare function writeCodexHooks(root: string, inv: Invocation): string;
 export declare function writeVscodeHooks(root: string, inv: Invocation): string;
 /** Windsurf's documented workspace hooks. It only supports deterministic
  * pre-hook blocking via exit code 2, so Hunch uses rules + MCP for context and
- * reserves the hook for strict edit protection and pipeline observation. */
-export declare function writeWindsurfHooks(root: string, inv: Invocation): string;
+ * reserves the hook for strict edit protection and pipeline observation.
+ * Devin Desktop (formerly Windsurf) reads .devin/hooks.json and ignores the
+ * legacy .windsurf/hooks.json whenever the former defines any hook, so Hunch
+ * merges into both (docs.devin.ai/desktop/cascade/hooks, #494). Both files are
+ * parsed before either is written: an unparseable one refuses the whole write. */
+export declare function writeWindsurfHooks(root: string, inv: Invocation): string[];
 /** Antigravity keeps hook groups at the top level (not under `hooks`). Hunch
  * owns only the `hunch` group and replaces its own old entries idempotently. */
 export declare function writeAntigravityHooks(root: string, inv: Invocation): string;

package/dist/integrations/providers.js

@@ -419,9 +419,26 @@ function publishedPinEvents(file) {
 }
 /** Windsurf's documented workspace hooks. It only supports deterministic
  * pre-hook blocking via exit code 2, so Hunch uses rules + MCP for context and
- * reserves the hook for strict edit protection and pipeline observation. */
+ * reserves the hook for strict edit protection and pipeline observation.
+ * Devin Desktop (formerly Windsurf) reads .devin/hooks.json and ignores the
+ * legacy .windsurf/hooks.json whenever the former defines any hook, so Hunch
+ * merges into both (docs.devin.ai/desktop/cascade/hooks, #494). Both files are
+ * parsed before either is written: an unparseable one refuses the whole write. */
 export function writeWindsurfHooks(root, inv) {
-    const file = join(root, ".windsurf", "hooks.json");
+    const files = [join(root, ".windsurf", "hooks.json"), join(root, ".devin", "hooks.json")];
+    // Same shape checks writeHookConfig applies at write time, so neither file is
+    // written when the other would refuse.
+    for (const file of files) {
+        const hooks = objectField(readJsonObj(file), "hooks", file);
+        for (const event of WINDSURF_EVENTS) {
+            if (hooks[event] !== undefined && !Array.isArray(hooks[event])) {
+                throw new Error(`refusing to edit ${file}: hooks.${event} must be an array when present; fix it, then re-run.`);
+            }
+        }
+    }
+    return files.map((file) => writeWindsurfHookFile(file, inv));
+}
+function writeWindsurfHookFile(file, inv) {
     const published = hookCommand(publishedMcpInvocation(), "windsurf");
     let command = hookCommand(inv, "windsurf");
     // A source-checkout run (tsx / local dist) must never replace a tracked

package/dist/integrations/team.js

@@ -8,6 +8,7 @@
 import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, renameSync, rmSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
+import { boundedSpawnSync } from "../core/boundedSpawn.js";
 import { writeFileAtomic } from "../core/io.js";
 import { machineFile } from "../core/machine.js";
 import { hunchTreeAttributesAreSafe, safeOverlayGitTreeListing, safeOverlayTree } from "../core/overlaySafety.js";
@@ -654,13 +655,14 @@ export function cloneValidatedTeamOverlay(sharedRepo, sharedRepoCwd, destination
         }
         const cloneEnv = boundedTeamGitEnv();
         stage = "clone";
-        const cloned = spawnSync("git", [
+        // Bounded so a timeout kills git's whole tree, not just the root (#498).
+        const cloned = boundedSpawnSync("git", [
             "-c", "protocol.ext.allow=never",
             "-c", `core.hooksPath=${emptyHooks}`,
             "clone", "--no-checkout", `--template=${emptyTemplate}`,
             "--", repo, stagedDest,
         ], {
-            stdio: "ignore",
+            stdout: "ignore",
             env: cloneEnv,
             timeout: timeoutMs,
         });

package/dist/integrations/uninstall.d.ts

@@ -1,6 +1,5 @@
-/** 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;
+import { isOptedOut, OPT_OUT_FILE } from "./optout.js";
+export { isOptedOut, OPT_OUT_FILE };
 /** Whether `start`, or the repository containing it, opted out: walks up through
  *  `start`'s ancestors (which need not exist yet), stopping after the first one holding
  *  `.git` or at the filesystem root, so a path inside an opted-out repository (`serve
@@ -8,7 +7,14 @@ export declare function isOptedOut(root: string): boolean;
  *  store is deliberately not a boundary: a partition store nested in an opted-out
  *  repository stays gated (fail closed). */
 export declare function optedOutAt(start: string): boolean;
-export declare function optOutMessage(): string;
+/** The opt-out marker that gates `start` (walked as in `optedOutAt`), or null. With
+ *  `withinRepo`, a marker counts only when the walk reaches a repository: outside one,
+ *  an ancestor's marker gates nothing. */
+export declare function optOutMarkerAt(start: string, opts?: {
+    withinRepo?: boolean;
+}): string | null;
+/** The refusal, naming the marker of the repository actually checked (#488). */
+export declare function optOutMessage(marker?: string): string;
 export interface UninstallStep {
     /** Repo-relative (POSIX) where possible, else absolute. */
     path: string;

package/dist/integrations/uninstall.js

@@ -12,7 +12,7 @@
  *
  * `.hunch/` holds the engineering memory, so it stays unless `--purge`.
  */
-import { existsSync, lstatSync, readFileSync, readdirSync, rmdirSync, rmSync, statSync, writeFileSync, chmodSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, rmdirSync, rmSync, statSync, writeFileSync, chmodSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { parse as parseToml } from "smol-toml";
@@ -26,16 +26,8 @@ import { gitRun, isInside, planHookRemoval, worktreeTops } from "./hooks.js";
 import { ATTR_LINES, targetRepositoryEnv } from "./mergeDriver.js";
 import { antigravityMcpFile, isHunchProviderHook, readJsonObj, TOML_END, TOML_START, windsurfMcpFile } from "./providers.js";
 import { SLASH_COMMAND_FILES } from "./scaffold.js";
-/** The opt-out marker, at the repository root. Commit it so every clone stays opted out. */
-export const OPT_OUT_FILE = ".hunch-removed";
-export function isOptedOut(root) {
-    try {
-        return lstatSync(join(root, OPT_OUT_FILE)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
+import { isOptedOut, OPT_OUT_FILE } from "./optout.js";
+export { isOptedOut, OPT_OUT_FILE };
 /** Whether `start`, or the repository containing it, opted out: walks up through
  *  `start`'s ancestors (which need not exist yet), stopping after the first one holding
  *  `.git` or at the filesystem root, so a path inside an opted-out repository (`serve
@@ -43,19 +35,30 @@ export function isOptedOut(root) {
  *  store is deliberately not a boundary: a partition store nested in an opted-out
  *  repository stays gated (fail closed). */
 export function optedOutAt(start) {
+    return optOutMarkerAt(start) !== null;
+}
+/** The opt-out marker that gates `start` (walked as in `optedOutAt`), or null. With
+ *  `withinRepo`, a marker counts only when the walk reaches a repository: outside one,
+ *  an ancestor's marker gates nothing. */
+export function optOutMarkerAt(start, opts = {}) {
+    let found = null;
     for (let dir = resolve(start);;) {
-        if (isOptedOut(dir))
-            return true;
+        if (!found && isOptedOut(dir)) {
+            found = join(dir, OPT_OUT_FILE);
+            if (!opts.withinRepo)
+                return found;
+        }
         if (existsSync(join(dir, ".git")))
-            return false;
+            return found;
         const parent = dirname(dir);
         if (parent === dir)
-            return false;
+            return opts.withinRepo ? null : found;
         dir = parent;
     }
 }
-export function optOutMessage() {
-    return `Hunch was removed from this repository on purpose (${OPT_OUT_FILE}), so it will not set itself up here again. To reinstall, delete ${OPT_OUT_FILE} and run \`hunch init\`.`;
+/** The refusal, naming the marker of the repository actually checked (#488). */
+export function optOutMessage(marker = OPT_OUT_FILE) {
+    return `Hunch was removed from this repository on purpose (${marker}), so it will not set itself up here again. To reinstall, delete ${marker} and run \`hunch init\`.`;
 }
 function markerText() {
     return [
@@ -310,6 +313,7 @@ export function planUninstall(root, opts = {}) {
     p.hookConfig(".codex/hooks.json", providerEntry);
     p.hookConfig(".github/hooks/hunch.json", providerEntry);
     p.hookConfig(".windsurf/hooks.json", providerEntry);
+    p.hookConfig(".devin/hooks.json", providerEntry);
     p.json(".agents/hooks.json", "removed the hunch hook group", (json) => {
         if (!("hunch" in json))
             return false;
@@ -459,7 +463,7 @@ export function planUninstall(root, opts = {}) {
 }
 /** Directories Hunch's writers create; removed only when left empty. Deepest first. */
 const PRUNE_DIRS = [
-    ".claude/commands", ".claude", ".cursor/rules", ".cursor", ".windsurf/rules", ".windsurf",
+    ".claude/commands", ".claude", ".cursor/rules", ".cursor", ".windsurf/rules", ".windsurf", ".devin",
     ".vscode", ".github/hooks", ".github/workflows", ".github", ".codex", ".agents",
 ];
 export function applyUninstall(plan) {

package/dist/mcp/server.d.ts

@@ -359,12 +359,12 @@ declare const DELIVERY_OUTPUT_SCHEMA: z.ZodObject<{
                 type: z.ZodEnum<{
                     depends_on: "depends_on";
                     calls: "calls";
+                    references: "references";
                     imports: "imports";
                     contains: "contains";
                     implements: "implements";
                     supersedes: "supersedes";
                     related_to: "related_to";
-                    references: "references";
                     provides: "provides";
                     belongs_to: "belongs_to";
                     implemented_by: "implemented_by";
@@ -624,10 +624,9 @@ export declare function compactEnvelope(envelope: z.infer<typeof DELIVERY_OUTPUT
  *  receipts and receipt_id are unchanged. */
 export declare function compactOmissions(envelope: z.infer<typeof DELIVERY_OUTPUT_SCHEMA>): z.infer<typeof DELIVERY_ADVERTISED_OUTPUT_SCHEMA>;
 export declare function decisionSubstanceChanged(before: Decision, after: Decision): boolean;
-/** Resolve a free-form target (symbol id / name / file path) to symbol records.
- *  Tiered exact-id > exact-name > exact-file > segment-anchored-suffix matching,
- *  shared with `HunchStore.why()` via `matchSymbolsTiered` so the two don't drift
- *  apart on the same question. */
+/** Resolve a free-form target (symbol id, name, or file path) to symbol records using
+ *  tiered matching — exact id, then exact name, then exact file, then a path-segment-anchored
+ *  suffix. Shared with HunchStore.why() through matchSymbolsTiered so the two never disagree. */
 export declare function resolveSymbols(store: HunchStore, target: string): Symbol[];
 /** Resolve a target to canonical indexed file path(s) (for file-granular blast
  *  radius). Falls back to the literal target so direct-scope checks still run. */