@davesheffer/hunch 0.29.0 → 0.31.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

@@ -47,6 +47,7 @@ import { blockingInScope, vetoInScope, proposedEditLines } from "../core/hookpol
 import { loadGoldenSet, evaluateGraphLift } from "../eval/harness.js";
 import { computeDrift } from "../core/drift.js";
 import { compareCandidates } from "../core/compare.js";
+import { checkConformance } from "../core/conformance.js";
 import { draftTripwires, knownRepoDeps } from "../synthesis/tripwires.js";
 import { constraintId } from "../core/ids.js";
 import { readManifest, writeManifest, SCHEMA_VERSION } from "../core/migrate.js";
@@ -598,6 +599,37 @@ program
         console.log(`✓ captured ${dec} decision(s) + ${con} constraint(s) from inline comments${opts.private ? " [private overlay]" : ""}`);
     store.close();
 });
+// ---- conform (intent-conformance: does code still satisfy the recorded why) ----
+program
+    .command("conform")
+    .description("Intent-conformance: prove the code still SATISFIES each in-force decision's recorded intent (deterministic, over the graph). Surfaces where code drifted from the why — even with no diff in scope.")
+    .option("--strict", "exit non-zero if any intent is violated")
+    .action((opts) => {
+    const { store } = storeFor();
+    store.reindex();
+    const results = checkConformance(store);
+    if (!results.length) {
+        console.log("No conformance predicates recorded yet.");
+        console.log(dim("  Add a `conformance` predicate to a decision (e.g. { assert: \"calls\", subject: \"pay\", object: \"verifySession\" }) to prove the code honors its intent."));
+        store.close();
+        return;
+    }
+    const violations = results.filter((r) => !r.satisfied);
+    console.log(`Intent-conformance: ${results.length - violations.length}/${results.length} satisfied\n`);
+    for (const r of results) {
+        console.log(`  ${r.satisfied ? "✅" : "⛔"} ${r.decision} — "${r.title}"`);
+        console.log(`     ${r.assert} ${r.subject}${r.object ? ` → ${r.object}` : ""}: ${r.detail}`);
+    }
+    if (violations.length) {
+        console.log(`\n⛔ ${violations.length} intent(s) the code no longer satisfies.`);
+        if (opts.strict)
+            process.exitCode = 1;
+    }
+    else {
+        console.log(`\n✅ the code satisfies every recorded intent.`);
+    }
+    store.close();
+});
 // ---- compare (rank N candidate solutions by architectural fit) ------------
 program
     .command("compare")

package/dist/core/conformance.js

@@ -0,0 +1,57 @@
+function resolveSymbol(store, ref) {
+    const syms = store.recs("symbols");
+    if (ref.startsWith("sym_"))
+        return syms.find((s) => s.id === ref) ?? null;
+    if (ref.includes(":")) {
+        const [f, n] = ref.split(":");
+        return syms.find((s) => s.name === n && (s.file === f || s.file.endsWith("/" + (f ?? "")))) ?? null;
+    }
+    return syms.find((s) => s.name === ref) ?? null;
+}
+function reaches(store, id, transitive) {
+    const set = new Set();
+    for (const d of store.getDependencies(id, transitive ? 6 : 1)) {
+        if (transitive || d.depth === 1)
+            set.add(d.id);
+    }
+    return set;
+}
+function evalPredicate(store, d, p) {
+    const base = { decision: d.id, title: d.title, assert: p.assert, subject: p.subject, object: p.object };
+    const subj = resolveSymbol(store, p.subject);
+    if (p.assert === "exists") {
+        return { ...base, satisfied: !!subj, detail: subj ? `${p.subject} exists (${subj.file})` : `${p.subject} no longer exists in the graph` };
+    }
+    if (!subj)
+        return { ...base, satisfied: false, detail: `subject "${p.subject}" not found in the graph — intent's subject is gone` };
+    const wantReach = p.assert === "calls" || p.assert === "imports";
+    const obj = p.object ? resolveSymbol(store, p.object) : null;
+    if (!obj) {
+        // a required target gone ⇒ the link can't hold (violated); a forbidden one trivially holds.
+        return { ...base, satisfied: !wantReach, detail: `target "${p.object ?? ""}" not found in the graph` };
+    }
+    const linked = reaches(store, subj.id, p.transitive).has(obj.id);
+    const satisfied = wantReach ? linked : !linked;
+    const via = p.transitive ? " (transitively)" : "";
+    const detail = satisfied
+        ? wantReach
+            ? `${subj.name} →${via} ${obj.name} ✓`
+            : `${subj.name} does not reach ${obj.name} ✓`
+        : wantReach
+            ? `${subj.name} no longer reaches${via} ${obj.name} — intent VIOLATED`
+            : `${subj.name} now reaches${via} ${obj.name} — intent VIOLATED`;
+    return { ...base, satisfied, detail };
+}
+/** Check every in-force decision's conformance predicates against the CURRENT graph.
+ *  `.satisfied === false` means the code drifted from the recorded intent. Deterministic. */
+export function checkConformance(store) {
+    const out = [];
+    for (const d of store.recs("decisions")) {
+        if (d.status === "superseded" || d.superseded_by)
+            continue; // in-force decisions only
+        for (const p of d.conformance ?? [])
+            out.push(evalPredicate(store, d, p));
+    }
+    return out;
+}
+//# sourceMappingURL=conformance.js.map

