@zuvia-software-solutions/code-mapper 2.0.0 → 2.0.2

package/dist/core/incremental/refresh.js

@@ -259,52 +259,91 @@ export async function refreshFiles(db, repoPath, dirtyFiles) {
     catch (err) {
         console.error(`Code Mapper: refresh tsgo failed: ${err instanceof Error ? err.message : err}`);
     }
-    if (tsgoReady) {
-        // Build the set of dirty file relative paths for Phase 5 filtering
-        const dirtyFilePaths = new Set(dirtyFiles.map(f => f.relativePath));
-        // Wrap Phase 4 + 5 in a transaction for performance
+    // Phase 4: Resolve call edges from dirty files
+    // Always runs — tsgo provides 0.99 confidence, heuristic fallback provides 0.5-0.95
+    if (callSites.length > 0) {
         db.exec('BEGIN');
         try {
-            // Notify tsgo about changed files so it has fresh state
-            for (const entry of filesToProcess) {
-                const absPath = path.resolve(repoPath, entry.relativePath);
-                if (isTypeScriptOrJavaScript(entry.relativePath)) {
-                    await tsgoService.notifyFileChanged(absPath);
+            const { findNodesByName } = await import('../db/adapter.js');
+            // Notify tsgo about changed files if available
+            if (tsgoReady) {
+                for (const entry of filesToProcess) {
+                    const absPath = path.resolve(repoPath, entry.relativePath);
+                    if (isTypeScriptOrJavaScript(entry.relativePath)) {
+                        await tsgoService.notifyFileChanged(absPath);
+                    }
                 }
             }
-            // Phase 4: Resolve call edges from dirty files
             console.error(`Code Mapper: refresh Phase 4 — ${callSites.length} call sites to resolve`);
-            if (callSites.length > 0) {
-                for (const callSite of callSites) {
-                    if (!isTypeScriptOrJavaScript(callSite.filePath))
-                        continue;
-                    const def = await tsgoService.resolveDefinition(callSite.absPath, callSite.line, callSite.character);
-                    if (!def)
-                        continue;
-                    // Find the source node (enclosing function of the call site)
-                    const sourceNode = findEnclosingNode(db, callSite.filePath, callSite.line);
-                    if (!sourceNode)
-                        continue;
-                    // Find the target node (the definition the call resolves to)
-                    const targetNode = findNodeByFileAndLine(db, def.filePath, def.line);
-                    if (!targetNode)
-                        continue;
-                    // Skip self-edges
-                    if (sourceNode.id === targetNode.id)
-                        continue;
-                    const edgeId = toEdgeId(`${sourceNode.id}_CALLS_${targetNode.id}`);
-                    insertEdge(db, {
-                        id: edgeId,
-                        sourceId: sourceNode.id,
-                        targetId: targetNode.id,
-                        type: 'CALLS',
-                        confidence: 0.99,
-                        reason: 'tsgo-lsp',
-                        callLine: callSite.line,
-                    });
-                    edgesInserted++;
+            for (const callSite of callSites) {
+                const sourceNode = findEnclosingNode(db, callSite.filePath, callSite.line);
+                if (!sourceNode)
+                    continue;
+                let targetNode;
+                let confidence = 0.5;
+                let reason = 'global';
+                // Try tsgo first for TS/JS files
+                if (tsgoReady && isTypeScriptOrJavaScript(callSite.filePath)) {
+                    try {
+                        const def = await tsgoService.resolveDefinition(callSite.absPath, callSite.line, callSite.character);
+                        if (def) {
+                            targetNode = findNodeByFileAndLine(db, def.filePath, def.line);
+                            if (targetNode) {
+                                confidence = 0.99;
+                                reason = 'tsgo-lsp';
+                            }
+                        }
+                    }
+                    catch { }
                 }
+                // Heuristic fallback: name-based lookup in DB
+                if (!targetNode) {
+                    const candidates = findNodesByName(db, callSite.name, undefined, 5);
+                    const sameFile = candidates.find(c => c.filePath === callSite.filePath);
+                    if (sameFile) {
+                        targetNode = sameFile;
+                        confidence = 0.95;
+                        reason = 'same-file';
+                    }
+                    else if (candidates.length === 1) {
+                        targetNode = candidates[0];
+                        confidence = 0.9;
+                        reason = 'import-resolved';
+                    }
+                    else if (candidates.length > 0) {
+                        targetNode = candidates[0];
+                        confidence = 0.5;
+                        reason = 'global';
+                    }
+                }
+                if (!targetNode)
+                    continue;
+                if (sourceNode.id === targetNode.id)
+                    continue;
+                const edgeId = toEdgeId(`${sourceNode.id}_CALLS_${targetNode.id}`);
+                insertEdge(db, {
+                    id: edgeId,
+                    sourceId: sourceNode.id,
+                    targetId: targetNode.id,
+                    type: 'CALLS',
+                    confidence,
+                    reason,
+                    callLine: callSite.line,
+                });
+                edgesInserted++;
             }
+            db.exec('COMMIT');
+        }
+        catch (err) {
+            db.exec('ROLLBACK');
+            console.error(`Code Mapper: Phase 4 call resolution failed: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    // Phase 5: Repair cross-file edges (tsgo only — needs findReferences)
+    if (tsgoReady) {
+        const dirtyFilePaths = new Set(dirtyFiles.map(f => f.relativePath));
+        db.exec('BEGIN');
+        try {
             // Phase 5: Repair cross-file edges
             // For each newly inserted definition, find references from UNCHANGED files
             // and create CALLS edges so the graph stays consistent.

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

@@ -59,11 +59,16 @@ const processParsingWithWorkers = async (graph, files, symbolTable, _astCache, w
                 ...(sym.parameterTypes !== undefined ? { parameterTypes: sym.parameterTypes } : {}),
             });
         }
-        allImports.push(...result.imports);
-        allCalls.push(...result.calls);
-        allHeritage.push(...result.heritage);
-        allRoutes.push(...result.routes);
-        allConstructorBindings.push(...result.constructorBindings);
+        for (const item of result.imports)
+            allImports.push(item);
+        for (const item of result.calls)
+            allCalls.push(item);
+        for (const item of result.heritage)
+            allHeritage.push(item);
+        for (const item of result.routes)
+            allRoutes.push(item);
+        for (const item of result.constructorBindings)
+            allConstructorBindings.push(item);
     }
     // Merge and log skipped languages
     const skippedLanguages = new Map();

package/dist/core/ingestion/pipeline.js

@@ -201,9 +201,12 @@ export const runPipelineFromRepo = async (repoPath, onProgress, opts) => {
                         });
                     }, repoPath, importCtx);
                     // COLLECT calls for deferred resolution (don't resolve yet — callee may be in later chunk)
-                    allExtractedCalls.push(...chunkWorkerData.calls);
+                    // Use loop instead of spread to avoid stack overflow on large codebases (100K+ calls)
+                    for (const call of chunkWorkerData.calls)
+                        allExtractedCalls.push(call);
                     if (chunkWorkerData.constructorBindings) {
-                        allConstructorBindings.push(...chunkWorkerData.constructorBindings);
+                        for (const cb of chunkWorkerData.constructorBindings)
+                            allConstructorBindings.push(cb);
                     }
                     // Heritage + Routes can resolve per-chunk (class-level, usually same-file)
                     await Promise.all([

package/dist/core/ingestion/workers/parse-worker.js

@@ -1072,15 +1072,24 @@ let accumulated = {
     imports: [], calls: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0,
 };
 let cumulativeProcessed = 0;
+/** Append src arrays into target without spread (avoids stack overflow on large codebases) */
 const mergeResult = (target, src) => {
-    target.nodes.push(...src.nodes);
-    target.relationships.push(...src.relationships);
-    target.symbols.push(...src.symbols);
-    target.imports.push(...src.imports);
-    target.calls.push(...src.calls);
-    target.heritage.push(...src.heritage);
-    target.routes.push(...src.routes);
-    target.constructorBindings.push(...src.constructorBindings);
+    for (const item of src.nodes)
+        target.nodes.push(item);
+    for (const item of src.relationships)
+        target.relationships.push(item);
+    for (const item of src.symbols)
+        target.symbols.push(item);
+    for (const item of src.imports)
+        target.imports.push(item);
+    for (const item of src.calls)
+        target.calls.push(item);
+    for (const item of src.heritage)
+        target.heritage.push(item);
+    for (const item of src.routes)
+        target.routes.push(item);
+    for (const item of src.constructorBindings)
+        target.constructorBindings.push(item);
     for (const [lang, count] of Object.entries(src.skippedLanguages)) {
         target.skippedLanguages[lang] = (target.skippedLanguages[lang] || 0) + count;
     }

package/dist/core/semantic/tsgo-service.d.ts

@@ -39,6 +39,8 @@ export declare class TsgoService {
      * @typescript/native-preview is not installed or tsgo fails to start.
      */
     start(): Promise<boolean>;
+    /** Get the resolved project root (where tsconfig.json was found) */
+    getProjectRoot(): string;
     /** Whether the server is running and ready for queries */
     isReady(): boolean;
     /** Resolve what a symbol at a given position points to (go-to-definition) */

package/dist/core/semantic/tsgo-service.js

@@ -59,6 +59,10 @@ export class TsgoService {
         this.initPromise = this.doStart();
         return this.initPromise;
     }
+    /** Get the resolved project root (where tsconfig.json was found) */
+    getProjectRoot() {
+        return this.projectRoot;
+    }
     /** Whether the server is running and ready for queries */
     isReady() {
         return this.ready;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zuvia-software-solutions/code-mapper",
-  "version": "2.0.0",
+  "version": "2.0.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",