@davesheffer/hunch 0.10.1 → 0.11.0

package/dist/cli/index.js

@@ -26,6 +26,7 @@ import { parseTestReport } from "../extractors/testreport.js";
 import { selectProvider } from "../synthesis/provider.js";
 import { isGitRepo, headSha, logSince, lastChangeDate, stagedFiles, commitFiles, asOfDate, stagedDiff, commitDiff } from "../extractors/git.js";
 import { analyzeDiff } from "../extractors/diff.js";
+import { isStrictBlocker } from "../core/strictgate.js";
 import { installPostCommitHook, installPreCommitHook } from "../integrations/hooks.js";
 import { installMergeDriver } from "../integrations/mergeDriver.js";
 import { updateClaudeMd } from "../integrations/claudemd.js";
@@ -509,7 +510,7 @@ program
     .description("Flag changes that touch a do-not-break invariant's scope (guardrail).")
     .option("--staged", "check git staged files (default)")
     .option("--commit <sha>", "check a specific commit's files")
-    .option("--strict", "exit non-zero if a blocking constraint is in scope (direct OR near)")
+    .option("--strict", "exit non-zero ONLY on a direct, high-confidence, non-stale blocking invariant (near/stale/low-confidence stay advisory)")
     .option("--blast", "also print the dependency blast radius of the changed files")
     .action((opts) => {
     if (opts.commit && opts.staged)
@@ -567,20 +568,29 @@ program
         store.close();
         return;
     }
-    let blocking = 0;
+    // --strict may FAIL a commit ONLY on a DIRECT, high-confidence, non-stale
+    // blocking invariant (see strictgate.ts) — never on a blast-radius ("near")
+    // guess or a stale/low-confidence record. Those weaker hits still print, as
+    // advisory, so strict mode is safe to enable on a shared repo.
+    const staleConstraintIds = opts.strict
+        ? new Set(store.staleness((f) => lastChangeDate(f, root)).filter((s) => s.kind === "constraint").map((s) => s.id))
+        : new Set();
+    let strictBlockers = 0;
     if (direct.size) {
         console.log(`Directly touches ${direct.size} invariant(s):\n`);
         for (const { c, files: fs } of direct.values()) {
-            if (c.severity === "blocking")
-                blocking++;
-            console.log(`  ${mark(c.severity)} [${c.severity}] ${c.statement}\n      ${c.id} · in: ${fs.join(", ")}\n      rationale: ${c.rationale || "—"}`);
+            const blocks = isStrictBlocker(c, staleConstraintIds.has(c.id));
+            if (blocks)
+                strictBlockers++;
+            const note = opts.strict && c.severity === "blocking" && !blocks
+                ? staleConstraintIds.has(c.id) ? "  (advisory: stale)" : "  (advisory: low confidence)"
+                : "";
+            console.log(`  ${mark(c.severity)} [${c.severity}] ${c.statement}${note}\n      ${c.id} · in: ${fs.join(", ")}\n      rationale: ${c.rationale || "—"}`);
         }
     }
     if (near.size) {
-        console.log(`${direct.size ? "\n" : ""}Near ${near.size} invariant(s) via blast radius (a guarded dependency changed — review):\n`);
+        console.log(`${direct.size ? "\n" : ""}Near ${near.size} invariant(s) via blast radius (a guarded dependency changed — review; never blocks):\n`);
         for (const { c, via } of near.values()) {
-            if (c.severity === "blocking")
-                blocking++;
             console.log(`  ${mark(c.severity)} [${c.severity}] ${c.statement}\n      ${c.id}\n      ${via.slice(0, 4).join("\n      ")}${via.length > 4 ? `\n      …+${via.length - 4} more path(s)` : ""}`);
         }
     }
@@ -590,16 +600,19 @@ program
             console.log(`  ${h.blocking ? "⛔" : "⚠"} re-adds ${h.kind} \`${h.name}\` — ${h.decision} removed it${h.blocking ? " (blocking-linked)" : ""}\n      “${h.title}”\n      ${h.reason}`);
         }
     }
