@davesheffer/hunch 0.33.0 → 0.34.0

package/dist/cli/index.js

@@ -35,6 +35,7 @@ import { renderText, renderMarkdown, reportFailsStrict } from "../core/checkrepo
 import { partitionReview, READY_MIN_GROUNDED } from "../core/reviewqueue.js";
 import { installPostCommitHook, installPreCommitHook } from "../integrations/hooks.js";
 import { ensureSharedOverlayPointer } from "../integrations/worktree.js";
+import { flushPrivate } from "../integrations/sync.js";
 import { installMergeDriver } from "../integrations/mergeDriver.js";
 import { ensureGitignore, ignoreHunchMemory, HUNCH_MEMORY_DIRS } from "../integrations/gitignore.js";
 import { writeCiWorkflow } from "../integrations/ciAction.js";
@@ -312,7 +313,7 @@ program
     .description("Enable a PRIVATE memory overlay — sensitive decisions/bugs/constraints kept in a separate location, unioned into local queries, never committed here. Writes a gitignored .hunch/local.json so it's auto-detected (no env var needed).")
     .option("--repo <url>", "clone a private git repo to use as the store (into ./.hunch-private)")
     .option("--no-hook", "don't switch the post-commit hook to private sync")
-    .option("--auto-commit", "opt-in: also git add+commit+push the private repo after each capture (post-commit hook AND MCP private writes)")
+    .option("--no-auto-commit", "DON'T auto commit+push the overlay after each capture (default: ON — fully automated two-way sync, never push by hand)")
     .option("--sync", "flush the configured private store now (git add+commit+push) — catches records made via MCP between commits")
     .option("--migrate", "ONE-TIME: move this repo's EXISTING public .hunch memory into the overlay, then make the public repo code-only — untrack + gitignore the memory tree and regenerate grounding so no memory is published here")
     .action((dir, opts) => {
@@ -344,6 +345,13 @@ program
     }
     // 2) create the layout (decisions/, manifest, …) so it's queryable immediately
     new JsonStore(hunchPathsForDir(hunchDir)).ensureDirs();
+    const inv = resolveInvocation();
+    // Install the structured merge driver IN the overlay repo so concurrent captures from
+    // multiple machines/worktrees merge by RECORD ID (no manual conflict resolution) when the
+    // two-way auto-sync pulls before pushing. The overlay repo root is the parent of its .hunch.
+    const overlayRoot = hunchPathsForDir(hunchDir).root;
+    if (isGitRepo(overlayRoot))
+        installMergeDriver(overlayRoot, inv.shell);
     // 3) record the path in a GITIGNORED local config — auto-detected, no env var, and
     //    the MCP server picks it up too. Atomic write (con_902759b3dc) since it's under .hunch/.
     mkdirSync(paths.hunch, { recursive: true }); // tolerate a repo where `hunch init` hasn't run yet
@@ -365,7 +373,6 @@ program
     // 4) route post-commit synthesis to the overlay (local hook, never committed)
     let hookNote = "";
     if (opts.hook && isGitRepo(root)) {
-        const inv = resolveInvocation();
         const h = installPostCommitHook(root, inv.shell, { private: true, commit: opts.autoCommit });
         hookNote = `  ✓ post-commit hook ${h.action} — captured decisions route here${opts.autoCommit ? " (auto-commit+push on)" : ""}\n`;
     }
@@ -409,6 +416,7 @@ program
     .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))
