@davesheffer/hunch 0.28.0 → 0.29.0

package/dist/cli/index.js

@@ -29,7 +29,8 @@ import { syncCommit, recordFailure, captureTestRun } from "../synthesis/synthesi
 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 { runbookId } from "../core/ids.js";
+import { runbookId, decisionId } from "../core/ids.js";
+import { extractInlineIntent } from "../extractors/comments.js";
 import { renderText, renderMarkdown, reportFailsStrict } from "../core/checkreport.js";
 import { partitionReview, READY_MIN_GROUNDED } from "../core/reviewqueue.js";
 import { installPostCommitHook, installPreCommitHook } from "../integrations/hooks.js";
@@ -536,6 +537,67 @@ program
     console.log(dim("  advisory, deterministic draft — refine the steps/gotchas; surfaced via `hunch query` and MCP."));
     store.close();
 });
+// ---- capture-comments (inline intent → graph; addendum #2) ----------------
+program
+    .command("capture-comments")
+    .description("Capture inline intent comments into the graph: `hunch-why:` → a decision, `hunch-rule:` → a file-scoped constraint. Deterministic + idempotent.")
+    .option("--private", "write captured records into the private overlay (HUNCH_PRIVATE_DIR)")
+    .action((opts) => {
+    const { store, root } = storeFor();
+    if (opts.private && !store.hasPrivate) {
+        store.close();
+        return fail("--private needs HUNCH_PRIVATE_DIR set to a private store");
+    }
+    const intents = extractInlineIntent(root);
+    const now = new Date().toISOString();
+    let dec = 0, con = 0;
+    for (const it of intents) {
+        const ev = [`${it.file}:${it.line}`];
+        if (it.kind === "why") {
+            const id = decisionId(`inline:${it.file}:${it.text}`);
+            const prev = store.recs("decisions").find((d) => d.id === id); // preserve window for idempotent re-capture
+            const rec = {
+                id, title: it.text, status: "accepted",
+                context: `Captured from an inline hunch-why comment (${it.file}:${it.line}).`,
+                decision: it.text, consequences: [], alternatives_rejected: [], rejected_tripwires: [],
+                related_components: [], related_files: [it.file], supersedes: null, superseded_by: null,
+                caused_by_bug: null, commit: null, valid_from: prev?.valid_from ?? now, valid_to: null,
+                retired: { symbols: [], deps: [] },
+                provenance: { source: "human_confirmed", confidence: 0.9, evidence: ev }, date: prev?.date ?? now,
+            };
+            if (opts.private)
+                store.putPrivate("decisions", rec);
+            else
+                store.json.put("decisions", rec);
+            dec++;
+        }
+        else {
+            const id = constraintId(`inline:${it.file}:${it.text}`);
+            const prev = store.recs("constraints").find((c) => c.id === id);
+            const rec = {
+                id, type: "correctness", statement: it.text, scope: [it.file],
+                // Advisory by default — an inline rule never auto-blocks a build; raise severity
+                // deliberately if you want enforcement. Keeps day-one zero false-positive rage.
+                severity: "warning", enforcement: "advisory_v1",
+                rationale: `Captured from an inline hunch-rule comment (${it.file}:${it.line}).`,
+                source_decision: null, violations: [], status: "active",
+                valid_from: prev?.valid_from ?? now, valid_to: null,
+                provenance: { source: "human_confirmed", confidence: 0.9, evidence: ev },
+            };
+            if (opts.private)
+                store.putPrivate("constraints", rec);
+            else
+                store.json.put("constraints", rec);
+            con++;
+        }
+    }
+    store.reindex();
+    if (!intents.length)
+        console.log("No `hunch-why:` / `hunch-rule:` comments found.");
+    else
+        console.log(`✓ captured ${dec} decision(s) + ${con} constraint(s) from inline comments${opts.private ? " [private overlay]" : ""}`);
+    store.close();
+});
 // ---- compare (rank N candidate solutions by architectural fit) ------------
 program
     .command("compare")

package/dist/extractors/comments.js

@@ -0,0 +1,75 @@
+/**
+ * Inline intent capture (roadmap addendum #2). A developer marks intent right where
+ * it lives in the code — `hunch-why: <reason>` (in a comment → a Decision) or
+ * `hunch-rule: <invariant>` (→ a file-scoped Constraint) — and Hunch lifts it into
+ * the graph, deterministically. The third capture source alongside commit synthesis and
+ * correction capture. The tag must follow a comment marker (the slash pair, #, *, --,
+ * <!--, ;) so a matching STRING literal in code isn't mistaken for intent. (Line-based,
+ * so a tagged line that is itself a string literal can still false-positive — advisory.)
+ */
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { trackedFiles } from "./git.js";
+import { toPosixTarget } from "../core/paths.js";
+const EXTS = [
+    ".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs",
+    ".py", ".go", ".rb", ".java", ".rs", ".php", ".cs", ".kt", ".swift", ".scala",
+    ".c", ".h", ".cc", ".cpp", ".hpp", ".sql", ".sh",
+];
+const SKIP = new Set(["node_modules", ".git", ".hunch", ".hunch-private", "dist", "build", "out", "vendor", ".next"]);
+const TAG = /(?:\/\/|#|\*|--|<!--|;)\s*hunch-(why|rule)\s*:\s*(.+?)\s*(?:\*\/|-->|$)/i;
+/** Tracked source files (git ls-files); falls back to a bounded walk outside git. */
+function sourceFiles(root) {
+    const tracked = trackedFiles(root, EXTS);
+    if (tracked.length)
+        return tracked;
+    const out = [];
+    const walk = (dir, rel, depth) => {
+        if (depth > 8)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (e.name.startsWith("."))
+                continue;
+            const r = rel ? `${rel}/${e.name}` : e.name;
+            if (e.isDirectory()) {
+                if (!SKIP.has(e.name))
+                    walk(join(dir, e.name), r, depth + 1);
+            }
+            else if (EXTS.some((x) => e.name.endsWith(x))) {
+                out.push(r);
+            }
+        }
+    };
+    walk(root, "", 0);
+    return out;
+}
+export function extractInlineIntent(root) {
+    const out = [];
+    for (const rel of sourceFiles(root)) {
+        let content;
+        try {
+            content = readFileSync(join(root, rel), "utf8");
+        }
+        catch {
+            continue;
+        }
+        if (!content.includes("hunch-"))
+            continue; // cheap skip before the per-line scan
+        const file = toPosixTarget(rel);
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+            const m = TAG.exec(lines[i]);
+            if (m)
+                out.push({ kind: m[1].toLowerCase(), text: m[2].trim(), file, line: i + 1 });
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=comments.js.map

package/package.json

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