@davesheffer/hunch 0.30.0 → 0.32.0

package/README.md

@@ -18,7 +18,7 @@ cd your-repo && hunch init && hunch backfill --since 90d
 hunch why src/some/file.ts     # …or just ask Claude Code: "why is X built this way?"
 ```
 
-<sub>Works with **Claude Code, Cursor, Copilot & Windsurf** from one shared graph.</sub>
+<sub>Works with **Claude Code, Cursor, Copilot, Windsurf & Google Antigravity** from one shared graph.</sub>
 
 ### 📚 **[Read the full documentation → hunch-pi.vercel.app/docs](https://hunch-pi.vercel.app/docs)**
 
@@ -96,7 +96,7 @@ hunch why src/auth/session.ts       # …then ask your assistant: "why is X buil
 
 `hunch init` scaffolds `.hunch/`, indexes the repo, installs the git hooks + merge driver,
 writes `.mcp.json` + slash commands + an auto-maintained `CLAUDE.md`, and wires up **every
-detected assistant** (Claude Code, Cursor, VS Code/Copilot, Windsurf, Codex) to the same
+detected assistant** (Claude Code, Cursor, VS Code/Copilot, Windsurf, Codex, Google Antigravity) to the same
 graph — merging idempotently into existing files. **Reload your assistant in the repo**
 afterward to pick up the `hunch_*` tools. Each teammate runs `hunch init` once; the
 `.hunch/` content is shared via git.

package/dist/cli/index.js

@@ -28,7 +28,7 @@ import { indexRepo } from "../extractors/indexer.js";
 import { syncCommit, recordFailure, captureTestRun } from "../synthesis/synthesize.js";
 import { parseTestReport } from "../extractors/testreport.js";
 import { selectProvider } from "../synthesis/provider.js";
-import { isGitRepo, headSha, logSince, lastChangeDate, stagedFiles, commitFiles, asOfDate, stagedDiff, commitDiff, rangeFiles, rangeDiff, rangeSubjects, revExists, commitAndPushHunch, gitUntrackCached } from "../extractors/git.js";
+import { isGitRepo, headSha, logSince, lastChangeDate, stagedFiles, commitFiles, asOfDate, stagedDiff, commitDiff, rangeFiles, rangeDiff, rangeSubjects, revExists, commitAndPushHunch, gitUntrackCached, gitCommonDir, isLinkedWorktree } from "../extractors/git.js";
 import { runbookId, decisionId } from "../core/ids.js";
 import { extractInlineIntent } from "../extractors/comments.js";
 import { renderText, renderMarkdown, reportFailsStrict } from "../core/checkreport.js";
@@ -344,6 +344,18 @@ program
     const stored = rel && !rel.startsWith("..") && !isAbsolute(rel) ? toPosixTarget(rel) : hunchDir;
     writeFileAtomic(join(paths.hunch, "local.json"), JSON.stringify({ privateDir: stored, autoCommit: !!opts.autoCommit }, null, 2) + "\n");
     ensureGitignore(root); // keeps .hunch/local.json + .hunch-private/ out of git
+    // Also register the overlay at the SHARED git common dir, so EVERY worktree of this repo
+    // (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");
+        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)
     let hookNote = "";
     if (opts.hook && isGitRepo(root)) {
@@ -379,6 +391,7 @@ program
     }
     console.log(`✓ private overlay enabled → ${hunchDir}\n` +
         `  ✓ recorded in .hunch/local.json (gitignored) — auto-detected, no env var or shell-profile edit\n` +
+        worktreeNote +
         hookNote +
         migrateNote +
         `  record sensitive items with private:true (hunch_record_decision / hunch_record_correction)\n` +
@@ -1467,6 +1480,16 @@ program
     console.log(store.privateDir
         ? `private:    on → ${store.privateDir} (local overlay — unioned into queries; never committed or posted publicly)`
         : dim(`private:    off — run \`hunch private\` to keep sensitive memory in a separate repo (or set HUNCH_PRIVATE_DIR)`));