@@ -439,8 +447,28 @@ program
     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}\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)`);
 });
@@ -653,6 +681,8 @@ program
         }
     }
     store.reindex();
+    if (opts.private && (dec || con))
+        flushPrivate(store, `hunch: capture ${dec + con} inline intent(s)`);
     if (!intents.length)
         console.log("No `hunch-why:` / `hunch-rule:` comments found.");
     else

package/dist/extractors/git.js

@@ -44,7 +44,51 @@ export function commitAndPushHunch(hunchDir, message) {
         };
         run(["add", "--", "."]);
         run(["commit", "-m", message]);
-        run(["push"]);
+        // Two-way sync: MERGE the remote BEFORE pushing, so a push can never be rejected
+        // non-fast-forward (the cause of memory piling up unpushed across machines). The .hunch
+        // merge driver resolves same-record conflicts by id; non-overlapping records merge cleanly
+        // without it. On an unresolved conflict / offline, mergeRemote aborts to a clean tree and we
+        // skip the push — the local commit stays and syncs on the next write (never lost).
+        if (mergeRemote(hunchDir, env))
+            run(["push"]);
+    }
+    finally {
+        try {
+            rmSync(lock, { recursive: true, force: true });
+        }
+        catch { /* released best-effort */ }
+    }
+}
+/** Merge the overlay's remote into the local branch (pull, no rebase), leaving a CLEAN tree
+ *  whether it succeeds or not. Returns true when the branch is safe to push (merged, or there's
+ *  no upstream to merge), false when a conflict was aborted (caller skips the push and retries
+ *  on the next write). Never throws. */
+function mergeRemote(hunchDir, env) {
+    const tryGit = (args) => {
+        try {
+            execFileSync("git", ["-C", hunchDir, ...args], { stdio: "ignore", env });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (!tryGit(["rev-parse", "--abbrev-ref", "@{upstream}"]))
+        return true; // no remote/offline → push no-ops
+    if (tryGit(["pull", "--no-edit", "--no-rebase", "--autostash"]))
+        return true;
+    tryGit(["merge", "--abort"]); // conflict the driver couldn't resolve → restore a clean tree
+    return false;
+}
+/** Best-effort READ-side sync: merge the overlay's remote into the local branch (e.g. on MCP
+ *  server start) so this machine/session sees other machines' memory. Never throws; leaves a
+ *  clean tree. Serialized with the commit lock so it can't race a concurrent flush. */
+export function pullHunch(hunchDir) {
+    const lock = join(hunchDir, ".hunch-commit.lock");
+    if (!acquireCommitLock(lock))
+        return;
+    try {
+        mergeRemote(hunchDir, { ...process.env, HUNCH_SYNC: "1" });
     }
     finally {
         try {

package/dist/integrations/sync.js

@@ -0,0 +1,8 @@
+import { commitAndPushHunch } from "../extractors/git.js";
+/** Auto-commit + push the overlay after a private write, when auto-commit is on. No-op
+ *  otherwise (manual `hunch private --sync` still works). Never throws. */
+export function flushPrivate(store, message) {
+    if (store.privateAutoCommit && store.privateDir)
+        commitAndPushHunch(store.privateDir, message);
+}
+//# sourceMappingURL=sync.js.map

package/dist/mcp/server.js

@@ -14,7 +14,7 @@ import { HunchStore } from "../store/hunchStore.js";
 import { selectEmbedder } from "../store/embedder.js";
 import { decisionId } from "../core/ids.js";
 import { buildCorrectionConstraint } from "../core/correction.js";
-import { revParse, asOfDate, revExists, lastChangeDate, rangeFiles, rangeDiff, commitFiles, commitDiff, stagedFiles, stagedDiff, commitAndPushHunch } from "../extractors/git.js";
+import { revParse, asOfDate, revExists, lastChangeDate, rangeFiles, rangeDiff, commitFiles, commitDiff, stagedFiles, stagedDiff, commitAndPushHunch, pullHunch } from "../extractors/git.js";
 import { formatContext } from "../core/format.js";
 import { compareCandidates } from "../core/compare.js";
 import { checkConformance } from "../core/conformance.js";
@@ -52,6 +52,15 @@ function resolveFiles(store, target) {
 }
 export function buildServer(root) {
     const store = new HunchStore(hunchPaths(root));
+    // Two-way sync (read side): pull the private overlay's remote on startup, so THIS machine's
+    // session sees memory captured on other machines/worktrees before we index — making the
+    // overlay genuinely one source of truth. Best-effort, leaves a clean tree, never blocks start.
+    if (store.privateDir) {
+        try {
+            pullHunch(store.privateDir);
+        }
+        catch { /* offline / no remote — proceed with local */ }
+    }
     // Ensure the SQLite index reflects the JSON source of truth on startup.
     try {
         store.reindex();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "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.",