@davesheffer/hunch 0.18.0 → 0.18.1

package/README.md

@@ -221,7 +221,7 @@ src/
 
 Everything lives under `.hunch/` as git-tracked JSON (the source of truth); SQLite is a
 throwaway derived index. → [storage layout](https://hunch-pi.vercel.app/docs#storage) ·
-[DESIGN.md](DESIGN.md) for the full conceptual model.
+[the docs](https://hunch-pi.vercel.app/docs) for the full conceptual model.
 
 ## Notable engineering decisions
 
@@ -247,5 +247,5 @@ npm run build           # compile to dist/ (the published artifact)
 ```
 
 Hunch is pure TypeScript ESM, Node ≥ 20, licensed **Apache-2.0**. See
-[CONTRIBUTING.md](CONTRIBUTING.md), [DESIGN.md](DESIGN.md), and the full
+[CONTRIBUTING.md](CONTRIBUTING.md) and the full
 [developer docs](https://hunch-pi.vercel.app/docs#develop).

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, revExists } from "../extractors/git.js";
+import { isGitRepo, headSha, logSince, lastChangeDate, stagedFiles, commitFiles, asOfDate, stagedDiff, commitDiff, rangeFiles, rangeDiff, revExists, commitAndPushHunch } from "../extractors/git.js";
 import { renderText, renderMarkdown, reportFailsStrict } from "../core/checkreport.js";
 import { installPostCommitHook, installPreCommitHook } from "../integrations/hooks.js";
 import { installMergeDriver } from "../integrations/mergeDriver.js";
@@ -254,10 +254,7 @@ program
         // hook (no recursion, including on a manual `hunch sync --commit`).
         const commitTarget = opts.commit ? (opts.private ? store.privateDir : hunchPaths(root).hunch) : undefined;
         if (commitTarget) {
-            const g = (args) => { spawnSync("git", ["-C", commitTarget, ...args], { stdio: "ignore", env: { ...process.env, HUNCH_SYNC: "1" } }); };
-            g(["add", "--", "."]);
-            g(["commit", "-m", `hunch: capture ${r.decision?.id ?? "decision"}`]);
-            g(["push"]);
+            commitAndPushHunch(commitTarget, `hunch: capture ${r.decision?.id ?? "decision"}`);
             if (!opts.quiet)
                 console.log(`  ↳ committed + pushed ${r.decision?.id} (${commitTarget})`);
         }
@@ -275,9 +272,20 @@ 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: the post-commit hook also git add+commit+pushes the private repo after each capture")
+    .option("--auto-commit", "opt-in: also git add+commit+push the private repo after each capture (post-commit hook AND MCP private writes)")
+    .option("--sync", "flush the configured private store now (git add+commit+push) — catches records made via MCP between commits")
     .action((dir, opts) => {
     const root = findRoot();
+    if (opts.sync) {
+        const s = new HunchStore(hunchPaths(root));
+        const target = s.privateDir;
+        s.close();
+        if (!target)
+            return fail("no private overlay configured — run `hunch private` first");
+        commitAndPushHunch(target, "hunch: sync private memory");
+        console.log(`✓ flushed private store → ${target}`);
+        return;
+    }
     const paths = hunchPaths(root);
     // 1) resolve the private store's hunch dir (holds decisions/, bugs/, …)
     let hunchDir;
@@ -303,7 +311,7 @@ program
     // a store elsewhere on disk. Resolution (env || local.json) re-resolves against root.
     const rel = relative(root, hunchDir);
     const stored = rel && !rel.startsWith("..") && !isAbsolute(rel) ? toPosixTarget(rel) : hunchDir;
-    writeFileAtomic(join(paths.hunch, "local.json"), JSON.stringify({ privateDir: stored }, null, 2) + "\n");
+    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
     // 4) route post-commit synthesis to the overlay (local hook, never committed)
     let hookNote = "";

package/dist/extractors/git.js

@@ -19,6 +19,23 @@ function gitSafe(args, cwd, maxBuffer) {
 export function isGitRepo(cwd) {
     return gitSafe(["rev-parse", "--is-inside-work-tree"], cwd) === "true";
 }
+/** Best-effort: stage ONLY the hunch dir, commit, and push the repo it lives in. Shared by
+ *  the post-commit auto-commit (CLI sync --commit), MCP private writes, and `hunch private
+ *  --sync`. HUNCH_SYNC=1 stops the created commit from re-triggering the post-commit hook
+ *  (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) => {
+        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"]);
+}
 export function headSha(cwd) {
     return gitSafe(["rev-parse", "HEAD"], cwd);
 }

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 } from "../extractors/git.js";
+import { revParse, asOfDate, revExists, lastChangeDate, rangeFiles, rangeDiff, commitFiles, commitDiff, stagedFiles, stagedDiff, commitAndPushHunch } from "../extractors/git.js";
 import { formatContext } from "../core/format.js";
 import { renderMarkdown, verdict } from "../core/checkreport.js";
 import { HUNCH_VERSION } from "../core/version.js";
@@ -292,9 +292,16 @@ export function buildServer(root) {
             // the public store, so skip it for a private record (a v1 limitation, not a leak).
             const superseded = decision.supersedes && !decision.private ? store.supersede(decision.supersedes, rec) : null;
             store.reindex();
+            // Auto-flush the private repo when configured (hunch private --auto-commit), so a
+            // record made via MCP between public commits is committed+pushed immediately.
+            let flushed = "";
+            if (decision.private && store.privateAutoCommit && store.privateDir) {
+                commitAndPushHunch(store.privateDir, `hunch: capture ${id}`);
+                flushed = " (committed + pushed to the private repo)";
+            }
             const supNote = superseded ? ` Superseded ${superseded.id} (window closed at ${rec.valid_from}).` : "";
             const note = decision.commit && !fullSha ? ` (note: commit "${decision.commit}" could not be resolved — recorded as a standalone decision, not linked to a commit)` : "";
-            const where = decision.private ? " [PRIVATE overlay — not committed to this repo]" : "";
+            const where = decision.private ? ` [PRIVATE overlay — not committed to this repo]${flushed}` : "";
             return ok(`Recorded decision ${id}: "${rec.title}" (status ${rec.status}, ${source}).${where}${supNote}${note}`);
         }
         catch (e) {
@@ -328,10 +335,15 @@ export function buildServer(root) {
             else
                 store.json.put("constraints", rec);
             store.reindex();
+            let flushed = "";
+            if (input.private && store.privateAutoCommit && store.privateDir) {
+                commitAndPushHunch(store.privateDir, `hunch: capture ${rec.id}`);
+                flushed = " (committed + pushed to the private repo)";
+            }
             const enforce = rec.severity === "blocking"
                 ? "blocks a DIRECT edit to its scope at strict firmness, and fails a PR whose diff touches that scope (CI guard); blast-radius hits and lower firmness stay advisory"
                 : "flags violating edits and PRs (advisory)";
-            const where = input.private ? " [PRIVATE overlay — not committed to this repo]" : "";
+            const where = input.private ? ` [PRIVATE overlay — not committed to this repo]${flushed}` : "";
             return ok(`${existing ? "Updated" : "Recorded"} ${rec.severity} constraint ${rec.id}: "${rec.statement}" (scope: ${rec.scope.join(", ")}).${where} It now ${enforce}.`);
         }
         catch (e) {

package/dist/store/hunchStore.js

@@ -31,6 +31,9 @@ export class HunchStore {
     /** The resolved private-overlay hunch dir (from env or .hunch/local.json), or undefined
      *  when no overlay is configured. Surfaced so `hunch doctor` reflects the true state. */
     privateDir;
+    /** Whether private writes should auto commit+push the private repo (from local.json
+     *  `autoCommit`, set by `hunch private --auto-commit`). Read by the MCP write tools. */
+    privateAutoCommit;
     /** When true, recs() ignores the private overlay (public-only). Set transiently by
      *  buildCheckReport({publicOnly}) so any PUBLICLY-POSTED report (the CI PR comment)
      *  can never render a private record — a publicly-posted output is a leak surface
@@ -43,24 +46,27 @@ export class HunchStore {
         // Private overlay location: env (override, for CI / portability) → else a gitignored
         // local config (.hunch/local.json) so `hunch private` enables it with NO env var, and
         // the MCP server / hook pick it up automatically. Relative paths resolve from root.
-        const priv = process.env.HUNCH_PRIVATE_DIR?.trim() || this.localPrivateDir();
+        const local = this.localConfig();
+        const priv = process.env.HUNCH_PRIVATE_DIR?.trim() || local.privateDir;
         if (priv) {
             this.privateDir = resolve(this.paths.root, priv);
             this.privateJson = new JsonStore(hunchPathsForDir(this.privateDir));
         }
+        this.privateAutoCommit = !!(priv && local.autoCommit);
     }
-    /** The private-overlay path from the gitignored `.hunch/local.json` (per-machine,
-     *  never committed). Tolerant: undefined on missing/invalid so reads never crash. */
-    localPrivateDir() {
+    /** 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))
-                return undefined;
+                return {};
             const v = JSON.parse(readFileSync(f, "utf8"));
-            return typeof v.privateDir === "string" && v.privateDir.trim() ? v.privateDir.trim() : undefined;
+            const privateDir = typeof v.privateDir === "string" && v.privateDir.trim() ? v.privateDir.trim() : undefined;
+            return { privateDir, autoCommit: v.autoCommit === true };
         }
         catch {
-            return undefined;
+            return {};
         }
     }
     /** Merged read: public ∪ private overlay (private wins on id collision). Every

package/package.json

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