wotann 0.5.0 → 0.5.39

package/dist/intelligence/kg-builder.js

@@ -1,807 +0,0 @@
-/**
- * KG-First-Stage Builder — Blitzy port (Phase 2 P1-C3).
- *
- * Blitzy (66.5% SWE-bench Pro) front-loads a knowledge-graph build
- * before any codebase-modification task. The agent queries the KG as a
- * retrieval source alongside normal grep. This module ports that
- * first-stage approach: walk a workspace, extract symbols, build a
- * call/type graph, persist into MemoryStore's knowledge_nodes /
- * knowledge_edges tables, support incremental per-file updates, and
- * expose query helpers (findCallers, findUsages, findDefinition).
- *
- * Design:
- *
- * 1. Symbol extraction is pluggable. We try to dynamic-import the
- *    TypeScript compiler API (if available — it's a devDep of this
- *    repo). If the import fails in a published distribution that strips
- *    devDeps, we fall back to a conservative regex extractor. This is
- *    "honest failures" (Session 2 bar #6): the fallback is declared,
- *    not silent.
- *
- * 2. Builder state is per-workspace (Session 3 bar #11). Each
- *    `new KGBuilder(store, workspaceRoot, opts)` carries its own
- *    include/exclude/parser settings. Two builders over two roots do
- *    not share mutable state.
- *
- * 3. Persistence is delegated to MemoryStore. We populate
- *    knowledge_nodes with entity_type in {"code_symbol", "code_module"}
- *    and a properties JSON payload { kind, filePath, line, exported }.
- *    Edges use relation in {"calls", "uses_type", "imports",
- *    "defined_in"}. Those are additional to P1-M7's
- *    updates/extends/derives human-memory edges; the kinds namespace
- *    does not clash because code relations live alongside in the same
- *    knowledge_edges table and are filtered by relation-string.
- *
- * 4. Incremental update (`updateFile`) re-parses a single file and
- *    rewrites only that file's nodes + edges, so watcher-based
- *    pipelines stay linear-time in changed-file count.
- */
-import { readFile, readdir } from "node:fs/promises";
-import { join, relative, extname, resolve } from "node:path";
-/** Relation strings emitted by this builder into knowledge_edges.relation. */
-export const KG_EDGE_RELATIONS = {
-    calls: "code:calls",
-    usesType: "code:uses_type",
-    imports: "code:imports",
-    definedIn: "code:defined_in",
-};
-export const KG_NODE_TYPES = {
-    symbol: "code_symbol",
-    module: "code_module",
-};
-// ── Patterns ───────────────────────────────────────────
-const DEFAULT_INCLUDES = ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"];
-const DEFAULT_EXCLUDES = [
-    "**/node_modules/**",
-    "**/dist/**",
-    "**/build/**",
-    "**/.git/**",
-    "**/coverage/**",
-    "**/.wotann/**",
-    "**/*.d.ts",
-];
-const DEFAULT_MAX_FILES = 5000;
-// ── Glob helpers ──────────────────────────────────────
-// Tiny, predictable glob→regex. Not a full-blown micromatch; enough for
-// the patterns above.
-function globToRegex(pattern) {
-    let out = "";
-    let i = 0;
-    while (i < pattern.length) {
-        const ch = pattern[i];
-        if (ch === "*") {
-            if (pattern[i + 1] === "*") {
-                out += ".*";
-                i += 2;
-                if (pattern[i] === "/")
-                    i++;
-            }
-            else {
-                out += "[^/]*";
-                i++;
-            }
-        }
-        else if (ch === "?") {
-            out += "[^/]";
-            i++;
-        }
-        else if (ch === ".") {
-            out += "\\.";
-            i++;
-        }
-        else if ("+^$(){}|\\".includes(ch)) {
-            out += "\\" + ch;
-            i++;
-        }
-        else {
-            out += ch;
-            i++;
-        }
-    }
-    return new RegExp("^" + out + "$");
-}
-function matchesAny(relPath, patterns) {
-    for (const p of patterns) {
-        if (globToRegex(p).test(relPath))
-            return true;
-    }
-    return false;
-}
-// ── Walker ────────────────────────────────────────────
-async function walkWorkspace(rootDir, includePatterns, excludePatterns, maxFiles) {
-    const root = resolve(rootDir);
-    const result = [];
-    const queue = [root];
-    while (queue.length > 0) {
-        if (result.length >= maxFiles)
-            break;
-        const dir = queue.shift();
-        let entries;
-        try {
-            entries = await readdir(dir, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            const abs = join(dir, entry.name);
-            const rel = relative(root, abs).split("\\").join("/");
-            if (matchesAny(rel, excludePatterns))
-                continue;
-            if (entry.isDirectory()) {
-                queue.push(abs);
-            }
-            else if (entry.isFile()) {
-                if (matchesAny(rel, includePatterns)) {
-                    result.push(abs);
-                    if (result.length >= maxFiles)
-                        break;
-                }
-            }
-        }
-    }
-    return result;
-}
-// ── Extractor: regex fallback ─────────────────────────
-// JavaScript reserved words + common built-ins we should not treat as callees.
-const RESERVED_WORDS = new Set([
-    "if",
-    "else",
-    "for",
-    "while",
-    "do",
-    "switch",
-    "case",
-    "break",
-    "continue",
-    "return",
-    "throw",
-    "try",
-    "catch",
-    "finally",
-    "function",
-    "class",
-    "interface",
-    "type",
-    "enum",
-    "const",
-    "let",
-    "var",
-    "import",
-    "export",
-    "from",
-    "as",
-    "default",
-    "new",
-    "delete",
-    "typeof",
-    "instanceof",
-    "in",
-    "of",
-    "void",
-    "true",
-    "false",
-    "null",
-    "undefined",
-    "this",
-    "super",
-    "async",
-    "await",
-    "yield",
-    "static",
-    "public",
-    "private",
-    "protected",
-    "readonly",
-    "declare",
-    "module",
-    "namespace",
-    "with",
-]);
-/**
- * Conservative regex symbol/call/import extractor. Purposely narrower
- * than the TS compiler API — only picks up obvious patterns. Accepts
- * some false negatives to avoid false positives.
- */
-export function extractFromSourceRegex(filePath, source) {
-    const symbols = [];
-    const imports = [];
-    const calls = [];
-    const typeRefs = [];
-    const lines = source.split(/\r?\n/);
-    // Imports — handles `import { A, B as C } from "..."`, `import * as ns from "..."`,
-    // `import D from "..."`, `import "..."`.
-    const importRe = /^\s*import\s+(?:(?:(?<def>[A-Za-z_$][\w$]*)\s*,?\s*)?(?:\{(?<named>[^}]*)\}|\*\s+as\s+(?<ns>[A-Za-z_$][\w$]*))?)?\s*(?:from\s*)?["'](?<spec>[^"']+)["']/;
-    for (const line of lines) {
-        const m = importRe.exec(line);
-        if (!m || !m.groups)
-            continue;
-        const named = [];
-        if (m.groups["def"])
-            named.push(m.groups["def"]);
-        if (m.groups["ns"])
-            named.push(m.groups["ns"]);
-        if (m.groups["named"]) {
-            for (const chunk of m.groups["named"].split(",")) {
-                const nm = chunk.replace(/\s+as\s+[A-Za-z_$][\w$]*/, "").trim();
-                if (nm.length > 0)
-                    named.push(nm);
-            }
-        }
-        imports.push({ specifier: m.groups["spec"], named });
-    }
-    // Symbols
-    const symRe = /^(?<indent>\s*)(?<exp>export\s+(?:default\s+)?)?(?<async>async\s+)?(?<kind>function|class|interface|type|enum|const|let|var)\s+(?<name>[A-Za-z_$][\w$]*)/;
-    const methodRe = /^(?<indent>\s+)(?<async>async\s+)?(?<name>[A-Za-z_$][\w$]*)\s*\(/;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        if (/^\s*(?:\*|\/\/|\*\/)/.test(line))
-            continue;
-        const m = symRe.exec(line);
-        if (m && m.groups) {
-            const kindRaw = m.groups["kind"];
-            const kind = kindRaw === "function"
-                ? "function"
-                : kindRaw === "class"
-                    ? "class"
-                    : kindRaw === "interface"
-                        ? "interface"
-                        : kindRaw === "type"
-                            ? "type"
-                            : kindRaw === "enum"
-                                ? "enum"
-                                : "variable";
-            symbols.push({
-                name: m.groups["name"],
-                kind,
-                line: i + 1,
-                exported: Boolean(m.groups["exp"]),
-            });
-            continue;
-        }
-        const mm = methodRe.exec(line);
-        if (mm && mm.groups && mm.groups["indent"].length > 0) {
-            const name = mm.groups["name"];
-            if (RESERVED_WORDS.has(name))
-                continue;
-            symbols.push({ name, kind: "method", line: i + 1, exported: false });
-        }
-    }
-    // Calls — `foo(` where foo is not a keyword. Attribute calls to the
-    // nearest preceding symbol as "enclosing".
-    const callRe = /(?<![\w$.])(?<callee>[A-Za-z_$][\w$]*)\s*\(/g;
-    let currentEnclosing = "module";
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const sym = symRe.exec(line);
-        if (sym && sym.groups) {
-            currentEnclosing = sym.groups["name"];
-        }
-        if (/^\s*(?:\*|\/\/|\*\/)/.test(line))
-            continue;
-        let m;
-        callRe.lastIndex = 0;
-        while ((m = callRe.exec(line)) !== null) {
-            const callee = m.groups?.["callee"] ?? "";
-            if (!callee)
-                continue;
-            if (RESERVED_WORDS.has(callee))
-                continue;
-            calls.push({ callee, enclosing: currentEnclosing, line: i + 1 });
-        }
-    }
-    // Type references — `: TypeName` and `<TypeName>` after identifiers.
-    const typeAnnRe = /(?<![\w$]):\s*(?<t>[A-Z][A-Za-z_$0-9]*)/g;
-    const typeArgRe = /<(?<t>[A-Z][A-Za-z_$0-9]*)(?:[<>,\s][^>]*)?>/g;
-    let enclosing = "module";
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const sym = symRe.exec(line);
-        if (sym && sym.groups)
-            enclosing = sym.groups["name"];
-        let m;
-        typeAnnRe.lastIndex = 0;
-        while ((m = typeAnnRe.exec(line)) !== null) {
-            const t = m.groups?.["t"];
-            if (!t)
-                continue;
-            typeRefs.push({ typeName: t, enclosing, line: i + 1 });
-        }
-        typeArgRe.lastIndex = 0;
-        while ((m = typeArgRe.exec(line)) !== null) {
-            const t = m.groups?.["t"];
-            if (!t)
-                continue;
-            typeRefs.push({ typeName: t, enclosing, line: i + 1 });
-        }
-    }
-    return { filePath, symbols, imports, calls, typeRefs, source: "regex" };
-}
-let cachedTsApi;
-async function loadTsApi() {
-    if (cachedTsApi !== undefined)
-        return cachedTsApi;
-    try {
-        const mod = (await import("typescript"));
-        const api = mod.default ?? mod;
-        if (typeof api.createSourceFile !== "function") {
-            cachedTsApi = null;
-            return null;
-        }
-        cachedTsApi = api;
-        return api;
-    }
-    catch {
-        cachedTsApi = null;
-        return null;
-    }
-}
-/** Visible for tests — lets a test force a "no TS api" state. */
-export function _resetTsApiCacheForTests() {
-    cachedTsApi = undefined;
-}
-function getScriptKindFor(ts, filePath) {
-    const ext = extname(filePath).toLowerCase();
-    if (ext === ".tsx")
-        return ts.ScriptKind.TSX;
-    if (ext === ".jsx")
-        return ts.ScriptKind.JSX;
-    if (ext === ".js")
-        return ts.ScriptKind.JS;
-    return ts.ScriptKind.TS;
-}
-function extractFromSourceTs(ts, filePath, source) {
-    const symbols = [];
-    const imports = [];
-    const calls = [];
-    const typeRefs = [];
-    const sf = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, getScriptKindFor(ts, filePath));
-    const lineOf = (n) => {
-        try {
-            return sf.getLineAndCharacterOfPosition(n.pos).line + 1;
-        }
-        catch {
-            return 1;
-        }
-    };
-    const visitTop = (node) => {
-        if (ts.isImportDeclaration(node)) {
-            const mod = node["moduleSpecifier"];
-            const spec = mod && ts.isStringLiteral(mod) ? (mod["text"] ?? "") : "";
-            const clause = node["importClause"];
-            const named = [];
-            if (clause) {
-                const defName = clause["name"];
-                if (defName && ts.isIdentifier(defName)) {
-                    named.push(defName["escapedText"] ?? defName["text"] ?? "");
-                }
-                const nb = clause["namedBindings"];
-                if (nb) {
-                    const elements = nb["elements"];
-                    if (Array.isArray(elements)) {
-                        for (const el of elements) {
-                            const nameNode = el["name"];
-                            if (nameNode && ts.isIdentifier(nameNode)) {
-                                const n = nameNode["escapedText"] ?? nameNode["text"] ?? "";
-                                if (n)
-                                    named.push(n);
-                            }
-                        }
-                    }
-                    const ns = nb["name"];
-                    if (ns && ts.isIdentifier(ns)) {
-                        const n = ns["escapedText"] ?? ns["text"] ?? "";
-                        if (n)
-                            named.push(n);
-                    }
-                }
-            }
-            imports.push({ specifier: spec, named });
-        }
-        ts.forEachChild(node, visitTop);
-    };
-    ts.forEachChild(sf, visitTop);
-    const isExported = (node) => {
-        const mods = node["modifiers"];
-        if (!Array.isArray(mods))
-            return false;
-        for (const m of mods) {
-            const name = Object.keys(ts.SyntaxKind).find((k) => ts.SyntaxKind[k] === m.kind);
-            if (name === "ExportKeyword")
-                return true;
-        }
-        return false;
-    };
-    const nameOf = (node) => {
-        const n = node["name"];
-        if (!n)
-            return undefined;
-        if (ts.isIdentifier(n)) {
-            return (n["escapedText"] ?? n["text"]);
-        }
-        return undefined;
-    };
-    const visitDecl = (node) => {
-        if (ts.isClassDeclaration(node)) {
-            const nm = nameOf(node);
-            if (nm)
-                symbols.push({ name: nm, kind: "class", line: lineOf(node), exported: isExported(node) });
-        }
-        else if (ts.isFunctionDeclaration(node)) {
-            const nm = nameOf(node);
-            if (nm)
-                symbols.push({
-                    name: nm,
-                    kind: "function",
-                    line: lineOf(node),
-                    exported: isExported(node),
-                });
-        }
-        else if (ts.isInterfaceDeclaration(node)) {
-            const nm = nameOf(node);
-            if (nm)
-                symbols.push({
-                    name: nm,
-                    kind: "interface",
-                    line: lineOf(node),
-                    exported: isExported(node),
-                });
-        }
-        else if (ts.isTypeAliasDeclaration(node)) {
-            const nm = nameOf(node);
-            if (nm)
-                symbols.push({ name: nm, kind: "type", line: lineOf(node), exported: isExported(node) });
-        }
-        else if (ts.isEnumDeclaration(node)) {
-            const nm = nameOf(node);
-            if (nm)
-                symbols.push({ name: nm, kind: "enum", line: lineOf(node), exported: isExported(node) });
-        }
-        else if (ts.isVariableStatement(node)) {
-            const decList = node["declarationList"];
-            const decls = decList?.["declarations"] ?? [];
-            const exp = isExported(node);
-            for (const d of decls) {
-                const n = d["name"];
-                if (n && ts.isIdentifier(n)) {
-                    const nm = (n["escapedText"] ?? n["text"]) || "";
-                    if (nm)
-                        symbols.push({ name: nm, kind: "variable", line: lineOf(d), exported: exp });
-                }
-            }
-        }
-        else if (ts.isMethodDeclaration(node)) {
-            const n = node["name"];
-            if (n && ts.isIdentifier(n)) {
-                const nm = (n["escapedText"] ?? n["text"]) || "";
-                if (nm)
-                    symbols.push({ name: nm, kind: "method", line: lineOf(node), exported: false });
-            }
-        }
-        ts.forEachChild(node, visitDecl);
-    };
-    ts.forEachChild(sf, visitDecl);
-    const walk = (node, enclosing) => {
-        let nextEnclosing = enclosing;
-        if (ts.isFunctionDeclaration(node) ||
-            ts.isMethodDeclaration(node) ||
-            ts.isClassDeclaration(node)) {
-            const nm = nameOf(node);
-            if (nm)
-                nextEnclosing = nm;
-        }
-        if (ts.isCallExpression(node)) {
-            const expr = node["expression"];
-            let callee = "";
-            if (expr) {
-                if (ts.isIdentifier(expr)) {
-                    callee = (expr["escapedText"] ?? expr["text"]) || "";
-                }
-                else if (ts.isPropertyAccessExpression(expr)) {
-                    const nm = expr["name"];
-                    if (nm && ts.isIdentifier(nm)) {
-                        callee = (nm["escapedText"] ?? nm["text"]) || "";
-                    }
-                }
-            }
-            if (callee && !RESERVED_WORDS.has(callee)) {
-                calls.push({ callee, enclosing: nextEnclosing, line: lineOf(node) });
-            }
-        }
-        if (ts.isTypeReferenceNode(node)) {
-            const tn = node["typeName"];
-            if (tn && ts.isIdentifier(tn)) {
-                const t = (tn["escapedText"] ?? tn["text"]) || "";
-                if (t)
-                    typeRefs.push({ typeName: t, enclosing: nextEnclosing, line: lineOf(node) });
-            }
-        }
-        ts.forEachChild(node, (child) => walk(child, nextEnclosing));
-    };
-    ts.forEachChild(sf, (child) => walk(child, "module"));
-    return { filePath, symbols, imports, calls, typeRefs, source: "ts-compiler" };
-}
-/**
- * Light wrapper over MemoryStore that lets the builder track which
- * nodes/edges it created, so incremental `updateFile` can deterministically
- * wipe + repopulate file-scoped state.
- */
-class KgPersistence {
-    store;
-    fileState = new Map();
-    constructor(store) {
-        this.store = store;
-    }
-    persistFile(workspaceRoot, extraction) {
-        const relPath = relative(workspaceRoot, extraction.filePath).split("\\").join("/");
-        const prior = this.fileState.get(relPath);
-        if (prior) {
-            for (const eid of prior.edgeIds) {
-                this.store.invalidateKnowledgeEdge(eid);
-            }
-        }
-        const moduleName = relPath;
-        const existingModuleId = prior?.moduleNodeId;
-        const moduleNodeId = existingModuleId ??
-            this.store.addKnowledgeNode(moduleName, KG_NODE_TYPES.module, {
-                path: relPath,
-            });
-        const symbolIdsByName = new Map();
-        const symbolsByName = new Map();
-        let inserted = 0;
-        let edges = 0;
-        const edgeIdsCollector = [];
-        for (const sym of extraction.symbols) {
-            const nodeName = `${relPath}#${sym.name}`;
-            const nodeId = this.store.addKnowledgeNode(nodeName, KG_NODE_TYPES.symbol, {
-                kind: sym.kind,
-                filePath: relPath,
-                line: sym.line !== undefined ? String(sym.line) : "",
-                exported: sym.exported ? "true" : "false",
-                displayName: sym.name,
-            });
-            symbolIdsByName.set(sym.name, nodeId);
-            symbolsByName.set(sym.name, sym);
-            inserted++;
-            const defEdgeId = this.store.addKnowledgeEdge(nodeId, moduleNodeId, KG_EDGE_RELATIONS.definedIn);
-            edges++;
-            edgeIdsCollector.push(defEdgeId);
-        }
-        for (const imp of extraction.imports) {
-            const edgeId = this.store.addKnowledgeEdge(moduleNodeId, moduleNodeId, KG_EDGE_RELATIONS.imports);
-            edgeIdsCollector.push(edgeId);
-            edges++;
-            void imp;
-        }
-        for (const call of extraction.calls) {
-            const callerId = symbolIdsByName.get(call.enclosing) ?? moduleNodeId;
-            const calleeId = symbolIdsByName.get(call.callee);
-            if (calleeId) {
-                const edgeId = this.store.addKnowledgeEdge(callerId, calleeId, KG_EDGE_RELATIONS.calls);
-                edgeIdsCollector.push(edgeId);
-                edges++;
-            }
-        }
-        for (const tr of extraction.typeRefs) {
-            const userId = symbolIdsByName.get(tr.enclosing) ?? moduleNodeId;
-            const typeId = symbolIdsByName.get(tr.typeName);
-            if (typeId) {
-                const edgeId = this.store.addKnowledgeEdge(userId, typeId, KG_EDGE_RELATIONS.usesType);
-                edgeIdsCollector.push(edgeId);
-                edges++;
-            }
-        }
-        this.fileState.set(relPath, {
-            symbolIdsByName,
-            symbolsByName,
-            callSites: extraction.calls,
-            typeReferences: extraction.typeRefs,
-            moduleNodeId,
-            edgeIds: edgeIdsCollector,
-        });
-        return { inserted, edges, moduleNodeId };
-    }
-    getFileInventory(relPath) {
-        return this.fileState.get(relPath);
-    }
-    getAllFilePaths() {
-        return Array.from(this.fileState.keys());
-    }
-}
-// ── Builder ───────────────────────────────────────────
-export class KGBuilder {
-    store;
-    persistence;
-    workspaceRoot;
-    includePatterns;
-    excludePatterns;
-    maxFiles;
-    forceRegex;
-    constructor(store, workspaceRoot, options = {}) {
-        this.store = store;
-        this.workspaceRoot = resolve(workspaceRoot);
-        this.includePatterns = options.includePatterns ?? DEFAULT_INCLUDES;
-        this.excludePatterns = options.excludePatterns ?? DEFAULT_EXCLUDES;
-        this.maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
-        this.forceRegex = options.forceRegex ?? false;
-        this.persistence = new KgPersistence(store);
-    }
-    /**
-     * Walk the workspace, extract symbols from each matched file, and
-     * persist into the knowledge graph. Returns a BuildSummary.
-     */
-    async buildForWorkspace(options = {}) {
-        const files = await walkWorkspace(this.workspaceRoot, this.includePatterns, this.excludePatterns, this.maxFiles);
-        const ts = this.forceRegex ? null : await loadTsApi();
-        let filesProcessed = 0;
-        let symbolsInserted = 0;
-        let edgesInserted = 0;
-        const parseErrors = [];
-        const sources = new Set();
-        for (const filePath of files) {
-            let extraction;
-            let source;
-            try {
-                source = await readFile(filePath, "utf-8");
-            }
-            catch (err) {
-                parseErrors.push({ path: filePath, error: `read failed: ${String(err)}` });
-                continue;
-            }
-            try {
-                if (ts) {
-                    extraction = extractFromSourceTs(ts, filePath, source);
-                }
-                else {
-                    extraction = extractFromSourceRegex(filePath, source);
-                }
-            }
-            catch (err) {
-                const fallback = extractFromSourceRegex(filePath, source);
-                extraction = {
-                    ...fallback,
-                    parseError: err instanceof Error ? err.message : String(err),
-                };
-                parseErrors.push({
-                    path: filePath,
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-            sources.add(extraction.source);
-            const { inserted, edges } = this.persistence.persistFile(this.workspaceRoot, extraction);
-            symbolsInserted += inserted;
-            edgesInserted += edges;
-            filesProcessed++;
-            if (options.onFile) {
-                const rel = relative(this.workspaceRoot, filePath).split("\\").join("/");
-                try {
-                    options.onFile(rel, extraction);
-                }
-                catch {
-                    /* ignore onFile errors */
-                }
-            }
-        }
-        const extractorUsed = sources.size === 0 ? "regex" : sources.size === 1 ? Array.from(sources)[0] : "mixed";
-        return {
-            filesVisited: files.length,
-            filesProcessed,
-            symbolsInserted,
-            edgesInserted,
-            parseErrors,
-            extractorUsed,
-        };
-    }
-    /**
-     * Re-parse a single file and replace its contribution to the graph.
-     * Accepts either an absolute path or a workspace-relative path.
-     */
-    async updateFile(filePath) {
-        const abs = filePath.startsWith("/") ? filePath : join(this.workspaceRoot, filePath);
-        let source;
-        try {
-            source = await readFile(abs, "utf-8");
-        }
-        catch (err) {
-            return { inserted: 0, edges: 0, parseError: `read failed: ${String(err)}` };
-        }
-        const ts = this.forceRegex ? null : await loadTsApi();
-        let extraction;
-        try {
-            extraction = ts ? extractFromSourceTs(ts, abs, source) : extractFromSourceRegex(abs, source);
-        }
-        catch (err) {
-            const fb = extractFromSourceRegex(abs, source);
-            extraction = { ...fb, parseError: err instanceof Error ? err.message : String(err) };
-        }
-        const { inserted, edges } = this.persistence.persistFile(this.workspaceRoot, extraction);
-        const base = { inserted, edges };
-        if (extraction.parseError !== undefined)
-            base.parseError = extraction.parseError;
-        return base;
-    }
-    /**
-     * Return the set of symbols (by enclosing name + file) that call
-     * `symbolName` across the workspace. Uses the per-file inventory +
-     * extraction records kept on each buildForWorkspace / updateFile call.
-     */
-    findCallers(symbolName) {
-        const out = [];
-        for (const filePath of this.persistence.getAllFilePaths()) {
-            const inv = this.persistence.getFileInventory(filePath);
-            if (!inv)
-                continue;
-            for (const call of inv.callSites) {
-                if (call.callee !== symbolName)
-                    continue;
-                const row = {
-                    file: filePath,
-                    enclosing: call.enclosing,
-                };
-                if (call.line !== undefined)
-                    row.line = call.line;
-                out.push(row);
-            }
-        }
-        return out;
-    }
-    /**
-     * Return the set of symbols that reference type `typeName` as a type
-     * argument / annotation.
-     */
-    findUsages(typeName) {
-        const out = [];
-        for (const filePath of this.persistence.getAllFilePaths()) {
-            const inv = this.persistence.getFileInventory(filePath);
-            if (!inv)
-                continue;
-            for (const tr of inv.typeReferences) {
-                if (tr.typeName !== typeName)
-                    continue;
-                if (tr.enclosing === typeName)
-                    continue; // skip the definition site
-                const row = {
-                    file: filePath,
-                    enclosing: tr.enclosing,
-                };
-                if (tr.line !== undefined)
-                    row.line = tr.line;
-                out.push(row);
-            }
-        }
-        return out;
-    }
-    /**
-     * Locate where a symbol is defined. Returns `{ file, kind, line }` for
-     * each definition (there may be more than one when the same name is
-     * used across files).
-     */
-    findDefinition(symbolName) {
-        const out = [];
-        for (const filePath of this.persistence.getAllFilePaths()) {
-            const inv = this.persistence.getFileInventory(filePath);
-            if (!inv)
-                continue;
-            const sym = inv.symbolsByName.get(symbolName);
-            if (!sym)
-                continue;
-            const row = {
-                file: filePath,
-                kind: sym.kind,
-            };
-            if (sym.line !== undefined)
-                row.line = sym.line;
-            out.push(row);
-        }
-        return out;
-    }
-    /** File-paths that have been indexed (workspace-relative). */
-    indexedFiles() {
-        return this.persistence.getAllFilePaths();
-    }
-    /** Current workspace root (absolute). */
-    getWorkspaceRoot() {
-        return this.workspaceRoot;
-    }
-}
-//# sourceMappingURL=kg-builder.js.map