package/dist/core/types.js

@@ -94,6 +94,18 @@ export const RejectedTripwireSchema = z.object({
     provenance: ProvenanceSchema,
 });
 /** ADR-style decision record, auto-drafted and human-confirmable. */
+/** Intent-conformance predicate (the "inversion": prove the code still SATISFIES a
+ *  decision's intent, not just that a diff didn't touch a guarded file). Each predicate
+ *  compiles a decision's intent into a DETERMINISTIC check over the symbol/dependency
+ *  graph Hunch already builds — no model. "pay must verify the session" becomes
+ *  { assert: "calls", subject: "pay", object: "verifySession" }; if pay stops calling
+ *  verifySession the intent is VIOLATED even with no diff in scope. */
+export const ConformancePredicateSchema = z.object({
+    assert: z.enum(["calls", "not-calls", "imports", "not-imports", "exists"]),
+    subject: z.string().describe("symbol name / id / file:name the intent is about"),
+    object: z.string().optional().describe("required (calls/imports) or forbidden (not-*) target"),
+    transitive: z.boolean().default(false).describe("allow an indirect path over the dependency graph"),
+});
 export const DecisionSchema = z.object({
     id: z.string().describe("dec_*"),
     title: z.string(),
@@ -117,6 +129,7 @@ export const DecisionSchema = z.object({
     valid_from: z.string().optional().describe("ISO instant the decision took effect (commit date)"),
     valid_to: z.string().nullable().default(null).describe("ISO instant it was superseded (null = in force)"),
     retired: RetiredSignalSchema.default({ symbols: [], deps: [] }),
+    conformance: z.array(ConformancePredicateSchema).optional().describe("deterministic intent-conformance checks over the graph"),
     provenance: ProvenanceSchema,
     date: z.string(),
 });

package/dist/integrations/claudemd.js

@@ -34,6 +34,7 @@ export function renderHunchSection(store) {
     lines.push("- `hunch_query(query)` — free-text search across all of Hunch.");
     lines.push("- `hunch_runbook(task)` — the proven steps for a recurring task (e.g. \"add an MCP tool\", \"cut a release\").");
     lines.push("- `hunch_compare(candidates)` — rank N candidate branches/commits by architectural fit (fewest invariant hits).");
+    lines.push("- `hunch_conformance()` — does the code still SATISFY recorded intent? (e.g. `pay` still reaches `verifySession`). Run before a refactor.");
     lines.push("- `hunch_record_decision(...)` — write back a decision after a non-trivial choice.");
     if (constraints.length) {
         lines.push("");

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/mcp/server.js

@@ -17,6 +17,7 @@ import { buildCorrectionConstraint } from "../core/correction.js";
 import { revParse, asOfDate, revExists, lastChangeDate, rangeFiles, rangeDiff, commitFiles, commitDiff, stagedFiles, stagedDiff, commitAndPushHunch } from "../extractors/git.js";
 import { formatContext } from "../core/format.js";
 import { compareCandidates } from "../core/compare.js";
+import { checkConformance } from "../core/conformance.js";
 import { renderMarkdown, verdict } from "../core/checkreport.js";
 import { HUNCH_VERSION } from "../core/version.js";
 const ok = (text) => ({ content: [{ type: "text", text }] });
@@ -435,6 +436,20 @@ export function buildServer(root) {
             return err(`Failed to compare candidates: ${e.message}`);
         }
     });
+    // -- hunch_conformance ----------------------------------------------------
+    server.registerTool("hunch_conformance", {
+        title: "Does the code still satisfy the recorded intent?",
+        description: "Intent-conformance (the inversion of a normal guard): for every in-force decision carrying a conformance predicate, deterministically verify the CODE still satisfies its intent over the dependency graph — e.g. 'pay still reaches verifySession'. Returns the violations: intent the code has silently drifted away from, with NO diff required. Run before a refactor or merge to catch intent erosion a diff-only check can't see.",
+        inputSchema: {},
+    }, async () => {
+        const results = checkConformance(store);
+        if (!results.length)
+            return ok("No conformance predicates recorded. Add a `conformance` predicate to a decision (e.g. {assert:'calls', subject:'pay', object:'verifySession'}) to prove the code honors its intent.");
+        const violations = results.filter((r) => !r.satisfied);
+        const lines = results.map((r) => `${r.satisfied ? "✅" : "⛔"} ${r.decision} "${r.title}" — ${r.assert} ${r.subject}${r.object ? ` → ${r.object}` : ""}: ${r.detail}`);
+        const head = violations.length ? `⛔ ${violations.length} intent(s) the code no longer satisfies` : "✅ the code satisfies every recorded intent";
+        return ok(`Intent-conformance (${results.length - violations.length}/${results.length} satisfied):\n\n${lines.join("\n")}\n\n${head}`);
+    });
     return server;
 }
 function provLine(record) {

package/package.json

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