@zuvia-software-solutions/code-mapper 2.3.7 → 2.3.9

package/dist/cli/analyze.js

@@ -136,10 +136,12 @@ export const analyzeCommand = async (inputPath, options) => {
     const t0Global = Date.now();
     const cpuStart = process.cpuUsage();
     let peakRssMB = 0;
-    // Phase timing tracker — records wall time and RSS for each phase
+    // Phase timing tracker — records wall time, RSS, file count, and worker count per phase
     const phaseTimes = [];
     let currentPhaseName = 'init';
     let currentPhaseStart = Date.now();
+    let currentPhaseFiles = 0;
+    let currentPhaseWorkers = 0;
     const recordPhase = (nextPhase) => {
         const now = Date.now();
         const elapsed = now - currentPhaseStart;
@@ -148,10 +150,14 @@ export const analyzeCommand = async (inputPath, options) => {
                 name: currentPhaseName,
                 ms: elapsed,
                 rssMB: Math.round(process.memoryUsage.rss() / (1024 * 1024)),
+                ...(currentPhaseFiles > 0 ? { fileCount: currentPhaseFiles } : {}),
+                ...(currentPhaseWorkers > 0 ? { workerCount: currentPhaseWorkers } : {}),
             });
         }
         currentPhaseName = nextPhase;
         currentPhaseStart = now;
+        currentPhaseFiles = 0;
+        currentPhaseWorkers = 0;
     };
     // Live resource stats for the progress bar
     const cpuCount = os.cpus().length;
@@ -164,26 +170,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 +225,29 @@ 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')) {
-            phaseLabel += ` (${progress.stats.filesProcessed.toLocaleString()}/${progress.stats.totalFiles.toLocaleString()})`;
+        const baseLabel = PHASE_LABELS[progress.phase] || progress.phase;
+        let phaseLabel = baseLabel;
+        if (progress.stats && progress.stats.totalFiles > 0) {
+            const current = progress.stats.filesProcessed;
+            const total = progress.stats.totalFiles;
+            // Track peak file count and worker count for the summary
+            currentPhaseFiles = Math.max(currentPhaseFiles, total);
+            if (progress.stats.workerCount)
+                currentPhaseWorkers = Math.max(currentPhaseWorkers, progress.stats.workerCount);
+            phaseLabel += ` (${current.toLocaleString()}/${total.toLocaleString()})`;
+            // Show rate (files/s) after 1s
+            const elapsedSec = (Date.now() - phaseStart) / 1000;
+            if (elapsedSec >= 1 && current > 0) {
+                const rate = Math.round(current / elapsedSec);
+                phaseLabel += ` ${rate}/s`;
+            }
+            // Show worker/process count if available
+            if (progress.stats.workerCount && progress.stats.workerCount > 1) {
+                phaseLabel += ` [${progress.stats.workerCount}p]`;
+            }
         }
         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');
@@ -432,7 +455,16 @@ export const analyzeCommand = async (inputPath, options) => {
         const pct = Math.round((phase.ms / totalMs) * 100);
         const name = PHASE_DISPLAY_NAMES[phase.name] || phase.name;
         const bar = pct >= 2 ? ' ' + '█'.repeat(Math.max(1, Math.round(pct / 3))) : '';
-        console.log(`    ${name.padEnd(22)} ${sec.padStart(6)}s  ${String(pct).padStart(3)}%  ${phase.rssMB}MB${bar}`);
+        // Build extra stats: rate + workers
+        let extra = '';
+        if (phase.fileCount && phase.ms > 0) {
+            const rate = Math.round(phase.fileCount / (phase.ms / 1000));
+            extra += `  ${phase.fileCount.toLocaleString()} files (${rate}/s)`;
+        }
+        if (phase.workerCount && phase.workerCount > 1) {
+            extra += `  [${phase.workerCount}p]`;
+        }
+        console.log(`    ${name.padEnd(22)} ${sec.padStart(6)}s  ${String(pct).padStart(3)}%  ${phase.rssMB}MB${bar}${extra}`);
     }
     console.log(`    ${'─'.repeat(50)}`);
     console.log(`    ${'Total'.padEnd(22)} ${totalTime.padStart(6)}s  100%  ${peakRssMB}MB peak`);

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

