@esneiderbravo/speclaw 2.0.9 → 2.0.10

package/dist/modules/compass/indexer.js

@@ -1,9 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
 import { createHash } from "node:crypto";
-import { openDb, clearNeedsReindex, needsReindex } from "./db.js";
+import { openDb, clearNeedsReindex, needsReindex, FILE_NODE_KIND } from "./db.js";
 import { langForPath } from "./languages.js";
-import { extract } from "./extract.js";
+import { extract, importSpecifier } from "./extract.js";
 import { getEmbedder, toBlob } from "./embedder.js";
 import { contentHashFor, defaultEmbedText } from "./embed-input.js";
 import { buildDirHashMap } from "./merkle.js";
@@ -36,106 +36,368 @@ function hashOf(content) {
 const DEFAULT_MAX_CACHE_MB = 256;
 const DEFAULT_RETENTION_DAYS = 30;
 /**
- * Point import edges at a representative node in the imported file so reverse
- * reachability can walk file-level dependencies (not just calls).
+ * Call names that are ambient globals in common runtimes and test frameworks.
+ * A plain call to one of them binds only to a definition in the same file, so
+ * a project symbol that happens to share the name never collects every test
+ * file as a caller.
+ */
+export const BUILTIN_GLOBALS = [
+    "describe",
+    "it",
+    "test",
+    "expect",
+    "beforeEach",
+    "afterEach",
+    "beforeAll",
+    "afterAll",
+    "setTimeout",
+    "setInterval",
+    "clearTimeout",
+    "clearInterval",
+    "queueMicrotask",
+    "parseInt",
+    "parseFloat",
+    "require",
+    "structuredClone",
+    "fetch",
+    "print",
+    "len",
+    "isinstance",
+    "super",
+];
+/** {@link BUILTIN_GLOBALS} as a quoted SQL `IN (...)` list. */
+export const BUILTIN_SQL_LIST = BUILTIN_GLOBALS.map((n) => `'${n}'`).join(", ");
+/** Most bind parameters a scoped {@link resolveEdges} call uses before running unscoped. */
+const MAX_SCOPE_PARAMS = 10_000;
+/**
+ * Resolve call and import edges to node ids — the one place edge resolution
+ * lives, shared by the full index run and incremental re-indexing.
+ *
+ * - Edges whose `dst_node_id` points at a node that no longer exists (its file
+ *   was re-extracted) are reset to unresolved first.
+ * - Imports are resolved first (below). A call's "import target" is the file
+ *   the same-file import edge with the call's `spec` resolved to.
+ * - Calls with `is_member = 1` are never resolved by name. Calls with
+ *   `is_member = 2` (a member call on an import binding) resolve only when their
+ *   import target exists: an import that no relative/alias/baseUrl resolution
+ *   maps to a project file is a package, so `path.parse()` stays foreign.
+ * - A call to a {@link BUILTIN_GLOBALS} name resolves only to a definition in
+ *   the same file or in its import target (`import { fetch } from "./http"`).
+ * - Otherwise a call prefers its import target, then a definition under the
+ *   import target's directory (a barrel's subtree), then a same-file
+ *   definition, else the lowest-id node with that name. File-owner nodes are
+ *   never call targets. An import of a symbol-less or re-exporting file (a
+ *   barrel) resolves to that file's file-owner node, so member calls through
+ *   it bind by name like this.
+ * - Imports resolve their specifier relative to the importing file, then
+ *   through the nearest `tsconfig.json`/`jsconfig.json` `paths`/`baseUrl`, and
+ *   point at the target file's file-owner node when it has one, otherwise at
+ *   its first node by `start_line`.
+ *
+ * The project root is read from the database's own path
+ * (`<root>/.speclaw/index.db`), so callers pass only the connection.
+ *
+ * @param db - Open index database (the caller owns the transaction).
+ * @param fileIds - When set, only calls owned by these files or by files whose
+ * import this pass resolved, and unresolved calls whose name a node in these
+ * files defines; unresolved imports are always all processed (a new file may
+ * satisfy any of them). When omitted, every
+ * unresolved edge.
+ * @returns How many call and import edges this call resolved.
+ */
+export function resolveEdges(db, fileIds) {
+    // Covers: req~impact-id-first~1
+    db.exec(`UPDATE edges SET dst_node_id = NULL
+     WHERE dst_node_id IS NOT NULL AND NOT EXISTS (SELECT 1 FROM nodes n WHERE n.id = edges.dst_node_id)`);
+    const scoped = fileIds !== undefined;
+    const ids = fileIds ?? [];
+    const idList = ids.map(() => "?").join(", ") || "NULL";
+    const resolvedCalls = () => Number(db
+        .prepare("SELECT COUNT(*) AS n FROM edges WHERE kind = 'call' AND dst_node_id IS NOT NULL")
+        .get().n);
+    // Imports first: whether a call on an import binding may bind depends on
+    // whether that binding's import resolved to a project file.
+    const { resolved: imports, srcFiles } = resolveImportEdges(db, projectRootOf(db));
+    const before = resolvedCalls();
+    // A file whose import just resolved may have pending is_member = 2 calls.
+    // Past a bound (SQLite caps bind parameters) the pass is simply unscoped.
+    const importScope = [...srcFiles];
+    const importList = importScope.map(() => "?").join(", ") || "NULL";
+    const narrow = scoped && 2 * ids.length + importScope.length <= MAX_SCOPE_PARAMS;
+    const callScope = narrow
+        ? `AND (src_file_id IN (${idList}) OR src_file_id IN (${importList})
+          OR dst_name IN (SELECT name FROM nodes WHERE file_id IN (${idList}) AND kind <> '${FILE_NODE_KIND}'))`
+        : "";
+    // File of the node the same-file import with this call's spec resolved to;
+    // NULL when the call has no spec (the subquery is skipped) or that import
+    // stayed unresolved (a package).
+    const importTarget = `(CASE WHEN edges.spec IS NULL THEN NULL ELSE (
+       SELECT t.file_id FROM edges i JOIN nodes t ON t.id = i.dst_node_id
+       WHERE i.src_file_id = edges.src_file_id AND i.kind = 'import' AND i.spec = edges.spec
+       ORDER BY i.id LIMIT 1) END)`;
+    // Candidate n lies under the import target's directory: a barrel
+    // (`libs/core/src/index.ts`) usually re-exports its own subtree, so this
+    // stands in for "reachable through the barrel's re-exports" without storing
+    // them. rtrim(p, <p without '/'>) is p's directory with its trailing slash.
+    const underTargetDir = `EXISTS (
+       SELECT 1 FROM files tf, files nf
+       WHERE tf.id = ${importTarget} AND nf.id = n.file_id
+         AND substr(nf.path, 1, length(rtrim(tf.path, replace(tf.path, '/', ''))))
+             = rtrim(tf.path, replace(tf.path, '/', '')))`;
+    db.prepare(`UPDATE edges SET dst_node_id = (
+       SELECT n.id FROM nodes n
+       WHERE n.name = edges.dst_name
+         AND n.kind <> '${FILE_NODE_KIND}'
+         AND (edges.dst_name NOT IN (${BUILTIN_SQL_LIST}) OR n.file_id = edges.src_file_id
+              OR n.file_id = ${importTarget})
+       ORDER BY CASE WHEN n.file_id = ${importTarget} THEN 0
+                     WHEN edges.spec IS NOT NULL AND ${underTargetDir} THEN 1
+                     WHEN n.file_id = edges.src_file_id THEN 2 ELSE 3 END, n.id
+       LIMIT 1
+     )
+     WHERE kind = 'call' AND dst_node_id IS NULL
+       AND (is_member = 0
+            OR (is_member = 2 AND edges.spec IS NOT NULL AND ${importTarget} IS NOT NULL))
+       ${callScope}`).run(...(narrow ? [...ids, ...importScope, ...ids] : []));
+    const calls = resolvedCalls() - before;
+    return { calls, imports };
+}
+/** Project root of an index database stored at `<root>/.speclaw/index.db`. */
+function projectRootOf(db) {
+    const row = db.prepare("SELECT file FROM pragma_database_list WHERE name = 'main'").get();
+    return path.dirname(path.dirname(row?.file ?? ""));
+}
+/**
+ * Point every unresolved import edge at a representative node of the imported
+ * file (its file-owner node, else its first node) so reverse reachability walks
+ * file-level dependencies, not just calls. Not narrowed by file: a newly
+ * indexed file can satisfy an import anywhere.
+ *
+ * @returns How many import edges were resolved, and the importing files' ids.
  */
 function resolveImportEdges(db, projectPath) {
+    // Covers: req~import-resolution~1
     const files = db.prepare("SELECT id, path FROM files").all();
     const byNorm = new Map();
-    for (const f of files) {
+    for (const f of files)
         byNorm.set(f.path.split("\\").join("/"), f.id);
-    }
-    const firstNode = db.prepare("SELECT id FROM nodes WHERE file_id = ? ORDER BY start_line ASC, id ASC LIMIT 1");
-    const namedNode = db.prepare("SELECT id FROM nodes WHERE file_id = ? AND name = ? ORDER BY id ASC LIMIT 1");
+    const target = db.prepare(`SELECT id FROM nodes WHERE file_id = ?
+     ORDER BY kind = '${FILE_NODE_KIND}' DESC, start_line ASC, id ASC LIMIT 1`);
     const upd = db.prepare("UPDATE edges SET dst_node_id = ? WHERE id = ?");
     const imports = db
-        .prepare(`SELECT e.id, e.dst_name, e.src_file_id, f.path AS src_path
+        .prepare(`SELECT e.id, e.dst_name, e.spec, e.src_file_id, f.path AS src_path
        FROM edges e JOIN files f ON f.id = e.src_file_id
        WHERE e.kind = 'import' AND e.dst_node_id IS NULL`)
         .all();
+    const aliases = new AliasResolver(projectPath);
+    let resolved = 0;
+    const srcFiles = new Set();
     for (const edge of imports) {
-        const spec = parseImportSpecifier(edge.dst_name);
+        const spec = edge.spec ?? importSpecifier(edge.dst_name);
         if (!spec)
             continue;
-        const targetRel = resolveImportPath(projectPath, edge.src_path, spec.from);
+        const targetRel = resolveImportPath(projectPath, edge.src_path, spec, byNorm, aliases);
         if (!targetRel)
             continue;
         const fileId = byNorm.get(targetRel);
         if (fileId === undefined)
             continue;
-        let nodeId;
-        for (const name of spec.names) {
-            const row = namedNode.get(fileId, name);
-            if (row) {
-                nodeId = row.id;
-                break;
+        const row = target.get(fileId);
+        if (!row)
+            continue;
+        upd.run(row.id, edge.id);
+        resolved++;
+        srcFiles.add(edge.src_file_id);
+    }
+    return { resolved, srcFiles };
+}
+/** Repo-relative candidate files for an import target (extension and index probing). */
+function importCandidates(projectPath, absBase) {
+    const rel = path.relative(projectPath, absBase).split(path.sep).join("/");
+    if (rel.startsWith("..") || path.isAbsolute(rel))
+        return [];
+    return [
+        rel,
+        rel.replace(/\.js$/, ".ts"),
+        rel.replace(/\.js$/, ".tsx"),
+        rel.replace(/\.jsx$/, ".tsx"),
+        rel.replace(/\.mjs$/, ".mts"),
+        rel.replace(/\.cjs$/, ".cts"),
+        `${rel}.ts`,
+        `${rel}.tsx`,
+        `${rel}.js`,
+        `${rel}.jsx`,
+        `${rel}.mjs`,
+        `${rel}.cjs`,
+        `${rel}/index.ts`,
+        `${rel}/index.tsx`,
+        `${rel}/index.js`,
+    ];
+}
+/**
+ * Resolve an import specifier to an indexed repo-relative path: relative
+ * specifiers against the importing file (including `.js` → `.ts`), then
+ * tsconfig/jsconfig `paths` aliases and bare `baseUrl` lookups. Bare package
+ * names that match no project file stay unresolved (null).
+ */
+function resolveImportPath(projectPath, srcRel, spec, indexed, aliases) {
+    const firstIndexed = (absBase) => importCandidates(projectPath, absBase).find((c) => indexed.has(c)) ?? null;
+    const srcDir = path.dirname(path.join(projectPath, srcRel));
+    if (spec.startsWith(".") || spec.startsWith("/")) {
+        return firstIndexed(path.resolve(srcDir, spec));
+    }
+    for (const absBase of aliases.candidates(srcDir, spec)) {
+        const hit = firstIndexed(absBase);
+        if (hit)
+            return hit;
+    }
+    return null;
+}
+/**
+ * Best-effort tsconfig/jsconfig alias lookup, cached per directory for one
+ * resolution pass. Never throws: an unreadable or malformed config disables
+ * alias resolution for the files under it, and relative imports still resolve.
+ */
+class AliasResolver {
+    root;
+    byDir = new Map();
+    constructor(root) {
+        this.root = root;
+    }
+    /** Absolute import bases to probe for a non-relative specifier, in order. */
+    candidates(fromDir, spec) {
+        const cfg = this.configFor(fromDir);
+        if (!cfg)
+            return [];
+        const out = [];
+        for (const { pattern, targets } of cfg.paths) {
+            const star = pattern.indexOf("*");
+            let captured = null;
+            if (star < 0) {
+                if (spec === pattern)
+                    captured = "";
+            }
+            else {
+                const pre = pattern.slice(0, star);
+                const post = pattern.slice(star + 1);
+                if (spec.startsWith(pre) &&
+                    spec.endsWith(post) &&
+                    spec.length >= pre.length + post.length) {
+                    captured = spec.slice(pre.length, spec.length - post.length);
+                }
+            }
+            if (captured === null)
+                continue;
+            for (const t of targets) {
+                out.push(path.resolve(cfg.baseUrl ?? cfg.pathsBase, t.replace("*", captured)));
             }
         }
-        if (nodeId === undefined) {
-            const row = firstNode.get(fileId);
-            nodeId = row?.id;
+        if (cfg.baseUrl)
+            out.push(path.resolve(cfg.baseUrl, spec));
+        return out;
+    }
+    /** Nearest tsconfig/jsconfig at or above `dir`, bounded by the project root. */
+    configFor(dir) {
+        const cached = this.byDir.get(dir);
+        if (cached !== undefined)
+            return cached;
+        let result = null;
+        const rel = path.relative(this.root, dir);
+        if (!rel.startsWith("..") && !path.isAbsolute(rel)) {
+            const own = ["tsconfig.json", "jsconfig.json"]
+                .map((n) => path.join(dir, n))
+                .find((f) => fs.existsSync(f));
+            if (own)
+                result = loadAliasConfig(own, this.root);
+            else if (dir !== this.root)
+                result = this.configFor(path.dirname(dir));
         }
-        if (nodeId !== undefined)
-            upd.run(nodeId, edge.id);
+        this.byDir.set(dir, result);
+        return result;
     }
 }
-/** Pull `from` path and optional named imports out of a raw import statement text. */
-function parseImportSpecifier(text) {
-    const fromMatch = text.match(/\bfrom\s+['"]([^'"]+)['"]/) ?? text.match(/require\s*\(\s*['"]([^'"]+)['"]/);
-    if (!fromMatch)
-        return null;
-    const from = fromMatch[1];
-    const names = [];
-    const brace = text.match(/\{([^}]+)\}/);
-    if (brace) {
-        for (const part of brace[1].split(",")) {
-            const id = part
-                .trim()
-                .split(/\s+as\s+/i)[0]
-                .trim();
-            if (id && /^[A-Za-z_$][\w$]*$/.test(id))
-                names.push(id);
+/**
+ * Strip `//` and block comments and trailing commas from JSONC text, leaving
+ * string literals untouched.
+ */
+export function stripJsonComments(text) {
+    let out = "";
+    let i = 0;
+    while (i < text.length) {
+        const ch = text[i];
+        if (ch === '"') {
+            let j = i + 1;
+            while (j < text.length && text[j] !== '"')
+                j += text[j] === "\\" ? 2 : 1;
+            out += text.slice(i, j + 1);
+            i = j + 1;
+        }
+        else if (ch === "/" && text[i + 1] === "/") {
+            while (i < text.length && text[i] !== "\n")
+                i++;
+        }
+        else if (ch === "/" && text[i + 1] === "*") {
+            const close = text.indexOf("*/", i + 2);
+            i = close < 0 ? text.length : close + 2;
+        }
+        else {
+            out += ch;
+            i++;
         }
     }
-    const def = text.match(/\bimport\s+([A-Za-z_$][\w$]*)\s+/);
-    if (def && !text.includes("{"))
-        names.push(def[1]);
-    return { from, names };
+    return out.replace(/,(\s*[}\]])/g, "$1");
 }
 /**
- * Resolve a relative/absolute-ish import specifier to a project-relative indexed path.
+ * Read a tsconfig and its relative `extends` chain (max depth 5, cycle-safe,
+ * inside the project root). The nearest definition of `baseUrl` and of `paths`
+ * wins, each resolved against the config file that declares it.
+ *
+ * @returns The effective alias config, or null when the file cannot be parsed.
  */
-function resolveImportPath(projectPath, srcRel, spec) {
-    if (!spec.startsWith(".") && !spec.startsWith("/"))
-        return null; // bare package — skip
-    const srcDir = path.dirname(path.join(projectPath, srcRel));
-    const absBase = path.resolve(srcDir, spec);
-    const candidates = [
-        absBase,
-        absBase.replace(/\.js$/, ".ts"),
-        absBase.replace(/\.js$/, ".tsx"),
-        absBase.replace(/\.jsx$/, ".tsx"),
-        `${absBase}.ts`,
-        `${absBase}.tsx`,
-        `${absBase}.js`,
-        `${absBase}.jsx`,
-        `${absBase}.mjs`,
-        `${absBase}.cjs`,
-        path.join(absBase, "index.ts"),
-        path.join(absBase, "index.js"),
-    ];
-    for (const abs of candidates) {
-        if (!fs.existsSync(abs) || !fs.statSync(abs).isFile())
-            continue;
-        return path.relative(projectPath, abs).split("\\").join("/");
+function loadAliasConfig(file, root) {
+    let baseUrl;
+    let paths;
+    let pathsBase = path.dirname(file);
+    const seen = new Set();
+    let current = file;
+    for (let depth = 0; current && depth < 6 && !seen.has(current); depth++) {
+        seen.add(current);
+        let parsed;
+        try {
+            parsed = JSON.parse(stripJsonComments(fs.readFileSync(current, "utf8")));
+        }
+        catch {
+            if (depth === 0)
+                return null;
+            break;
+        }
+        const dir = path.dirname(current);
+        const co = parsed.compilerOptions ?? {};
+        if (baseUrl === undefined && typeof co.baseUrl === "string") {
+            baseUrl = path.resolve(dir, co.baseUrl);
+        }
+        if (paths === undefined && co.paths && typeof co.paths === "object") {
+            paths = co.paths;
+            pathsBase = dir;
+        }
+        current = null;
+        if (typeof parsed.extends === "string" && parsed.extends.startsWith(".")) {
+            let next = path.resolve(dir, parsed.extends);
+            if (!next.endsWith(".json"))
+                next += ".json";
+            const rel = path.relative(root, next);
+            if (!rel.startsWith("..") && !path.isAbsolute(rel) && fs.existsSync(next))
+                current = next;
+        }
     }
-    // Fall back without existence check — strip a trailing .js for TS sources.
-    let rel = path.relative(projectPath, absBase).split("\\").join("/");
-    if (rel.endsWith(".js"))
-        rel = rel.slice(0, -3) + ".ts";
-    else if (!/\.(ts|tsx|js|jsx|mjs|cjs)$/.test(rel))
-        rel = `${rel}.ts`;
-    return rel.replace(/^\.\//, "");
+    const entries = Object.entries(paths ?? {})
+        .filter(([, t]) => Array.isArray(t))
+        .map(([pattern, targets]) => ({
+        pattern,
+        targets: targets.filter((t) => typeof t === "string"),
+    }))
+        .sort((a, b) => b.pattern.split("*")[0].length - a.pattern.split("*")[0].length);
+    return { baseUrl, paths: entries, pathsBase };
 }
 /**
  * Infer a covering artifact's type from its project-relative path.
@@ -243,7 +505,7 @@ export async function buildIndex(projectPath, onProgressOrOpts) {
     const insNode = db.prepare(`INSERT INTO nodes(file_id, name, kind, start_line, end_line, start_byte, end_byte, parent_id, signature, body_hash, norm_hash, content_hash)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
     const insMetrics = db.prepare(`INSERT INTO node_metrics(node_id, loc, max_nesting, branches) VALUES (?, ?, ?, ?)`);
-    const insEdge = db.prepare(`INSERT INTO edges(src_node_id, src_file_id, dst_name, kind, line) VALUES (?, ?, ?, ?, ?)`);
+    const insEdge = db.prepare(`INSERT INTO edges(src_node_id, src_file_id, dst_name, kind, line, is_member, spec) VALUES (?, ?, ?, ?, ?, ?, ?)`);
     const insCoverage = db.prepare(`INSERT OR REPLACE INTO coverage_links(
        artifact_type, name, revision, kind, file_path, line, node_id, source_type, origin
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
@@ -320,7 +582,7 @@ export async function buildIndex(projectPath, onProgressOrOpts) {
             else {
                 fileId = Number(insFile.run(rel, hash, lang.id, isTest, mod, mtimeMs, size).lastInsertRowid);
             }
-            const { symbols, refs, coverage } = await extract(content, lang);
+            const { symbols, refs, coverage, reexports } = await extract(content, lang);
             const nodeIds = [];
             const now = Date.now();
             const touchCache = db.prepare(`UPDATE embedding_cache SET last_seen_at = ? WHERE content_hash = ? AND model = ?`);
@@ -350,12 +612,21 @@ export async function buildIndex(projectPath, onProgressOrOpts) {
                 }
                 stats.embeddings++;
             }
-            const fileOwner = nodeIds[0] ?? null;
+            // Covers: req~impact-id-first~1
+            // Imports and calls outside any definition belong to the file: give the
+            // file one hidden owner node so no edge is ever stored ownerless. A file
+            // with no symbols or with re-exports (a barrel: `export * from "./x"`)
+            // gets one too, so an import of it resolves to the file instead of
+            // looking like a package. It gets no text, embedding, or metrics.
+            const isOrphan = (r) => r.kind === "import" || r.ownerIndex === null;
+            let fileOwner = null;
+            if (refs.some(isOrphan) || symbols.length === 0 || reexports.length > 0) {
+                const lastLine = content.length === 0 ? 1 : content.replace(/\n$/, "").split("\n").length;
+                fileOwner = Number(insNode.run(fileId, rel, FILE_NODE_KIND, 1, lastLine, 0, content.length, null, null, null, null, null).lastInsertRowid);
+            }
             for (const r of refs) {
-                let srcId = r.ownerIndex !== null ? nodeIds[r.ownerIndex] : null;
-                if (srcId === null && r.kind === "import")
-                    srcId = fileOwner;
-                insEdge.run(srcId, fileId, r.name, r.kind, r.line);
+                const srcId = isOrphan(r) ? fileOwner : nodeIds[r.ownerIndex];
+                insEdge.run(srcId, fileId, r.name, r.kind, r.line, r.member, r.spec);
                 stats.edges++;
             }
             const sourceType = inferSourceType(rel);
@@ -393,16 +664,7 @@ export async function buildIndex(projectPath, onProgressOrOpts) {
                 const nFiles = [...fileHashes.keys()].filter((f) => dir === "" ? true : f === dir || f.startsWith(dir + "/")).length;
                 insDir.run(dir, hash, nFiles, now);
             }
-            db.exec(`
-        UPDATE edges SET dst_node_id = (
-          SELECT n.id FROM nodes n
-          WHERE n.name = edges.dst_name
-          ORDER BY CASE WHEN n.file_id = edges.src_file_id THEN 0 ELSE 1 END, n.id
-          LIMIT 1
-        )
-        WHERE kind = 'call' AND dst_node_id IS NULL
-      `);
-            resolveImportEdges(db, projectPath);
+            resolveEdges(db);
             recomputeGlobalPagerank(db);
             // Touch last_seen for all live content hashes under active model
             db.prepare(`UPDATE embedding_cache SET last_seen_at = ?
@@ -446,7 +708,8 @@ export async function buildIndex(projectPath, onProgressOrOpts) {
 }
 function countTotals(db) {
     const count = (table) => Number(db.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get().n);
-    return { files: count("files"), nodes: count("nodes"), edges: count("edges") };
+    const nodes = Number(db.prepare(`SELECT COUNT(*) AS n FROM nodes WHERE kind <> '${FILE_NODE_KIND}'`).get().n);
+    return { files: count("files"), nodes, edges: count("edges") };
 }
 /** Next-step hint printed after an index run; names the query tools, not grep. */
 export function indexNextStep(totals) {
@@ -482,7 +745,11 @@ function evictCacheBySize(db, maxCacheMB) {
  */
 export function recomputeGlobalPagerank(db) {
     const files = db.prepare("SELECT id, path FROM files").all();
-    const nodes = db.prepare("SELECT id, name, file_id FROM nodes").all();
+    // File-owner nodes are not ranked symbols; their outgoing calls count as
+    // references from their file in the file–symbol graph.
+    const nodes = db
+        .prepare(`SELECT id, name, file_id FROM nodes WHERE kind <> '${FILE_NODE_KIND}'`)
+        .all();
     if (nodes.length === 0) {
         db.exec("DELETE FROM pagerank");
         return;
@@ -499,10 +766,12 @@ export function recomputeGlobalPagerank(db) {
         defCount.set(n.name, (defCount.get(n.name) ?? 0) + 1);
     const refCount = new Map();
     const callEdges = db
-        .prepare(`SELECT e.src_node_id, e.dst_node_id, e.dst_name, f.path AS src_path
+        .prepare(`SELECT e.src_node_id, e.src_file_id, src.kind AS src_kind, e.dst_node_id, e.dst_name,
+              f.path AS src_path
        FROM edges e
        JOIN files f ON f.id = e.src_file_id
-       WHERE e.kind = 'call' AND e.src_node_id IS NOT NULL`)
+       JOIN nodes src ON src.id = e.src_node_id
+       WHERE e.kind = 'call'`)
         .all();
     for (const e of callEdges) {
         refCount.set(e.dst_name, (refCount.get(e.dst_name) ?? 0) + 1);
@@ -521,7 +790,8 @@ export function recomputeGlobalPagerank(db) {
         if (e.dst_node_id == null)
             continue;
         const w = edgeWeightMul(e.dst_name, e.src_path, ctx);
-        edges.push({ from: e.src_node_id, to: e.dst_node_id, weight: w });
+        const from = e.src_kind === FILE_NODE_KIND ? fileNodeId(e.src_file_id) : e.src_node_id;
+        edges.push({ from, to: e.dst_node_id, weight: w });
     }
     const scores = personalizedPageRank(nodeIds, edges, []);
     db.exec("DELETE FROM pagerank");

package/dist/modules/compass/map.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { openDb } from "./db.js";
+import { openDb, FILE_NODE_KIND } from "./db.js";
 import { estimateTokens } from "../../shared/tokens.js";
 import { loadDeclaredBudget } from "../../shared/exposure.js";
 export const MAP_START = "<!-- speclaw:map:start -->";
@@ -19,7 +19,7 @@ export function generateCompactMap(projectPath) {
     const db = openDb(projectPath);
     try {
         const fileCount = db.prepare("SELECT COUNT(*) AS c FROM files").get().c;
-        const nodeCount = db.prepare("SELECT COUNT(*) AS c FROM nodes").get().c;
+        const nodeCount = db.prepare(`SELECT COUNT(*) AS c FROM nodes WHERE kind <> '${FILE_NODE_KIND}'`).get().c;
         if (fileCount === 0)
             return null;
         const hubs = db