@davesheffer/hunch 0.32.0 → 0.33.1

package/README.md

@@ -185,6 +185,16 @@ is **OS-agnostic**: paths are stored in POSIX form and an installed Hunch regist
 server by package name, so Windows / macOS / Linux teammates share one memory without
 per-machine fixups. → [docs](https://hunch-pi.vercel.app/docs#team)
 
+### Branches & worktrees
+
+Memory follows you across every branch and **git worktree**, with no per-worktree setup. The
+private overlay is registered once at the repo's **git common dir** (shared by all worktrees), so
+a fresh `git worktree add` on any branch sees the same decisions, bugs, and invariants. Create one
+already wired in with **`hunch worktree <path> [-b <branch>]`**, or just run `hunch init` / `hunch
+private` once and every worktree picks it up. Auto-captured decisions are tagged with their branch,
+and concurrent overlay writes are serialized — so parallel worktrees never corrupt or lose memory.
+`hunch doctor` confirms a worktree is sharing.
+
 ## Private memory (public repo, private context)
 
 Open-source your code without open-sourcing your *reasoning*. **`hunch private`** sets up a

package/dist/cli/index.js

@@ -34,6 +34,7 @@ import { extractInlineIntent } from "../extractors/comments.js";
 import { renderText, renderMarkdown, reportFailsStrict } from "../core/checkreport.js";
 import { partitionReview, READY_MIN_GROUNDED } from "../core/reviewqueue.js";
 import { installPostCommitHook, installPreCommitHook } from "../integrations/hooks.js";
+import { ensureSharedOverlayPointer } from "../integrations/worktree.js";
 import { installMergeDriver } from "../integrations/mergeDriver.js";
 import { ensureGitignore, ignoreHunchMemory, HUNCH_MEMORY_DIRS } from "../integrations/gitignore.js";
 import { writeCiWorkflow } from "../integrations/ciAction.js";
@@ -154,6 +155,15 @@ program
     // case-split in ~/.claude.json, merge it so hunch resolves under either casing.
     // No-op (silent) off Windows.
     reportClaudeConfigHeal();
+    // Worktree-seamless: register any configured overlay at the git common dir so EVERY
+    // worktree of this repo auto-discovers it (also backfills pre-0.32 single-worktree setups),
+    // and note when we're initializing inside a linked worktree (memory is shared, not separate).
+    if (ensureSharedOverlayPointer(root, store.privateDir, store.privateAutoCommit)) {
+        console.log(`  ✓ private overlay registered at the git common dir — shared by every worktree of this repo`);
+    }
+    if (isLinkedWorktree(root)) {
+        console.log(`  ✓ linked worktree — sharing the repo's hooks + memory (no separate setup needed)`);
+    }
     store.close();
     console.log("\nNext: make a commit (the hook captures a decision), then ask your coding assistant \"why is X built this way?\"");
     console.log("Cold start? Seed from history:  hunch backfill --since 90d");
@@ -348,12 +358,8 @@ program
     // (current + future, any branch) auto-discovers the same memory with zero per-worktree
     // setup. Stored ABSOLUTE — a linked worktree resolves relative paths from its OWN root, so
     // only an absolute path survives the move. Lives under .git/ (never tracked; nothing to ignore).
-    const commonDir = gitCommonDir(root);
     let worktreeNote = "";
-    if (commonDir) {
-        const sharedDir = join(commonDir, "hunch");
-        mkdirSync(sharedDir, { recursive: true });
-        writeFileAtomic(join(sharedDir, "local.json"), JSON.stringify({ privateDir: hunchDir, autoCommit: !!opts.autoCommit }, null, 2) + "\n");
+    if (ensureSharedOverlayPointer(root, hunchDir, !!opts.autoCommit)) {
         worktreeNote = `  ✓ registered in the git common dir — shared by every worktree of this repo, on any branch\n`;
     }
     // 4) route post-commit synthesis to the overlay (local hook, never committed)
@@ -397,6 +403,68 @@ program
         `  record sensitive items with private:true (hunch_record_decision / hunch_record_correction)\n` +
         `  override per-shell with HUNCH_PRIVATE_DIR; CI / public PR comments stay public-only.`);
 });