@@ -3,14 +3,14 @@ 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;
 }[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<ExtractedHeritage[]>;
 export declare const extractReturnTypeName: (raw: string, depth?: number) => string | undefined;
 /** Resolve pre-extracted call sites from workers (no AST parsing needed) */
-export declare const processCallsFromExtracted: (graph: KnowledgeGraph, extractedCalls: ExtractedCall[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, constructorBindings?: FileConstructorBindings[], tsgoService?: TsgoService | null, repoPath?: string) => Promise<void>;
+export declare const processCallsFromExtracted: (graph: KnowledgeGraph, extractedCalls: ExtractedCall[], ctx: ResolutionContext, onProgress?: (current: number, total: number, workerCount?: number) => void, constructorBindings?: FileConstructorBindings[], tsgoService?: TsgoService | null, repoPath?: string) => Promise<void>;
 /** Resolve pre-extracted Laravel routes to CALLS edges from route files to controller methods */
 export declare const processRoutesFromExtracted: (graph: KnowledgeGraph, extractedRoutes: ExtractedRoute[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<void>;
 /**

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) => {
@@ -777,11 +778,11 @@ async function batchResolveTsgo(tsgoService, extractedCalls, ctx, graph, repoPat
     ]);
     // 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
+    // B. Member calls on built-in receivers — tsgo always fails on these
+    // Note: member calls with known receiver types are NOT skipped — tsgo provides
+    // compiler-verified 0.99 confidence that the heuristic can't match.
     const tsgoEligible = [];
     let skippedUnambiguous = 0;
-    const skippedKnownType = 0;
     let skippedBuiltin = 0;
     for (const call of eligible) {
         // A. Free-form, unique name match
@@ -809,80 +810,161 @@ async function batchResolveTsgo(tsgoService, extractedCalls, ctx, graph, repoPat
         }
         list.push(call);
     }
-    let resolved = 0;
-    let failed = 0;
     const t0 = Date.now();
-    const skippedTotal = skippedUnambiguous + skippedKnownType + skippedBuiltin;
-    console.error(`Code Mapper: tsgo resolving ${tsgoEligible.length} calls across ${tsgoByFile.size} files (skipped ${skippedTotal}: ${skippedUnambiguous} unambiguous, ${skippedKnownType} known-type, ${skippedBuiltin} builtin)...`);
-    let tsgoFilesProcessed = 0;
+    const skippedTotal = skippedUnambiguous + 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);
+    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)...`);
+    }
+    // Dynamic dispatch: shared queue, each process grabs the next file when done.
+    // Naturally self-balancing — fast processes get more work, zero idle time.
+    // Sort heaviest files first so they're assigned early (avoids tail latency).
+    const fileEntries = [...tsgoByFile.entries()];
+    fileEntries.sort((a, b) => b[1].length - a[1].length);
+    // Shared progress counter and file queue (single-threaded, no mutex needed)
+    let totalFilesProcessed = 0;
+    let nextFileIdx = 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;
+    const getNextFile = () => {
+        if (nextFileIdx >= fileEntries.length)
+            return null;
+        return fileEntries[nextFileIdx++];
+    };
+    /** Resolve files from the shared queue using a single tsgo service */
+    const resolveWorker = async (service) => {
+        const sliceResults = new Map();
+        let sliceResolved = 0;
+        let sliceFailed = 0;
+        let entry;
+        while ((entry = getNextFile()) !== null) {
+            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);
+                    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++;
+            // Close file after all its calls are resolved — frees tsgo memory,
+            // prevents progressive slowdown as the type graph grows
+            service.notifyFileDeleted(absFilePath);
+        }
+        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 resolveWorker(tsgoService);
+        resolved = outcome.resolved;
+        failed = outcome.failed;
+        for (const [k, v] of outcome.results)
+            results.set(k, v);
+    }
+    else {
+        // Parallel — spawn extra services, all pull from shared queue
+        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];
+            if (process.env['CODE_MAPPER_VERBOSE'])
+                console.error(`Code Mapper: ${services.length} tsgo processes ready, resolving with dynamic dispatch...`);
+            // All workers pull from the shared queue — naturally self-balancing
+            const outcomes = await Promise.all(services.map(svc => resolveWorker(svc)));
+            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)`);
+    if (process.env['CODE_MAPPER_VERBOSE'])
+        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) */
@@ -928,7 +1010,7 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
     for (const [filePath, calls] of byFile) {
         filesProcessed++;
         if (filesProcessed % 25 === 0) {
-            onProgress?.(filesProcessed, totalFiles);
+            onProgress?.(filesProcessed, totalFiles, 1);
             await yieldToEventLoop();
         }
         ctx.enableCache(filePath);

package/dist/core/ingestion/pipeline.js

@@ -192,7 +192,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, opts) => {
                         percent: Math.round(parsingProgress),
                         message: `Parsing chunk ${chunkIdx + 1}/${numChunks}...`,
                         detail: filePath,
-                        stats: { filesProcessed: globalCurrent, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
+                        stats: { filesProcessed: globalCurrent, totalFiles: totalParseable, nodesCreated: graph.nodeCount, ...(workerPool ? { workerCount: workerPool.size } : {}) },
                     });
                 }, workerPool);
                 const parseMs = Date.now() - parseStart;
@@ -297,13 +297,13 @@ export const runPipelineFromRepo = async (repoPath, onProgress, opts) => {
                 }
             }
             try {
-                await processCallsFromExtracted(graph, allExtractedCalls, ctx, (current, total) => {
+                await processCallsFromExtracted(graph, allExtractedCalls, ctx, (current, total, workerCount) => {
                     const callPercent = 70 + Math.round((current / Math.max(total, 1)) * 12);
                     onProgress({
                         phase: 'calls',
                         percent: callPercent,
                         message: `Resolving calls: ${current}/${total} files...`,
-                        stats: { filesProcessed: current, totalFiles: total, nodesCreated: graph.nodeCount },
+                        stats: { filesProcessed: current, totalFiles: total, nodesCreated: graph.nodeCount, ...(workerCount ? { workerCount } : {}) },
                     });
                 }, allConstructorBindings.length > 0 ? allConstructorBindings : undefined, tsgoService, repoPath);
             }

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

@@ -258,10 +258,10 @@ export class TsgoService {
             this.process.stderr.on('data', (chunk) => {
                 const msg = chunk.toString().trim();
                 if (msg)
-                    console.error(`[tsgo-service] stderr: ${msg}`);
+                    verbose('stderr:', msg);
             });
             this.process.on('exit', (code, signal) => {
-                console.error(`[tsgo-service] process exited (code=${code}, signal=${signal})`);
+                verbose(`process exited (code=${code}, signal=${signal})`);
                 this.ready = false;
                 this.process = null;
             });
@@ -284,7 +284,7 @@ export class TsgoService {
             // Send initialized notification
             this.send({ jsonrpc: '2.0', method: 'initialized', params: {} });
             this.ready = true;
-            console.error('Code Mapper: tsgo LSP ready (semantic resolution enabled)');
+            verbose('LSP ready');
             return true;
         }
         catch (err) {

package/dist/types/pipeline.d.ts

@@ -13,6 +13,7 @@ export interface PipelineProgress {
         filesProcessed: number;
         totalFiles: number;
         nodesCreated: number;
+        workerCount?: number;
     };
 }
 export interface PipelineResult {

package/package.json

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