@zuvia-software-solutions/code-mapper 2.6.0 → 2.6.2

package/dist/cli/analyze.js

@@ -273,59 +273,73 @@ export const analyzeCommand = async (inputPath, options) => {
     recordPhase('refs');
     updateBar(85, 'Building refs index...');
     {
-        const { clearRefs, insertRefsBatch, clearFileWords, upsertFileWords } = await import('../core/db/adapter.js');
-        const fsRef = await import('fs/promises');
+        const { clearRefs, clearFileWords, upsertFileWords } = await import('../core/db/adapter.js');
+        const fsSync = await import('fs');
         clearRefs(db);
         clearFileWords(db);
-        // Scan all source files for identifier occurrences
         const STOP_WORDS = new Set(['the', 'and', 'for', 'from', 'with', 'this', 'that', 'have', 'has', 'not', 'are', 'was', 'were', 'been', 'being', 'will', 'would', 'could', 'should', 'may', 'might', 'can', 'does', 'did', 'let', 'var', 'const', 'new', 'return', 'function', 'class', 'import', 'export', 'default', 'void', 'null', 'undefined', 'true', 'false', 'else', 'case', 'break', 'continue', 'while', 'throw', 'catch', 'try', 'finally', 'async', 'await', 'yield', 'typeof', 'instanceof', 'delete', 'switch', 'interface', 'type', 'enum', 'extends', 'implements', 'static', 'private', 'public', 'protected', 'abstract', 'readonly', 'override', 'declare', 'module', 'namespace', 'require', 'string', 'number', 'boolean', 'object', 'any', 'never', 'unknown', 'symbol']);
         const SRC_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.py', '.go', '.rs', '.java', '.c', '.h', '.cpp', '.hpp', '.cs', '.rb', '.php', '.kt', '.swift', '.mts', '.mjs', '.cts', '.cjs']);
         const identRegex = /\b[a-zA-Z_]\w{2,}\b/g;
         const wordRegex = /\b[a-zA-Z]\w{2,}\b/g;
-        // Get all file paths from the nodes table
         const fileRows = db.prepare("SELECT DISTINCT filePath FROM nodes WHERE label = 'File'").all();
-        let refsBuilt = 0;
-        for (const { filePath } of fileRows) {
-            const ext = path.extname(filePath).toLowerCase();
-            if (!SRC_EXTENSIONS.has(ext))
-                continue;
-            let content;
-            try {
-                content = await fsRef.readFile(path.resolve(repoPath, filePath), 'utf-8');
-            }
-            catch {
-                continue;
-            }
-            // Build refs (identifier occurrences — skip language keywords)
-            const refs = [];
-            const lines = content.split('\n');
-            for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
-                let match;
+        // Single transaction for all refs + file_words — avoids per-file transaction overhead
+        const refsStmt = db.prepare('INSERT INTO refs (symbol, filePath, line) VALUES (?, ?, ?)');
+        const tx = db.transaction(() => {
+            let refsBuilt = 0;
+            for (const { filePath } of fileRows) {
+                const ext = path.extname(filePath).toLowerCase();
+                if (!SRC_EXTENSIONS.has(ext))
+                    continue;
+                let content;
+                try {
+                    content = fsSync.readFileSync(path.resolve(repoPath, filePath), 'utf-8');
+                }
+                catch {
+                    continue;
+                }
+                // Pre-build line offset table for O(1) line lookups
+                const lineOffsets = [0];
+                for (let i = 0; i < content.length; i++) {
+                    if (content.charCodeAt(i) === 10)
+                        lineOffsets.push(i + 1);
+                }
+                const getLine = (offset) => {
+                    let lo = 0, hi = lineOffsets.length - 1;
+                    while (lo < hi) {
+                        const mid = (lo + hi + 1) >> 1;
+                        if (lineOffsets[mid] <= offset)
+                            lo = mid;
+                        else
+                            hi = mid - 1;
+                    }
+                    return lo;
+                };
+                // Refs: regex over whole content with binary-search line lookup
                 identRegex.lastIndex = 0;
-                while ((match = identRegex.exec(lines[lineIdx])) !== null) {
+                let match;
+                while ((match = identRegex.exec(content)) !== null) {
                     if (!STOP_WORDS.has(match[0].toLowerCase())) {
-                        refs.push({ symbol: match[0], filePath, line: lineIdx });
+                        refsStmt.run(match[0], filePath, getLine(match.index));
                     }
                 }
+                // File words for conceptual search
+                const wordSet = new Set();
+                wordRegex.lastIndex = 0;
+                let wMatch;
+                while ((wMatch = wordRegex.exec(content)) !== null) {
+                    const w = wMatch[0].toLowerCase();
+                    if (!STOP_WORDS.has(w))
+                        wordSet.add(w);
+                }
+                if (wordSet.size > 0)
+                    upsertFileWords(db, filePath, [...wordSet].join(' '));
+                refsBuilt++;
+                if (refsBuilt % 500 === 0) {
+                    updateBar(85, `Building refs index... (${refsBuilt}/${fileRows.length})`);
+                }
             }
-            if (refs.length > 0)
-                insertRefsBatch(db, refs);
-            // Build file_words (conceptual search)
-            const wordSet = new Set();
-            let wMatch;
-            wordRegex.lastIndex = 0;
-            while ((wMatch = wordRegex.exec(content)) !== null) {
-                const w = wMatch[0].toLowerCase();
-                if (!STOP_WORDS.has(w))
-                    wordSet.add(w);
-            }
-            if (wordSet.size > 0)
-                upsertFileWords(db, filePath, [...wordSet].join(' '));
-            refsBuilt++;
-            if (refsBuilt % 500 === 0) {
-                updateBar(85, `Building refs index... (${refsBuilt}/${fileRows.length})`);
-            }
-        }
+        });
+        tx();
     }
     // Phase 3: FTS (85-90%)
     // FTS5 is auto-created by schema triggers — no manual index creation needed

package/dist/core/ingestion/call-processor.js

@@ -766,6 +766,42 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
         }
         list.push(call);
     }