-    if (opts.strict && (blocking || regBlocking)) {
+    if (opts.strict && (strictBlockers || regBlocking)) {
         const reasons = [
-            blocking ? `${blocking} blocking invariant(s) in scope` : "",
+            strictBlockers ? `${strictBlockers} high-confidence blocking invariant(s) directly in scope` : "",
             regBlocking ? `${regBlocking} blocking-linked regression(s)` : "",
         ].filter(Boolean).join(" + ");
         console.log(`\n✗ ${reasons} — review before committing.`);
         process.exitCode = 1;
     }
+    else if (opts.strict) {
+        console.log(`\nReview these — none are a direct, high-confidence, non-stale blocking invariant, so the commit is NOT blocked.`);
+    }
     else {
-        console.log(`\nReview that these invariants still hold. (Advisory — run with --strict to fail on blocking.)`);
+        console.log(`\nReview that these invariants still hold. (Advisory — run with --strict to fail on direct, high-confidence, non-stale blocking invariants.)`);
     }
     store.close();
 });

package/dist/core/strictgate.js

@@ -0,0 +1,24 @@
+/** The hardened gate for `hunch check --strict` (and the strict pre-commit hook):
+ *  which invariants may actually FAIL a commit. Extracted + pure so the rule lives
+ *  in one audited, unit-tested place (mirrors hookpolicy.ts).
+ *
+ *  A commit is only ever blocked by a DIRECTLY-scoped, high-confidence, NON-STALE
+ *  blocking invariant — never by a blast-radius ("near") guess, nor by a record the
+ *  graph may have gone stale on, nor by a low-confidence auto-derived guess. Those
+ *  weaker signals still print, as advisory. This makes strict mode safe to enable
+ *  on a shared repo: a false positive downgrades to a warning instead of wrongly
+ *  failing a teammate's commit. */
+export const STRICT_MIN_CONFIDENCE = 0.8;
+/** May this invariant FAIL a commit under --strict? Requires blocking severity,
+ *  a fresh (non-stale) record, and either high provenance confidence or a
+ *  human-confirmed source (a person vouched for it). Near/blast-radius hits never
+ *  reach here — the caller passes only directly-scoped invariants. */
+export function isStrictBlocker(c, stale) {
+    if (c.severity !== "blocking")
+        return false;
+    if (stale)
+        return false;
+    const confidence = c.provenance?.confidence ?? 0;
+    return confidence >= STRICT_MIN_CONFIDENCE || c.provenance?.source === "human_confirmed";
+}
+//# sourceMappingURL=strictgate.js.map

package/dist/extractors/git.js

@@ -1,16 +1,16 @@
 /** Deterministic git introspection for the extractor + learning loop.
  *  No LLM here — just parsing what git already knows. */
 import { execFileSync } from "node:child_process";
-function git(args, cwd) {
+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, {
-        cwd, encoding: "utf8", maxBuffer: 64 * 1024 * 1024,
+        cwd, encoding: "utf8", maxBuffer,
         stdio: ["ignore", "pipe", "ignore"],
     }).trim();
 }
