@zuvia-software-solutions/code-mapper 2.3.3 → 2.3.5

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

@@ -739,7 +739,7 @@ function isTypeScriptOrJavaScript(filePath) {
  *
  * Call key format: "sourceId\0calledName\0callLine" — unique per call site.
  */
-async function batchResolveTsgo(tsgoService, extractedCalls, ctx, graph, repoPath) {
+async function batchResolveTsgo(tsgoService, extractedCalls, ctx, graph, repoPath, onProgress) {
     const results = new Map();
     // Collect eligible calls (TS/JS files with line+column info)
     const eligible = [];
@@ -764,13 +764,46 @@ async function batchResolveTsgo(tsgoService, extractedCalls, ctx, graph, repoPat
         }
         list.push(call);
     }
+    // Pre-filter: skip free-form calls ONLY when the function name is unambiguous
+    // in the symbol table. Heuristic resolves unique names perfectly.
+    // Ambiguous names (multiple symbols with same name) need tsgo for disambiguation.
+    const tsgoEligible = [];
+    let skippedHeuristic = 0;
+    for (const call of eligible) {
+        if (call.callForm === 'free' || call.callForm === undefined) {
+            const resolved = ctx.resolve(call.calledName, call.filePath);
+            // Unique match — heuristic handles this at high confidence
+            if (resolved && resolved.candidates.length === 1) {
+                skippedHeuristic++;
+                continue;
+            }
+        }
+        tsgoEligible.push(call);
+    }
+    // Regroup filtered calls by file
+    const tsgoByFile = new Map();
+    for (const call of tsgoEligible) {
+        let list = tsgoByFile.get(call.filePath);
+        if (!list) {
+            list = [];
+            tsgoByFile.set(call.filePath, list);
+        }
+        list.push(call);
+    }
     let resolved = 0;
     let failed = 0;
     const t0 = Date.now();
-    console.error(`Code Mapper: tsgo resolving ${eligible.length} calls across ${byFile.size} files...`);
-    for (const [filePath, calls] of byFile) {
+    console.error(`Code Mapper: tsgo resolving ${tsgoEligible.length} calls across ${tsgoByFile.size} files (skipped ${skippedHeuristic} heuristic-resolvable)...`);
+    let tsgoFilesProcessed = 0;
+    const tsgoTotalFiles = tsgoByFile.size;
+    for (const [filePath, calls] of tsgoByFile) {
+        tsgoFilesProcessed++;
+        if (tsgoFilesProcessed % 25 === 0) {
+            onProgress?.(tsgoFilesProcessed, tsgoTotalFiles);
+            await yieldToEventLoop();
+        }
         const absFilePath = path.resolve(repoPath, filePath);
-        // Resolve all calls in this file sequentially
+        // Sequential LSP requests — tsgo processes over stdio, concurrent floods cause hangs
         for (const call of calls) {
             try {
                 const def = await tsgoService.resolveDefinition(absFilePath, call.callLine - 1, call.callColumn);
@@ -806,10 +839,7 @@ async function batchResolveTsgo(tsgoService, extractedCalls, ctx, graph, repoPat
                     }
                 }
                 if (bestMatch) {
-                    // Drop self-referencing tsgo edges: these come from property access
-                    // on parameters (req.params, res.json) that tsgo resolves back to
-                    // the enclosing function's definition. Legitimate recursion is captured
-                    // by the heuristic path (free-form calls to the function's own name).
+                    // Drop self-referencing tsgo edges
                     if (bestMatch.nodeId === call.sourceId) {
                         failed++;
                         continue;
@@ -871,13 +901,13 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
     // Batch pre-resolve via tsgo LSP (highest confidence, TS/JS only)
     let tsgoResolved;
     if (tsgoService?.isReady() && repoPath) {
-        tsgoResolved = await batchResolveTsgo(tsgoService, extractedCalls, ctx, graph, repoPath);
+        tsgoResolved = await batchResolveTsgo(tsgoService, extractedCalls, ctx, graph, repoPath, onProgress);
     }
     const totalFiles = byFile.size;
     let filesProcessed = 0;
     for (const [filePath, calls] of byFile) {
         filesProcessed++;
-        if (filesProcessed % 100 === 0) {
+        if (filesProcessed % 25 === 0) {
             onProgress?.(filesProcessed, totalFiles);
             await yieldToEventLoop();
         }

package/dist/core/ingestion/pipeline.js

@@ -103,7 +103,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, opts) => {
         if (totalParseable === 0) {
             onProgress({
                 phase: 'parsing',
-                percent: 82,
+                percent: 70,
                 message: 'No parseable files found — skipping parsing phase',
                 stats: { filesProcessed: 0, totalFiles: 0, nodesCreated: graph.nodeCount },
             });
@@ -186,7 +186,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, opts) => {
                 const parseStart = Date.now();
                 const chunkWorkerData = await processParsing(graph, chunkFiles, symbolTable, astCache, (current, _total, filePath) => {
                     const globalCurrent = filesParsedSoFar + current;
-                    const parsingProgress = 20 + ((globalCurrent / totalParseable) * 62);
+                    const parsingProgress = 20 + ((globalCurrent / totalParseable) * 50);
                     onProgress({
                         phase: 'parsing',
                         percent: Math.round(parsingProgress),
@@ -197,7 +197,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, opts) => {
                 }, workerPool);
                 const parseMs = Date.now() - parseStart;
                 verbose(`[parse] chunk ${chunkIdx + 1}/${numChunks}: parsed ${parseMs}ms (${memoryGuard.summary()})`);
-                const chunkBasePercent = 20 + ((filesParsedSoFar / totalParseable) * 62);
+                const chunkBasePercent = 20 + ((filesParsedSoFar / totalParseable) * 50);
                 if (chunkWorkerData) {
                     // Resolve imports per-chunk (file-level, doesn't need full symbol table)
                     await processImportsFromExtracted(graph, allPathObjects, chunkWorkerData.imports, ctx, (current, total) => {
@@ -274,10 +274,11 @@ export const runPipelineFromRepo = async (repoPath, onProgress, opts) => {
         }
         let tsgoWasUsed = false;
         // Phase B: Resolve ALL deferred calls now that every symbol is registered
+        // Progress range: 70-82% (advancing, not fixed)
         if (allExtractedCalls.length > 0) {
             onProgress({
-                phase: 'parsing',
-                percent: 82,
+                phase: 'calls',
+                percent: 70,
                 message: `Resolving ${allExtractedCalls.length} calls across all files...`,
                 stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
             });
@@ -297,9 +298,10 @@ export const runPipelineFromRepo = async (repoPath, onProgress, opts) => {
             }
             try {
                 await processCallsFromExtracted(graph, allExtractedCalls, ctx, (current, total) => {
+                    const callPercent = 70 + Math.round((current / Math.max(total, 1)) * 12);
                     onProgress({
-                        phase: 'parsing',
-                        percent: 82,
+                        phase: 'calls',
+                        percent: callPercent,
                         message: `Resolving calls: ${current}/${total} files...`,
                         stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
                     });
@@ -337,7 +339,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, opts) => {
         // Phase 4.5b: Method Resolution Order
         onProgress({
             phase: 'parsing',
-            percent: 81,
+            percent: 82,
             message: 'Computing method resolution order...',
             stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
         });

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

@@ -46,7 +46,8 @@ export const createWorkerPool = (workerUrl, poolSize) => {
     if (!fs.existsSync(workerPath)) {
         throw new Error(`Worker script not found: ${workerPath}`);
     }
-    const size = poolSize ?? Math.min(8, Math.max(1, os.cpus().length - 1));
+    // Use 75% of cores — leaves headroom for main thread, OS, and other processes
+    const size = poolSize ?? Math.max(1, Math.floor(os.cpus().length * 0.75));
     const workers = [];
     for (let i = 0; i < size; i++) {
         workers.push(new Worker(workerUrl));

package/package.json

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