@zuvia-software-solutions/code-mapper 2.3.6 → 2.3.8

package/dist/cli/analyze.js

@@ -164,26 +164,27 @@ export const analyzeCommand = async (inputPath, options) => {
         const cpuPct = Math.round(((cpuDelta.user + cpuDelta.system) / 1e3) / wallMs * 100);
         return `${rssMB}MB | CPU ${cpuPct}%`;
     };
-    // Track elapsed time per phase — both updateBar and the interval use
-    // the same format so they don't flicker against each other
-    let lastPhaseLabel = 'Initializing...';
+    // Track elapsed time per BASE phase (without counts) so the timer
+    // doesn't reset every time the count updates
+    let lastBasePhase = 'Initializing...';
+    let lastFullLabel = 'Initializing...';
     let phaseStart = Date.now();
-    // Update bar with phase label + elapsed seconds (shown after 3s)
-    const updateBar = (value, phaseLabel) => {
-        if (phaseLabel !== lastPhaseLabel) {
-            lastPhaseLabel = phaseLabel;
+    const updateBar = (value, phaseLabel, basePhase) => {
+        const base = basePhase ?? phaseLabel;
+        if (base !== lastBasePhase) {
+            lastBasePhase = base;
             phaseStart = Date.now();
         }
+        lastFullLabel = phaseLabel;
         const elapsed = Math.round((Date.now() - phaseStart) / 1000);
-        const display = elapsed >= 3 ? `${phaseLabel} (${elapsed}s)` : phaseLabel;
+        const display = elapsed >= 1 ? `${phaseLabel} (${elapsed}s)` : phaseLabel;
         bar.update(value, { phase: display, resources: getResourceStats() });
     };
     // Tick elapsed seconds for phases with infrequent progress callbacks
-    // (e.g. CSV streaming, FTS indexing) — uses the same display format as updateBar
     const elapsedTimer = setInterval(() => {
         const elapsed = Math.round((Date.now() - phaseStart) / 1000);
-        if (elapsed >= 3) {
-            bar.update({ phase: `${lastPhaseLabel} (${elapsed}s)`, resources: getResourceStats() });
+        if (elapsed >= 1) {
+            bar.update({ phase: `${lastFullLabel} (${elapsed}s)`, resources: getResourceStats() });
         }
     }, 1000);
     // Cache embeddings from existing index before rebuild
@@ -218,13 +219,13 @@ export const analyzeCommand = async (inputPath, options) => {
             recordPhase(progress.phase);
             lastPipelinePhase = progress.phase;
         }
-        let phaseLabel = PHASE_LABELS[progress.phase] || progress.phase;
-        if (progress.stats && progress.stats.totalFiles > 0 &&
-            (progress.phase === 'parsing' || progress.phase === 'extracting' || progress.phase === 'calls')) {
+        const baseLabel = PHASE_LABELS[progress.phase] || progress.phase;
+        let phaseLabel = baseLabel;
+        if (progress.stats && progress.stats.totalFiles > 0) {
             phaseLabel += ` (${progress.stats.filesProcessed.toLocaleString()}/${progress.stats.totalFiles.toLocaleString()})`;
         }
         const scaled = Math.round(progress.percent * 0.6);
-        updateBar(scaled, phaseLabel);
+        updateBar(scaled, phaseLabel, baseLabel);
     }, options?.tsgo === false ? { tsgo: false } : {});
     // Phase 2: SQLite (60-85%)
     recordPhase('sqlite');

package/dist/core/ingestion/call-processor.d.ts

@@ -3,7 +3,7 @@ import type { KnowledgeGraph } from '../graph/types.js';
 import type { ASTCache } from './ast-cache.js';
 import type { ResolutionContext } from './resolution-context.js';
 import type { ExtractedCall, ExtractedHeritage, ExtractedRoute, FileConstructorBindings } from './workers/parse-worker.js';
-import type { TsgoService } from '../semantic/tsgo-service.js';
+import { TsgoService } from '../semantic/tsgo-service.js';
 export declare const processCalls: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;

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

@@ -10,6 +10,7 @@ import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop, F
 import { buildTypeEnv } from './type-env.js';
 import { getTreeSitterBufferSize } from './constants.js';
 import { callRouters } from './call-routing.js';
+import { TsgoService } from '../semantic/tsgo-service.js';
 import path from 'node:path';
 /** Walk up the AST to find the enclosing function/method, or null for top-level code */
 const findEnclosingFunction = (node, filePath, ctx) => {
@@ -764,20 +765,39 @@ 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.
+    // Built-in receiver names that resolve to external types, not project code.
+    // tsgo always fails on these — skip them to avoid wasted LSP round-trips.
+    const BUILTIN_RECEIVERS = new Set([
+        'console', 'Math', 'JSON', 'Object', 'Array', 'String', 'Number', 'Boolean',
+        'Date', 'RegExp', 'Error', 'Promise', 'Map', 'Set', 'WeakMap', 'WeakSet',
+        'Buffer', 'process', 'globalThis', 'window', 'document', 'navigator',
+        'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval',
+        'require', 'module', 'exports', '__dirname', '__filename',
+        'fs', 'path', 'os', 'url', 'util', 'crypto', 'http', 'https', 'net',
+        'child_process', 'stream', 'events', 'assert', 'zlib',
+    ]);
+    // Pre-filter calls where tsgo won't add value:
+    // A. Free-form calls with unambiguous name — heuristic resolves perfectly
+    // B. Member calls with known receiver type AND unambiguous method — heuristic handles
+    // C. Member calls on built-in receivers — tsgo always fails on these
     const tsgoEligible = [];
-    let skippedHeuristic = 0;
+    let skippedUnambiguous = 0;
+    const skippedKnownType = 0;
+    let skippedBuiltin = 0;
     for (const call of eligible) {
+        // A. Free-form, unique name match
         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++;
+                skippedUnambiguous++;
                 continue;
             }
         }
+        // B. Built-in receiver — tsgo resolves to node_modules/lib.d.ts, never project code
+        if (call.callForm === 'member' && call.receiverName && BUILTIN_RECEIVERS.has(call.receiverName)) {
+            skippedBuiltin++;
+            continue;
+        }
         tsgoEligible.push(call);
     }
     // Regroup filtered calls by file
@@ -790,79 +810,160 @@ async function batchResolveTsgo(tsgoService, extractedCalls, ctx, graph, repoPat
         }
         list.push(call);
     }
