@davesheffer/hunch 0.10.1 → 0.10.2

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/package.json

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