sdl-mcp 0.6.0

package/dist/indexer/indexer.js

@@ -0,0 +1,1229 @@
+import { watch } from "fs";
+import { createRequire } from "module";
+import { dirname, join, relative, resolve } from "path";
+import { platform } from "process";
+import os from "os";
+import { getRepo, upsertFile, deleteSymbolsByFileWithEdges, deleteFileTransaction, upsertSymbolTransaction, createEdgeTransaction, createSnapshotTransaction, getFilesByRepo, getFileByRepoPath, getSymbolsByFile, getSymbolsByFileLite, getSymbolsByRepoForSnapshot, getEdgesByRepo, getSymbolsByRepo, getSymbol, getFile, deleteSymbolReferencesByFileId, insertSymbolReference, } from "../db/queries.js";
+import { getDb } from "../db/db.js";
+import { scanRepository } from "./fileScanner.js";
+import { generateAstFingerprint, generateSymbolId } from "./fingerprints.js";
+import { WATCH_DEBOUNCE_MS, WATCH_STABILITY_THRESHOLD_MS, WATCH_POLL_INTERVAL_MS, WATCHER_ERROR_MAX_COUNT, } from "../config/constants.js";
+import { hashContent } from "../util/hashing.js";
+import { normalizePath } from "../util/paths.js";
+import { generateSummary, extractInvariants, extractSideEffects, } from "./summaries.js";
+import { updateMetricsForRepo } from "../graph/metrics.js";
+import { extractConfigEdgesFromTree } from "./configEdges.js";
+import { loadConfig } from "../config/loadConfig.js";
+import { createTsCallResolver } from "./ts/tsParser.js";
+import { getAdapterForExtension } from "./adapter/registry.js";
+import { ParserWorkerPool } from "./workerPool.js";
+import { logger } from "../util/logger.js";
+import { readFileAsync, existsAsync } from "../util/asyncFs.js";
+const require = createRequire(import.meta.url);
+async function processFile(params) {
+    const { repoId, repoRoot, fileMeta, languages, mode, existingFile, symbolIndex, pendingCallEdges, createdCallEdges, tsResolver, config, allSymbolsByName, onProgress: _onProgress, workerPool, } = params;
+    try {
+        const filePath = join(repoRoot, fileMeta.path);
+        const content = await readFileAsync(filePath, "utf-8");
+        const contentHash = hashContent(content);
+        const ext = fileMeta.path.split(".").pop() || "";
+        const extWithDot = `.${ext}`;
+        if (mode === "incremental" &&
+            existingFile &&
+            existingFile.content_hash === contentHash) {
+            return {
+                symbolsIndexed: 0,
+                edgesCreated: 0,
+                changed: false,
+                configEdges: [],
+            };
+        }
+        if (!languages.includes(ext)) {
+            logger.debug(`Language ${ext} not in enabled languages, skipping ${fileMeta.path}`);
+            if (existingFile) {
+                deleteSymbolsByFileWithEdges(existingFile.file_id);
+            }
+            upsertFile({
+                repo_id: repoId,
+                rel_path: fileMeta.path,
+                content_hash: contentHash,
+                language: ext,
+                byte_size: fileMeta.size,
+                last_indexed_at: new Date().toISOString(),
+            });
+            return {
+                symbolsIndexed: 0,
+                edgesCreated: 0,
+                changed: true,
+                configEdges: [],
+            };
+        }
+        const adapter = getAdapterForExtension(extWithDot);
+        if (!adapter) {
+            logger.debug(`No adapter found for ${extWithDot}, skipping ${fileMeta.path}`);
+            if (existingFile) {
+                deleteSymbolsByFileWithEdges(existingFile.file_id);
+            }
+            upsertFile({
+                repo_id: repoId,
+                rel_path: fileMeta.path,
+                content_hash: contentHash,
+                language: ext,
+                byte_size: fileMeta.size,
+                last_indexed_at: new Date().toISOString(),
+            });
+            return {
+                symbolsIndexed: 0,
+                edgesCreated: 0,
+                changed: true,
+                configEdges: [],
+            };
+        }
+        let symbolsWithNodeIds = [];
+        let imports = [];
+        let calls = [];
+        let parseError = null;
+        let tree = null;
+        try {
+            if (workerPool) {
+                try {
+                    const result = await workerPool.parse(filePath, content, extWithDot);
+                    symbolsWithNodeIds = result.symbols;
+                    imports = result.imports;
+                    calls = result.calls;
+                    // tree remains null when using worker pool - fingerprinting will use empty string
+                }
+                catch (workerError) {
+                    parseError =
+                        workerError instanceof Error
+                            ? workerError
+                            : new Error(String(workerError));
+                    logger.warn(`Worker pool parse failed for ${fileMeta.path}, falling back to sync: ${parseError.message}`);
+                }
+            }
+            if (parseError || !workerPool) {
+                tree = adapter.parse(content, filePath);
+                if (!tree) {
+                    if (existingFile) {
+                        deleteSymbolsByFileWithEdges(existingFile.file_id);
+                    }
+                    upsertFile({
+                        repo_id: repoId,
+                        rel_path: fileMeta.path,
+                        content_hash: contentHash,
+                        language: adapter.languageId,
+                        byte_size: fileMeta.size,
+                        last_indexed_at: new Date().toISOString(),
+                    });
+                    return {
+                        symbolsIndexed: 0,
+                        edgesCreated: 0,
+                        changed: true,
+                        configEdges: [],
+                    };
+                }
+                let extractedSymbols;
+                try {
+                    extractedSymbols = adapter.extractSymbols(tree, content, filePath);
+                }
+                catch (error) {
+                    logger.warn(`Partial parse error for ${fileMeta.path}: ${error}, extracting available symbols`);
+                    extractedSymbols = [];
+                }
+                imports = adapter.extractImports(tree, content, filePath);
+                symbolsWithNodeIds = extractedSymbols.map((symbol) => ({
+                    nodeId: symbol.nodeId,
+                    kind: symbol.kind,
+                    name: symbol.name,
+                    exported: symbol.exported,
+                    range: symbol.range,
+                    signature: symbol.signature,
+                    visibility: symbol.visibility,
+                }));
+                calls = adapter.extractCalls(tree, content, filePath, symbolsWithNodeIds);
+            }
+        }
+        catch (error) {
+            logger.error(`Fatal parse error for ${fileMeta.path}: ${error}`);
+            return {
+                symbolsIndexed: 0,
+                edgesCreated: 0,
+                changed: false,
+                configEdges: [],
+            };
+        }
+        const symbolsIndexed = symbolsWithNodeIds.length;
+        let edgesCreated = 0;
+        const existingSymbolsById = new Map();
+        if (existingFile) {
+            const existingSymbols = getSymbolsByFile(existingFile.file_id);
+            for (const symbol of existingSymbols) {
+                existingSymbolsById.set(symbol.symbol_id, symbol);
+            }
+        }
+        const fileRecord = {
+            repo_id: repoId,
+            rel_path: fileMeta.path,
+            content_hash: contentHash,
+            language: ext,
+            byte_size: fileMeta.size,
+            last_indexed_at: new Date().toISOString(),
+        };
+        upsertFile(fileRecord);
+        const file = getFileByRepoPath(repoId, fileMeta.path);
+        if (!file) {
+            return { symbolsIndexed, edgesCreated, changed: true, configEdges: [] };
+        }
+        if (existingFile) {
+            deleteSymbolsByFileWithEdges(existingFile.file_id);
+            deleteSymbolReferencesByFileId(existingFile.file_id);
+        }
+        if (isTestFile(fileMeta.path, languages)) {
+            extractSymbolReferences(content, repoId, file.file_id);
+        }
+        const exportSymbols = symbolsWithNodeIds.filter((symbol) => symbol.exported);
+        const edgeSourceSymbols = exportSymbols.length > 0 ? exportSymbols : symbolsWithNodeIds;
+        const extensions = languages.map((lang) => `.${lang}`);
+        const importResolution = await resolveImportTargets(repoId, repoRoot, fileMeta.path, imports, extensions, adapter.languageId);
+        const importTargets = importResolution.targets;
+        const symbolDetails = symbolsWithNodeIds.map((extractedSymbol) => {
+            // When using worker pool, tree is null - use empty fingerprint
+            // The fingerprint is still useful for change detection but not critical
+            let astFingerprint = "";
+            if (tree) {
+                const astNode = tree.rootNode
+                    .descendantsOfType(extractedSymbol.kind === "function"
+                    ? "function_declaration"
+                    : extractedSymbol.kind === "class"
+                        ? "class_declaration"
+                        : extractedSymbol.kind === "interface"
+                            ? "interface_declaration"
+                            : extractedSymbol.kind === "type"
+                                ? "type_alias_declaration"
+                                : extractedSymbol.kind === "method"
+                                    ? "method_definition"
+                                    : extractedSymbol.kind === "variable"
+                                        ? "variable_declaration"
+                                        : "ambient_statement")
+                    .find((node) => {
+                    const nameNode = node.childForFieldName("name");
+                    return nameNode?.text === extractedSymbol.name;
+                });
+                astFingerprint = astNode ? generateAstFingerprint(astNode) : "";
+            }
+            const symbolId = generateSymbolId(repoId, fileMeta.path, extractedSymbol.kind, extractedSymbol.name, astFingerprint);
+            return {
+                extractedSymbol,
+                astFingerprint,
+                symbolId,
+            };
+        });
+        const nodeIdToSymbolId = new Map();
+        const nameToSymbolIds = new Map();
+        for (const detail of symbolDetails) {
+            nodeIdToSymbolId.set(detail.extractedSymbol.nodeId, detail.symbolId);
+            const existing = nameToSymbolIds.get(detail.extractedSymbol.name) ?? [];
+            existing.push(detail.symbolId);
+            nameToSymbolIds.set(detail.extractedSymbol.name, existing);
+        }
+        for (const detail of symbolDetails) {
+            const extractedSymbol = detail.extractedSymbol;
+            const symbolId = detail.symbolId;
+            const existingSymbol = existingSymbolsById.get(symbolId);
+            let summary = existingSymbol?.summary ?? null;
+            if (summary === null) {
+                summary = generateSummary(extractedSymbol, content);
+            }
+            let invariantsJson = existingSymbol?.invariants_json ?? null;
+            if (invariantsJson === null) {
+                const invariants = extractInvariants(extractedSymbol, content);
+                invariantsJson =
+                    invariants.length > 0 ? JSON.stringify(invariants) : null;
+            }
+            let sideEffectsJson = existingSymbol?.side_effects_json ?? null;
+            if (sideEffectsJson === null) {
+                const sideEffects = extractSideEffects(extractedSymbol, content);
+                sideEffectsJson =
+                    sideEffects.length > 0 ? JSON.stringify(sideEffects) : null;
+            }
+            const symbol = {
+                symbol_id: symbolId,
+                repo_id: repoId,
+                file_id: file.file_id,
+                kind: extractedSymbol.kind,
+                name: extractedSymbol.name,
+                exported: extractedSymbol.exported ? 1 : 0,
+                visibility: extractedSymbol.visibility || null,
+                language: adapter.languageId,
+                range_start_line: extractedSymbol.range.startLine,
+                range_start_col: extractedSymbol.range.startCol,
+                range_end_line: extractedSymbol.range.endLine,
+                range_end_col: extractedSymbol.range.endCol,
+                ast_fingerprint: detail.astFingerprint,
+                signature_json: extractedSymbol.signature
+                    ? JSON.stringify(extractedSymbol.signature)
+                    : null,
+                summary,
+                invariants_json: invariantsJson,
+                side_effects_json: sideEffectsJson,
+                updated_at: new Date().toISOString(),
+            };
+            upsertSymbolTransaction(symbol);
+            if (symbolIndex) {
+                addToSymbolIndex(symbolIndex, fileMeta.path, symbol.symbol_id, symbol.name, symbol.kind);
+            }
+            if (edgeSourceSymbols.some((s) => s.nodeId === extractedSymbol.nodeId)) {
+                for (const target of importTargets) {
+                    const edge = {
+                        repo_id: repoId,
+                        from_symbol_id: symbolId,
+                        to_symbol_id: target.symbolId,
+                        type: "import",
+                        weight: 0.6,
+                        provenance: `import:${target.provenance}`,
+                        created_at: new Date().toISOString(),
+                    };
+                    createEdgeTransaction(edge);
+                    edgesCreated++;
+                }
+            }
+            for (const call of calls) {
+                if (call.callerNodeId !== extractedSymbol.nodeId) {
+                    continue;
+                }
+                const resolved = resolveCallTarget(call, nodeIdToSymbolId, nameToSymbolIds, importResolution.importedNameToSymbolIds, importResolution.namespaceImports);
+                if (!resolved) {
+                    continue;
+                }
+                // 36-1.3: Handle both resolved and unresolved edges
+                if (resolved.isResolved && resolved.symbolId) {
+                    // Fully resolved edge
+                    const edgeKey = `${symbolId}->${resolved.symbolId}`;
+                    if (createdCallEdges && createdCallEdges.has(edgeKey)) {
+                        continue;
+                    }
+                    const edge = {
+                        repo_id: repoId,
+                        from_symbol_id: symbolId,
+                        to_symbol_id: resolved.symbolId,
+                        type: "call",
+                        weight: 1.0,
+                        provenance: `call:${call.calleeIdentifier}`,
+                        created_at: new Date().toISOString(),
+                    };
+                    createEdgeTransaction(edge);
+                    createdCallEdges?.add(edgeKey);
+                    edgesCreated++;
+                }
+                else if (resolved.targetName) {
+                    // 36-1.3: Unresolved edge - still useful for graph traversal
+                    // Use a placeholder symbol ID that encodes the unresolved target
+                    const unresolvedTargetId = `unresolved:call:${resolved.targetName}`;
+                    const edgeKey = `${symbolId}->${unresolvedTargetId}`;
+                    if (createdCallEdges && createdCallEdges.has(edgeKey)) {
+                        continue;
+                    }
+                    const edge = {
+                        repo_id: repoId,
+                        from_symbol_id: symbolId,
+                        to_symbol_id: unresolvedTargetId,
+                        type: "call",
+                        weight: 0.5, // Lower weight for unresolved edges
+                        provenance: `unresolved-call:${call.calleeIdentifier}${resolved.candidateCount ? `:candidates=${resolved.candidateCount}` : ""}`,
+                        created_at: new Date().toISOString(),
+                    };
+                    createEdgeTransaction(edge);
+                    createdCallEdges?.add(edgeKey);
+                    edgesCreated++;
+                }
+            }
+        }
+        if (tsResolver && symbolIndex && pendingCallEdges && createdCallEdges) {
+            const tsCalls = tsResolver.getResolvedCalls(fileMeta.path);
+            for (const tsCall of tsCalls) {
+                const callerNodeId = findEnclosingSymbolByRange(tsCall.caller, symbolDetails);
+                if (!callerNodeId)
+                    continue;
+                const fromSymbolId = nodeIdToSymbolId.get(callerNodeId);
+                if (!fromSymbolId)
+                    continue;
+                const toSymbolId = resolveSymbolIdFromIndex(symbolIndex, repoId, tsCall.callee.filePath, tsCall.callee.name, tsCall.callee.kind, adapter.languageId);
+                if (toSymbolId) {
+                    const edgeKey = `${fromSymbolId}->${toSymbolId}`;
+                    if (createdCallEdges.has(edgeKey))
+                        continue;
+                    createEdgeTransaction({
+                        repo_id: repoId,
+                        from_symbol_id: fromSymbolId,
+                        to_symbol_id: toSymbolId,
+                        type: "call",
+                        weight: 1.0,
+                        provenance: `ts-call:${tsCall.callee.name}`,
+                        created_at: new Date().toISOString(),
+                    });
+                    createdCallEdges.add(edgeKey);
+                    edgesCreated++;
+                }
+                else {
+                    pendingCallEdges.push({
+                        fromSymbolId,
+                        toFile: tsCall.callee.filePath,
+                        toName: tsCall.callee.name,
+                        toKind: tsCall.callee.kind,
+                        provenance: `ts-call:${tsCall.callee.name}`,
+                        callerLanguage: adapter.languageId,
+                    });
+                }
+            }
+        }
+        let configEdges = [];
+        // Config edges require the AST tree - skip when using worker pool (tree is null)
+        if (config && allSymbolsByName && tree) {
+            const fileSymbols = getSymbolsByFile(file.file_id);
+            configEdges = extractConfigEdgesFromTree({
+                repoId,
+                repoRoot,
+                config,
+                tree,
+                fileSymbols,
+                allSymbolsByName,
+            });
+        }
+        return { symbolsIndexed, edgesCreated, changed: true, configEdges };
+    }
+    catch (error) {
+        console.error(`Error processing file ${fileMeta.path}:`, error);
+        return {
+            symbolsIndexed: 0,
+            edgesCreated: 0,
+            changed: false,
+            configEdges: [],
+        };
+    }
+}
+function isTestFile(relPath, languages) {
+    const ext = relPath.split(".").pop() || "";
+    if (!languages.includes(ext))
+        return false;
+    const fileName = relPath.split("/").pop() || relPath.split("\\").pop() || "";
+    const hasTestSuffix = fileName.includes(".test.") || fileName.includes(".spec.");
+    const isInTestDir = relPath.includes("/tests/") ||
+        relPath.includes("\\tests\\") ||
+        relPath.includes("/__tests__/") ||
+        relPath.includes("\\__tests__\\");
+    return hasTestSuffix || isInTestDir;
+}
+function extractSymbolReferences(content, repoId, fileId) {
+    const tokens = content.match(/[A-Za-z_][A-Za-z0-9_]*/g);
+    if (!tokens)
+        return;
+    const uniqueTokens = new Set(tokens);
+    const createdAt = new Date().toISOString();
+    for (const token of uniqueTokens) {
+        insertSymbolReference({
+            repo_id: repoId,
+            symbol_name: token,
+            file_id: fileId,
+            line_number: null,
+            created_at: createdAt,
+        });
+    }
+}
+async function resolveImportTargets(repoId, repoRoot, importerRelPath, imports, extensions, importerLanguage) {
+    const targets = [];
+    const importedNameToSymbolIds = new Map();
+    const namespaceImports = new Map();
+    for (const imp of imports) {
+        const resolvedPath = await resolveImportToPath(repoRoot, importerRelPath, imp.specifier, extensions);
+        const importedNames = new Set();
+        if (imp.defaultImport)
+            importedNames.add(imp.defaultImport);
+        for (const name of imp.imports)
+            importedNames.add(name);
+        if (importedNames.size === 0) {
+            importedNames.add("*");
+        }
+        if (!resolvedPath) {
+            for (const name of importedNames) {
+                targets.push({
+                    symbolId: `unresolved:${imp.specifier}:${name}`,
+                    provenance: `${imp.specifier}:${name}`,
+                });
+            }
+            if (imp.namespaceImport) {
+                targets.push({
+                    symbolId: `unresolved:${imp.specifier}:* as ${imp.namespaceImport}`,
+                    provenance: `${imp.specifier}:* as ${imp.namespaceImport}`,
+                });
+            }
+            continue;
+        }
+        const targetFile = getFileByRepoPath(repoId, resolvedPath);
+        if (!targetFile) {
+            for (const name of importedNames) {
+                targets.push({
+                    symbolId: `unresolved:${resolvedPath}:${name}`,
+                    provenance: `${resolvedPath}:${name}`,
+                });
+            }
+            if (imp.namespaceImport) {
+                targets.push({
+                    symbolId: `unresolved:${resolvedPath}:* as ${imp.namespaceImport}`,
+                    provenance: `${resolvedPath}:* as ${imp.namespaceImport}`,
+                });
+            }
+            continue;
+        }
+        // ML-D.1: Language-aware import resolution
+        // Cross-language imports are resolved when possible
+        if (targetFile.language !== importerLanguage) {
+            for (const name of importedNames) {
+                targets.push({
+                    symbolId: `unresolved:${resolvedPath}:${name}`,
+                    provenance: `cross-language:${targetFile.language}->${importerLanguage}:${name}`,
+                });
+            }
+            if (imp.namespaceImport) {
+                targets.push({
+                    symbolId: `unresolved:${resolvedPath}:* as ${imp.namespaceImport}`,
+                    provenance: `cross-language:${targetFile.language}->${importerLanguage}:* as ${imp.namespaceImport}`,
+                });
+            }
+        }
+        const targetSymbols = getSymbolsByFileLite(targetFile.file_id).filter((symbol) => symbol.exported === 1);
+        for (const name of importedNames) {
+            if (name.startsWith("*")) {
+                targets.push({
+                    symbolId: `unresolved:${resolvedPath}:${name}`,
+                    provenance: `${resolvedPath}:${name}`,
+                });
+                continue;
+            }
+            let match = targetSymbols.find((symbol) => symbol.name === name);
+            if (!match && imp.defaultImport === name && targetSymbols.length === 1) {
+                match = targetSymbols[0];
+            }
+            if (match) {
+                targets.push({
+                    symbolId: match.symbol_id,
+                    provenance: `${resolvedPath}:${name}`,
+                });
+                const existing = importedNameToSymbolIds.get(name) ?? [];
+                existing.push(match.symbol_id);
+                importedNameToSymbolIds.set(name, existing);
+            }
+            else {
+                targets.push({
+                    symbolId: `unresolved:${resolvedPath}:${name}`,
+                    provenance: `${resolvedPath}:${name}`,
+                });
+            }
+        }
+        if (imp.namespaceImport) {
+            const namespaceMap = new Map();
+            for (const symbol of targetSymbols) {
+                namespaceMap.set(symbol.name, symbol.symbol_id);
+                targets.push({
+                    symbolId: symbol.symbol_id,
+                    provenance: `${resolvedPath}:*`,
+                });
+            }
+            if (namespaceMap.size > 0) {
+                namespaceImports.set(imp.namespaceImport, namespaceMap);
+            }
+            else {
+                targets.push({
+                    symbolId: `unresolved:${resolvedPath}:* as ${imp.namespaceImport}`,
+                    provenance: `${resolvedPath}:* as ${imp.namespaceImport}`,
+                });
+            }
+        }
+    }
+    return { targets, importedNameToSymbolIds, namespaceImports };
+}
+async function resolveImportToPath(repoRoot, importerRelPath, specifier, extensions) {
+    if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
+        return null;
+    }
+    const importerDir = dirname(importerRelPath);
+    const baseRelPath = normalizePath(join(importerDir, specifier));
+    const baseAbsPath = resolve(repoRoot, baseRelPath);
+    const hasExtension = extensions.some((ext) => baseRelPath.endsWith(ext));
+    const candidates = [];
+    if (hasExtension) {
+        candidates.push(baseRelPath);
+    }
+    else {
+        for (const ext of extensions) {
+            candidates.push(`${baseRelPath}${ext}`);
+        }
+        for (const ext of extensions) {
+            candidates.push(normalizePath(join(baseRelPath, `index${ext}`)));
+        }
+    }
+    for (const relPath of candidates) {
+        const absPath = resolve(repoRoot, relPath);
+        if (await existsAsync(absPath)) {
+            return normalizePath(relPath);
+        }
+    }
+    if (hasExtension && (await existsAsync(baseAbsPath))) {
+        return normalizePath(baseRelPath);
+    }
+    return null;
+}
+function resolveCallTarget(call, nodeIdToSymbolId, nameToSymbolIds, importedNameToSymbolIds, namespaceImports) {
+    // Already resolved to a specific symbol
+    if (call.calleeSymbolId && nodeIdToSymbolId.has(call.calleeSymbolId)) {
+        return {
+            symbolId: nodeIdToSymbolId.get(call.calleeSymbolId) ?? null,
+            isResolved: true,
+        };
+    }
+    const candidateId = call.calleeSymbolId ?? call.calleeIdentifier;
+    if (!candidateId) {
+        return null;
+    }
+    const cleaned = candidateId.replace(/^new\s+/, "");
+    if (cleaned.includes(".")) {
+        const parts = cleaned.split(".");
+        const prefix = parts[0];
+        const member = parts[parts.length - 1];
+        const namespace = namespaceImports.get(prefix);
+        if (namespace && namespace.has(member)) {
+            return {
+                symbolId: namespace.get(member) ?? null,
+                isResolved: true,
+            };
+        }
+    }
+    const identifier = extractLastIdentifier(candidateId);
+    if (!identifier) {
+        return null;
+    }
+    // Check imported names first
+    const importedCandidates = importedNameToSymbolIds.get(identifier);
+    if (importedCandidates && importedCandidates.length === 1) {
+        return {
+            symbolId: importedCandidates[0],
+            isResolved: true,
+        };
+    }
+    // 36-1.3: Handle ambiguous imported names - create unresolved edge
+    if (importedCandidates && importedCandidates.length > 1) {
+        return {
+            symbolId: null,
+            isResolved: false,
+            candidateCount: importedCandidates.length,
+            targetName: identifier,
+        };
+    }
+    // Check local symbols
+    const candidates = nameToSymbolIds.get(identifier);
+    if (candidates && candidates.length === 1) {
+        return {
+            symbolId: candidates[0],
+            isResolved: true,
+        };
+    }
+    // 36-1.3: Handle ambiguous local names - create unresolved edge
+    if (candidates && candidates.length > 1) {
+        return {
+            symbolId: null,
+            isResolved: false,
+            candidateCount: candidates.length,
+            targetName: identifier,
+        };
+    }
+    // No candidates at all - still create an unresolved edge if we have a name
+    // This helps with external calls that might be resolved later
+    if (identifier && call.callType !== "dynamic") {
+        return {
+            symbolId: null,
+            isResolved: false,
+            candidateCount: 0,
+            targetName: identifier,
+        };
+    }
+    return null;
+}
+function extractLastIdentifier(text) {
+    const cleaned = text.replace(/^new\s+/, "");
+    const parts = cleaned.split(".");
+    const last = parts[parts.length - 1]?.trim();
+    return last || null;
+}
+function addToSymbolIndex(index, filePath, symbolId, name, kind) {
+    const fileKey = normalizePath(filePath);
+    let fileEntry = index.get(fileKey);
+    if (!fileEntry) {
+        fileEntry = new Map();
+        index.set(fileKey, fileEntry);
+    }
+    let nameEntry = fileEntry.get(name);
+    if (!nameEntry) {
+        nameEntry = new Map();
+        fileEntry.set(name, nameEntry);
+    }
+    const kindEntry = nameEntry.get(kind) ?? [];
+    kindEntry.push(symbolId);
+    nameEntry.set(kind, kindEntry);
+}
+function resolveSymbolIdFromIndex(index, repoId, filePath, name, kind, callerLanguage) {
+    const fileEntry = index.get(normalizePath(filePath));
+    if (!fileEntry)
+        return null;
+    const nameEntry = fileEntry.get(name);
+    if (!nameEntry)
+        return null;
+    const candidates = nameEntry.get(kind);
+    if (!candidates || candidates.length !== 1)
+        return null;
+    // ML-D.1: Language-aware symbol resolution
+    // If callerLanguage is provided, check if the target file is the same language
+    if (callerLanguage) {
+        const targetFile = getFileByRepoPath(repoId, filePath);
+        if (targetFile && targetFile.language !== callerLanguage) {
+            // Cross-language call - return null to mark as unresolved
+            return null;
+        }
+    }
+    return candidates[0];
+}
+function resolvePendingCallEdges(pending, index, created, repoId) {
+    for (const edge of pending) {
+        const toSymbolId = resolveSymbolIdFromIndex(index, repoId, edge.toFile, edge.toName, edge.toKind, edge.callerLanguage);
+        if (!toSymbolId) {
+            continue;
+        }
+        const edgeKey = `${edge.fromSymbolId}->${toSymbolId}`;
+        if (created.has(edgeKey)) {
+            continue;
+        }
+        createEdgeTransaction({
+            repo_id: repoId,
+            from_symbol_id: edge.fromSymbolId,
+            to_symbol_id: toSymbolId,
+            type: "call",
+            weight: 1.0,
+            provenance: edge.provenance,
+            created_at: new Date().toISOString(),
+        });
+        created.add(edgeKey);
+    }
+}
+function cleanupUnresolvedEdges(repoId) {
+    const allEdges = getEdgesByRepo(repoId);
+    const unresolvedEdges = allEdges.filter((edge) => edge.to_symbol_id.startsWith("unresolved:"));
+    const database = getDb();
+    const deleteEdgeStmt = database.prepare("DELETE FROM edges WHERE from_symbol_id = ? AND to_symbol_id = ?");
+    // IE-K.3: Node.js built-ins to skip
+    const nodeBuiltins = new Set([
+        "assert",
+        "async_hooks",
+        "buffer",
+        "child_process",
+        "cluster",
+        "console",
+        "crypto",
+        "dgram",
+        "dns",
+        "domain",
+        "events",
+        "fs",
+        "http",
+        "http2",
+        "https",
+        "inspector",
+        "module",
+        "net",
+        "os",
+        "path",
+        "perf_hooks",
+        "process",
+        "punycode",
+        "querystring",
+        "readline",
+        "repl",
+        "stream",
+        "string_decoder",
+        "sys",
+        "timers",
+        "tls",
+        "trace_events",
+        "tty",
+        "url",
+        "util",
+        "v8",
+        "vm",
+        "worker_threads",
+        "zlib",
+    ]);
+    // IE-K.3: Check if unresolved edge points to external package
+    const isExternalPackage = (target, edgeType) => {
+        // Import edges: unresolved:package:name (e.g., unresolved:tree-sitter:Parser)
+        if (edgeType === "import") {
+            const parts = target.split(":");
+            if (parts.length >= 3) {
+                const packagePath = parts[1];
+                // Skip if not relative path (i.e., external package)
+                if (!packagePath.startsWith("./") &&
+                    !packagePath.startsWith("../") &&
+                    !packagePath.startsWith("/")) {
+                    return true;
+                }
+            }
+        }
+        // Call edges: unresolved:call:name or unresolved:call:package:name
+        // Check if name matches known patterns (Node.js built-ins or external packages)
+        if (target.startsWith("unresolved:call:")) {
+            const namePart = target.slice("unresolved:call:".length);
+            // Skip if name is a Node.js builtin
+            if (nodeBuiltins.has(namePart)) {
+                return true;
+            }
+            // Skip if name contains package-like pattern (e.g., "tree-sitter:Parser")
+            if (namePart.includes(":") &&
+                !namePart.startsWith("./") &&
+                !namePart.startsWith("../")) {
+                return true;
+            }
+        }
+        return false;
+    };
+    // Cache repo symbols for call edge resolution
+    let repoSymbols = null;
+    const getRepoSymbolsCached = () => {
+        if (!repoSymbols) {
+            repoSymbols = getSymbolsByRepo(repoId);
+        }
+        return repoSymbols;
+    };
+    // Cache symbol-to-file mapping
+    const symbolToFile = new Map();
+    const getSymbolFile = (symbolId) => {
+        if (symbolToFile.has(symbolId)) {
+            return symbolToFile.get(symbolId) ?? null;
+        }
+        const symbol = getSymbol(symbolId);
+        if (!symbol) {
+            symbolToFile.set(symbolId, null);
+            return null;
+        }
+        const file = getFile(symbol.file_id);
+        symbolToFile.set(symbolId, file ?? null);
+        return file ?? null;
+    };
+    for (const edge of unresolvedEdges) {
+        const target = edge.to_symbol_id;
+        // IE-K.3: Skip external package edges (don't try to resolve, don't warn)
+        if (isExternalPackage(target, edge.type)) {
+            continue;
+        }
+        let matchingSymbolId;
+        // Format 1: unresolved:call:functionName - simple call edge
+        const callMatch = target.match(/^unresolved:call:(.+)$/);
+        if (callMatch) {
+            const targetName = callMatch[1];
+            const match = getRepoSymbolsCached().find((sym) => {
+                if (sym.name === targetName)
+                    return true;
+                if (targetName.includes(":")) {
+                    const parts = targetName.split(":");
+                    return parts.some((part) => sym.name === part);
+                }
+                return false;
+            });
+            matchingSymbolId = match?.symbol_id;
+        }
+        // Format 2: unresolved:path/to/file.js:symbolName - import edge with file path
+        // Skip namespace imports (* as X) and star imports (*)
+        if (!callMatch && !target.includes(":*")) {
+            // Parse: unresolved:path:symbolName (last colon separates path from symbol)
+            const lastColon = target.lastIndexOf(":");
+            if (lastColon > 11) {
+                // "unresolved:".length = 11
+                const pathPart = target.slice(11, lastColon);
+                const symbolName = target.slice(lastColon + 1);
+                // Get the source file to resolve relative paths
+                const sourceFile = getSymbolFile(edge.from_symbol_id);
+                if (sourceFile &&
+                    (pathPart.startsWith("./") || pathPart.startsWith("../"))) {
+                    // Resolve relative path from source file's directory
+                    const sourceDir = dirname(sourceFile.rel_path);
+                    const joinedPath = join(sourceDir, pathPart);
+                    const normalizedJoined = normalizePath(joinedPath);
+                    // Try multiple path variants for better matching
+                    const pathVariants = [
+                        // Normalized path with original extension
+                        normalizedJoined,
+                        // .js -> .ts conversion
+                        normalizedJoined.replace(/\.js$/, ".ts"),
+                        // .jsx -> .tsx conversion
+                        normalizedJoined.replace(/\.jsx$/, ".tsx"),
+                        // Try with .ts extension if no extension
+                        !normalizedJoined.match(/\.(js|ts|jsx|tsx)$/)
+                            ? `${normalizedJoined}.ts`
+                            : normalizedJoined,
+                        // Try with .js extension if no extension
+                        !normalizedJoined.match(/\.(js|ts|jsx|tsx)$/)
+                            ? `${normalizedJoined}.js`
+                            : normalizedJoined,
+                        // Try index.ts (with and without trailing slash)
+                        normalizedJoined.replace(/\.(js|ts|jsx|tsx)$/, "") + "/index.ts",
+                        // Try index.js
+                        normalizedJoined.replace(/\.(js|ts|jsx|tsx)$/, "") + "/index.js",
+                        // Try removing any extension and keeping as directory
+                        normalizedJoined.replace(/\.(js|ts|jsx|tsx)$/, ""),
+                    ];
+                    // Remove duplicates from variants
+                    const uniqueVariants = [...new Set(pathVariants)];
+                    for (const variant of uniqueVariants) {
+                        const targetFile = getFileByRepoPath(repoId, variant);
+                        if (targetFile) {
+                            // Find exported symbol by name in that file
+                            const fileSymbols = getSymbolsByFileLite(targetFile.file_id).filter((s) => s.exported === 1);
+                            const match = fileSymbols.find((s) => s.name === symbolName);
+                            if (match) {
+                                matchingSymbolId = match.symbol_id;
+                                break;
+                            }
+                            // Fallback: if single export and looking for default
+                            if (!matchingSymbolId && fileSymbols.length === 1) {
+                                matchingSymbolId = fileSymbols[0].symbol_id;
+                                break;
+                            }
+                        }
+                        // IE-K.2: Try case-insensitive matching on Windows
+                        if (!matchingSymbolId && platform === "win32") {
+                            const allFiles = getFilesByRepo(repoId);
+                            const caseInsensitiveMatch = allFiles.find((f) => f.rel_path.toLowerCase() === variant.toLowerCase());
+                            if (caseInsensitiveMatch) {
+                                const fileSymbols = getSymbolsByFileLite(caseInsensitiveMatch.file_id).filter((s) => s.exported === 1);
+                                const match = fileSymbols.find((s) => s.name === symbolName);
+                                if (match) {
+                                    matchingSymbolId = match.symbol_id;
+                                    break;
+                                }
+                                // Fallback: if single export and looking for default
+                                if (!matchingSymbolId && fileSymbols.length === 1) {
+                                    matchingSymbolId = fileSymbols[0].symbol_id;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (!pathPart.startsWith("./") && !pathPart.startsWith("../")) {
+                    // Non-relative import (node_modules, etc.) - skip
+                    continue;
+                }
+            }
+        }
+        if (matchingSymbolId) {
+            deleteEdgeStmt.run(edge.from_symbol_id, edge.to_symbol_id);
+            createEdgeTransaction({
+                repo_id: edge.repo_id,
+                from_symbol_id: edge.from_symbol_id,
+                to_symbol_id: matchingSymbolId,
+                type: edge.type,
+                weight: edge.type === "import" ? 0.6 : 1.0,
+                provenance: edge.provenance,
+                created_at: new Date().toISOString(),
+            });
+        }
+    }
+}
+function findEnclosingSymbolByRange(range, symbols) {
+    let bestMatch = null;
+    for (const detail of symbols) {
+        const symRange = detail.extractedSymbol.range;
+        const nodeLine = range.startLine;
+        const nodeCol = range.startCol;
+        if (nodeLine < symRange.startLine || nodeLine > symRange.endLine) {
+            continue;
+        }
+        if (nodeLine === symRange.startLine && nodeCol < symRange.startCol) {
+            continue;
+        }
+        if (nodeLine === symRange.endLine && nodeCol > symRange.endCol) {
+            continue;
+        }
+        const size = symRange.endLine -
+            symRange.startLine +
+            (symRange.endCol - symRange.startCol);
+        if (!bestMatch || size < bestMatch.size) {
+            bestMatch = { nodeId: detail.extractedSymbol.nodeId, size };
+        }
+    }
+    return bestMatch?.nodeId ?? null;
+}
+export async function indexRepo(repoId, mode, onProgress) {
+    const startTime = Date.now();
+    const repoRow = getRepo(repoId);
+    if (!repoRow) {
+        throw new Error(`Repository ${repoId} not found`);
+    }
+    const config = JSON.parse(repoRow.config_json);
+    onProgress?.({ stage: "scanning", current: 0, total: 0 });
+    const files = await scanRepository(repoRow.root_path, config);
+    onProgress?.({ stage: "parsing", current: 0, total: files.length });
+    const appConfig = loadConfig();
+    const concurrency = Math.max(1, Math.min(appConfig.indexing?.concurrency ?? 4, files.length || 1));
+    const workerPool = new ParserWorkerPool(appConfig.indexing?.workerPoolSize ?? os.cpus().length - 1);
+    const existingFiles = getFilesByRepo(repoId);
+    const existingByPath = new Map(existingFiles.map((file) => [file.rel_path, file]));
+    const scannedPaths = new Set(files.map((file) => file.path));
+    let removedFiles = 0;
+    for (const file of existingFiles) {
+        if (!scannedPaths.has(file.rel_path)) {
+            deleteFileTransaction(file.file_id);
+            removedFiles++;
+        }
+    }
+    const symbolIndex = new Map();
+    const pendingCallEdges = [];
+    const createdCallEdges = new Set();
+    const tsResolver = createTsCallResolver(repoRow.root_path, files);
+    const allSymbolsByName = new Map();
+    const repoSymbols = getSymbolsByRepo(repoId);
+    for (const symbol of repoSymbols) {
+        const byName = allSymbolsByName.get(symbol.name) ?? [];
+        byName.push(symbol);
+        allSymbolsByName.set(symbol.name, byName);
+    }
+    let filesProcessed = 0;
+    let changedFiles = 0;
+    let totalSymbolsIndexed = 0;
+    let totalEdgesCreated = 0;
+    let configEdgesCreated = 0;
+    const allConfigEdges = [];
+    const changedFileIds = new Set();
+    let nextIndex = 0;
+    const updateProgress = (currentFile) => {
+        onProgress?.({
+            stage: "indexing",
+            current: Math.min(filesProcessed, files.length),
+            total: files.length,
+            currentFile,
+        });
+    };
+    const runWorker = async () => {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const index = nextIndex++;
+            if (index >= files.length) {
+                return;
+            }
+            const file = files[index];
+            updateProgress(file.path);
+            try {
+                const result = await processFile({
+                    repoId,
+                    repoRoot: repoRow.root_path,
+                    fileMeta: file,
+                    languages: config.languages,
+                    mode,
+                    existingFile: existingByPath.get(file.path),
+                    symbolIndex,
+                    pendingCallEdges,
+                    createdCallEdges,
+                    tsResolver,
+                    config,
+                    allSymbolsByName,
+                    onProgress,
+                    workerPool,
+                });
+                filesProcessed++;
+                if (result.changed) {
+                    changedFiles++;
+                    const fileRecord = getFileByRepoPath(repoId, file.path);
+                    if (fileRecord) {
+                        changedFileIds.add(fileRecord.file_id);
+                    }
+                }
+                totalSymbolsIndexed += result.symbolsIndexed;
+                totalEdgesCreated += result.edgesCreated;
+                allConfigEdges.push(...result.configEdges);
+            }
+            catch (error) {
+                filesProcessed++;
+                console.error(`Error processing file ${file.path}:`, error);
+            }
+        }
+    };
+    const workers = Array.from({ length: Math.min(concurrency, files.length || 1) }, () => runWorker());
+    await Promise.all(workers);
+    onProgress?.({
+        stage: "finalizing",
+        current: files.length,
+        total: files.length,
+    });
+    changedFiles += removedFiles;
+    resolvePendingCallEdges(pendingCallEdges, symbolIndex, createdCallEdges, repoId);
+    cleanupUnresolvedEdges(repoId);
+    const configWeight = appConfig.slice?.edgeWeights?.config !== undefined
+        ? appConfig.slice.edgeWeights.config
+        : 0.8;
+    for (const edge of allConfigEdges) {
+        createEdgeTransaction({
+            repo_id: repoId,
+            from_symbol_id: edge.fromSymbolId,
+            to_symbol_id: edge.toSymbolId,
+            type: "config",
+            weight: edge.weight ?? configWeight,
+            provenance: edge.provenance ?? "config",
+            created_at: new Date().toISOString(),
+        });
+        configEdgesCreated++;
+    }
+    const versionId = `v${Date.now()}`;
+    const version = {
+        version_id: versionId,
+        repo_id: repoId,
+        created_at: new Date().toISOString(),
+        reason: mode === "full" ? "Full index" : "Incremental index",
+        prev_version_hash: null,
+        version_hash: null,
+    };
+    const symbols = getSymbolsByRepoForSnapshot(repoId);
+    const snapshots = symbols.map((symbol) => ({
+        version_id: versionId,
+        symbol_id: symbol.symbol_id,
+        ast_fingerprint: symbol.ast_fingerprint,
+        signature_json: symbol.signature_json,
+        summary: symbol.summary,
+        invariants_json: symbol.invariants_json,
+        side_effects_json: symbol.side_effects_json,
+    }));
+    createSnapshotTransaction(version, snapshots);
+    const durationMs = Date.now() - startTime;
+    const changedFileIdsParam = mode === "incremental" && changedFileIds.size > 0
+        ? changedFileIds
+        : undefined;
+    await updateMetricsForRepo(repoId, changedFileIdsParam);
+    // Shutdown worker pool to release resources
+    await workerPool.shutdown();
+    return {
+        versionId,
+        filesProcessed,
+        changedFiles,
+        removedFiles,
+        symbolsIndexed: totalSymbolsIndexed,
+        edgesCreated: totalEdgesCreated + configEdgesCreated,
+        durationMs,
+    };
+}
+function loadChokidar() {
+    try {
+        return require("chokidar");
+    }
+    catch {
+        return null;
+    }
+}
+const watcherErrors = [];
+export function watchRepository(repoId) {
+    const repoRow = getRepo(repoId);
+    if (!repoRow) {
+        throw new Error(`Repository ${repoId} not found`);
+    }
+    const config = JSON.parse(repoRow.config_json);
+    const extensions = config.languages.map((lang) => `.${lang}`);
+    const reindex = async (filePath) => {
+        try {
+            process.stderr.write(`[sdl-mcp] File change detected: ${filePath}\n`);
+            await indexRepo(repoId, "incremental");
+        }
+        catch (error) {
+            process.stderr.write(`[sdl-mcp] Failed incremental index for ${filePath}: ${error}\n`);
+        }
+    };
+    const pending = new Map();
+    const schedule = (filePath) => {
+        const existing = pending.get(filePath);
+        if (existing) {
+            clearTimeout(existing);
+        }
+        pending.set(filePath, setTimeout(() => {
+            pending.delete(filePath);
+            void reindex(filePath);
+        }, WATCH_DEBOUNCE_MS));
+    };
+    const chokidar = loadChokidar();
+    if (chokidar) {
+        const watcher = chokidar.watch(repoRow.root_path, {
+            ignored: config.ignore,
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: WATCH_STABILITY_THRESHOLD_MS,
+                pollInterval: WATCH_POLL_INTERVAL_MS,
+            },
+        });
+        watcher.on("error", (error) => {
+            const errorMsg = `[sdl-mcp] File watcher error: ${error}`;
+            process.stderr.write(`${errorMsg}
+`);
+            watcherErrors.push(`${new Date().toISOString()} - ${errorMsg}`);
+            if (watcherErrors.length > WATCHER_ERROR_MAX_COUNT) {
+                watcherErrors.shift();
+            }
+        });
+        const handler = (filePath) => {
+            const relPath = normalizePath(relative(repoRow.root_path, filePath));
+            if (shouldIgnorePath(relPath, config.ignore)) {
+                return;
+            }
+            if (!matchesExtensions(relPath, extensions)) {
+                return;
+            }
+            schedule(relPath);
+        };
+        watcher.on("add", handler);
+        watcher.on("change", handler);
+        watcher.on("unlink", handler);
+        return {
+            close: async () => {
+                await watcher.close();
+            },
+        };
+    }
+    const watcher = watch(repoRow.root_path, { recursive: true }, (_eventType, filename) => {
+        if (!filename)
+            return;
+        const relPath = normalizePath(filename.toString());
+        if (shouldIgnorePath(relPath, config.ignore)) {
+            return;
+        }
+        if (!matchesExtensions(relPath, extensions)) {
+            return;
+        }
+        schedule(relPath);
+    });
+    return {
+        close: async () => {
+            watcher.close();
+        },
+    };
+}
+function matchesExtensions(path, extensions) {
+    return extensions.some((ext) => path.endsWith(ext));
+}
+function shouldIgnorePath(path, ignorePatterns) {
+    const normalized = normalizePath(path);
+    for (const pattern of ignorePatterns) {
+        const token = pattern
+            .replace(/\*\*\//g, "")
+            .replace(/\/\*\*/g, "")
+            .replace(/\*/g, "")
+            .replace(/\/+/g, "/")
+            .trim();
+        if (!token)
+            continue;
+        if (normalized.includes(token)) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=indexer.js.map