grepmind-core 0.1.0-alpha

package/dist/indexer/code/graph/index.js

@@ -0,0 +1,1876 @@
+import * as lancedb from '@lancedb/lancedb';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { glob } from 'glob';
+import { createError } from '../../../types.js';
+import { generateContentHash } from '../chunker.js';
+import { extractFacts } from './facts.js';
+import { createEdgeId, createExportId } from './id.js';
+import { extractEmbedded, parseCSSContent, parseGraphQLContent } from './embedded.js';
+import { buildNodeEmbeddingText } from './queries.js';
+import { ExportMapBuilder, loadTSConfig, resolveModule, clearResolverCache, WorkspaceResolver } from './resolver.js';
+import { analyzeAllFilesSemantics, loadTypeScript } from './semantic.js';
+/** Convert CodeEdge to LanceDB record */
+function toEdgeRecord(edge) {
+    return {
+        id: edge.id,
+        source_id: edge.sourceId,
+        target_id: edge.targetId,
+        edge_type: edge.edgeType,
+        source_file: edge.sourceFile,
+        target_file: edge.targetFile ?? '',
+        target_module: edge.targetModule ?? '',
+        confidence: edge.confidence,
+        metadata: edge.metadata ?? '',
+    };
+}
+/** Convert LanceDB record to CodeEdge */
+function fromEdgeRecord(r) {
+    return {
+        id: r.id,
+        sourceId: r.source_id,
+        targetId: r.target_id,
+        edgeType: r.edge_type,
+        sourceFile: r.source_file,
+        targetFile: r.target_file || null,
+        targetModule: r.target_module || null,
+        confidence: r.confidence,
+        metadata: r.metadata || null,
+    };
+}
+/** Convert CodeExport to LanceDB record */
+function toExportRecord(exp) {
+    return {
+        id: exp.id,
+        file_id: exp.fileId,
+        export_name: exp.exportName,
+        symbol_id: exp.symbolId,
+        is_reexport: exp.isReexport,
+        original_file: exp.originalFile ?? '',
+    };
+}
+/** Convert LanceDB record to CodeExport */
+function fromExportRecord(r) {
+    return {
+        id: r.id,
+        fileId: r.file_id,
+        exportName: r.export_name,
+        symbolId: r.symbol_id,
+        isReexport: r.is_reexport,
+        originalFile: r.original_file || null,
+    };
+}
+/** Convert CodeModule to LanceDB record */
+function toModuleRecord(mod) {
+    return {
+        id: mod.id,
+        type: mod.type,
+        package_name: mod.packageName ?? '',
+        path: mod.path ?? '',
+        version: mod.version ?? '',
+        exports: mod.exports,
+    };
+}
+/** Convert LanceDB record to CodeModule */
+function fromModuleRecord(r) {
+    return {
+        id: r.id,
+        type: r.type,
+        packageName: r.package_name || null,
+        path: r.path || null,
+        version: r.version || null,
+        exports: r.exports,
+    };
+}
+/** Convert EmbeddedChunk (camelCase) to EmbeddedRecord (snake_case) for LanceDB */
+function toEmbeddedRecord(chunk) {
+    return {
+        id: chunk.id,
+        host_file_id: chunk.hostFileId,
+        host_symbol_id: chunk.hostSymbolId ?? '',
+        embedded_type: chunk.embeddedType,
+        content: chunk.content,
+        start_offset: chunk.startOffset,
+        end_offset: chunk.endOffset,
+        start_line: chunk.startLine,
+        end_line: chunk.endLine,
+    };
+}
+const DEFAULT_INCLUDE = [
+    '**/*.ts',
+    '**/*.tsx',
+    '**/*.js',
+    '**/*.jsx',
+    '**/*.mjs',
+    '**/*.cjs',
+];
+const DEFAULT_EXCLUDE = [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/.git/**',
+];
+export const QUALITY_PRESETS = {
+    fast: {
+        useTypeChecker: false,
+        maxClosureDepth: 0,
+        maxClosureFiles: 0,
+        embedEmbedded: false,
+    },
+    balanced: {
+        useTypeChecker: true,
+        maxClosureDepth: 2,
+        maxClosureFiles: 30,
+        embedEmbedded: true,
+    },
+    accurate: {
+        useTypeChecker: true,
+        maxClosureDepth: 5,
+        maxClosureFiles: 100,
+        embedEmbedded: true,
+    },
+};
+function normalizePath(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+function stringifyMetadata(value) {
+    if (value == null)
+        return null;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return null;
+    }
+}
+function parseMetadata(value) {
+    if (!value)
+        return {};
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return {};
+    }
+}
+function edgeTypeCount() {
+    return {
+        IMPORTS_FILE: 0,
+        IMPORTS_SYMBOL: 0,
+        EXPORTS: 0,
+        DEFINES: 0,
+        REFS: 0,
+        CALLS: 0,
+        EXTENDS: 0,
+        IMPLEMENTS: 0,
+        EMBEDS: 0,
+        USES_FRAGMENT: 0,
+    };
+}
+function buildStatsFromPrepared(filesIndexed, symbols, edges, embeddedChunks) {
+    const edgeTypes = edgeTypeCount();
+    for (const edge of edges) {
+        edgeTypes[edge.edgeType] += 1;
+    }
+    const embeddedByType = {
+        graphql: 0,
+        css: 0,
+        styled: 0,
+    };
+    for (const chunk of embeddedChunks) {
+        // Use camelCase from EmbeddedChunk
+        embeddedByType[chunk.embeddedType] += 1;
+    }
+    return {
+        filesIndexed,
+        symbols,
+        edges: edges.length,
+        edgeTypes,
+        unresolvedImports: edges.filter((edge) => edge.edgeType === 'IMPORTS_FILE' && edge.confidence === 'unresolved').length,
+        embeddedChunks: embeddedChunks.length,
+        embeddedByType,
+    };
+}
+export class ReverseIndexBuilder {
+    index = new Map();
+    buildFromEdges(edges) {
+        this.index.clear();
+        for (const edge of edges) {
+            if (edge.edgeType !== 'IMPORTS_FILE' || !edge.targetFile)
+                continue;
+            const importers = this.index.get(edge.targetFile) ?? new Set();
+            importers.add(edge.sourceFile);
+            this.index.set(edge.targetFile, importers);
+        }
+    }
+    updateForFile(fileId, oldImports, newImports) {
+        for (const oldTarget of oldImports) {
+            this.index.get(oldTarget)?.delete(fileId);
+        }
+        for (const newTarget of newImports) {
+            const importers = this.index.get(newTarget) ?? new Set();
+            importers.add(fileId);
+            this.index.set(newTarget, importers);
+        }
+    }
+    getImporters(fileId) {
+        return this.index.get(fileId) ?? new Set();
+    }
+    getTransitiveImporters(fileId, maxDepth = 2) {
+        const result = new Set();
+        const queue = [{ file: fileId, depth: 0 }];
+        while (queue.length > 0) {
+            const item = queue.shift();
+            if (!item)
+                break;
+            if (item.depth >= maxDepth)
+                continue;
+            for (const importer of this.getImporters(item.file)) {
+                if (result.has(importer))
+                    continue;
+                result.add(importer);
+                queue.push({ file: importer, depth: item.depth + 1 });
+            }
+        }
+        return result;
+    }
+}
+export async function detectChanges(currentFiles, previousIndex, reverseIndex, transitiveDepth = 2) {
+    const modified = [];
+    const deleted = [];
+    for (const [filePath, meta] of currentFiles) {
+        const prev = previousIndex.get(filePath);
+        if (!prev || prev.contentHash !== meta.contentHash) {
+            modified.push(filePath);
+        }
+    }
+    for (const filePath of previousIndex.keys()) {
+        if (!currentFiles.has(filePath)) {
+            deleted.push(filePath);
+        }
+    }
+    // Use transitive importers to handle re-exports properly
+    // When file A re-exports from B, and B changes, importers of A are also affected
+    const affectedSet = new Set();
+    const modifiedSet = new Set(modified);
+    const deletedSet = new Set(deleted);
+    for (const fileId of [...modified, ...deleted]) {
+        // Get transitive importers (handles re-export chains)
+        const transitiveImporters = reverseIndex.getTransitiveImporters(fileId, transitiveDepth);
+        for (const importer of transitiveImporters) {
+            if (modifiedSet.has(importer) || deletedSet.has(importer))
+                continue;
+            affectedSet.add(importer);
+        }
+    }
+    return {
+        modified,
+        deleted,
+        affected: [...affectedSet],
+    };
+}
+export class GraphIndexer {
+    rootPath;
+    dbPath;
+    codeConfig;
+    parser;
+    storageOptions;
+    db = null;
+    initialized = false;
+    chunksTable = null;
+    edgesTable = null;
+    modulesTable = null;
+    exportsTable = null;
+    embeddedTable = null;
+    graphFileTable = null;
+    reverseIndex = new ReverseIndexBuilder();
+    tsConfigLoaded = false;
+    tsConfig = null;
+    moduleResolveCache = new Map();
+    // Multi-tsconfig support: cache configs by directory
+    tsConfigCache = new Map();
+    tsConfigsDiscovered = false;
+    // Workspace resolution for monorepo cross-package imports
+    workspaceResolver = null;
+    constructor(deps) {
+        this.rootPath = path.resolve(deps.rootPath);
+        this.dbPath = deps.dbPath;
+        this.codeConfig = deps.codeConfig;
+        this.parser = deps.parser;
+        this.storageOptions = deps.storageOptions;
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        const isRemoteDbPath = /^[a-z][a-z0-9+.-]*:\/\//i.test(this.dbPath);
+        if (!isRemoteDbPath) {
+            await fs.mkdir(this.dbPath, { recursive: true });
+        }
+        this.db = await lancedb.connect(this.dbPath, {
+            storageOptions: this.storageOptions,
+        });
+        this.initialized = true;
+        // Auto-create all tables at startup
+        await this.ensureAllTables();
+        // Discover workspace packages for cross-package resolution
+        this.workspaceResolver = new WorkspaceResolver(this.rootPath);
+        await this.workspaceResolver.discover();
+    }
+    /**
+     * Ensure all graph tables exist with proper schema.
+     * Safe to call multiple times (idempotent).
+     */
+    async ensureAllTables() {
+        if (!this.initialized) {
+            await this.initialize();
+            return; // initialize() already called ensureAllTables()
+        }
+        await this.ensureEdgesTable();
+        await this.ensureExportsTable();
+        await this.ensureModulesTable();
+        await this.ensureEmbeddedTable();
+        await this.ensureGraphFileTable();
+    }
+    async getTsConfig() {
+        if (this.tsConfigLoaded)
+            return this.tsConfig;
+        this.tsConfigLoaded = true;
+        this.tsConfig = await loadTSConfig(this.rootPath, this.codeConfig.graph.resolution.tsConfigPath);
+        return this.tsConfig;
+    }
+    /**
+     * Discover all tsconfig.json files in the project.
+     * Call once before processing to populate the cache.
+     */
+    async discoverAllTsConfigs() {
+        if (this.tsConfigsDiscovered)
+            return;
+        this.tsConfigsDiscovered = true;
+        try {
+            const tsConfigFiles = await glob(path.join(this.rootPath, '**/tsconfig.json'), {
+                ignore: ['**/node_modules/**'],
+                nodir: true,
+            });
+            for (const configPath of tsConfigFiles) {
+                const dir = normalizePath(path.relative(this.rootPath, path.dirname(configPath)));
+                const config = await loadTSConfig(this.rootPath, path.join(dir, 'tsconfig.json'));
+                if (config) {
+                    this.tsConfigCache.set(dir || '.', config);
+                }
+            }
+        }
+        catch {
+            // Ignore errors during discovery
+        }
+    }
+    /**
+     * Get the tsconfig for a specific file by walking up directories.
+     * Falls back to root tsconfig or null if none found.
+     */
+    async getTsConfigForFile(fileId) {
+        // Ensure configs are discovered
+        await this.discoverAllTsConfigs();
+        // Walk up from file's directory to find closest tsconfig
+        let dir = normalizePath(path.dirname(fileId));
+        while (true) {
+            const cachedConfig = this.tsConfigCache.get(dir);
+            if (cachedConfig !== undefined) {
+                return cachedConfig;
+            }
+            // Try root
+            if (dir === '.' || dir === '') {
+                break;
+            }
+            // Go up one level
+            const parent = normalizePath(path.dirname(dir));
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        // Fallback to root tsconfig (from config or auto-detect)
+        return this.getTsConfig();
+    }
+    async replaceTable(tableName, seedRow, rows) {
+        const table = await this.db.createTable(tableName, [seedRow, ...rows], { mode: 'overwrite' });
+        if ('id' in seedRow) {
+            await table.delete("id = '__init__'");
+        }
+        else if ('path' in seedRow) {
+            await table.delete("path = '__init__'");
+        }
+        return table;
+    }
+    async ensureChunksTable() {
+        if (this.chunksTable)
+            return this.chunksTable;
+        this.chunksTable = await this.db.openTable('code_chunks');
+        return this.chunksTable;
+    }
+    async ensureEdgesTable() {
+        if (this.edgesTable)
+            return this.edgesTable;
+        try {
+            this.edgesTable = await this.db.openTable('code_edges');
+        }
+        catch {
+            // Table doesn't exist, create it
+            this.edgesTable = await this.db.createTable('code_edges', [{
+                    id: '__init__',
+                    source_id: '',
+                    target_id: '',
+                    edge_type: 'IMPORTS_FILE',
+                    source_file: '',
+                    target_file: '',
+                    target_module: '',
+                    confidence: 'resolved',
+                    metadata: '',
+                }], { mode: 'overwrite' });
+            await this.edgesTable.delete("id = '__init__'");
+        }
+        return this.edgesTable;
+    }
+    async ensureExportsTable() {
+        if (this.exportsTable)
+            return this.exportsTable;
+        try {
+            this.exportsTable = await this.db.openTable('code_exports');
+        }
+        catch {
+            this.exportsTable = await this.db.createTable('code_exports', [{
+                    id: '__init__',
+                    file_id: '',
+                    export_name: '',
+                    symbol_id: '',
+                    is_reexport: false,
+                    original_file: '',
+                }], { mode: 'overwrite' });
+            await this.exportsTable.delete("id = '__init__'");
+        }
+        return this.exportsTable;
+    }
+    async ensureEmbeddedTable() {
+        if (this.embeddedTable)
+            return this.embeddedTable;
+        try {
+            this.embeddedTable = await this.db.openTable('code_embedded');
+        }
+        catch {
+            this.embeddedTable = await this.db.createTable('code_embedded', [{
+                    id: '__init__',
+                    host_file_id: '',
+                    host_symbol_id: '',
+                    embedded_type: 'graphql',
+                    content: '',
+                    start_offset: 0,
+                    end_offset: 0,
+                    start_line: 0,
+                    end_line: 0,
+                }], { mode: 'overwrite' });
+            await this.embeddedTable.delete("id = '__init__'");
+        }
+        return this.embeddedTable;
+    }
+    async ensureGraphFileTable() {
+        if (this.graphFileTable)
+            return this.graphFileTable;
+        try {
+            this.graphFileTable = await this.db.openTable('code_graph_file_index');
+        }
+        catch {
+            // Use snake_case column names for LanceDB SQL compatibility
+            this.graphFileTable = await this.db.createTable('code_graph_file_index', [{
+                    path: '__init__',
+                    content_hash: '',
+                    indexed_at: 0,
+                }], { mode: 'overwrite' });
+            await this.graphFileTable.delete("path = '__init__'");
+        }
+        return this.graphFileTable;
+    }
+    async ensureModulesTable() {
+        if (this.modulesTable)
+            return this.modulesTable;
+        try {
+            this.modulesTable = await this.db.openTable('code_modules');
+        }
+        catch {
+            // Use snake_case column names for LanceDB SQL compatibility
+            this.modulesTable = await this.db.createTable('code_modules', [{
+                    id: '__init__',
+                    type: 'npm',
+                    package_name: '',
+                    path: '',
+                    version: '',
+                    exports: '[]',
+                }], { mode: 'overwrite' });
+            await this.modulesTable.delete("id = '__init__'");
+        }
+        return this.modulesTable;
+    }
+    async addEdges(edges) {
+        if (edges.length === 0)
+            return;
+        const table = await this.ensureEdgesTable();
+        // Convert to snake_case records for LanceDB
+        await table.add(edges.map(toEdgeRecord));
+    }
+    async addExports(exports) {
+        if (exports.length === 0)
+            return;
+        const table = await this.ensureExportsTable();
+        // Convert to snake_case records for LanceDB
+        await table.add(exports.map(toExportRecord));
+    }
+    async addEmbedded(chunks) {
+        if (chunks.length === 0)
+            return;
+        const table = await this.ensureEmbeddedTable();
+        // Convert EmbeddedChunk (camelCase) to EmbeddedRecord (snake_case) for LanceDB
+        await table.add(chunks.map(toEmbeddedRecord));
+    }
+    async addModules(modules) {
+        if (modules.length === 0)
+            return;
+        const table = await this.ensureModulesTable();
+        // Filter out modules that already exist
+        const existing = new Set();
+        const existingRows = await table.query().select(['id']).toArray();
+        for (const row of existingRows) {
+            existing.add(row.id);
+        }
+        const newModules = modules.filter(m => !existing.has(m.id));
+        if (newModules.length > 0) {
+            // Convert to snake_case records for LanceDB
+            await table.add(newModules.map(toModuleRecord));
+        }
+    }
+    async updateGraphFileRecords(recordsOrFileId, contentHash, mtime) {
+        const table = await this.ensureGraphFileTable();
+        // Overload: single record
+        if (typeof recordsOrFileId === 'string') {
+            const path = recordsOrFileId;
+            await table.delete(`path = '${path.replace(/'/g, "''")}'`);
+            await table.add([{ path, content_hash: contentHash, indexed_at: mtime }]);
+            return;
+        }
+        // Overload: array of records (already in snake_case)
+        const records = recordsOrFileId;
+        if (records.length === 0)
+            return;
+        for (const record of records) {
+            await table.delete(`path = '${record.path.replace(/'/g, "''")}'`);
+        }
+        await table.add(records);
+    }
+    async listCodeFiles() {
+        const include = this.codeConfig.include ?? DEFAULT_INCLUDE;
+        const exclude = this.codeConfig.exclude ?? DEFAULT_EXCLUDE;
+        const files = [];
+        for (const pattern of include) {
+            const matches = await glob(path.join(this.rootPath, pattern), {
+                ignore: exclude,
+                nodir: true,
+            });
+            files.push(...matches);
+        }
+        return [...new Set(files)]
+            .map((filePath) => normalizePath(path.relative(this.rootPath, filePath)));
+    }
+    /**
+     * Parse a single file on-demand for graph analysis (without embeddings).
+     * Used when import resolution discovers files outside the indexed set.
+     * Returns the chunks or null if file cannot be parsed.
+     */
+    async parseFileOnDemand(fileId) {
+        const absolutePath = path.resolve(this.rootPath, fileId);
+        // Check if file is within project and not excluded
+        if (!this.isFileAllowedForGraph(fileId)) {
+            return null;
+        }
+        try {
+            const content = await fs.readFile(absolutePath, 'utf-8');
+            const language = this.parser.getLanguageForFile(absolutePath);
+            if (!language)
+                return null;
+            const tree = await this.parser.parse(content, language);
+            if (!tree)
+                return null;
+            // Use tree-sitter to extract symbols (lightweight, no embeddings)
+            const extractedSymbols = this.parser.extractSymbols(tree, language);
+            const chunks = [];
+            for (const sym of extractedSymbols) {
+                const chunk = {
+                    id: `${fileId}:${sym.name}:${sym.startLine}`,
+                    path: fileId,
+                    language,
+                    symbolType: sym.type,
+                    symbolName: sym.name,
+                    signature: null,
+                    parentSymbol: null,
+                    scope: [],
+                    content: '', // Empty - not needed for graph analysis
+                    startLine: sym.startLine,
+                    endLine: sym.endLine,
+                    docstring: null,
+                    modified: Date.now(),
+                    contentHash: '',
+                };
+                chunks.push(chunk);
+            }
+            if (chunks.length > 0) {
+                chunks.sort((a, b) => a.startLine - b.startLine || a.endLine - b.endLine);
+                return chunks;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Check if a file is allowed for graph analysis.
+     * Files must be within project root (or workspace root for monorepos) and not in node_modules.
+     */
+    isFileAllowedForGraph(fileId) {
+        // Skip node_modules
+        if (fileId.includes('node_modules')) {
+            return false;
+        }
+        // Must be a supported file type
+        if (!/\.(ts|tsx|js|jsx|mjs|cjs)$/.test(fileId)) {
+            return false;
+        }
+        // Absolute paths are not allowed
+        if (path.isAbsolute(fileId)) {
+            return false;
+        }
+        // Check if within project root
+        if (!fileId.startsWith('..')) {
+            return true;
+        }
+        // For paths starting with .., check if they're within workspace root
+        const workspaceRoot = this.workspaceResolver?.getWorkspaceRoot();
+        if (!workspaceRoot) {
+            return false;
+        }
+        // Resolve the absolute path and check if it's within workspace root
+        const absolutePath = path.resolve(this.rootPath, fileId);
+        const relativeToWorkspace = path.relative(workspaceRoot, absolutePath);
+        // Must be within workspace root and not in node_modules
+        return !relativeToWorkspace.startsWith('..') &&
+            !path.isAbsolute(relativeToWorkspace) &&
+            !relativeToWorkspace.includes('node_modules');
+    }
+    /**
+     * Ensure files are parsed for graph analysis.
+     * Parses any files that are not already in chunksByFile.
+     */
+    async ensureFilesParsedForGraph(fileIds, chunksByFile, symbolToFile) {
+        for (const fileId of fileIds) {
+            if (chunksByFile.has(fileId))
+                continue;
+            const chunks = await this.parseFileOnDemand(fileId);
+            if (chunks) {
+                chunksByFile.set(fileId, chunks);
+                // Update symbolToFile map
+                for (const chunk of chunks) {
+                    if (chunk.symbolType !== 'file') {
+                        symbolToFile.set(chunk.id, fileId);
+                    }
+                }
+            }
+        }
+    }
+    async loadFileMetadata(files) {
+        const metadata = new Map();
+        for (const fileId of files) {
+            const absolutePath = path.resolve(this.rootPath, fileId);
+            try {
+                const [stat, content] = await Promise.all([
+                    fs.stat(absolutePath),
+                    fs.readFile(absolutePath, 'utf-8'),
+                ]);
+                metadata.set(fileId, {
+                    contentHash: generateContentHash(content),
+                    mtime: stat.mtimeMs,
+                });
+            }
+            catch {
+                // ignore unreadable files
+            }
+        }
+        return metadata;
+    }
+    async loadPreviousGraphFileIndex() {
+        if (!this.graphFileTable) {
+            try {
+                this.graphFileTable = await this.db.openTable('code_graph_file_index');
+            }
+            catch {
+                return new Map();
+            }
+        }
+        const rows = await this.graphFileTable.query().toArray();
+        const result = new Map();
+        for (const row of rows) {
+            const filePath = row.path;
+            // Read snake_case columns from LanceDB
+            result.set(filePath, {
+                contentHash: row.content_hash,
+                mtime: row.indexed_at,
+            });
+        }
+        return result;
+    }
+    async loadChunksByFile() {
+        const table = await this.ensureChunksTable();
+        const rows = await table.query().toArray();
+        const byFile = new Map();
+        for (const row of rows) {
+            // Read from snake_case columns (code_chunks table was migrated)
+            const chunk = {
+                id: row.id,
+                path: row.path,
+                language: row.language,
+                symbolType: row.symbol_type,
+                symbolName: row.symbol_name,
+                signature: row.signature,
+                parentSymbol: row.parent_symbol,
+                scope: JSON.parse(row.scope || '[]'),
+                content: row.content,
+                startLine: row.start_line,
+                endLine: row.end_line,
+                docstring: row.docstring,
+                modified: row.modified,
+                contentHash: row.content_hash,
+            };
+            const arr = byFile.get(chunk.path) ?? [];
+            arr.push(chunk);
+            byFile.set(chunk.path, arr);
+        }
+        for (const chunks of byFile.values()) {
+            chunks.sort((a, b) => a.startLine - b.startLine || a.endLine - b.endLine);
+        }
+        return byFile;
+    }
+    async resolveImport(spec, basePath) {
+        const cacheKey = `${basePath}::${spec}`;
+        const cached = this.moduleResolveCache.get(cacheKey);
+        if (cached)
+            return cached;
+        // Use tsconfig closest to the importing file for proper path resolution
+        const resolved = await resolveModule(spec, {
+            basePath,
+            rootPath: this.rootPath,
+            tsConfig: await this.getTsConfigForFile(basePath),
+            nodeModulesPath: path.join(this.rootPath, 'node_modules'),
+            respectTSPaths: this.codeConfig.graph.resolution.respectTSPaths,
+            workspaceResolver: this.workspaceResolver ?? undefined,
+        });
+        this.moduleResolveCache.set(cacheKey, resolved);
+        return resolved;
+    }
+    async buildFacts(files, chunksByFile, embedEnabled, onProgress) {
+        const factsPerFile = new Map();
+        const fileMetadata = new Map();
+        const embeddedChunks = [];
+        for (let i = 0; i < files.length; i++) {
+            const fileId = files[i];
+            onProgress?.(i, files.length, 'parsing');
+            const absolutePath = path.resolve(this.rootPath, fileId);
+            try {
+                const [stat, content] = await Promise.all([
+                    fs.stat(absolutePath),
+                    fs.readFile(absolutePath, 'utf-8'),
+                ]);
+                const language = this.parser.getLanguageForFile(absolutePath);
+                const chunks = chunksByFile.get(fileId) ?? [];
+                const facts = await extractFacts(content, fileId, {
+                    language,
+                    parser: this.parser,
+                    chunks,
+                });
+                factsPerFile.set(fileId, facts);
+                fileMetadata.set(fileId, {
+                    contentHash: generateContentHash(content),
+                    mtime: stat.mtimeMs,
+                });
+                if (embedEnabled && (language === 'typescript' || language === 'tsx' || language === 'javascript' || language === 'jsx')) {
+                    const embedded = await extractEmbedded({
+                        fileId,
+                        fileContent: content,
+                        chunks,
+                    });
+                    for (const chunk of embedded) {
+                        if (chunk.embeddedType === 'graphql' && !this.codeConfig.graph.embedded.graphql) {
+                            continue;
+                        }
+                        if ((chunk.embeddedType === 'css' || chunk.embeddedType === 'styled') && !this.codeConfig.graph.embedded.css) {
+                            continue;
+                        }
+                        if (chunk.embeddedType === 'graphql') {
+                            parseGraphQLContent(chunk.content);
+                        }
+                        else {
+                            parseCSSContent(chunk.content);
+                        }
+                        // Keep as EmbeddedChunk (camelCase) for internal use
+                        embeddedChunks.push(chunk);
+                    }
+                }
+            }
+            catch {
+                // Skip unreadable files.
+            }
+        }
+        return { factsPerFile, fileMetadata, embeddedChunks };
+    }
+    buildSemanticEdges(semanticFacts, fileId, symbolToFile) {
+        const edges = [];
+        const push = (edgeType, sourceId, targetId, line) => {
+            edges.push({
+                id: createEdgeId(sourceId, targetId, edgeType),
+                sourceId,
+                targetId,
+                edgeType,
+                sourceFile: fileId,
+                targetFile: symbolToFile.get(targetId) ?? null,
+                targetModule: null,
+                confidence: 'resolved',
+                metadata: stringifyMetadata({ line }),
+            });
+        };
+        for (const rel of semanticFacts.refs) {
+            push('REFS', rel.sourceSymbol, rel.targetSymbol, rel.line);
+        }
+        for (const rel of semanticFacts.calls) {
+            push('CALLS', rel.sourceSymbol, rel.targetSymbol, rel.line);
+        }
+        for (const rel of semanticFacts.extends) {
+            push('EXTENDS', rel.sourceSymbol, rel.targetSymbol, rel.line);
+        }
+        for (const rel of semanticFacts.implements) {
+            push('IMPLEMENTS', rel.sourceSymbol, rel.targetSymbol, rel.line);
+        }
+        return edges;
+    }
+    async buildGraphFromFacts(factsPerFile, chunksByFile, qualityConfig, embeddedChunks, filesToProcess, onProgress) {
+        const edges = [];
+        const exports = [];
+        const modules = new Map();
+        const fileGraph = new Map();
+        const symbolToFile = new Map();
+        for (const [fileId, chunks] of chunksByFile) {
+            for (const chunk of chunks) {
+                if (chunk.symbolType === 'file')
+                    continue;
+                symbolToFile.set(chunk.id, fileId);
+            }
+        }
+        const resolveOptions = {
+            basePath: '',
+            rootPath: this.rootPath,
+            tsConfig: await this.getTsConfig(),
+            nodeModulesPath: path.join(this.rootPath, 'node_modules'),
+            respectTSPaths: this.codeConfig.graph.resolution.respectTSPaths,
+            workspaceResolver: this.workspaceResolver ?? undefined,
+        };
+        // Build export map from ALL files (needed for re-export resolution)
+        const exportMapBuilder = new ExportMapBuilder(resolveOptions);
+        await exportMapBuilder.buildExportMap(factsPerFile);
+        // Phase 1: Process definitions and exports (synchronous, no I/O)
+        for (const [fileId, facts] of factsPerFile) {
+            if (filesToProcess && !filesToProcess.has(fileId))
+                continue;
+            for (const definition of facts.definitions) {
+                edges.push({
+                    id: createEdgeId(fileId, definition.symbolId, 'DEFINES'),
+                    sourceId: fileId,
+                    targetId: definition.symbolId,
+                    edgeType: 'DEFINES',
+                    sourceFile: fileId,
+                    targetFile: fileId,
+                    targetModule: null,
+                    confidence: 'resolved',
+                    metadata: stringifyMetadata({ line: definition.line, kind: definition.kind }),
+                });
+            }
+            for (const exp of facts.exports) {
+                edges.push({
+                    id: createEdgeId(fileId, exp.symbolId, 'EXPORTS'),
+                    sourceId: fileId,
+                    targetId: exp.symbolId,
+                    edgeType: 'EXPORTS',
+                    sourceFile: fileId,
+                    targetFile: symbolToFile.get(exp.symbolId) ?? fileId,
+                    targetModule: null,
+                    confidence: 'resolved',
+                    metadata: stringifyMetadata({ name: exp.name, line: exp.line }),
+                });
+                exports.push({
+                    id: createExportId(fileId, exp.name),
+                    fileId,
+                    exportName: exp.name,
+                    symbolId: exp.symbolId,
+                    isReexport: exp.kind === 'reexport',
+                    originalFile: null,
+                });
+            }
+        }
+        const importTasks = [];
+        for (const [fileId, facts] of factsPerFile) {
+            if (filesToProcess && !filesToProcess.has(fileId))
+                continue;
+            for (const imp of facts.imports) {
+                importTasks.push({ fileId, imp });
+            }
+        }
+        // Resolve imports in parallel with concurrency limit
+        onProgress?.(0, importTasks.length, 'resolving');
+        const CONCURRENCY = 50;
+        const resolvedImports = [];
+        for (let i = 0; i < importTasks.length; i += CONCURRENCY) {
+            const batch = importTasks.slice(i, i + CONCURRENCY);
+            const batchResults = await Promise.all(batch.map(async (task) => ({
+                task,
+                result: await this.resolveImport(task.imp.spec, task.fileId),
+            })));
+            resolvedImports.push(...batchResults);
+            onProgress?.(Math.min(i + CONCURRENCY, importTasks.length), importTasks.length, 'resolving');
+        }
+        // Phase 3: Build edges from resolved imports
+        const localImportsByFile = new Map();
+        for (const { task, result: resolved } of resolvedImports) {
+            const { fileId, imp } = task;
+            if (!localImportsByFile.has(fileId)) {
+                localImportsByFile.set(fileId, new Set());
+            }
+            const localImports = localImportsByFile.get(fileId);
+            if (resolved.type === 'local' && resolved.fileId) {
+                localImports.add(resolved.fileId);
+                edges.push({
+                    id: createEdgeId(fileId, resolved.fileId, 'IMPORTS_FILE'),
+                    sourceId: fileId,
+                    targetId: resolved.fileId,
+                    edgeType: 'IMPORTS_FILE',
+                    sourceFile: fileId,
+                    targetFile: resolved.fileId,
+                    targetModule: resolved.module ?? null,
+                    confidence: 'resolved',
+                    metadata: stringifyMetadata({ spec: imp.spec, line: imp.line }),
+                });
+                for (const name of imp.names) {
+                    const targetSymbol = exportMapBuilder.resolveImport(resolved.fileId, name);
+                    if (!targetSymbol)
+                        continue;
+                    edges.push({
+                        id: createEdgeId(fileId, targetSymbol, 'IMPORTS_SYMBOL'),
+                        sourceId: fileId,
+                        targetId: targetSymbol,
+                        edgeType: 'IMPORTS_SYMBOL',
+                        sourceFile: fileId,
+                        targetFile: resolved.fileId,
+                        targetModule: null,
+                        confidence: 'resolved',
+                        metadata: stringifyMetadata({ name, alias: imp.alias, line: imp.line }),
+                    });
+                }
+                continue;
+            }
+            if (resolved.type === 'workspace') {
+                const moduleId = resolved.module ?? imp.spec;
+                const workspaceTargetId = resolved.subpath
+                    ? `WORKSPACE:${moduleId}:${resolved.subpath}`
+                    : `WORKSPACE:${moduleId}`;
+                edges.push({
+                    id: createEdgeId(fileId, workspaceTargetId, 'IMPORTS_FILE'),
+                    sourceId: fileId,
+                    targetId: workspaceTargetId,
+                    edgeType: 'IMPORTS_FILE',
+                    sourceFile: fileId,
+                    targetFile: null,
+                    targetModule: moduleId,
+                    confidence: 'resolved',
+                    metadata: stringifyMetadata({ spec: imp.spec, line: imp.line, subpath: resolved.subpath }),
+                });
+                if (!modules.has(workspaceTargetId)) {
+                    modules.set(workspaceTargetId, {
+                        id: workspaceTargetId,
+                        type: 'workspace',
+                        packageName: moduleId,
+                        path: resolved.path ?? null,
+                        version: null,
+                        exports: '[]',
+                    });
+                }
+                continue;
+            }
+            if (resolved.type === 'npm' || resolved.type === 'builtin') {
+                const moduleId = resolved.module ?? imp.spec;
+                edges.push({
+                    id: createEdgeId(fileId, moduleId, 'IMPORTS_FILE'),
+                    sourceId: fileId,
+                    targetId: moduleId,
+                    edgeType: 'IMPORTS_FILE',
+                    sourceFile: fileId,
+                    targetFile: null,
+                    targetModule: moduleId,
+                    confidence: 'resolved',
+                    metadata: stringifyMetadata({ spec: imp.spec, line: imp.line, subpath: resolved.subpath }),
+                });
+                if (!modules.has(moduleId)) {
+                    modules.set(moduleId, {
+                        id: moduleId,
+                        type: resolved.type === 'builtin' ? 'builtin' : 'npm',
+                        packageName: resolved.type === 'npm' ? moduleId : null,
+                        path: null,
+                        version: null,
+                        exports: '[]',
+                    });
+                }
+                continue;
+            }
+            edges.push({
+                id: createEdgeId(fileId, `UNRESOLVED:${imp.spec}`, 'IMPORTS_FILE'),
+                sourceId: fileId,
+                targetId: `UNRESOLVED:${imp.spec}`,
+                edgeType: 'IMPORTS_FILE',
+                sourceFile: fileId,
+                targetFile: null,
+                targetModule: null,
+                confidence: 'unresolved',
+                metadata: stringifyMetadata({ spec: imp.spec, line: imp.line, error: resolved.error }),
+            });
+        }
+        // Build fileGraph from collected local imports
+        for (const [fileId, localImports] of localImportsByFile) {
+            fileGraph.set(fileId, [...localImports]);
+        }
+        // Filter embedded chunks if processing specific files (using camelCase properties)
+        const filteredEmbedded = filesToProcess
+            ? embeddedChunks.filter(e => filesToProcess.has(e.hostFileId))
+            : embeddedChunks;
+        for (const embedded of filteredEmbedded) {
+            const hostSymbol = embedded.hostSymbolId ?? embedded.hostFileId;
+            edges.push({
+                id: createEdgeId(hostSymbol, embedded.id, 'EMBEDS'),
+                sourceId: hostSymbol,
+                targetId: embedded.id,
+                edgeType: 'EMBEDS',
+                sourceFile: embedded.hostFileId,
+                targetFile: embedded.hostFileId,
+                targetModule: null,
+                confidence: 'resolved',
+                metadata: stringifyMetadata({ embeddedType: embedded.embeddedType, line: embedded.startLine }),
+            });
+        }
+        const fragmentToNodeId = new Map();
+        for (const embedded of filteredEmbedded) {
+            if (embedded.embeddedType !== 'graphql')
+                continue;
+            const gqlFacts = parseGraphQLContent(embedded.content);
+            if (!gqlFacts)
+                continue;
+            for (const fragment of gqlFacts.fragments) {
+                fragmentToNodeId.set(fragment.name, `${embedded.id}#fragment:${fragment.name}`);
+            }
+        }
+        for (const embedded of filteredEmbedded) {
+            if (embedded.embeddedType !== 'graphql')
+                continue;
+            const gqlFacts = parseGraphQLContent(embedded.content);
+            if (!gqlFacts)
+                continue;
+            for (const operation of gqlFacts.operations) {
+                const operationId = `${embedded.id}#operation:${operation.name ?? 'anonymous'}`;
+                for (const usedFragment of gqlFacts.usedFragments) {
+                    const fragmentId = fragmentToNodeId.get(usedFragment);
+                    if (!fragmentId)
+                        continue;
+                    edges.push({
+                        id: createEdgeId(operationId, fragmentId, 'USES_FRAGMENT'),
+                        sourceId: operationId,
+                        targetId: fragmentId,
+                        edgeType: 'USES_FRAGMENT',
+                        sourceFile: embedded.hostFileId,
+                        targetFile: embedded.hostFileId,
+                        targetModule: null,
+                        confidence: 'resolved',
+                        metadata: stringifyMetadata({ fragment: usedFragment }),
+                    });
+                }
+            }
+        }
+        if (qualityConfig.useTypeChecker && this.codeConfig.graph.semantic.enabled) {
+            const ts = await loadTypeScript();
+            if (!ts && this.codeConfig.graph.quality === 'accurate') {
+                throw new Error('Quality mode "accurate" requires TypeScript. Install it: npm install typescript');
+            }
+            if (ts) {
+                // On-demand parsing: collect all resolved local files from import resolution
+                // and parse any that aren't already in chunksByFile
+                const resolvedLocalFiles = new Set();
+                for (const { result } of resolvedImports) {
+                    if (result.type === 'local' && result.fileId) {
+                        resolvedLocalFiles.add(result.fileId);
+                    }
+                }
+                // Also include files from reexport chains (e.g., index.ts -> embedding/factory.ts)
+                const reexportFiles = exportMapBuilder.getResolvedLocalFiles();
+                for (const fileId of reexportFiles) {
+                    resolvedLocalFiles.add(fileId);
+                }
+                // Parse files discovered through imports (outside original include patterns)
+                await this.ensureFilesParsedForGraph([...resolvedLocalFiles], chunksByFile, symbolToFile);
+                // Filter files for semantic analysis - include both indexed and on-demand parsed files
+                const allFiles = [...chunksByFile.keys()].filter((fileId) => /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(fileId));
+                const files = filesToProcess
+                    ? allFiles.filter(f => filesToProcess.has(f))
+                    : allFiles;
+                // Use shared TypeScript Program for all files (much faster than per-file analysis)
+                onProgress?.(0, files.length, 'semantic');
+                const allSemanticFacts = await analyzeAllFilesSemantics({
+                    fileIds: files,
+                    rootPath: this.rootPath,
+                    chunksByFile,
+                    onProgress: (current, total) => {
+                        onProgress?.(current, total, 'semantic');
+                    },
+                });
+                let semanticProcessed = 0;
+                for (const [fileId, semanticFacts] of allSemanticFacts) {
+                    edges.push(...this.buildSemanticEdges(semanticFacts, fileId, symbolToFile));
+                    semanticProcessed++;
+                }
+                onProgress?.(files.length, files.length, 'semantic');
+            }
+        }
+        // Phase: Building final graph structure
+        onProgress?.(0, 1, 'building');
+        const dedupedEdges = new Map();
+        for (const edge of edges) {
+            dedupedEdges.set(edge.id, edge);
+        }
+        onProgress?.(1, 1, 'building');
+        return {
+            edges: [...dedupedEdges.values()],
+            modules: [...modules.values()],
+            exports,
+        };
+    }
+    buildEmbeddingRecords(files) {
+        const records = [];
+        for (const file of files) {
+            const imports = [...new Set(file.facts.imports.map((imp) => imp.spec).filter(Boolean))];
+            for (const chunk of file.chunks) {
+                if (chunk.symbolType === 'file')
+                    continue;
+                records.push({
+                    chunkId: chunk.id,
+                    fileId: file.fileId,
+                    symbolName: chunk.symbolName,
+                    symbolType: chunk.symbolType,
+                    startLine: chunk.startLine,
+                    endLine: chunk.endLine,
+                    imports,
+                    embeddingText: buildNodeEmbeddingText(chunk, file.facts),
+                });
+            }
+        }
+        return records.sort((a, b) => a.fileId.localeCompare(b.fileId) || a.startLine - b.startLine);
+    }
+    async prepareGraph(quality = this.codeConfig.graph.quality, preParsedChunksByFile, onProgress) {
+        await this.initialize();
+        this.moduleResolveCache.clear();
+        clearResolverCache();
+        const qualityConfig = QUALITY_PRESETS[quality] ?? QUALITY_PRESETS.balanced;
+        // Phase 1: Loading chunks
+        onProgress?.(0, 1, 'loading');
+        const chunksByFile = preParsedChunksByFile
+            ? new Map(preParsedChunksByFile)
+            : await this.loadChunksByFile();
+        const files = preParsedChunksByFile
+            ? [...new Set(chunksByFile.keys())]
+            : await this.listCodeFiles();
+        onProgress?.(1, 1, 'loading');
+        // Phase 2: Parsing and extracting facts
+        onProgress?.(0, files.length, 'parsing');
+        const { factsPerFile, fileMetadata, embeddedChunks } = await this.buildFacts(files, chunksByFile, qualityConfig.embedEmbedded && (this.codeConfig.graph.embedded.css || this.codeConfig.graph.embedded.graphql), onProgress);
+        onProgress?.(files.length, files.length, 'parsing');
+        // Phase 3-5: Building graph (resolving, semantic, building)
+        const graph = await this.buildGraphFromFacts(factsPerFile, chunksByFile, qualityConfig, embeddedChunks, undefined, onProgress);
+        const embeddedByFile = new Map();
+        for (const chunk of embeddedChunks) {
+            // Use camelCase property from EmbeddedChunk
+            const arr = embeddedByFile.get(chunk.hostFileId) ?? [];
+            arr.push(chunk);
+            embeddedByFile.set(chunk.hostFileId, arr);
+        }
+        const preparedFiles = [];
+        const orderedFiles = [...new Set(files)].sort((a, b) => a.localeCompare(b));
+        for (const fileId of orderedFiles) {
+            const facts = factsPerFile.get(fileId);
+            const metadata = fileMetadata.get(fileId);
+            if (!facts || !metadata)
+                continue;
+            const chunks = chunksByFile.get(fileId) ?? [];
+            preparedFiles.push({
+                fileId,
+                language: chunks[0]?.language ?? null,
+                contentHash: metadata.contentHash,
+                mtime: metadata.mtime,
+                chunks,
+                facts,
+                embedded: embeddedByFile.get(fileId) ?? [],
+            });
+        }
+        const symbols = preparedFiles.reduce((acc, file) => acc + file.chunks.length, 0);
+        const stats = buildStatsFromPrepared(preparedFiles.length, symbols, graph.edges, embeddedChunks);
+        return {
+            quality,
+            files: preparedFiles,
+            edges: graph.edges,
+            modules: graph.modules,
+            exports: graph.exports,
+            embeddingRecords: this.buildEmbeddingRecords(preparedFiles),
+            stats,
+            parseErrors: [],
+        };
+    }
+    async indexAll(quality = this.codeConfig.graph.quality, options = {}) {
+        const { onProgress } = options;
+        // Phase 1: Preparing graph (parsing, building facts, resolving, semantic)
+        const prepared = await this.prepareGraph(quality, undefined, onProgress);
+        this.reverseIndex.buildFromEdges(prepared.edges);
+        // Phase 2: Indexing tables (5 tables total)
+        const totalTables = 5;
+        let tablesIndexed = 0;
+        // Use snake_case column names for all LanceDB tables
+        this.edgesTable = await this.replaceTable('code_edges', {
+            id: '__init__',
+            source_id: '',
+            target_id: '',
+            edge_type: 'IMPORTS_FILE',
+            source_file: '',
+            target_file: '',
+            target_module: '',
+            confidence: 'resolved',
+            metadata: '',
+        }, prepared.edges.map(toEdgeRecord));
+        onProgress?.(++tablesIndexed, totalTables, 'indexing');
+        this.modulesTable = await this.replaceTable('code_modules', {
+            id: '__init__',
+            type: 'npm',
+            package_name: '',
+            path: '',
+            version: '',
+            exports: '[]',
+        }, prepared.modules.map(toModuleRecord));
+        onProgress?.(++tablesIndexed, totalTables, 'indexing');
+        this.exportsTable = await this.replaceTable('code_exports', {
+            id: '__init__',
+            file_id: '',
+            export_name: '',
+            symbol_id: '',
+            is_reexport: false,
+            original_file: '',
+        }, prepared.exports.map(toExportRecord));
+        onProgress?.(++tablesIndexed, totalTables, 'indexing');
+        // Convert EmbeddedChunk (camelCase) to EmbeddedRecord (snake_case) for LanceDB
+        const embeddedRecords = prepared.files.flatMap((file) => file.embedded).map(toEmbeddedRecord);
+        this.embeddedTable = await this.replaceTable('code_embedded', {
+            id: '__init__',
+            host_file_id: '',
+            host_symbol_id: '',
+            embedded_type: 'graphql',
+            content: '',
+            start_offset: 0,
+            end_offset: 0,
+            start_line: 0,
+            end_line: 0,
+        }, embeddedRecords);
+        onProgress?.(++tablesIndexed, totalTables, 'indexing');
+        const graphFileRows = prepared.files.map((file) => ({
+            path: file.fileId,
+            content_hash: file.contentHash,
+            indexed_at: file.mtime,
+        }));
+        this.graphFileTable = await this.replaceTable('code_graph_file_index', {
+            path: '__init__',
+            content_hash: '',
+            indexed_at: 0,
+        }, graphFileRows);
+        onProgress?.(++tablesIndexed, totalTables, 'indexing');
+        return prepared.stats;
+    }
+    async incrementalUpdate() {
+        await this.initialize();
+        this.moduleResolveCache.clear();
+        clearResolverCache();
+        const files = await this.listCodeFiles();
+        const current = await this.loadFileMetadata(files);
+        const previous = await this.loadPreviousGraphFileIndex();
+        const existingEdges = await this.getAllEdges();
+        this.reverseIndex.buildFromEdges(existingEdges);
+        const changes = await detectChanges(current, previous, this.reverseIndex);
+        if (changes.modified.length === 0 && changes.deleted.length === 0 && changes.affected.length === 0) {
+            return { updated: 0, deleted: 0, affected: 0 };
+        }
+        // Calculate total files to update
+        const filesToUpdate = new Set([...changes.modified, ...changes.affected]);
+        const totalFiles = files.length;
+        // If more than 30% of files changed, do full reindex (more efficient)
+        if (filesToUpdate.size > totalFiles * 0.3) {
+            await this.indexAll();
+            return {
+                updated: changes.modified.length,
+                deleted: changes.deleted.length,
+                affected: changes.affected.length,
+            };
+        }
+        // Incremental update: only process changed files
+        const qualityConfig = QUALITY_PRESETS[this.codeConfig.graph.quality] ?? QUALITY_PRESETS.balanced;
+        // Step 1: Delete old data for files that will be updated or deleted
+        const filesToDelete = new Set([...filesToUpdate, ...changes.deleted]);
+        for (const fileId of filesToDelete) {
+            await this.deleteByFile(fileId);
+        }
+        // Step 2: Load existing chunks for ALL files (needed for symbolToFile mapping)
+        const chunksByFile = await this.loadChunksByFile();
+        // Step 3: Build facts for ALL files (needed for ExportMapBuilder to resolve re-exports)
+        // This is fast as it doesn't involve embeddings
+        const { factsPerFile, fileMetadata, embeddedChunks } = await this.buildFacts(files, chunksByFile, qualityConfig.embedEmbedded && (this.codeConfig.graph.embedded.css || this.codeConfig.graph.embedded.graphql));
+        // Step 4: Build graph only for modified + affected files
+        const graph = await this.buildGraphFromFacts(factsPerFile, chunksByFile, qualityConfig, embeddedChunks, filesToUpdate // Only process these files
+        );
+        // Step 5: Add new edges, exports, modules, embedded
+        await this.addEdges(graph.edges);
+        await this.addExports(graph.exports);
+        await this.addModules(graph.modules);
+        // Filter embedded for updated files only (using camelCase property)
+        const embeddedForUpdatedFiles = embeddedChunks.filter(e => filesToUpdate.has(e.hostFileId));
+        await this.addEmbedded(embeddedForUpdatedFiles);
+        // Step 6: Update graph file index for modified + affected files (snake_case columns)
+        const graphFileRecords = [];
+        for (const fileId of filesToUpdate) {
+            const metadata = fileMetadata.get(fileId);
+            if (metadata) {
+                graphFileRecords.push({
+                    path: fileId,
+                    content_hash: metadata.contentHash,
+                    indexed_at: metadata.mtime,
+                });
+            }
+        }
+        await this.updateGraphFileRecords(graphFileRecords);
+        // Step 7: Update reverse index with new edges
+        this.reverseIndex.buildFromEdges(await this.getAllEdges());
+        return {
+            updated: changes.modified.length,
+            deleted: changes.deleted.length,
+            affected: changes.affected.length,
+        };
+    }
+    async updateFiles(changedFiles) {
+        if (changedFiles.length === 0) {
+            return { updated: 0, deleted: 0, affected: 0 };
+        }
+        await this.initialize();
+        await this.ensureAllTables();
+        this.moduleResolveCache.clear();
+        clearResolverCache();
+        // Build reverse index from existing edges to find affected files
+        const existingEdges = await this.getAllEdges();
+        this.reverseIndex.buildFromEdges(existingEdges);
+        // Find affected files (importers of changed files)
+        const affectedSet = new Set();
+        const changedSet = new Set(changedFiles.map(f => normalizePath(f)));
+        for (const fileId of changedSet) {
+            const transitiveImporters = this.reverseIndex.getTransitiveImporters(fileId, 2);
+            for (const importer of transitiveImporters) {
+                if (!changedSet.has(importer)) {
+                    affectedSet.add(importer);
+                }
+            }
+        }
+        const filesToUpdate = new Set([...changedSet, ...affectedSet]);
+        const allFiles = await this.listCodeFiles();
+        // If more than 30% of files affected, do full reindex
+        if (filesToUpdate.size > allFiles.length * 0.3) {
+            await this.indexAll();
+            return { updated: changedFiles.length, deleted: 0, affected: affectedSet.size };
+        }
+        // Incremental update
+        const qualityConfig = QUALITY_PRESETS[this.codeConfig.graph.quality] ?? QUALITY_PRESETS.balanced;
+        // Delete old data for files to update
+        for (const fileId of filesToUpdate) {
+            await this.deleteByFile(fileId);
+        }
+        // Load chunks and build facts
+        const chunksByFile = await this.loadChunksByFile();
+        const { factsPerFile, fileMetadata, embeddedChunks } = await this.buildFacts(allFiles, chunksByFile, qualityConfig.embedEmbedded && (this.codeConfig.graph.embedded.css || this.codeConfig.graph.embedded.graphql));
+        // Build graph only for updated files
+        const graph = await this.buildGraphFromFacts(factsPerFile, chunksByFile, qualityConfig, embeddedChunks, filesToUpdate);
+        // Add new data
+        await this.addEdges(graph.edges);
+        await this.addExports(graph.exports);
+        await this.addModules(graph.modules);
+        // Filter embedded for updated files (using camelCase property)
+        const embeddedForUpdatedFiles = embeddedChunks.filter(e => filesToUpdate.has(e.hostFileId));
+        await this.addEmbedded(embeddedForUpdatedFiles);
+        // Update file index (snake_case columns)
+        const graphFileRecords = [];
+        for (const fileId of filesToUpdate) {
+            const metadata = fileMetadata.get(fileId);
+            if (metadata) {
+                graphFileRecords.push({
+                    path: fileId,
+                    content_hash: metadata.contentHash,
+                    indexed_at: metadata.mtime,
+                });
+            }
+        }
+        await this.updateGraphFileRecords(graphFileRecords);
+        // Update reverse index
+        this.reverseIndex.buildFromEdges(await this.getAllEdges());
+        return { updated: changedFiles.length, deleted: 0, affected: affectedSet.size };
+    }
+    async removeFile(filePath) {
+        await this.initialize();
+        const normalized = normalizePath(filePath);
+        await this.deleteByFile(normalized);
+    }
+    async deleteByFile(fileId) {
+        if (!this.edgesTable) {
+            try {
+                this.edgesTable = await this.db.openTable('code_edges');
+            }
+            catch {
+                return;
+            }
+        }
+        // Use snake_case column names for LanceDB SQL queries
+        await this.edgesTable.delete(`source_file = '${fileId.replace(/'/g, "''")}'`);
+        await this.edgesTable.delete(`target_file = '${fileId.replace(/'/g, "''")}'`);
+        if (this.exportsTable) {
+            await this.exportsTable.delete(`file_id = '${fileId.replace(/'/g, "''")}'`);
+        }
+        if (this.embeddedTable) {
+            await this.embeddedTable.delete(`host_file_id = '${fileId.replace(/'/g, "''")}'`);
+        }
+        if (this.graphFileTable) {
+            await this.graphFileTable.delete(`path = '${fileId.replace(/'/g, "''")}'`);
+        }
+    }
+    async clear() {
+        await this.initialize();
+        const tables = await this.db.tableNames();
+        for (const name of ['code_edges', 'code_modules', 'code_exports', 'code_embedded', 'code_graph_file_index']) {
+            if (tables.includes(name)) {
+                await this.db.dropTable(name);
+            }
+        }
+        this.chunksTable = null;
+        this.edgesTable = null;
+        this.modulesTable = null;
+        this.exportsTable = null;
+        this.embeddedTable = null;
+        this.graphFileTable = null;
+        this.reverseIndex = new ReverseIndexBuilder();
+    }
+    async getAllEdges() {
+        await this.initialize();
+        if (!this.edgesTable) {
+            try {
+                this.edgesTable = await this.db.openTable('code_edges');
+            }
+            catch {
+                return [];
+            }
+        }
+        const rows = await this.edgesTable.query().toArray();
+        // Convert from snake_case LanceDB records to camelCase CodeEdge
+        return rows.map(fromEdgeRecord);
+    }
+    async getChunkById(chunkId) {
+        const table = await this.ensureChunksTable();
+        const rows = await table.query().where(`id = '${chunkId.replace(/'/g, "''")}'`).toArray();
+        const row = rows[0];
+        if (!row)
+            return null;
+        // Read from snake_case columns
+        return {
+            id: row.id,
+            path: row.path,
+            language: row.language,
+            symbolType: row.symbol_type,
+            symbolName: row.symbol_name,
+            signature: row.signature,
+            parentSymbol: row.parent_symbol,
+            scope: JSON.parse(row.scope || '[]'),
+            content: row.content,
+            startLine: row.start_line,
+            endLine: row.end_line,
+            docstring: row.docstring,
+            modified: row.modified,
+            contentHash: row.content_hash,
+        };
+    }
+    async findSymbolChunk(symbolId, symbolName) {
+        if (symbolId) {
+            return this.getChunkById(symbolId);
+        }
+        if (!symbolName)
+            return null;
+        const table = await this.ensureChunksTable();
+        // Use snake_case column name in SQL query
+        const rows = await table
+            .query()
+            .where(`symbol_name = '${symbolName.replace(/'/g, "''")}'`)
+            .limit(1)
+            .toArray();
+        if (rows.length === 0)
+            return null;
+        const row = rows[0];
+        // Read from snake_case columns
+        return {
+            id: row.id,
+            path: row.path,
+            language: row.language,
+            symbolType: row.symbol_type,
+            symbolName: row.symbol_name,
+            signature: row.signature,
+            parentSymbol: row.parent_symbol,
+            scope: JSON.parse(row.scope || '[]'),
+            content: row.content,
+            startLine: row.start_line,
+            endLine: row.end_line,
+            docstring: row.docstring,
+            modified: row.modified,
+            contentHash: row.content_hash,
+        };
+    }
+    async readContextLine(fileId, line) {
+        try {
+            const content = await fs.readFile(path.resolve(this.rootPath, fileId), 'utf-8');
+            const lines = content.split('\n');
+            return (lines[line - 1] ?? '').trim();
+        }
+        catch {
+            return '';
+        }
+    }
+    async graphRefs(input) {
+        await this.initialize();
+        const symbol = await this.findSymbolChunk(input.symbolId, input.symbolName);
+        if (!symbol) {
+            return createError('GRAPH_SYMBOL_NOT_FOUND', 'Symbol not found');
+        }
+        const includeImports = input.includeImports ?? true;
+        const limit = input.limit ?? 50;
+        const edges = await this.getAllEdges();
+        const allowed = new Map([
+            ['REFS', 'ref'],
+            ['CALLS', 'call'],
+            ['EXTENDS', 'extend'],
+            ['IMPLEMENTS', 'implement'],
+            ['IMPORTS_SYMBOL', 'import'],
+        ]);
+        const references = [];
+        for (const edge of edges) {
+            if (edge.targetId !== symbol.id)
+                continue;
+            if (!allowed.has(edge.edgeType))
+                continue;
+            if (!includeImports && edge.edgeType === 'IMPORTS_SYMBOL')
+                continue;
+            if (input.file && edge.sourceFile !== input.file)
+                continue;
+            const meta = parseMetadata(edge.metadata);
+            const line = Number(meta.line ?? 1);
+            const context = await this.readContextLine(edge.sourceFile, line);
+            references.push({
+                file: edge.sourceFile,
+                line,
+                context,
+                type: allowed.get(edge.edgeType),
+            });
+        }
+        references.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+        const limited = references.slice(0, limit);
+        return {
+            symbol,
+            references: limited,
+            totalCount: references.length,
+        };
+    }
+    async buildCallNodes(rootId, direction, depth, limit) {
+        const edges = (await this.getAllEdges()).filter((edge) => edge.edgeType === 'CALLS');
+        const queue = [{ id: rootId, depth: 0 }];
+        const visited = new Set([rootId]);
+        const nodes = [];
+        while (queue.length > 0 && nodes.length < limit) {
+            const current = queue.shift();
+            if (!current)
+                break;
+            if (current.depth >= depth)
+                continue;
+            const relevant = edges.filter((edge) => direction === 'callers'
+                ? edge.targetId === current.id
+                : edge.sourceId === current.id);
+            for (const edge of relevant) {
+                const nextId = direction === 'callers' ? edge.sourceId : edge.targetId;
+                if (visited.has(nextId))
+                    continue;
+                visited.add(nextId);
+                const chunk = await this.getChunkById(nextId);
+                if (!chunk)
+                    continue;
+                const meta = parseMetadata(edge.metadata);
+                nodes.push({
+                    symbol: chunk,
+                    depth: current.depth + 1,
+                    callSites: [{
+                            file: edge.sourceFile,
+                            line: Number(meta.line ?? 1),
+                        }],
+                    children: [],
+                });
+                queue.push({ id: nextId, depth: current.depth + 1 });
+            }
+        }
+        return nodes;
+    }
+    async graphCalls(input) {
+        await this.initialize();
+        const symbol = await this.findSymbolChunk(input.symbolId, input.symbolName);
+        if (!symbol) {
+            return createError('GRAPH_SYMBOL_NOT_FOUND', 'Symbol not found');
+        }
+        const depth = input.depth ?? 2;
+        const limit = input.limit ?? 50;
+        const direction = input.direction;
+        const callers = direction === 'callees'
+            ? []
+            : await this.buildCallNodes(symbol.id, 'callers', depth, limit);
+        const callees = direction === 'callers'
+            ? []
+            : await this.buildCallNodes(symbol.id, 'callees', depth, limit);
+        return {
+            root: symbol,
+            callers,
+            callees,
+        };
+    }
+    async dependencySymbols(sourceFile, targetFile) {
+        const edges = await this.getAllEdges();
+        return edges
+            .filter((edge) => edge.edgeType === 'IMPORTS_SYMBOL' &&
+            edge.sourceFile === sourceFile &&
+            edge.targetFile === targetFile)
+            .map((edge) => {
+            const meta = parseMetadata(edge.metadata);
+            return String(meta.name ?? meta.alias ?? edge.targetId);
+        })
+            .filter(Boolean);
+    }
+    async traverseImports(fileId, includeExternal, maxDepth) {
+        const edges = (await this.getAllEdges()).filter((edge) => edge.edgeType === 'IMPORTS_FILE');
+        const queue = [{ file: fileId, depth: 0 }];
+        const visited = new Set([fileId]);
+        const result = [];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current)
+                break;
+            if (current.depth >= maxDepth)
+                continue;
+            const outgoing = edges.filter((edge) => edge.sourceFile === current.file);
+            for (const edge of outgoing) {
+                const nextFile = edge.targetFile ?? edge.targetModule ?? edge.targetId;
+                if (!includeExternal && !edge.targetFile)
+                    continue;
+                if (!nextFile || visited.has(nextFile))
+                    continue;
+                visited.add(nextFile);
+                const symbols = edge.targetFile
+                    ? await this.dependencySymbols(current.file, edge.targetFile)
+                    : [];
+                result.push({
+                    file: nextFile,
+                    type: edge.targetFile ? 'local' : edge.targetModule && edge.targetModule.startsWith('node:') ? 'builtin' : 'npm',
+                    symbols,
+                    depth: current.depth + 1,
+                    children: [],
+                });
+                if (edge.targetFile) {
+                    queue.push({ file: edge.targetFile, depth: current.depth + 1 });
+                }
+            }
+        }
+        return result;
+    }
+    async traverseImporters(fileId, maxDepth) {
+        const edges = (await this.getAllEdges()).filter((edge) => edge.edgeType === 'IMPORTS_FILE');
+        const queue = [{ file: fileId, depth: 0 }];
+        const visited = new Set([fileId]);
+        const result = [];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current)
+                break;
+            if (current.depth >= maxDepth)
+                continue;
+            const incoming = edges.filter((edge) => edge.targetFile === current.file);
+            for (const edge of incoming) {
+                if (visited.has(edge.sourceFile))
+                    continue;
+                visited.add(edge.sourceFile);
+                result.push({
+                    file: edge.sourceFile,
+                    type: 'local',
+                    symbols: [],
+                    depth: current.depth + 1,
+                    children: [],
+                });
+                queue.push({ file: edge.sourceFile, depth: current.depth + 1 });
+            }
+        }
+        return result;
+    }
+    async graphDeps(input) {
+        await this.initialize();
+        const depth = input.depth ?? 1;
+        const includeExternal = input.includeExternal ?? false;
+        // Normalize file path to match stored paths in database
+        const fileId = normalizePath(input.file);
+        const imports = input.direction === 'importedBy'
+            ? []
+            : await this.traverseImports(fileId, includeExternal, depth);
+        const importedBy = input.direction === 'imports'
+            ? []
+            : await this.traverseImporters(fileId, depth);
+        return {
+            file: fileId,
+            imports,
+            importedBy,
+        };
+    }
+    async collectHierarchyIds(rootId, edgeType, incoming) {
+        const edges = (await this.getAllEdges()).filter((edge) => edge.edgeType === edgeType);
+        const queue = [rootId];
+        const result = new Set();
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current)
+                break;
+            const matches = edges.filter((edge) => incoming ? edge.targetId === current : edge.sourceId === current);
+            for (const edge of matches) {
+                const next = incoming ? edge.sourceId : edge.targetId;
+                if (next === rootId || result.has(next))
+                    continue;
+                result.add(next);
+                queue.push(next);
+            }
+        }
+        return [...result];
+    }
+    async getChunksByIds(ids) {
+        const chunks = [];
+        for (const id of ids) {
+            const chunk = await this.getChunkById(id);
+            if (chunk)
+                chunks.push(chunk);
+        }
+        return chunks;
+    }
+    async graphHierarchy(input) {
+        await this.initialize();
+        const symbol = await this.findSymbolChunk(input.symbolId, input.symbolName);
+        if (!symbol) {
+            return createError('GRAPH_SYMBOL_NOT_FOUND', 'Symbol not found');
+        }
+        const extendsIds = await this.collectHierarchyIds(symbol.id, 'EXTENDS', false);
+        const implementsIds = await this.collectHierarchyIds(symbol.id, 'IMPLEMENTS', false);
+        const extendedByIds = await this.collectHierarchyIds(symbol.id, 'EXTENDS', true);
+        const implementedByIds = await this.collectHierarchyIds(symbol.id, 'IMPLEMENTS', true);
+        return {
+            symbol,
+            extends: await this.getChunksByIds(extendsIds),
+            implements: await this.getChunksByIds(implementsIds),
+            extendedBy: await this.getChunksByIds(extendedByIds),
+            implementedBy: await this.getChunksByIds(implementedByIds),
+        };
+    }
+    async getStats() {
+        await this.initialize();
+        const edges = await this.getAllEdges();
+        const edgeTypes = edgeTypeCount();
+        for (const edge of edges) {
+            edgeTypes[edge.edgeType] += 1;
+        }
+        const chunksTable = await this.ensureChunksTable();
+        const chunksCount = await chunksTable.countRows();
+        let graphFiles = 0;
+        if (this.graphFileTable) {
+            graphFiles = await this.graphFileTable.countRows();
+        }
+        else {
+            try {
+                this.graphFileTable = await this.db.openTable('code_graph_file_index');
+                graphFiles = await this.graphFileTable.countRows();
+            }
+            catch {
+                graphFiles = 0;
+            }
+        }
+        let embeddedRows = [];
+        if (!this.embeddedTable) {
+            try {
+                this.embeddedTable = await this.db.openTable('code_embedded');
+            }
+            catch {
+                this.embeddedTable = null;
+            }
+        }
+        if (this.embeddedTable) {
+            embeddedRows = (await this.embeddedTable.query().toArray());
+        }
+        const embeddedByType = {
+            graphql: 0,
+            css: 0,
+            styled: 0,
+        };
+        for (const row of embeddedRows) {
+            // Use snake_case column name from LanceDB record
+            const embeddedType = row.embedded_type;
+            if (embeddedType) {
+                embeddedByType[embeddedType] += 1;
+            }
+        }
+        return {
+            filesIndexed: graphFiles,
+            symbols: chunksCount,
+            edges: edges.length,
+            edgeTypes,
+            unresolvedImports: edges.filter((edge) => edge.edgeType === 'IMPORTS_FILE' && edge.confidence === 'unresolved').length,
+            embeddedChunks: embeddedRows.length,
+            embeddedByType,
+        };
+    }
+    async exportGraph(format = 'json') {
+        const edges = await this.getAllEdges();
+        if (format === 'json') {
+            return JSON.stringify(edges, null, 2);
+        }
+        const lines = ['digraph CodeGraph {'];
+        for (const edge of edges) {
+            const source = edge.sourceId.replace(/"/g, '\\"');
+            const target = edge.targetId.replace(/"/g, '\\"');
+            lines.push(`  "${source}" -> "${target}" [label="${edge.edgeType}"];`);
+        }
+        lines.push('}');
+        return lines.join('\n');
+    }
+}
+//# sourceMappingURL=index.js.map