+    // Worktree posture: linked worktrees share ONE memory via the git common dir. Only
+    // surfaced in a linked worktree (no noise in a normal single checkout), so a
+    // "memory missing here" symptom has an obvious cause + fix.
+    if (isLinkedWorktree(root)) {
+        const common = gitCommonDir(root);
+        const sharedPtr = !!common && existsSync(join(common, "hunch", "local.json"));
+        console.log(store.privateDir
+            ? `worktree:   linked — sharing the repo's memory${sharedPtr ? " via the git common dir" : ""}`
+            : dim(`worktree:   linked, but no overlay resolved here — run \`hunch private\` once (any worktree) so all worktrees share it`));
+    }
     // Semantic search is opt-in and local. Report availability + coverage without
     // loading the model (selectEmbedder only probes; embeddingStats just counts rows).
     const emb = await selectEmbedder();

package/dist/extractors/git.js

@@ -1,6 +1,8 @@
 /** Deterministic git introspection for the extractor + learning loop.
  *  No LLM here — just parsing what git already knows. */
 import { execFileSync } from "node:child_process";
+import { isAbsolute, resolve, join } from "node:path";
+import { mkdirSync, rmSync, statSync, realpathSync } from "node:fs";
 function git(args, cwd, maxBuffer = 64 * 1024 * 1024) {
     // stdio: capture stdout, silence stderr (so "no commits yet" etc. don't leak).
     return execFileSync("git", args, {
@@ -25,16 +27,50 @@ export function isGitRepo(cwd) {
  *  (no recursion). Stages with a pathspec scoped to `hunchDir`, so it never sweeps unrelated
  *  working-tree changes. Never throws — a non-repo dir / offline push just no-ops. */
 export function commitAndPushHunch(hunchDir, message) {
-    const env = { ...process.env, HUNCH_SYNC: "1" };
-    const run = (args) => {
+    // Serialize across worktrees: several worktrees auto-committing the SAME overlay repo
+    // at once would race git's index.lock. An atomic-mkdir lock lets one proceed; the others
+    // skip — safe because each record is already written to disk, so `git add .` here sweeps
+    // up anything a skipped run left pending (eventually-consistent, never lost).
+    const lock = join(hunchDir, ".hunch-commit.lock");
+    if (!acquireCommitLock(lock))
+        return;
+    try {
+        const env = { ...process.env, HUNCH_SYNC: "1" };
+        const run = (args) => {
+            try {
+                execFileSync("git", ["-C", hunchDir, ...args], { stdio: "ignore", env });
+            }
+            catch { /* best-effort: nothing staged / not a repo / offline */ }
+        };
+        run(["add", "--", "."]);
+        run(["commit", "-m", message]);
+        run(["push"]);
+    }
+    finally {
         try {
-            execFileSync("git", ["-C", hunchDir, ...args], { stdio: "ignore", env });
+            rmSync(lock, { recursive: true, force: true });
         }
-        catch { /* best-effort: nothing staged / not a repo / offline */ }
-    };
-    run(["add", "--", "."]);
-    run(["commit", "-m", message]);
-    run(["push"]);
+        catch { /* released best-effort */ }
+    }
+}
+/** Atomic mkdir lock; reclaims a stale lock (a crashed holder) older than 60s. Returns
+ *  false when another live holder owns it — the caller skips rather than blocks. */
+function acquireCommitLock(lock) {
+    try {
+        mkdirSync(lock);
+        return true;
+    }
+    catch {
+        try {
+            if (Date.now() - statSync(lock).mtimeMs > 60_000) {
+                rmSync(lock, { recursive: true, force: true });
+                mkdirSync(lock);
+                return true;
+            }
+        }
+        catch { /* lock vanished or races another reclaimer — treat as held */ }
+        return false;
+    }
 }
 export function headSha(cwd) {
     return gitSafe(["rev-parse", "HEAD"], cwd);
@@ -65,6 +101,39 @@ export function hooksDir(cwd) {
 export function gitDir(cwd) {
     return gitSafe(["rev-parse", "--git-dir"], cwd) || ".git";
 }
+/** The SHARED git dir for the repo — identical across ALL linked worktrees (unlike
+ *  `gitDir`, which is per-worktree). Absolute, so callers can anchor worktree-shared
+ *  state (the private-overlay pointer) at one stable place. "" when not a git repo. */
+export function gitCommonDir(cwd) {
+    const p = gitSafe(["rev-parse", "--git-common-dir"], cwd);
+    if (!p)
+        return "";
+    return isAbsolute(p) ? p : resolve(cwd, p);
+}
+/** True when `cwd` is inside a LINKED worktree (not the main checkout): its own git
+ *  dir differs from the shared common dir. Used by `hunch doctor` and setup messaging. */
+export function isLinkedWorktree(cwd) {
+    const common = gitCommonDir(cwd);
+    const own = gitSafe(["rev-parse", "--absolute-git-dir"], cwd);
+    if (!common || !own)
+        return false;
+    // realpath BOTH before comparing: `--absolute-git-dir` is symlink-resolved while
+    // gitCommonDir is not, so on macOS the main checkout would otherwise mismatch on
+    // /var vs /private/var and falsely read as "linked".
+    const norm = (p) => { try {
+        return realpathSync(p);
+    }
+    catch {
+        return resolve(p);
+    } };
+    return norm(own) !== norm(common);
+}
+/** Current branch name (e.g. "main", "feat/x"), or "" in detached HEAD / non-repo.
+ *  Stamped onto auto-captured decisions so branch-scoped work stays filterable. */
+export function currentBranch(cwd) {
+    const b = gitSafe(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+    return b === "HEAD" ? "" : b; // detached HEAD reports "HEAD" — treat as no branch
+}
 /** Files changed in a single commit. `--root` makes the initial commit (which
  *  has no parent) report its files as additions instead of returning nothing. */
 export function commitFiles(sha, cwd) {

package/dist/integrations/providers.js

@@ -18,6 +18,7 @@
  * and is idempotent, so re-running `hunch init` is safe.
  */
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
 import { join, dirname } from "node:path";
 import { renderHunchSection, upsertSection, updateClaudeMd } from "./claudemd.js";
 /** Strip // line and block comments + trailing commas (JSONC → JSON). String-aware
@@ -153,6 +154,37 @@ export function writeVscodeMcp(root, inv) {
     json.servers.hunch = { type: "stdio", command: inv.command, args: [...inv.args, "mcp"] };
     return writeJson(file, json);
 }
+/** Google Antigravity's MCP config is GLOBAL (user home), not project-local — and the
+ *  dir moved between versions (`antigravity/` vs `config/`). Resolve adaptively: an
+ *  existing config wins, else an existing parent dir, else null (Antigravity not
+ *  installed — we never create a global config for an absent tool). `home` is injectable
+ *  for tests so we never touch the real ~/.gemini. */
+export function antigravityMcpFile(home = homedir()) {
+    const candidates = [
+        join(home, ".gemini", "antigravity", "mcp_config.json"),
+        join(home, ".gemini", "config", "mcp_config.json"),
+    ];
+    for (const c of candidates)
+        if (existsSync(c))
+            return c;
+    for (const c of candidates)
+        if (existsSync(dirname(c)))
+            return c;
+    return null;
+}
+/** Antigravity: merge the hunch stdio server into the global mcp_config.json — same
+ *  `mcpServers` { command, args } shape as Cursor/Claude (stdio; `serverUrl` is only for
+ *  HTTP servers). Returns null when Antigravity isn't detected. Grounding needs nothing
+ *  extra: Antigravity reads the project-root AGENTS.md Hunch already writes. */
+export function writeAntigravityMcp(inv, home = homedir()) {
+    const file = antigravityMcpFile(home);
+    if (!file)
+        return null;
+    const json = readJsonObj(file);
+    json.mcpServers = json.mcpServers ?? {};
+    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 <<<";
 /** Codex CLI: .codex/config.toml — `[mcp_servers.hunch]` stdio entry. We own only
@@ -278,6 +310,9 @@ export function scaffoldProviders(root, inv, store) {
         ["VS Code (Copilot)", () => [writeVscodeMcp(root, inv), writeCopilotInstructions(root, store)]],
         ["Codex CLI", () => [writeCodexConfig(root, inv)]],
         ["Windsurf", () => [writeWindsurfMcp(root, inv), writeWindsurfRule(root, store)]],
+        // Antigravity reads project-root AGENTS.md for grounding (written below); its MCP
+        // config is global + detection-gated, so it only writes when Antigravity is installed.
+        ["Google Antigravity", () => { const f = writeAntigravityMcp(inv); return f ? [f] : []; }],
         ["Any (AGENTS.md)", () => [writeAgentsMd(root, store)]],
     ];
     return tasks.map(([assistant, run]) => {

package/dist/store/hunchStore.js

@@ -18,6 +18,7 @@ import { openDb } from "./db.js";
 import { RESET_SQL, embedHash } from "./schema.js";
 import { selectEmbedder } from "./embedder.js";
 import { JsonStore } from "./jsonStore.js";
+import { gitCommonDir } from "../extractors/git.js";
 import { pathMatchesGlob } from "../core/glob.js";
 import { edgeId } from "../core/ids.js";
 import { isStrictBlocker, isVetoBlocker } from "../core/strictgate.js";
@@ -57,17 +58,33 @@ export class HunchStore {
     /** The private-overlay config from the gitignored `.hunch/local.json` (per-machine,
      *  never committed). Tolerant: returns {} on missing/invalid so reads never crash. */
     localConfig() {
-        try {
-            const f = join(this.paths.hunch, "local.json");
-            if (!existsSync(f))
+        const read = (file) => {
+            try {
+                if (!existsSync(file))
+                    return {};
+                const v = JSON.parse(readFileSync(file, "utf8"));
+                const privateDir = typeof v.privateDir === "string" && v.privateDir.trim() ? v.privateDir.trim() : undefined;
+                return { privateDir, autoCommit: v.autoCommit === true };
+            }
+            catch {
                 return {};
-            const v = JSON.parse(readFileSync(f, "utf8"));
-            const privateDir = typeof v.privateDir === "string" && v.privateDir.trim() ? v.privateDir.trim() : undefined;
-            return { privateDir, autoCommit: v.autoCommit === true };
-        }
-        catch {
-            return {};
+            }
+        };
+        // Per-worktree pointer first (explicit / back-compat). If it names no overlay, fall back to
+        // the SHARED pointer in the git common dir — identical across ALL worktrees, so a freshly
+        // added worktree (whose gitignored .hunch/local.json doesn't exist yet) still auto-discovers
+        // the same memory. The git lookup runs ONLY when the cheap per-worktree read is empty, keeping
+        // it off the hot path for already-configured checkouts.
+        const perWorktree = read(join(this.paths.hunch, "local.json"));
+        if (perWorktree.privateDir)
+            return perWorktree;
+        const common = gitCommonDir(this.paths.root);
+        if (common) {
+            const shared = read(join(common, "hunch", "local.json"));
+            if (shared.privateDir)
+                return shared;
         }
+        return perWorktree;
     }
     /** Merged read: public ∪ private overlay (private wins on id collision). Every
      *  QUERY / REINDEX path uses this so MCP + the guards see private memory. Public-

package/dist/synthesis/synthesize.js

@@ -1,4 +1,4 @@
-import { commitMeta, commitDiff, headSha } from "../extractors/git.js";
+import { commitMeta, commitDiff, headSha, currentBranch } from "../extractors/git.js";
 import { analyzeDiff } from "../extractors/diff.js";
 import { selectProvider, selectEnsemble, selectVerifier, verifyDecisionSafe, DeterministicProvider } from "./provider.js";
 import { decisionId, bugId, constraintId } from "../core/ids.js";
@@ -101,6 +101,11 @@ export async function syncCommit(store, root, sha, opts = {}) {
     if (draft.pruned)
         synthBits.push(`pruned=${draft.pruned}`); // the Critic's visible value
     const synthEvidence = `synth:${synthBits.join(" ")}`;
+    // Tag the capturing branch so branch-scoped work stays FILTERABLE in the one shared store
+    // (every worktree/branch writes to the same overlay — this keeps "what was decided on
+    // feature-x?" answerable without fragmenting memory per branch). Empty in detached HEAD.
+    const branch = currentBranch(root);
+    const branchTag = branch ? [`branch:${branch}`] : [];
     const components = store.json.loadAll("components");
     const relatedComponents = components
         .filter((c) => codeFiles.some((f) => c.paths.some((g) => pathMatchesGlob(f, g))))
@@ -144,7 +149,7 @@ export async function syncCommit(store, root, sha, opts = {}) {
         provenance: {
             source: draft.source,
             confidence: draft.confidence,
-            evidence: [`commit:${meta.shortSha}`, synthEvidence, ...codeFiles.slice(0, 8)],
+            evidence: [`commit:${meta.shortSha}`, synthEvidence, ...branchTag, ...codeFiles.slice(0, 8)],
             last_verified: new Date().toISOString(), // when the Hunch last re-derived this
         },
         date: meta.date, // the commit date

package/package.json

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