-function gitSafe(args, cwd) {
+function gitSafe(args, cwd, maxBuffer) {
     try {
-        return git(args, cwd);
+        return git(args, cwd, maxBuffer);
     }
     catch {
         return "";
@@ -100,6 +100,54 @@ export function lastCommitForFile(file, cwd) {
 export function lastChangeDate(file, cwd) {
     return gitSafe(["log", "-1", "--format=%aI", "--", file], cwd);
 }
+/** Batched per-file git metrics for indexing: churn (commits touching the file in
+ *  the last `days`; pass 0 to skip) and the most-recent commit (`commit:<sha>`).
+ *
+ *  Replaces the indexer's O(files) × 2 `git log` spawns — which dominate
+ *  `hunch index` wall-time on a large repo, especially on Windows where process
+ *  creation is costly — with ONE `git log` pass each. Only paths present in `want`
+ *  are returned (every requested path gets an entry, defaulting to 0 / ""). */
+export function fileGitMetrics(cwd, want, days = 90) {
+    const out = new Map();
+    for (const f of want)
+        out.set(f, { churn: 0, lastCommit: "" });
+    if (out.size === 0)
+        return out;
+    // churn — one windowed log; tally each wanted path's appearances (= commits).
+    if (days > 0) {
+        const raw = gitSafe(["log", `--since=${days}.days.ago`, "--name-only", "--format="], cwd);
+        if (raw) {
+            for (const line of raw.split("\n")) {
+                const e = line && out.get(line);
+                if (e)
+                    e.churn++;
+            }
+        }
+    }
+    // last commit — one newest-first log; the FIRST time a path appears is its most
+    // recent commit. NUL-prefixed lines mark commit boundaries; the rest are paths.
+    // 256MB buffer for the all-history name-only stream on large repos.
+    const raw = gitSafe(["log", "--name-only", "--format=%x00%h"], cwd, 256 * 1024 * 1024);
+    if (raw) {
+        let remaining = out.size;
+        let sha = "";
+        for (const line of raw.split("\n")) {
+            if (line.charCodeAt(0) === 0) {
+                sha = line.slice(1);
+                continue;
+            }
+            if (!line)
+                continue;
+            const e = out.get(line);
+            if (e && !e.lastCommit && sha) {
+                e.lastCommit = `commit:${sha}`;
+                if (--remaining === 0)
+                    break; // every wanted path resolved — stop scanning
+            }
+        }
+    }
+    return out;
+}
 /** Files staged for commit (for `hunch check` pre-commit enforcement). */
 export function stagedFiles(cwd) {
     const out = gitSafe(["diff", "--cached", "--name-only", "--diff-filter=ACMR"], cwd);

package/dist/extractors/indexer.js

@@ -12,7 +12,7 @@ import { join, relative, dirname, posix } from "node:path";
 import { parseSource, attributeCalls } from "./parse.js";
 import { symbolId, componentId, edgeId, sha1 } from "../core/ids.js";
 import { extracted, inferred } from "../core/types.js";
-import { isGitRepo, trackedFiles, fileChurn, lastCommitForFile } from "./git.js";
+import { isGitRepo, trackedFiles, fileGitMetrics } from "./git.js";
 const CODE_EXTS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", ".hunch", "coverage", ".next", "out"]);
 export function indexRepo(store, root, opts = {}) {
@@ -25,7 +25,10 @@ export function indexRepo(store, root, opts = {}) {
     const fileStartByteId = new Map(); // file -> (symbol startByte -> id)
     const perFileCalls = [];
     const perFileImports = [];
-    const churnCache = new Map();
+    // Batched per-file git metrics (churn + last commit) in TWO `git log` spawns
+    // total, instead of two per file — the dominant cost of indexing a large repo.
+    const rels = files.map((abs) => toPosix(relative(root, abs)));
+    const gitMeta = useGit ? fileGitMetrics(root, rels, opts.churn === false ? 0 : 90) : null;
     let skipped = 0;
     for (const abs of files) {
         const rel = toPosix(relative(root, abs));
@@ -50,9 +53,9 @@ export function indexRepo(store, root, opts = {}) {
             skipped++;
             continue;
         }
-        const churn = opts.churn !== false && useGit ? (churnCache.get(rel) ?? fileChurn(rel, root)) : 0;
-        churnCache.set(rel, churn);
-        const last = useGit ? lastCommitForFile(rel, root) : "";
+        const m = gitMeta?.get(rel);
+        const churn = m?.churn ?? 0;
+        const last = m?.lastCommit ?? "";
         const idsInFile = [];
         const startByteId = new Map();
         const idCounts = new Map(); // disambiguate same (file,name,kind)

package/dist/integrations/hooks.js

@@ -52,7 +52,9 @@ const PRE_MARK = "# >>> hunch pre-commit (constraint guard) >>>";
 const PRE_END = "# <<< hunch pre-commit <<<";
 /** Install a pre-commit constraint guard (DESIGN §4 enforcement). Advisory by
  *  default (prints invariants in scope, never blocks); pass strict to fail the
- *  commit on a blocking invariant. Preserves any existing pre-commit hook. */
+ *  commit — but even strict only fails on a DIRECT, high-confidence, non-stale
+ *  blocking invariant (see strictgate.ts), so it's safe on a shared repo.
+ *  Preserves any existing pre-commit hook. */
 export function installPreCommitHook(root, invocation, strict = false) {
     const dir = hooksDir(root);
     const abs = dir.startsWith("/") ? dir : join(root, dir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "license": "MIT",
   "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.",