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

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.1",
   "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",