@davesheffer/hunch 0.1.0 → 0.1.1

package/dist/cli/index.js

@@ -177,11 +177,11 @@ program
     let hits;
     let how = "";
     if (opts.semantic) {
-        // Resolve once; if semantic isn't actually usable, say so and degrade to FTS
-        // (rather than silently returning identical keyword results under a flag).
+        // Same gate hybridSearch uses internally (store.semanticReady), so the flag's
+        // messaging can't drift from what actually runs. If unusable, say so and use FTS
+        // rather than silently returning identical keyword results under the flag.
         const emb = await selectEmbedder();
-        const cov = emb ? store.embeddingStats(emb.id) : null;
-        if (!emb || !cov || cov.embedded === 0) {
+        if (!store.semanticReady(emb)) {
             console.log("· semantic search isn't enabled yet — run `hunch embed` (using keyword search for now).\n");
             hits = store.search(q, 12);
         }

package/dist/core/ids.js

@@ -3,7 +3,7 @@
  *  git diff of `.hunch/` stays minimal. Decisions/bugs use a content hash too,
  *  so the learning loop is idempotent for the same commit. */
 import { createHash } from "node:crypto";
-function shortHash(input, len = 10) {
+export function shortHash(input, len = 10) {
     return createHash("sha1").update(input).digest("hex").slice(0, len);
 }
 /** Full sha1 (used for signature_hash etc.). */

package/dist/store/embedder.js

@@ -32,36 +32,31 @@ function installedPackage() {
     }
     return null;
 }
-/** Run `fn` with stray stdout writes rerouted to stderr. transformers.js / its
- *  backends may log during model load; on the MCP stdio channel a single stray
- *  byte on stdout corrupts JSON-RPC. The guard is active only for the duration of
- *  `fn` (model load), which is the only noisy phase. */
-async function withStdoutGuarded(fn) {
-    const orig = process.stdout.write.bind(process.stdout);
-    const toErr = process.stderr.write.bind(process.stderr);
-    process.stdout.write = toErr;
-    try {
-        return await fn();
-    }
-    finally {
-        process.stdout.write = orig;
-    }
-}
 export class TransformersEmbedder {
     dim = 384;
     id = "all-MiniLM-L6-v2";
     extractor = null;
     load() {
         if (!this.extractor) {
-            this.extractor = withStdoutGuarded(async () => {
+            const p = (async () => {
                 const pkg = installedPackage();
                 if (!pkg)
                     throw new Error("transformers.js not installed");
                 // String var (not a literal) so tsc doesn't require the optional dep to be
                 // present to typecheck/build, and the import resolves at runtime when it is.
+                // transformers.js logs only via an opt-in progress_callback (which we never
+                // pass) and onnxruntime warns to stderr, so the model load never writes to
+                // stdout — safe for the MCP JSON-RPC stdio channel without redirecting it.
                 const mod = (await import(pkg));
                 return (await mod.pipeline("feature-extraction", HF_MODEL));
-            });
+            })();
+            this.extractor = p;
+            // Never cache a REJECTED load: a transient failure (network blip during the
+            // first model download, a missing/incompatible native backend) must not poison
+            // the embedder for the rest of a long-lived (MCP) process. Reset so the next
+            // call retries from scratch.
+            p.catch(() => { if (this.extractor === p)
+                this.extractor = null; });
         }
         return this.extractor;
     }

package/dist/store/hunchStore.js

@@ -135,6 +135,11 @@ export class HunchStore {
      *  (doc_hash mismatch). Model-free and cheap; run at the end of every reindex()
      *  so vectors track the JSON truth without ever being reset. Returns the count. */
     pruneStaleEmbeddings() {
+        // Lean-install fast path: no vectors → nothing to reconcile. This runs at the
+        // end of EVERY reindex() (a hot path), so skip the full doc scan + per-doc hash
+        // unless embeddings actually exist.
+        if (this.db.prepare(`SELECT count(*) c FROM embeddings`).get().c === 0)
+            return 0;
         const live = new Map(); // ref -> current doc_hash
         for (const d of this.searchDocs())
             live.set(d.ref, embedHash(d.title, d.body));
@@ -157,6 +162,12 @@ export class HunchStore {
         const embedded = this.db.prepare(`SELECT count(*) c FROM embeddings WHERE model = ?`).get(model).c;
         return { embedded, total };
     }
+    /** The SINGLE gate for "can semantic search run right now": an embedder exists and
+     *  it has at least one stored vector. Used by both hybridSearch and the CLI so the
+     *  definition can't drift between them. */
+    semanticReady(embedder) {
+        return !!embedder && this.db.prepare(`SELECT count(*) c FROM embeddings WHERE model = ?`).get(embedder.id).c > 0;
+    }
     /** Generate/refresh embeddings for every doc missing an up-to-date vector for
      *  this embedder's model. Batched + flushed per batch so a Ctrl-C leaves a
      *  coherent partial index that a re-run resumes. Assumes reindex() ran first. */
@@ -170,22 +181,25 @@ export class HunchStore {
         const todo = docs.filter((d) => current.get(d.ref) !== d.hash);
         const ins = this.db.prepare(`INSERT OR REPLACE INTO embeddings (ref, kind, model, dim, doc_hash, vec) VALUES (?,?,?,?,?,?)`);
         const batchSize = opts.batch ?? 32;
-        let done = 0;
+        let embedded = 0; // ACTUAL rows written (a batch may yield fewer vectors than docs)
+        let attempted = 0;
         for (let i = 0; i < todo.length; i += batchSize) {
             const slice = todo.slice(i, i + batchSize);
             const vecs = await embedder.embed(slice.map((d) => `${d.title}\n${d.body}`));
             const tx = this.db.transaction(() => {
                 slice.forEach((d, j) => {
                     const v = vecs[j];
-                    if (v)
+                    if (v) {
                         ins.run(d.ref, d.kind, model, embedder.dim, d.hash, vecToBlob(v));
+                        embedded++;
+                    }
                 });
             });
             tx();
-            done += slice.length;
-            opts.onProgress?.(done, todo.length);
+            attempted += slice.length;
+            opts.onProgress?.(attempted, todo.length);
         }
-        return { embedded: todo.length, skipped: docs.length - todo.length, total: docs.length };
+        return { embedded, skipped: docs.length - todo.length, total: docs.length };
     }
     /** Hybrid search (hunch_query / `hunch query --semantic`): FTS bm25 fused with
      *  cosine over stored embeddings via Reciprocal Rank Fusion. Degrades to pure
@@ -194,40 +208,54 @@ export class HunchStore {
      *  `embedder: null` to FORCE FTS-only without auto-selecting. */
     async hybridSearch(query, limit = 12, opts = {}) {
         const embedder = opts.embedder !== undefined ? opts.embedder : await selectEmbedder();
-        if (!embedder)
-            return this.search(query, limit);
-        const count = this.db.prepare(`SELECT count(*) c FROM embeddings WHERE model = ?`).get(embedder.id).c;
-        if (count === 0)
+        if (!this.semanticReady(embedder))
             return this.search(query, limit);
         const fts = this.search(query, Math.max(limit, 50));
-        let qvec;
         try {
-            [qvec] = await embedder.embed([query]);
+            // The whole semantic leg (query embedding + decode + cosine + fuse) is guarded:
+            // any failure — model load, a corrupt/dim-mismatched vector — degrades to the
+            // lexical results rather than failing the query.
+            const [qvec] = await embedder.embed([query]);
+            if (!qvec)
+                return fts.slice(0, limit);
+            const sem = this.cosineRank(qvec, embedder.id, 50);
+            return this.rrfFuse(fts, sem, limit);
         }
         catch {
-            return fts.slice(0, limit); // embedding failed at query time → lexical only
-        }
-        if (!qvec)
             return fts.slice(0, limit);
-        const sem = this.cosineRank(qvec, embedder.id, 50);
-        return this.rrfFuse(fts, sem, limit);
+        }
     }
     /** Brute-force exact cosine top-n over stored vectors for one model. Vectors are
-     *  pre-normalized, so cosine == dot product. */
+     *  pre-normalized, so cosine == dot product. Scoped to `dim = qvec.length` so a
+     *  row stored at a different dimension (model id reused at a new dim) can never
+     *  drive an out-of-bounds BLOB read; any with an unexpected byte length are
+     *  skipped defensively rather than crashing the query. */
     cosineRank(qvec, model, n) {
-        const rows = this.db.prepare(`SELECT ref, kind, vec FROM embeddings WHERE model = ?`).all(model);
         const dim = qvec.length;
-        const scored = rows.map((r) => {
+        const rows = this.db.prepare(`SELECT ref, kind, vec FROM embeddings WHERE model = ? AND dim = ?`).all(model, dim);
+        const scored = [];
+        for (const r of rows) {
+            if (r.vec.byteLength !== dim * 4)
+                continue; // corrupt/legacy row — skip, don't read past it
             const v = blobToVec(r.vec, dim);
             let dot = 0;
             for (let i = 0; i < dim; i++)
                 dot += qvec[i] * v[i];
-            return { ref: r.ref, kind: r.kind, score: dot };
-        });
+            scored.push({ ref: r.ref, kind: r.kind, score: dot });
+        }
         scored.sort((a, b) => b.score - a.score);
-        return scored.slice(0, n).map((s) => {
-            const row = this.db.prepare(`SELECT title, body FROM search WHERE ref = ?`).get(s.ref);
-            return { ref: s.ref, kind: s.kind, title: row?.title ?? s.ref, snippet: (row?.body ?? "").slice(0, 120), score: s.score };
+        const top = scored.slice(0, n);
+        // Hydrate title/snippet for the top-n in ONE query (not a per-row SELECT).
+        const meta = new Map();
+        if (top.length) {
+            const placeholders = top.map(() => "?").join(",");
+            for (const row of this.db.prepare(`SELECT ref, title, body FROM search WHERE ref IN (${placeholders})`).all(...top.map((s) => s.ref))) {
+                meta.set(row.ref, { title: row.title, body: row.body });
+            }
+        }
+        return top.map((s) => {
+            const m = meta.get(s.ref);
+            return { ref: s.ref, kind: s.kind, title: m?.title ?? s.ref, snippet: (m?.body ?? "").slice(0, 120), score: s.score };
         });
     }
     /** Rank-based Reciprocal Rank Fusion of the FTS and semantic lists. Ranks (not

package/dist/store/schema.js

@@ -6,95 +6,96 @@
  * — we only need them indexed where we query them. Search is a single unified
  * FTS5 table; the graph is plain tables walked with recursive CTEs.
  */
-import { createHash } from "node:crypto";
+import { shortHash } from "../core/ids.js";
 /** Canonical content hash of the exact title+body that fed both FTS and the
  *  embedding for a doc. Stored in `embeddings.doc_hash` so reindex can tell, with
  *  NO model loaded, whether a stored vector is stale (its source text changed).
- *  The NUL separator keeps the title/body boundary unambiguous. */
+ *  The NUL separator keeps the title/body boundary unambiguous. Reuses the shared
+ *  sha1-truncate idiom from core/ids so the hashing scheme lives in one place. */
 export function embedHash(title, body) {
-    return createHash("sha1").update(title).update("\x00").update(body ?? "").digest("hex").slice(0, 16);
+    return shortHash(`${title}\x00${body ?? ""}`, 16);
 }
-export const SCHEMA_SQL = /* sql */ `
-PRAGMA journal_mode = WAL;
-PRAGMA foreign_keys = OFF;
-
-CREATE TABLE IF NOT EXISTS components (
-  id TEXT PRIMARY KEY,
-  kind TEXT, name TEXT, responsibility TEXT,
-  paths TEXT, status TEXT, owners TEXT,
-  fragility REAL,
-  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT,
-  created_at TEXT, updated_at TEXT
-);
-
-CREATE TABLE IF NOT EXISTS edges (
-  id TEXT PRIMARY KEY,
-  "from" TEXT, "to" TEXT, type TEXT, reason TEXT, strength REAL,
-  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT
-);
-CREATE INDEX IF NOT EXISTS idx_edges_from ON edges("from");
-CREATE INDEX IF NOT EXISTS idx_edges_to ON edges("to");
-CREATE INDEX IF NOT EXISTS idx_edges_type ON edges(type);
-
-CREATE TABLE IF NOT EXISTS symbols (
-  id TEXT PRIMARY KEY,
-  file TEXT, name TEXT, kind TEXT, signature_hash TEXT,
-  calls TEXT, called_by TEXT,
-  loc INTEGER, churn_90d INTEGER, bug_count INTEGER, fan_in INTEGER, fan_out INTEGER,
-  last_changed TEXT
-);
-CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file);
-CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
-
-CREATE TABLE IF NOT EXISTS decisions (
-  id TEXT PRIMARY KEY,
-  title TEXT, status TEXT, context TEXT, decision TEXT,
-  consequences TEXT, alternatives_rejected TEXT,
-  related_components TEXT, related_files TEXT,
-  supersedes TEXT, caused_by_bug TEXT, "commit" TEXT,
-  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT,
-  date TEXT
-);
-
-CREATE TABLE IF NOT EXISTS bugs (
-  id TEXT PRIMARY KEY,
-  title TEXT, symptom TEXT, root_cause TEXT, severity TEXT, status TEXT,
-  affected_files TEXT, affected_symbols TEXT, lineage TEXT,
-  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT
-);
-
-CREATE TABLE IF NOT EXISTS constraints (
-  id TEXT PRIMARY KEY,
-  type TEXT, statement TEXT, scope TEXT, severity TEXT, enforcement TEXT,
-  rationale TEXT, source_decision TEXT, violations TEXT,
-  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT
-);
-
--- Unified full-text search across every entity. Rebuilt on index; bm25-ranked.
-CREATE VIRTUAL TABLE IF NOT EXISTS search USING fts5(
-  ref UNINDEXED,   -- entity id
-  kind UNINDEXED,  -- components | edges | symbols | decisions | bugs | constraints
-  title,
-  body,
-  tokenize = 'porter unicode61'
-);
-
--- Local semantic-search vectors (opt-in; written by \`hunch embed\`). One row per
--- (ref, model); vec is a Float32 BLOB. DELIBERATELY NOT in RESET_SQL: reindex()
--- runs RESET on nearly every path (MCP startup, every query/context), so resetting
--- embeddings here would wipe them constantly and make the feature a no-op. Staleness
--- is tracked by doc_hash and reconciled by pruneStaleEmbeddings() instead. Recall is
--- exact brute-force cosine in JS (graphs are small); sqlite-vec only past ~100k rows.
-CREATE TABLE IF NOT EXISTS embeddings (
-  ref TEXT, kind TEXT, model TEXT, dim INTEGER, doc_hash TEXT, vec BLOB,
-  PRIMARY KEY (ref, model)
-);
+export const SCHEMA_SQL = /* sql */ `
+PRAGMA journal_mode = WAL;
+PRAGMA foreign_keys = OFF;
+
+CREATE TABLE IF NOT EXISTS components (
+  id TEXT PRIMARY KEY,
+  kind TEXT, name TEXT, responsibility TEXT,
+  paths TEXT, status TEXT, owners TEXT,
+  fragility REAL,
+  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT,
+  created_at TEXT, updated_at TEXT
+);
+
+CREATE TABLE IF NOT EXISTS edges (
+  id TEXT PRIMARY KEY,
+  "from" TEXT, "to" TEXT, type TEXT, reason TEXT, strength REAL,
+  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_edges_from ON edges("from");
+CREATE INDEX IF NOT EXISTS idx_edges_to ON edges("to");
+CREATE INDEX IF NOT EXISTS idx_edges_type ON edges(type);
+
+CREATE TABLE IF NOT EXISTS symbols (
+  id TEXT PRIMARY KEY,
+  file TEXT, name TEXT, kind TEXT, signature_hash TEXT,
+  calls TEXT, called_by TEXT,
+  loc INTEGER, churn_90d INTEGER, bug_count INTEGER, fan_in INTEGER, fan_out INTEGER,
+  last_changed TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file);
+CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
+
+CREATE TABLE IF NOT EXISTS decisions (
+  id TEXT PRIMARY KEY,
+  title TEXT, status TEXT, context TEXT, decision TEXT,
+  consequences TEXT, alternatives_rejected TEXT,
+  related_components TEXT, related_files TEXT,
+  supersedes TEXT, caused_by_bug TEXT, "commit" TEXT,
+  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT,
+  date TEXT
+);
+
+CREATE TABLE IF NOT EXISTS bugs (
+  id TEXT PRIMARY KEY,
+  title TEXT, symptom TEXT, root_cause TEXT, severity TEXT, status TEXT,
+  affected_files TEXT, affected_symbols TEXT, lineage TEXT,
+  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT
+);
+
+CREATE TABLE IF NOT EXISTS constraints (
+  id TEXT PRIMARY KEY,
+  type TEXT, statement TEXT, scope TEXT, severity TEXT, enforcement TEXT,
+  rationale TEXT, source_decision TEXT, violations TEXT,
+  prov_source TEXT, prov_confidence REAL, prov_evidence TEXT
+);
+
+-- Unified full-text search across every entity. Rebuilt on index; bm25-ranked.
+CREATE VIRTUAL TABLE IF NOT EXISTS search USING fts5(
+  ref UNINDEXED,   -- entity id
+  kind UNINDEXED,  -- components | edges | symbols | decisions | bugs | constraints
+  title,
+  body,
+  tokenize = 'porter unicode61'
+);
+
+-- Local semantic-search vectors (opt-in; written by \`hunch embed\`). One row per
+-- (ref, model); vec is a Float32 BLOB. DELIBERATELY NOT in RESET_SQL: reindex()
+-- runs RESET on nearly every path (MCP startup, every query/context), so resetting
+-- embeddings here would wipe them constantly and make the feature a no-op. Staleness
+-- is tracked by doc_hash and reconciled by pruneStaleEmbeddings() instead. Recall is
+-- exact brute-force cosine in JS (graphs are small); sqlite-vec only past ~100k rows.
+CREATE TABLE IF NOT EXISTS embeddings (
+  ref TEXT, kind TEXT, model TEXT, dim INTEGER, doc_hash TEXT, vec BLOB,
+  PRIMARY KEY (ref, model)
+);
 `;
 /** Drop derived data (used before a full reindex). NOTE: embeddings is omitted on
  *  purpose — see the embeddings table comment above. */
-export const RESET_SQL = /* sql */ `
-DELETE FROM components; DELETE FROM edges; DELETE FROM symbols;
-DELETE FROM decisions; DELETE FROM bugs; DELETE FROM constraints;
-DELETE FROM search;
+export const RESET_SQL = /* sql */ `
+DELETE FROM components; DELETE FROM edges; DELETE FROM symbols;
+DELETE FROM decisions; DELETE FROM bugs; DELETE FROM constraints;
+DELETE FROM search;
 `;
 //# sourceMappingURL=schema.js.map

package/dist/synthesis/provider.js

@@ -16,11 +16,86 @@
  * Every provider returns the same shape so the rest of the system never knows
  * (or cares) which one ran.
  */
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
+import { spawn } from "node:child_process";
 import { tmpdir } from "node:os";
 import { summarizeDiff } from "../extractors/diff.js";
-const pexec = promisify(execFile);
+const IS_WIN = process.platform === "win32";
+/**
+ * Run a command, optionally feeding `input` to its stdin, and resolve its
+ * stdout. Uses spawn (not execFile) so we can:
+ *   1. Pass untrusted content (the prompt/diff) via STDIN, never as an argv
+ *      element — so a `shell:true` resolution can't shell-interpret it.
+ *   2. Resolve Windows shims: the npm `claude` is a `.cmd`/`.ps1`, which
+ *      `execFile` (CreateProcess, *.exe only) cannot launch → it threw ENOENT
+ *      and made the CLI provider look unavailable on Windows. `shell:true` on
+ *      win32 routes through cmd.exe so the shim resolves. Safe here because
+ *      every argv we pass is a trusted, space-free flag (the prompt is stdin).
+ */
+export function pexecIn(cmd, args, opts = {}) {
+    return new Promise((resolve, reject) => {
+        // Windows: launch through cmd.exe so the `claude` .cmd/.ps1 shim resolves,
+        // and pass the whole line as ONE shell string (args are trusted, space-free
+        // flags) — avoids Node's DEP0190 warning for `args + shell:true`. The prompt
+        // is never here; it goes via stdin below. POSIX: no shell, argv as-is.
+        const child = IS_WIN
+            ? spawn([cmd, ...args].join(" "), {
+                shell: true,
+                env: opts.env,
+                cwd: opts.cwd,
+                windowsHide: true,
+            })
+            : spawn(cmd, args, {
+                env: opts.env,
+                cwd: opts.cwd,
+                windowsHide: true,
+            });
+        const max = opts.maxBuffer ?? 16 * 1024 * 1024;
+        let out = "";
+        let err = "";
+        let outLen = 0;
+        let settled = false;
+        const done = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            fn();
+        };
+        const timer = opts.timeout
+            ? setTimeout(() => {
+                child.kill();
+                done(() => reject(new Error(`"${cmd}" timed out after ${opts.timeout}ms`)));
+            }, opts.timeout)
+            : null;
+        child.on("error", (e) => done(() => reject(e)));
+        child.stdout.on("data", (d) => {
+            outLen += d.length;
+            if (outLen > max) {
+                child.kill();
+                done(() => reject(new Error(`"${cmd}" exceeded maxBuffer (${max} bytes)`)));
+                return;
+            }
+            out += d.toString();
+        });
+        child.stderr.on("data", (d) => {
+            err += d.toString();
+        });
+        child.on("close", (code) => {
+            done(() => {
+                if (code === 0)
+                    resolve({ stdout: out });
+                else
+                    reject(new Error(`"${cmd}" exited ${code}: ${err.slice(0, 300)}`));
+            });
+        });
+        // Feed stdin (the prompt) then close it; commands with no input just get EOF.
+        if (opts.input != null)
+            child.stdin.write(opts.input);
+        child.stdin.on("error", () => { }); // ignore EPIPE if the child exits early
+        child.stdin.end();
+    });
+}
 const SYSTEM = `You are the synthesis engine of an Engineering Memory OS. You turn raw
 developer activity (a git commit diff, or a test failure) into a single structured
 "why" record. Be precise and evidence-grounded; never invent facts not supported by
@@ -66,7 +141,7 @@ class ClaudeCliProvider {
     model = process.env.HUNCH_SYNTH_MODEL || "haiku";
     async available() {
         try {
-            await pexec("claude", ["--version"], { timeout: 8000 });
+            await pexecIn("claude", ["--version"], { timeout: 8000 });
             return true;
         }
         catch {
@@ -87,8 +162,11 @@ class ClaudeCliProvider {
         // repo's own hunch MCP server / CLAUDE.md on every commit (cheaper, and no
         // risk of the synthesis call recursing through the Hunch). Auth lives in the
         // user's home config, not cwd, so this doesn't affect subscription billing.
-        const args = ["-p", prompt, "--output-format", "json", "--model", this.model, "--max-turns", "1"];
-        const { stdout } = await pexec("claude", args, {
+        // Prompt goes via STDIN (-p reads piped stdin), never argv — keeps untrusted
+        // diff content out of any shell the spawn helper uses on Windows.
+        const args = ["-p", "--output-format", "json", "--model", this.model, "--max-turns", "1"];
+        const { stdout } = await pexecIn("claude", args, {
+            input: prompt,
             env: childEnv,
             cwd: tmpdir(),
             maxBuffer: 16 * 1024 * 1024,

package/package.json

@@ -1,68 +1,68 @@
-{
-  "name": "@davesheffer/hunch",
-  "version": "0.1.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.",
-  "homepage": "https://hunch.sh",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/davesheffer/hunch.git"
-  },
-  "bugs": {
-    "url": "https://github.com/davesheffer/hunch/issues"
-  },
-  "type": "module",
-  "bin": {
-    "hunch": "dist/cli/index.js"
-  },
-  "files": [
-    "dist/**/*.js"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "keywords": [
-    "claude-code",
-    "mcp",
-    "engineering-memory",
-    "knowledge-graph",
-    "code-intelligence",
-    "ai",
-    "developer-tools"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "clean": "node --input-type=commonjs -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
-    "build": "npm run clean && tsc -p tsconfig.json",
-    "dev": "tsx src/cli/index.ts",
-    "hunch": "tsx src/cli/index.ts",
-    "test": "tsx --test test/*.test.ts",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "prepublishOnly": "npm run build"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "better-sqlite3": "12.9.0",
-    "commander": "^15.0.0",
-    "tree-sitter": "0.21.1",
-    "tree-sitter-typescript": "^0.23.2",
-    "zod": "^4.4.3"
-  },
-  "devDependencies": {
-    "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^20.19.0",
-    "tsx": "^4.22.4",
-    "typescript": "^5.9.3"
-  },
-  "peerDependencies": {
-    "@huggingface/transformers": ">=3"
-  },
-  "peerDependenciesMeta": {
-    "@huggingface/transformers": {
-      "optional": true
-    }
-  }
-}
+{
+  "name": "@davesheffer/hunch",
+  "version": "0.1.1",
+  "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.",
+  "homepage": "https://hunch.sh",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/davesheffer/hunch.git"
+  },
+  "bugs": {
+    "url": "https://github.com/davesheffer/hunch/issues"
+  },
+  "type": "module",
+  "bin": {
+    "hunch": "dist/cli/index.js"
+  },
+  "files": [
+    "dist/**/*.js"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "claude-code",
+    "mcp",
+    "engineering-memory",
+    "knowledge-graph",
+    "code-intelligence",
+    "ai",
+    "developer-tools"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "clean": "node --input-type=commonjs -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "dev": "tsx src/cli/index.ts",
+    "hunch": "tsx src/cli/index.ts",
+    "test": "tsx --test test/*.test.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "better-sqlite3": "12.9.0",
+    "commander": "^15.0.0",
+    "tree-sitter": "0.21.1",
+    "tree-sitter-typescript": "^0.23.2",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^20.19.0",
+    "tsx": "^4.22.4",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@huggingface/transformers": ">=3"
+  },
+  "peerDependenciesMeta": {
+    "@huggingface/transformers": {
+      "optional": true
+    }
+  }
+}