grepmax 0.17.23 → 0.18.0

package/dist/eval-graph-sanity.js

@@ -1,20 +1,28 @@
 "use strict";
 /**
- * Phase 0 sanity check for Bundle B G1' (graph-as-recall-recovery).
+ * Graph sanity checks.
  *
- * For each platform hard-miss case (BeyondError, ErrorCodes, resolveActor,
- * errorHandler), mirror the searcher's dense+FTS+RRF pipeline to produce
- * the post-fusion top-200 candidate pool, then count how many of those
- * 200 chunks have `referenced_symbols` containing the target symbol.
+ * Default mode — caller-count guard (regression net for the chunker-v2 /
+ * call-site-dedup fix). Before that fix, `splitIfTooBig` copied a parent
+ * chunk's full `referenced_symbols` onto every sub-chunk, so `getCallers`
+ * multiplied chunk rows: a symbol with 3 real call sites reported 66 callers
+ * (22x). For a set of known gmax symbols this asserts `getCallers`' raw count
+ * stays within a small multiple of grep-truth (word-boundary line matches
+ * across tracked source). Exits nonzero if any symbol blows past the ceiling.
+ * Run after a reindex so the index matches the working tree.
  *
- * ≥1 hit per case = 1-hop outbound graph walk can recover the target
- * (the seed chunk's defined symbol points at the target via the call
- * graph) → worth building the recovery layer.
+ *   npx tsx src/eval-graph-sanity.ts
  *
- * 0 hits across all 4 = the signal isn't in the graph at this seed
- * depth → stop and report the negative result.
+ * Platform mode (--platform) — the original Phase 0 probe for Bundle B G1'
+ * (graph-as-recall-recovery). For each platform hard-miss case (BeyondError,
+ * ErrorCodes, resolveActor, errorHandler), mirror the searcher's dense+FTS+RRF
+ * pipeline to the post-fusion top-200 pool, then count how many of those chunks
+ * carry the target in `referenced_symbols`. ≥1 hit = a 1-hop outbound graph
+ * walk can recover the target → worth building the recovery layer; 0 across all
+ * 4 = the signal isn't in the graph at this depth. Requires
+ * ~/Development/beyond/platform to be indexed.
  *
- * Run: `npx tsx src/eval-graph-sanity.ts`
+ *   npx tsx src/eval-graph-sanity.ts --platform
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -62,12 +70,15 @@ var _a, _b;
 var _c;
 Object.defineProperty(exports, "__esModule", { value: true });
 (_a = (_c = process.env).GMAX_WORKER_COUNT) !== null && _a !== void 0 ? _a : (_c.GMAX_WORKER_COUNT = "1");
+const node_child_process_1 = require("node:child_process");
 const path = __importStar(require("node:path"));
 const config_1 = require("./config");
+const callsites_1 = require("./lib/graph/callsites");
+const graph_builder_1 = require("./lib/graph/graph-builder");
 const vector_db_1 = require("./lib/store/vector-db");
 const exit_1 = require("./lib/utils/exit");
-const pool_1 = require("./lib/workers/pool");
 const filter_builder_1 = require("./lib/utils/filter-builder");
+const pool_1 = require("./lib/workers/pool");
 const PLATFORM_ROOT = path.join((_b = process.env.HOME) !== null && _b !== void 0 ? _b : "", "Development/beyond/platform");
 const HARD_MISS_TARGETS = [
     "BeyondError",
@@ -104,7 +115,9 @@ function probe(target) {
         const table = yield db.ensureTable();
         const pool = (0, pool_1.getWorkerPool)();
         const { dense } = yield pool.encodeQuery(target);
-        const pathPrefix = PLATFORM_ROOT.endsWith("/") ? PLATFORM_ROOT : `${PLATFORM_ROOT}/`;
+        const pathPrefix = PLATFORM_ROOT.endsWith("/")
+            ? PLATFORM_ROOT
+            : `${PLATFORM_ROOT}/`;
         const where = `path LIKE '${(0, filter_builder_1.escapeSqlString)(pathPrefix)}%'`;
         const columns = [
             "id",
@@ -136,14 +149,12 @@ function probe(target) {
         const candidateScores = new Map();
         const docMap = new Map();
         vectorRows.forEach((doc, rank) => {
-            const key = doc.id ||
-                `${doc.path}:${doc.chunk_index}`;
+            const key = doc.id || `${doc.path}:${doc.chunk_index}`;
             docMap.set(key, doc);
             candidateScores.set(key, (candidateScores.get(key) || 0) + 1.0 / (RRF_K + rank + 1));
         });
         ftsRows.forEach((doc, rank) => {
-            const key = doc.id ||
-                `${doc.path}:${doc.chunk_index}`;
+            const key = doc.id || `${doc.path}:${doc.chunk_index}`;
             if (!docMap.has(key))
                 docMap.set(key, doc);
             candidateScores.set(key, (candidateScores.get(key) || 0) + 1.0 / (RRF_K + rank + 1));
@@ -189,7 +200,7 @@ function probe(target) {
         };
     });
 }
-function main() {
+function platformProbe() {
     return __awaiter(this, void 0, void 0, function* () {
         console.log(`Phase 0 sanity check — graph reachability on platform hard-miss cases`);
         console.log(`pathPrefix: ${PLATFORM_ROOT}`);
@@ -214,7 +225,115 @@ function main() {
         console.log(`\nVerdict: ${anyReachable ? "BUILD (≥1 case has graph signal in top-200)" : "ABORT (graph is empty at this depth — pick a different mechanism)"}`);
         console.log(`\nJSON:`);
         console.log(JSON.stringify(summary, null, 2));
-        yield (0, exit_1.gracefulExit)(0);
+    });
+}
+// ---------------------------------------------------------------------------
+// Caller-count guard (default mode)
+// ---------------------------------------------------------------------------
+const GMAX_ROOT = path.resolve(__dirname, "..");
+/**
+ * Distinctive gmax symbols with a spread of real usage. All sit comfortably
+ * below getCallers' internal `.limit(100)`, so the cap can never silently mask
+ * an explosion — if the chunker regresses, the raw count blows past the
+ * ceiling rather than getting clamped to 100. Names are intentionally unusual
+ * (no bare words) so `git grep -w` truth isn't polluted by unrelated matches.
+ */
+const GUARD_SYMBOLS = [
+    "resolveCallSites",
+    "findCallSiteSnippet",
+    "withQueryTimeout",
+    "isFileCached",
+    "getWorkerPool",
+    "isBuiltinCallee",
+    "findDependents",
+    "buildFileSubgraph",
+];
+/**
+ * getCallers returns one chunk-row per referencing chunk. Healthy, that count
+ * is ≤ the number of source lines mentioning the symbol (several mentions in
+ * one chunk collapse to one row; def/import lines aren't call references). So
+ * the healthy ratio is ≤ ~1. A small multiple absorbs index-vs-worktree skew
+ * and chunk-boundary splits while still catching the 22x chunker-v2 blowup.
+ */
+const CEILING_MULTIPLE = 3;
+/** Mirror of getCallers' internal `.limit(100)` — at the cap the guard is blind. */
+const CALLER_LIMIT = 100;
+/**
+ * grep-truth: word-boundary line + file counts for `symbol` across tracked
+ * `.ts` (repo-wide, so experiments/ and scripts/ count too — they're indexed).
+ * `git grep` skips gitignored paths (dist/), matching the indexed corpus.
+ */
+function grepTruth(symbol) {
+    let out;
+    try {
+        out = (0, node_child_process_1.execFileSync)("git", ["grep", "-Fwc", symbol, "--", "*.ts"], {
+            cwd: GMAX_ROOT,
+            encoding: "utf-8",
+        });
+    }
+    catch (_a) {
+        // git grep exits 1 when there are zero matches.
+        return { lines: 0, files: 0 };
+    }
+    let lines = 0;
+    let files = 0;
+    for (const row of out.split("\n")) {
+        const idx = row.lastIndexOf(":");
+        if (idx < 0)
+            continue;
+        const n = Number(row.slice(idx + 1));
+        if (Number.isFinite(n) && n > 0) {
+            lines += n;
+            files++;
+        }
+    }
+    return { lines, files };
+}
+function callerCountGuard() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = new vector_db_1.VectorDB(config_1.PATHS.lancedbDir);
+        yield db.ensureTable();
+        const builder = new graph_builder_1.GraphBuilder(db, GMAX_ROOT);
+        const fileCache = new Map();
+        console.log(`Caller-count guard — getCallers vs grep-truth call sites`);
+        console.log(`root: ${GMAX_ROOT}`);
+        console.log(`ceiling = ${CEILING_MULTIPLE}x grep lines · getCallers cap = ${CALLER_LIMIT}`);
+        console.log(`(run after a reindex so the index matches the working tree)\n`);
+        let allOK = true;
+        for (const sym of GUARD_SYMBOLS) {
+            const { lines: grepLines, files: grepFiles } = grepTruth(sym);
+            const callers = yield builder.getCallers(sym);
+            const raw = callers.length;
+            const deduped = (0, callsites_1.resolveCallSites)(callers.map((c) => ({ symbol: c.symbol, file: c.file, line: c.line })), sym, fileCache).length;
+            const ceiling = CEILING_MULTIPLE * Math.max(1, grepLines);
+            const capped = raw >= CALLER_LIMIT;
+            const ratio = grepLines > 0 ? raw / grepLines : raw;
+            // capped is a failure too: the fixture grew too common, so the cap now
+            // hides explosions — swap it for a lower-usage symbol.
+            const ok = !capped && raw <= ceiling;
+            if (!ok)
+                allOK = false;
+            console.log(`${ok ? "✓" : "✗"} ${sym.padEnd(20)} ` +
+                `callers=${String(raw).padStart(3)} (dedup ${String(deduped).padStart(3)})  ` +
+                `grep=${String(grepLines).padStart(3)}L/${String(grepFiles).padStart(2)}f  ` +
+                `ratio=${ratio.toFixed(2)}  ceiling=${ceiling}` +
+                (capped ? "  [CAPPED — fixture too common]" : ""));
+        }
+        console.log(`\nVerdict: ${allOK ? "PASS (no caller-count explosion)" : "FAIL (getCallers exceeds grep-truth ceiling — chunker symbol dedup regressed)"}`);
+        yield db.close();
+        return allOK;
+    });
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const platform = process.argv.includes("--platform");
+        if (platform) {
+            yield platformProbe();
+            yield (0, exit_1.gracefulExit)(0);
+            return;
+        }
+        const ok = yield callerCountGuard();
+        yield (0, exit_1.gracefulExit)(ok ? 0 : 1);
     });
 }
 if (require.main === module) {