@zuvia-software-solutions/code-mapper 2.5.0 → 2.5.2

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

@@ -795,14 +795,17 @@ async function batchResolveTsgo(tsgoService, extractedCalls, ctx, graph, repoPat
     }
     const t0 = Date.now();
     const skippedTotal = skippedUnambiguous + skippedBuiltin;
-    // Adaptive parallelism
+    // Adaptive parallelism — conservative to avoid freezing the machine.
+    // Each tsgo LSP process loads the full project into memory (~1.5-3GB for
+    // large codebases) and pins a CPU core at 100%, so we cap aggressively.
     const osModule = await import('os');
     const cpuCount = osModule.cpus().length;
     const freeMemGB = osModule.freemem() / (1024 * 1024 * 1024);
-    const maxByCpu = Math.max(1, Math.floor(cpuCount * 0.75));
-    const maxByMemory = Math.max(1, Math.floor(freeMemGB / 0.5));
-    const maxByWorkload = Math.max(1, Math.floor(tsgoByFile.size / 50));
-    const actualWorkers = Math.min(maxByCpu, maxByMemory, maxByWorkload);
+    const maxByCpu = Math.max(1, Math.floor(cpuCount * 0.5));
+    const maxByMemory = Math.max(1, Math.floor(freeMemGB / 2)); // ~2GB per process
+    const maxByWorkload = Math.max(1, Math.floor(tsgoByFile.size / 100));
+    const HARD_CAP = 4; // never more than 4 tsgo processes regardless of hardware
+    const actualWorkers = Math.min(maxByCpu, maxByMemory, maxByWorkload, HARD_CAP);
     if (process.env['CODE_MAPPER_VERBOSE']) {
         console.error(`Code Mapper: tsgo resolving ${tsgoEligible.length} calls across ${tsgoByFile.size} files with ${actualWorkers} process${actualWorkers > 1 ? 'es' : ''} (skipped ${skippedTotal}: ${skippedUnambiguous} unambiguous, ${skippedBuiltin} builtin)...`);
     }
@@ -823,15 +826,26 @@ async function batchResolveTsgo(tsgoService, extractedCalls, ctx, graph, repoPat
         let sliceFailed = 0;
         let entry;
         while ((entry = getNextFile()) !== null) {
+            // Bail out early if tsgo process died — no point sending more requests
+            if (!service.isReady())
+                break;
             const [filePath, calls] = entry;
             totalFilesProcessed++;
             if (totalFilesProcessed % 25 === 0) {
                 onProgress?.(totalFilesProcessed, tsgoTotalFiles, actualWorkers);
             }
             const absFilePath = path.resolve(repoPath, filePath);
-            for (const call of calls) {
-                try {
-                    const def = await service.resolveDefinition(absFilePath, call.callLine - 1, call.callColumn);
+            // Pipeline: fire all definition requests for this file concurrently.
+            // The LSP server processes them serially, but we eliminate round-trip
+            // latency between requests — major speedup on large files.
+            const BATCH = 50;
+            for (let i = 0; i < calls.length; i += BATCH) {
+                const batch = calls.slice(i, i + BATCH);
+                const defs = await Promise.all(batch.map(call => service.resolveDefinition(absFilePath, call.callLine - 1, call.callColumn)
+                    .catch(() => null)));
+                for (let j = 0; j < batch.length; j++) {
+                    const call = batch[j];
+                    const def = defs[j];
                     if (!def) {
                         sliceFailed++;
                         continue;
@@ -879,9 +893,6 @@ async function batchResolveTsgo(tsgoService, extractedCalls, ctx, graph, repoPat
                         sliceFailed++;
                     }
                 }
-                catch {
-                    sliceFailed++;
-                }
             }
             service.notifyFileDeleted(absFilePath);
         }

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

@@ -260,9 +260,25 @@ export class TsgoService {
                 if (msg)
                     verbose('stderr:', msg);
             });
+            // Handle EPIPE / write errors on stdin — without this handler,
+            // a dead tsgo process causes an unhandled 'error' event that crashes Node.
+            this.process.stdin.on('error', (err) => {
+                verbose(`stdin error: ${err.code ?? err.message}`);
+                this.ready = false;
+                // Reject all pending requests so callers don't hang
+                for (const cb of this.pending.values()) {
+                    cb({ id: -1, error: { message: `tsgo stdin error: ${err.code}` } });
+                }
+                this.pending.clear();
+            });
             this.process.on('exit', (code, signal) => {
                 verbose(`process exited (code=${code}, signal=${signal})`);
                 this.ready = false;
+                // Reject all pending requests on unexpected exit
+                for (const cb of this.pending.values()) {
+                    cb({ id: -1, error: { message: `tsgo exited (code=${code}, signal=${signal})` } });
+                }
+                this.pending.clear();
                 this.process = null;
             });
             // Initialize LSP handshake

package/package.json

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