-    let resolved = 0;
-    let failed = 0;
     const t0 = Date.now();
-    console.error(`Code Mapper: tsgo resolving ${tsgoEligible.length} calls across ${tsgoByFile.size} files (skipped ${skippedHeuristic} heuristic-resolvable)...`);
-    let tsgoFilesProcessed = 0;
+    const skippedTotal = skippedUnambiguous + skippedKnownType + skippedBuiltin;
+    // Adaptive parallelism based on three constraints:
+    // 1. CPU: 75% of cores — parsing workers are done, leave 25% for Node.js event loop + OS
+    // 2. Memory: each tsgo loads the full project (~500MB estimate) — cap by free system memory
+    // 3. Workload: at least 50 files per process to amortize ~0.5s startup cost
+    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);
+    console.error(`Code Mapper: tsgo resolving ${tsgoEligible.length} calls across ${tsgoByFile.size} files with ${actualWorkers} process${actualWorkers > 1 ? 'es' : ''} (skipped ${skippedTotal}: ${skippedUnambiguous} unambiguous, ${skippedKnownType} known-type, ${skippedBuiltin} builtin)...`);
+    // Split files round-robin across workers for balanced distribution
+    const fileEntries = [...tsgoByFile.entries()];
+    const workerSlices = Array.from({ length: actualWorkers }, () => []);
+    for (let i = 0; i < fileEntries.length; i++) {
+        workerSlices[i % actualWorkers].push(fileEntries[i]);
+    }
+    // Shared progress counter
+    let totalFilesProcessed = 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);
-        // 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);
-                if (!def) {
-                    failed++;
-                    continue;
-                }
-                const targetSymbols = ctx.symbols.lookupAllInFile(def.filePath);
-                if (targetSymbols.length === 0) {
-                    failed++;
-                    continue;
-                }
-                // Match by exact startLine, then by range containment
-                let bestMatch;
-                for (const sym of targetSymbols) {
-                    const node = graph.getNode(toNodeId(sym.nodeId));
-                    if (node && node.properties.startLine === def.line) {
-                        bestMatch = sym;
-                        break;
+    /** Resolve a slice of files using a single tsgo service */
+    const resolveSlice = async (service, slice) => {
+        const sliceResults = new Map();
+        let sliceResolved = 0;
+        let sliceFailed = 0;
+        for (const [filePath, calls] of slice) {
+            totalFilesProcessed++;
+            if (totalFilesProcessed % 25 === 0) {
+                onProgress?.(totalFilesProcessed, tsgoTotalFiles);
+            }
+            const absFilePath = path.resolve(repoPath, filePath);
+            for (const call of calls) {
+                try {
+                    const def = await service.resolveDefinition(absFilePath, call.callLine - 1, call.callColumn);
+                    if (!def) {
+                        sliceFailed++;
+                        continue;
                     }
-                }
-                if (!bestMatch) {
+                    const targetSymbols = ctx.symbols.lookupAllInFile(def.filePath);
+                    if (targetSymbols.length === 0) {
+                        sliceFailed++;
+                        continue;
+                    }
+                    // Match by exact startLine, then by range containment
+                    let bestMatch;
                     for (const sym of targetSymbols) {
                         const node = graph.getNode(toNodeId(sym.nodeId));
-                        if (node) {
-                            const sl = node.properties.startLine;
-                            const el = node.properties.endLine;
-                            if (sl !== undefined && el !== undefined && def.line >= sl && def.line <= el) {
-                                bestMatch = sym;
-                                break;
+                        if (node && node.properties.startLine === def.line) {
+                            bestMatch = sym;
+                            break;
+                        }
+                    }
+                    if (!bestMatch) {
+                        for (const sym of targetSymbols) {
+                            const node = graph.getNode(toNodeId(sym.nodeId));
+                            if (node) {
+                                const sl = node.properties.startLine;
+                                const el = node.properties.endLine;
+                                if (sl !== undefined && el !== undefined && def.line >= sl && def.line <= el) {
+                                    bestMatch = sym;
+                                    break;
+                                }
                             }
                         }
                     }
-                }
-                if (bestMatch) {
-                    // Drop self-referencing tsgo edges
-                    if (bestMatch.nodeId === call.sourceId) {
-                        failed++;
-                        continue;
+                    if (bestMatch) {
+                        if (bestMatch.nodeId === call.sourceId) {
+                            sliceFailed++;
+                            continue;
+                        }
+                        const callKey = `${call.sourceId}\0${call.calledName}\0${call.callLine}`;
+                        sliceResults.set(callKey, {
+                            nodeId: bestMatch.nodeId,
+                            confidence: TIER_CONFIDENCE['tsgo-resolved'],
+                            reason: 'tsgo-lsp',
+                        });
+                        sliceResolved++;
+                    }
+                    else {
+                        sliceFailed++;
                     }
-                    const callKey = `${call.sourceId}\0${call.calledName}\0${call.callLine}`;
-                    results.set(callKey, {
-                        nodeId: bestMatch.nodeId,
-                        confidence: TIER_CONFIDENCE['tsgo-resolved'],
-                        reason: 'tsgo-lsp',
-                    });
-                    resolved++;
                 }
-                else {
-                    failed++;
+                catch {
+                    sliceFailed++;
                 }
             }
-            catch {
-                failed++;
+        }
+        return { resolved: sliceResolved, failed: sliceFailed, results: sliceResults };
+    };
+    let resolved = 0;
+    let failed = 0;
+    if (actualWorkers === 1) {
+        // Single process — use the existing service (already started)
+        const outcome = await resolveSlice(tsgoService, fileEntries);
+        resolved = outcome.resolved;
+        failed = outcome.failed;
+        for (const [k, v] of outcome.results)
+            results.set(k, v);
+    }
+    else {
+        // Parallel — spawn extra services, keep the original for slice 0
+        const extraServices = [];
+        try {
+            // Start extra tsgo processes in parallel
+            const startPromises = [];
+            for (let i = 1; i < actualWorkers; i++) {
+                startPromises.push((async () => {
+                    const svc = new TsgoService(repoPath);
+                    if (await svc.start())
+                        return svc;
+                    return null;
+                })());
+            }
+            const started = await Promise.all(startPromises);
+            for (const svc of started) {
+                if (svc)
+                    extraServices.push(svc);
+            }
+            // Build final service list: original + extras that started successfully
+            const services = [tsgoService, ...extraServices];
+            const activeSlices = workerSlices.slice(0, services.length);
+            // If some services failed to start, redistribute their slices
+            if (services.length < actualWorkers) {
+                for (let i = services.length; i < actualWorkers; i++) {
+                    const orphanSlice = workerSlices[i];
+                    if (orphanSlice) {
+                        // Distribute orphan files round-robin across active services
+                        for (let j = 0; j < orphanSlice.length; j++) {
+                            activeSlices[j % services.length].push(orphanSlice[j]);
+                        }
+                    }
+                }
             }
+            console.error(`Code Mapper: ${services.length} tsgo processes ready, resolving in parallel...`);
+            // Resolve all slices in parallel
+            const outcomes = await Promise.all(activeSlices.map((slice, i) => resolveSlice(services[i], slice)));
+            for (const outcome of outcomes) {
+                resolved += outcome.resolved;
+                failed += outcome.failed;
+                for (const [k, v] of outcome.results)
+                    results.set(k, v);
+            }
+        }
+        finally {
+            // Stop extra services (the original is stopped by the caller)
+            for (const svc of extraServices)
+                svc.stop();
         }
     }
     const elapsed = Date.now() - t0;
-    console.error(`Code Mapper: tsgo resolved ${resolved}/${eligible.length} calls in ${elapsed}ms (${failed} unresolvable)`);
+    console.error(`Code Mapper: tsgo resolved ${resolved}/${eligible.length} calls in ${elapsed}ms (${failed} unresolvable, ${actualWorkers} process${actualWorkers > 1 ? 'es' : ''})`);
     return results;
 }
 /** Generic method names that produce false edges when receiver type is unknown (worker-extracted path) */

package/package.json

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