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

package/dist/cli/analyze.d.ts

@@ -2,7 +2,6 @@
 export interface AnalyzeOptions {
     force?: boolean;
     embeddings?: boolean;
-    tsgo?: boolean;
     verbose?: boolean;
 }
 export declare const analyzeCommand: (inputPath?: string, options?: AnalyzeOptions) => Promise<void>;

package/dist/cli/analyze.js

@@ -248,7 +248,7 @@ export const analyzeCommand = async (inputPath, options) => {
         }
         const scaled = Math.round(progress.percent * 0.6);
         updateBar(scaled, phaseLabel, baseLabel);
-    }, options?.tsgo === false ? { tsgo: false } : {});
+    });
     // Phase 2: SQLite (60-85%)
     recordPhase('sqlite');
     updateBar(60, 'Loading into database...');
@@ -431,7 +431,6 @@ export const analyzeCommand = async (inputPath, options) => {
     const wallMs = Date.now() - t0Global || 1;
     const cpuPct = Math.round(((cpuEnd.user + cpuEnd.system) / 1e3) / wallMs * 100);
     console.log(`  Memory: peak ${peakRssMB}MB RSS | CPU: ${cpuPct}% (${cpuCount} cores)`);
-    console.log(`  tsgo: ${pipelineResult.tsgoEnabled ? 'enabled (compiler-verified call resolution)' : 'disabled — install @typescript/native-preview for higher accuracy'}`);
     console.log(`  ${repoPath}`);
     if (aiContext.files.length > 0) {
         console.log(`  Context: ${aiContext.files.join(', ')}`);

package/dist/cli/index.js

@@ -24,7 +24,6 @@ program
     .option('-f, --force', 'Force full re-index even if up to date')
     .option('--embeddings', 'Generate semantic embeddings (bge-small, CPU, fast)')
     .option('--no-embeddings', 'Skip embedding generation')
-    .option('--no-tsgo', 'Skip tsgo LSP for call resolution (faster, less accurate)')
     .option('-v, --verbose', 'Enable verbose ingestion warnings (default: false)')
     .addHelpText('after', '\nEnvironment variables:\n  CODE_MAPPER_NO_GITIGNORE=1  Skip .gitignore parsing (still reads .code-mapperignore)')
     .action(createLazyAction(() => import('./analyze.js'), 'analyzeCommand'));
@@ -72,7 +71,6 @@ program
     .option('-u, --uid <uid>', 'Direct symbol UID (zero-ambiguity lookup)')
     .option('-f, --file <path>', 'File path to disambiguate common names')
     .option('--content', 'Include full symbol source code')
-    .option('--no-tsgo', 'Disable tsgo LSP enrichment (faster, less accurate)')
     .action(createLazyAction(() => import('./tool.js'), 'contextCommand'));
 program
     .command('impact <target>')
@@ -81,7 +79,6 @@ program
     .option('-r, --repo <name>', 'Target repository')
     .option('--depth <n>', 'Max relationship depth (default: 3)')
     .option('--include-tests', 'Include test files in results')
-    .option('--no-tsgo', 'Disable tsgo LSP enrichment (faster, less accurate)')
     .action(createLazyAction(() => import('./tool.js'), 'impactCommand'));
 program
     .command('sql <query>')

package/dist/cli/refresh.js

@@ -119,9 +119,6 @@ export const refreshCommand = async (options) => {
         const result = await refreshFiles(db, repoRoot, entries);
         const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
         console.log(`Refreshed ${result.filesProcessed} file(s) in ${elapsed}s`);
-        if (!result.tsgoEnabled) {
-            console.log('Note: tsgo unavailable — call resolution used heuristic matching. Install @typescript/native-preview for higher accuracy.');
-        }
         // Refresh embeddings for dirty files (same quality as full analyze — graph context enriched)
         await refreshEmbeddings(db, entries);
         // Update metadata with current commit

package/dist/cli/tool.d.ts

@@ -15,14 +15,12 @@ export declare function contextCommand(name: string, options?: {
     file?: string;
     uid?: string;
     content?: boolean;
-    tsgo?: boolean;
 }): Promise<void>;
 export declare function impactCommand(target: string, options?: {
     direction?: string;
     repo?: string;
     depth?: string;
     includeTests?: boolean;
-    tsgo?: boolean;
 }): Promise<void>;
 export declare function sqlCommand(query: string, options?: {
     repo?: string;

package/dist/cli/tool.js

@@ -50,7 +50,6 @@ export async function contextCommand(name, options) {
         uid: options?.uid,
         file_path: options?.file,
         include_content: options?.content ?? false,
-        tsgo: options?.tsgo,
         repo: options?.repo,
     });
     output(result);
@@ -66,7 +65,6 @@ export async function impactCommand(target, options) {
         direction: options?.direction || 'upstream',
         maxDepth: options?.depth ? parseInt(options.depth) : undefined,
         includeTests: options?.includeTests ?? false,
-        tsgo: options?.tsgo,
         repo: options?.repo,
     });
     output(result);

package/dist/core/embeddings/nl-embed-worker.d.ts

@@ -3,6 +3,6 @@
  * Spawned by buildNlEmbeddings — loads bge-small independently,
  * embeds texts received via IPC, sends vectors back.
  *
- * Same architecture as parallel tsgo: N processes, each with own model.
+ * Spawned by buildNlEmbeddings — loads bge-small independently,
  */
 export {};

package/dist/core/embeddings/nl-embed-worker.js

@@ -4,7 +4,7 @@
  * Spawned by buildNlEmbeddings — loads bge-small independently,
  * embeds texts received via IPC, sends vectors back.
  *
- * Same architecture as parallel tsgo: N processes, each with own model.
+ * Spawned by buildNlEmbeddings — loads bge-small independently,
  */
 import { pipeline } from '@huggingface/transformers';
 const MODEL_ID = 'Xenova/bge-small-en-v1.5';

package/dist/core/embeddings/nl-embedder.js

@@ -258,7 +258,7 @@ export async function buildNlEmbeddings(db, onProgress) {
         db.prepare('DELETE FROM nl_embeddings').run();
     }
     catch { /* table may not exist */ }
-    // Parallel multi-process embedding — same architecture as tsgo
+    // Parallel multi-process embedding — N workers, each with own model
     // Each worker loads its own bge-small model, embeds independently.
     const os = await import('os');
     const { fork } = await import('child_process');

package/dist/core/incremental/refresh.d.ts

@@ -9,8 +9,7 @@
  *   1. Delete old nodes for dirty files
  *   2. Parse modified/created files with tree-sitter
  *   3. Insert File nodes + symbol nodes + DEFINES edges
- *   4. Resolve call edges using tsgo LSP (TS/JS files only)
- *   5. Repair cross-file edges (callers from unchanged files → changed symbols)
+ *   4. Resolve call edges (heuristic name-based matching)
  */
 import type Database from 'better-sqlite3';
 import { type DirtyFileEntry, type RefreshResult } from './types.js';
@@ -20,8 +19,7 @@ import { type DirtyFileEntry, type RefreshResult } from './types.js';
  * Phase 1: Delete old nodes for all dirty files
  * Phase 2: Parse modified/created files with tree-sitter
  * Phase 3: Insert File nodes + symbol nodes + DEFINES edges
- * Phase 4: Resolve call edges using tsgo LSP (TS/JS only, optional)
- * Phase 5: Repair cross-file edges from unchanged files (tsgo, optional)
+ * Phase 4: Resolve call edges (heuristic name-based matching)
  *
  * @param db - Open better-sqlite3 database instance
  * @param repoPath - Absolute path to the repository root

package/dist/core/incremental/refresh.js

@@ -10,8 +10,7 @@
  *   1. Delete old nodes for dirty files
  *   2. Parse modified/created files with tree-sitter
  *   3. Insert File nodes + symbol nodes + DEFINES edges
- *   4. Resolve call edges using tsgo LSP (TS/JS files only)
- *   5. Repair cross-file edges (callers from unchanged files → changed symbols)
+ *   4. Resolve call edges (heuristic name-based matching)
  */
 import path from 'path';
 import fsSync from 'fs';
@@ -24,17 +23,10 @@ import { generateId } from '../../lib/utils.js';
 import { deleteNodesByFile, insertNode, insertEdge, findNodeAtLine, findNodesByFile, deleteEmbeddingsByFile, insertEmbeddingsBatch, countEmbeddings, deleteRefsByFile, insertRefsBatch, deleteFileWordsByFile, upsertFileWords } from '../db/adapter.js';
 import { assertNodeLabel, toNodeId, toEdgeId } from '../db/schema.js';
 import {} from './types.js';
-import { getTsgoService } from '../semantic/tsgo-service.js';
 import { EMBEDDABLE_LABELS } from '../embeddings/types.js';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-/** File extensions that tsgo can resolve */
-const TS_JS_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mts', '.cts', '.mjs', '.cjs']);
-function isTypeScriptOrJavaScript(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    return TS_JS_EXTENSIONS.has(ext);
-}
 /**
  * Find the innermost symbol node enclosing a given 0-based line in a file.
  * Excludes structural nodes (File, Folder, Community, Process).
@@ -42,31 +34,13 @@ function isTypeScriptOrJavaScript(filePath) {
 function findEnclosingNode(db, filePath, line) {
     return findNodeAtLine(db, filePath, line, 'File');
 }
-/**
- * Find a node whose definition starts at a given 0-based line in a file.
- * Falls back to the enclosing node if no exact match.
- */
-function findNodeByFileAndLine(db, filePath, line) {
-    // Try exact startLine match first (exclude structural labels)
-    const exact = db.prepare(`SELECT * FROM nodes
-     WHERE filePath = ? AND startLine = ?
-       AND label NOT IN ('File', 'Folder', 'Community', 'Process')
-     LIMIT 1`
-    // Safe: schema and NodeRow defined together in schema.ts
-    ).get(filePath, line);
-    if (exact)
-        return exact;
-    // Fall back to enclosing node
-    return findEnclosingNode(db, filePath, line);
-}
 /**
  * Parse dirty files with tree-sitter and write nodes/edges to the database.
  *
  * Phase 1: Delete old nodes for all dirty files
  * Phase 2: Parse modified/created files with tree-sitter
  * Phase 3: Insert File nodes + symbol nodes + DEFINES edges
- * Phase 4: Resolve call edges using tsgo LSP (TS/JS only, optional)
- * Phase 5: Repair cross-file edges from unchanged files (tsgo, optional)
+ * Phase 4: Resolve call edges (heuristic name-based matching)
  *
  * @param db - Open better-sqlite3 database instance
  * @param repoPath - Absolute path to the repository root
@@ -158,10 +132,9 @@ export async function refreshFiles(db, repoPath, dirtyFiles) {
                 const callNameNode = captureMap['call.name'];
                 if (callNameNode) {
                     callSites.push({
-                        filePath: relPath, absPath,
+                        filePath: relPath,
                         name: callNameNode.text,
                         line: callNameNode.startPosition.row,
-                        character: callNameNode.startPosition.column,
                     });
                 }
                 continue;
@@ -283,33 +256,11 @@ export async function refreshFiles(db, repoPath, dirtyFiles) {
         if (wordSet.size > 0)
             upsertFileWords(db, relPath, [...wordSet].join(' '));
     }
-    // Phase 4 + 5: Resolve call edges and cross-file edges using tsgo LSP
-    // (TS/JS files only — tsgo is optional, skip if unavailable)
-    console.error(`Code Mapper: refresh tsgo init with repoPath=${repoPath}`);
-    const tsgoService = getTsgoService(repoPath);
-    let tsgoReady = false;
-    try {
-        tsgoReady = await tsgoService.start();
-        console.error(`Code Mapper: refresh tsgo ready=${tsgoReady}`);
-    }
-    catch (err) {
-        console.error(`Code Mapper: refresh tsgo failed: ${err instanceof Error ? err.message : err}`);
-    }
-    // Phase 4: Resolve call edges from dirty files
-    // Always runs — tsgo provides 0.99 confidence, heuristic fallback provides 0.5-0.95
+    // Phase 4: Resolve call edges from dirty files (heuristic name-based matching)
     if (callSites.length > 0) {
         db.exec('BEGIN');
         try {
             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);
-                    }
-                }
-            }
             console.error(`Code Mapper: refresh Phase 4 — ${callSites.length} call sites to resolve`);
             for (const callSite of callSites) {
                 const sourceNode = findEnclosingNode(db, callSite.filePath, callSite.line);
@@ -318,39 +269,23 @@ export async function refreshFiles(db, repoPath, dirtyFiles) {
                 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: name-based lookup in DB
+                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';
                 }
-                // 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';
-                    }
+                else if (candidates.length > 0) {
+                    targetNode = candidates[0];
+                    confidence = 0.5;
+                    reason = 'global';
                 }
                 if (!targetNode)
                     continue;
@@ -375,61 +310,11 @@ export async function refreshFiles(db, repoPath, dirtyFiles) {
             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.
-            for (const def of allDefinitions) {
-                if (!isTypeScriptOrJavaScript(def.filePath))
-                    continue;
-                const absPath = path.resolve(repoPath, def.filePath);
-                const refs = await tsgoService.findReferences(absPath, def.startLine, 0);
-                for (const ref of refs) {
-                    // Skip refs from dirty files — already handled in Phase 4
-                    if (dirtyFilePaths.has(ref.filePath))
-                        continue;
-                    // Skip refs from non-TS/JS files
-                    if (!isTypeScriptOrJavaScript(ref.filePath))
-                        continue;
-                    // This reference is from an UNCHANGED file → create/update the CALLS edge
-                    const sourceNode = findEnclosingNode(db, ref.filePath, ref.line);
-                    if (!sourceNode)
-                        continue;
-                    const targetId = toNodeId(def.nodeId);
-                    // Skip self-edges
-                    if (sourceNode.id === targetId)
-                        continue;
-                    const edgeId = toEdgeId(`${sourceNode.id}_CALLS_${targetId}`);
-                    insertEdge(db, {
-                        id: edgeId,
-                        sourceId: sourceNode.id,
-                        targetId,
-                        type: 'CALLS',
-                        confidence: 0.99,
-                        reason: 'tsgo-cross-file',
-                        callLine: ref.line,
-                    });
-                    edgesInserted++;
-                }
-            }
-            db.exec('COMMIT');
-        }
-        catch (err) {
-            db.exec('ROLLBACK');
-            // Log but don't fail the entire refresh — Phases 1-3 already committed
-            console.error(`Code Mapper: tsgo call resolution failed: ${err instanceof Error ? err.message : err}`);
-        }
-    }
     // FTS5 auto-updates via triggers — no manual rebuild needed
     return {
         filesProcessed: filesToProcess.length, filesSkipped,
         nodesDeleted, nodesInserted, edgesInserted,
         durationMs: Date.now() - t0,
-        tsgoEnabled: tsgoReady,
     };
 }
 // ---------------------------------------------------------------------------

package/dist/core/incremental/types.d.ts

@@ -55,7 +55,6 @@ export interface RefreshResult {
     readonly nodesInserted: number;
     readonly edgesInserted: number;
     readonly durationMs: number;
-    readonly tsgoEnabled: boolean;
 }
 /** Messages from child to parent */
 export type ChildToParentMessage = {

package/dist/core/incremental/types.js

@@ -131,7 +131,6 @@ export function parseChildMessage(raw) {
                 nodesInserted: Number(p['nodesInserted']) || 0,
                 edgesInserted: Number(p['edgesInserted']) || 0,
                 durationMs: Number(p['durationMs']) || 0,
-                tsgoEnabled: Boolean(p['tsgoEnabled']),
             },
         };
     }

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

@@ -3,14 +3,13 @@ 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 { 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, workerCount?: 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[]) => 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>;
 /**
@@ -41,6 +40,6 @@ export declare const createProvidesEdges: (graph: KnowledgeGraph, ctx: Resolutio
  * Creates CALLS edges: InterfaceMethod → ImplementationFunction.
  *
  * This makes the call chain traversable:
- *   register() →[tsgo]→ EventBus.emit (Method) →[dispatch]→ emit (Function in event-bus.ts)
+ *   register() → EventBus.emit (Method) →[dispatch]→ emit (Function in event-bus.ts)
  */
 export declare const resolveInterfaceDispatches: (graph: KnowledgeGraph, ctx: ResolutionContext) => Promise<number>;