+    // Pre-build indexes for O(1) lookups in the hot loop.
+    // Without these, interface dispatch does graph.relationships.filter() per call = O(calls × edges).
+    const implementsIndex = new Map(); // interfaceNodeId → [classNodeId, ...]
+    const hasMethodIndex = new Map(); // classNodeId → methods
+    const reverseImportIndex = new Map(); // importedFile → [importingFile, ...]
+    for (const rel of graph.iterRelationships()) {
+        if (rel.type === 'IMPLEMENTS') {
+            let arr = implementsIndex.get(rel.targetId);
+            if (!arr) {
+                arr = [];
+                implementsIndex.set(rel.targetId, arr);
+            }
+            arr.push(rel.sourceId);
+        }
+        else if (rel.type === 'HAS_METHOD') {
+            const methodNode = graph.getNode(rel.targetId);
+            if (methodNode) {
+                let arr = hasMethodIndex.get(rel.sourceId);
+                if (!arr) {
+                    arr = [];
+                    hasMethodIndex.set(rel.sourceId, arr);
+                }
+                arr.push({ targetId: rel.targetId, name: methodNode.properties.name });
+            }
+        }
+    }
+    for (const [file, importedFiles] of ctx.importMap) {
+        for (const imported of importedFiles) {
+            let arr = reverseImportIndex.get(imported);
+            if (!arr) {
+                arr = [];
+                reverseImportIndex.set(imported, arr);
+            }
+            arr.push(file);
+        }
+    }
     const totalFiles = byFile.size;
     let filesProcessed = 0;
     for (const [filePath, calls] of byFile) {
@@ -825,38 +861,29 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
                     const interfaceDefs = receiverResolved.candidates.filter(d => d.type === 'Interface' || d.type === 'Trait');
                     if (interfaceDefs.length > 0) {
                         for (const ifaceDef of interfaceDefs) {
-                            // Strategy 1: Class-based — find IMPLEMENTS edges
-                            const implRows = graph.relationships.filter(r => r.type === 'IMPLEMENTS' && r.targetId === toNodeId(ifaceDef.nodeId));
-                            for (const implRel of implRows) {
-                                const methodEdges = graph.relationships.filter(r => r.type === 'HAS_METHOD' && r.sourceId === implRel.sourceId);
-                                for (const methodEdge of methodEdges) {
-                                    const methodNode = graph.getNode(methodEdge.targetId);
-                                    if (methodNode && methodNode.properties.name === effectiveCall.calledName) {
-                                        resolved = { nodeId: methodEdge.targetId, confidence: 0.85, reason: 'interface-dispatch' };
-                                        break;
+                            // Strategy 1: Class-based — find IMPLEMENTS edges via pre-built index
+                            const implClassIds = implementsIndex.get(toNodeId(ifaceDef.nodeId));
+                            if (implClassIds) {
+                                for (const classId of implClassIds) {
+                                    const methods = hasMethodIndex.get(classId);
+                                    if (methods) {
+                                        const match = methods.find(m => m.name === effectiveCall.calledName);
+                                        if (match) {
+                                            resolved = { nodeId: match.targetId, confidence: 0.85, reason: 'interface-dispatch' };
+                                            break;
+                                        }
                                     }
                                 }
-                                if (resolved)
-                                    break;
                             }
                             if (resolved)
                                 break;
                             // Strategy 2: Factory/closure pattern — find functions returning this interface
-                            // e.g. createEventBus(): EventBus → the closure has emit/subscribe as inner functions
-                            // Look for the method name in files that import the interface's file
                             if (!resolved) {
                                 const methodName = effectiveCall.calledName;
                                 const ifaceFile = ifaceDef.filePath;
-                                // Check: which files import the interface's file?
-                                const importingFiles = [];
-                                for (const [file, importedFiles] of ctx.importMap) {
-                                    if (importedFiles.has(ifaceFile)) {
-                                        importingFiles.push(file);
-                                    }
-                                }
+                                const importingFiles = reverseImportIndex.get(ifaceFile) ?? [];
                                 // Also check the interface's own file
-                                importingFiles.push(ifaceFile);
-                                for (const file of importingFiles) {
+                                for (const file of [...importingFiles, ifaceFile]) {
                                     const method = ctx.symbols.lookupExactFull(file, methodName);
                                     if (method && (method.type === 'Function' || method.type === 'Method')) {
                                         resolved = { nodeId: method.nodeId, confidence: 0.75, reason: 'interface-factory-dispatch' };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zuvia-software-solutions/code-mapper",
-  "version": "2.6.0",
+  "version": "2.6.2",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",