+// ---- worktree (one-command worktree wired into Hunch) ----------------------
+program
+    .command("worktree <path>")
+    .description("Create a git worktree already wired into Hunch — it shares this repo's memory (the private overlay), with zero per-worktree setup.")
+    .option("-b, --branch <name>", "create the worktree on a NEW branch")
+    .option("--no-share", "don't register the overlay at the git common dir (the worktree won't see private memory)")
+    .option("--no-index", "don't build the new worktree's code graph (skip if you'll index later)")
+    .action((path, opts) => {
+    const root = findRoot();
+    if (!isGitRepo(root))
+        return fail("`hunch worktree` needs a git repo");
+    const dest = resolve(root, path);
+    if (existsSync(dest))
+        return fail(`path already exists: ${dest}`);
+    // 1) create the worktree (on a new branch if asked, else a checkout of HEAD)
+    const r = spawnSync("git", ["-C", root, "worktree", "add", ...(opts.branch ? ["-b", opts.branch] : []), dest], { stdio: "inherit" });
+    if (r.status !== 0)
+        return fail("git worktree add failed");
+    // 2) register the overlay at the SHARED git common dir so the new worktree (and every
+    //    other) auto-discovers the same memory — also backfills pre-0.32 single-worktree setups.
+    const store = new HunchStore(hunchPaths(root));
+    const overlay = store.privateDir;
+    const autoCommit = store.privateAutoCommit;
+    store.close();
+    let shareNote;
+    if (!opts.share) {
+        shareNote = `  · --no-share — the worktree will NOT see private memory`;
+    }
+    else if (overlay && ensureSharedOverlayPointer(root, overlay, autoCommit)) {
+        shareNote = `  ✓ memory shared via the git common dir — this worktree sees the same decisions / bugs / constraints`;
+    }
+    else if (overlay) {
+        shareNote = `  · could not register the shared overlay pointer (no git common dir?)`;
+    }
+    else {
+        shareNote = `  · no private overlay configured — run \`hunch private\` to share memory across worktrees`;
+    }
+    // 3) build the new worktree's CODE GRAPH (symbols/edges → blast-radius / dependents).
+    //    Indexed IN-PROCESS (uses THIS install's tree-sitter, so the worktree needs no
+    //    node_modules) and ONLY when the graph isn't already committed in the checkout —
+    //    re-parsing a normal repo would just dirty its tracked .hunch/*.json. Writes the
+    //    derived (gitignored) index, never the working tree.
+    let indexNote = "";
+    if (opts.index !== false) {
+        const wstore = new HunchStore(hunchPaths(dest));
+        wstore.json.ensureDirs();
+        if (wstore.json.loadAll("symbols").length === 0) {
+            const res = indexRepo(wstore, dest);
+            wstore.reindex();
+            indexNote = `\n  ✓ indexed ${res.files} file(s) → ${res.symbols} symbols — blast-radius ready (code graph isn't committed here)`;
+        }
+        else {
+            wstore.reindex(); // committed graph already in the checkout → just build the derived SQLite
+            indexNote = `\n  ✓ code graph present in the checkout — blast-radius ready`;
+        }
+        wstore.close();
+    }
+    console.log(`✓ worktree created → ${dest}${opts.branch ? ` (new branch ${opts.branch})` : ""}\n` +
+        `${shareNote}${indexNote}\n` +
+        `  hooks + MCP server are shared (worktree-aware) — open your assistant in the new worktree to start.\n` +
+        `  (needs \`hunch\` installed globally; a worktree has no node_modules of its own)`);
+});
 // ---- query ----------------------------------------------------------------
 program
     .command("query")

package/dist/integrations/worktree.js

@@ -0,0 +1,33 @@
+/**
+ * Worktree wiring — make a repo's private-overlay memory seamless across every git
+ * worktree (v0.32+). A worktree's gitignored `.hunch/local.json` pointer doesn't exist
+ * in a fresh checkout, so we register the overlay at the SHARED git common dir
+ * (`git rev-parse --git-common-dir`), which every linked worktree resolves identically.
+ */
+import { existsSync, readFileSync, mkdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { gitCommonDir } from "../extractors/git.js";
+import { writeFileAtomic } from "../core/io.js";
+/** Register the resolved private overlay at the shared git common dir, so every worktree
+ *  of this repo auto-discovers the same memory. Idempotent (writes only when missing or
+ *  changed). Stored ABSOLUTE — a worktree resolves relative paths from its OWN root.
+ *  Returns true once the shared pointer is in place (memory is worktree-shared), false when
+ *  there's no overlay configured or no git common dir. Reused by `init`/`worktree`/`private`. */
+export function ensureSharedOverlayPointer(root, overlayDir, autoCommit) {
+    const common = overlayDir ? gitCommonDir(root) : "";
+    if (!common || !overlayDir)
+        return false;
+    const file = join(common, "hunch", "local.json");
+    const want = JSON.stringify({ privateDir: resolve(overlayDir), autoCommit }, null, 2) + "\n";
+    try {
+        if (!(existsSync(file) && readFileSync(file, "utf8") === want)) {
+            mkdirSync(join(common, "hunch"), { recursive: true });
+            writeFileAtomic(file, want);
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=worktree.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "0.32.0",
+  "version": "0.33.1",
   "license": "Apache-2.0",
   "author": "Dave Sheffer <dave.sheffer1@gmail.com>",
   "description": "Hunch — an Engineering Memory OS: a persistent, git-native reasoning graph over a codebase, exposed to Claude Code via MCP.",