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

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>;

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

@@ -6,12 +6,10 @@ import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/pa
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
 import { toNodeId, toEdgeId } from '../db/schema.js';
-import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, findEnclosingClassId, CALL_EXPRESSION_TYPES, extractCallChain, } from './utils.js';
+import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, findEnclosingClassId, findEnclosingClassName, SELF_RECEIVER_KEYWORDS, CALL_EXPRESSION_TYPES, extractCallChain, } from './utils.js';
 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) => {
     let current = node.parent;
@@ -302,6 +300,12 @@ export const processCalls = async (graph, files, astCache, ctx, onProgress) => {
             const callForm = inferCallForm(callNode, nameNode);
             const receiverName = callForm === 'member' ? extractReceiverName(nameNode) : undefined;
             let receiverTypeName = receiverName && typeEnv ? typeEnv.lookup(receiverName, callNode) : undefined;
+            // Resolve this/self/base to enclosing class name
+            if (!receiverTypeName && receiverName && SELF_RECEIVER_KEYWORDS.has(receiverName)) {
+                const className = findEnclosingClassName(callNode);
+                if (className)
+                    receiverTypeName = className;
+            }
             // Fall back to verified constructor bindings
             if (!receiverTypeName && receiverName && verifiedReceivers.size > 0) {
                 const enclosingFunc = findEnclosingFunction(callNode, file.path, ctx);
@@ -728,223 +732,7 @@ const lookupReceiverType = (map, funcName, varName) => {
     // Fallback: file-level scope
     return map.get(fileLevelKey);
 };
-/** Check if a file is TypeScript or JavaScript (extensions tsgo can handle) */
-function isTypeScriptOrJavaScript(filePath) {
-    return /\.(ts|tsx|js|jsx|mts|mjs|cts|cjs)$/.test(filePath);
-}
-/**
- * Batch-resolve call sites via tsgo LSP before heuristic resolution.
- *
- * For each TS/JS call with line+column info, asks tsgo for go-to-definition.
- * Returns a Map from callKey -> ResolveResult for calls that tsgo resolved.
- *
- * Call key format: "sourceId\0calledName\0callLine" — unique per call site.
- */
-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 = [];
-    for (const call of extractedCalls) {
-        if (isTypeScriptOrJavaScript(call.filePath) &&
-            call.callLine !== undefined &&
-            call.callColumn !== undefined) {
-            eligible.push(call);
-        }
-    }
-    if (eligible.length === 0)
-        return results;
-    // Built-in receiver names that resolve to external types, not project code.
-    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 on built-in receivers — tsgo always fails on these
-    const tsgoEligible = [];
-    let skippedUnambiguous = 0;
-    let skippedBuiltin = 0;
-    for (const call of eligible) {
-        if (call.callForm === 'free' || call.callForm === undefined) {
-            const resolved = ctx.resolve(call.calledName, call.filePath);
-            if (resolved && resolved.candidates.length === 1) {
-                skippedUnambiguous++;
-                continue;
-            }
-        }
-        if (call.callForm === 'member' && call.receiverName && BUILTIN_RECEIVERS.has(call.receiverName)) {
-            skippedBuiltin++;
-            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);
-    }
-    const t0 = Date.now();
-    const skippedTotal = skippedUnambiguous + skippedBuiltin;
-    // 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.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)...`);
-    }
-    // Dynamic dispatch: shared queue sorted by call count descending
-    const fileEntries = [...tsgoByFile.entries()];
-    fileEntries.sort((a, b) => b[1].length - a[1].length);
-    let totalFilesProcessed = 0;
-    let nextFileIdx = 0;
-    const tsgoTotalFiles = tsgoByFile.size;
-    const getNextFile = () => {
-        if (nextFileIdx >= fileEntries.length)
-            return null;
-        return fileEntries[nextFileIdx++];
-    };
-    const resolveWorker = async (service) => {
-        const sliceResults = new Map();
-        let sliceResolved = 0;
-        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);
-            // 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;
-                    }
-                    const targetSymbols = ctx.symbols.lookupAllInFile(def.filePath);
-                    if (targetSymbols.length === 0) {
-                        sliceFailed++;
-                        continue;
-                    }
-                    let bestMatch;
-                    for (const sym of targetSymbols) {
-                        const node = graph.getNode(toNodeId(sym.nodeId));
-                        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) {
-                        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++;
-                    }
-                }
-            }
-            service.notifyFileDeleted(absFilePath);
-        }
-        return { resolved: sliceResolved, failed: sliceFailed, results: sliceResults };
-    };
-    let resolved = 0;
-    let failed = 0;
-    if (actualWorkers === 1) {
-        const outcome = await resolveWorker(tsgoService);
-        resolved = outcome.resolved;
-        failed = outcome.failed;
-        for (const [k, v] of outcome.results)
-            results.set(k, v);
-    }
-    else {
-        const extraServices = [];
-        try {
-            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);
-            }
-            const services = [tsgoService, ...extraServices];
-            if (process.env['CODE_MAPPER_VERBOSE'])
-                console.error(`Code Mapper: ${services.length} tsgo processes ready, resolving with dynamic dispatch...`);
-            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 {
-            for (const svc of extraServices)
-                svc.stop();
-        }
-    }
-    const elapsed = Date.now() - t0;
-    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) */
 /** Generic method names that produce false edges when receiver type is unknown (worker-extracted path) */
 const GENERIC_MEMBER_METHODS_WORKER = new Set([
     'has', 'get', 'set', 'add', 'remove', 'delete', 'close', 'stop', 'clear', 'reset',
@@ -958,7 +746,7 @@ const GENERIC_MEMBER_METHODS_WORKER = new Set([
     'json', 'text', 'blob', 'status', 'send', 'end', // HTTP response
 ]);
 /** Resolve pre-extracted call sites from workers (no AST parsing needed) */
-export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onProgress, constructorBindings, tsgoService, repoPath) => {
+export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onProgress, constructorBindings) => {
     // Scope-aware receiver types keyed by filePath -> scope\0varName -> typeName
     const fileReceiverTypes = new Map();
     if (constructorBindings) {
@@ -978,11 +766,6 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
         }
         list.push(call);
     }
-    // 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, onProgress);
-    }
     const totalFiles = byFile.size;
     let filesProcessed = 0;
     for (const [filePath, calls] of byFile) {
@@ -1031,16 +814,7 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
             if (effectiveCall.callForm === 'member' && !effectiveCall.receiverTypeName && GENERIC_MEMBER_METHODS_WORKER.has(effectiveCall.calledName)) {
                 continue;
             }
-            // Check tsgo pre-resolved map first (highest confidence)
-            let resolved;
-            if (tsgoResolved && effectiveCall.callLine !== undefined) {
-                const callKey = `${effectiveCall.sourceId}\0${effectiveCall.calledName}\0${effectiveCall.callLine}`;
-                resolved = tsgoResolved.get(callKey);
-            }
-            // Fall through to heuristic resolution if tsgo didn't resolve
-            if (!resolved) {
-                resolved = resolveCallTarget(effectiveCall, effectiveCall.filePath, ctx);
-            }
+            let resolved = resolveCallTarget(effectiveCall, effectiveCall.filePath, ctx);
             // RC-I: Interface dispatch — when receiver type is an Interface, find implementations.
             // Strategy 1: Classes with IMPLEMENTS edges to the interface.
             // Strategy 2: Factory functions whose return type matches the interface name.
@@ -1371,7 +1145,7 @@ export const createProvidesEdges = async (graph, ctx) => {
  * 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 const resolveInterfaceDispatches = async (graph, ctx) => {
     let edgesCreated = 0;

package/dist/core/ingestion/pipeline.d.ts

@@ -1,5 +1,3 @@
 /** @file pipeline.ts @description Main ingestion pipeline that orchestrates scanning, parsing, resolution, community detection, and process detection across chunked file batches */
 import type { PipelineProgress, PipelineResult } from '../../types/pipeline.js';
-export declare const runPipelineFromRepo: (repoPath: string, onProgress: (progress: PipelineProgress) => void, opts?: {
-    tsgo?: boolean;
-}) => Promise<PipelineResult>;
+export declare const runPipelineFromRepo: (repoPath: string, onProgress: (progress: PipelineProgress) => void) => Promise<PipelineResult>;

package/dist/core/ingestion/pipeline.js

@@ -20,7 +20,6 @@ import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { memoryGuard } from '../../lib/memory-guard.js';
 import { toNodeId, toEdgeId } from '../db/schema.js';
-import { getTsgoService } from '../semantic/tsgo-service.js';
 const verbose = (...args) => {
     if (process.env['CODE_MAPPER_VERBOSE'])
         console.error(...args);
@@ -33,7 +32,7 @@ const DEFAULT_CHUNK_BYTE_BUDGET = 50 * 1024 * 1024;
 const WORKING_MEMORY_MULTIPLIER = 20;
 // Max AST trees to keep in LRU cache
 const AST_CACHE_CAP = 50;
-export const runPipelineFromRepo = async (repoPath, onProgress, opts) => {
+export const runPipelineFromRepo = async (repoPath, onProgress) => {
     const graph = createKnowledgeGraph();
     const ctx = createResolutionContext();
     const symbolTable = ctx.symbols;
@@ -272,7 +271,6 @@ export const runPipelineFromRepo = async (repoPath, onProgress, opts) => {
             }
             astCache.clear();
         }
-        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) {
@@ -282,35 +280,15 @@ export const runPipelineFromRepo = async (repoPath, onProgress, opts) => {
                 message: `Resolving ${allExtractedCalls.length} calls across all files...`,
                 stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
             });
-            // Start tsgo for high-confidence TS/JS resolution (optional — graceful fallback)
-            let tsgoService = null;
-            if (opts?.tsgo !== false) {
-                try {
-                    const service = getTsgoService(repoPath);
-                    if (await service.start()) {
-                        tsgoService = service;
-                        tsgoWasUsed = true;
-                    }
-                }
-                catch {
-                    // tsgo is optional — if @typescript/native-preview isn't installed, skip silently
-                }
-            }
-            try {
-                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, ...(workerCount ? { workerCount } : {}) },
-                    });
-                }, allConstructorBindings.length > 0 ? allConstructorBindings : undefined, tsgoService, repoPath);
-            }
-            finally {
-                // Stop tsgo after call resolution completes
-                tsgoService?.stop();
-            }
+            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, ...(workerCount ? { workerCount } : {}) },
+                });
+            }, allConstructorBindings.length > 0 ? allConstructorBindings : undefined);
         }
         {
             const rcStats = ctx.getStats();
@@ -446,7 +424,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, opts) => {
             },
         });
         astCache.clear();
-        return { graph, repoPath, totalFileCount: totalFiles, communityResult, processResult, tsgoEnabled: tsgoWasUsed };
+        return { graph, repoPath, totalFileCount: totalFiles, communityResult, processResult };
     }
     catch (error) {
         cleanup();

package/dist/core/ingestion/resolution-context.d.ts

@@ -11,7 +11,7 @@
  */
 import type { SymbolTable, SymbolDefinition } from './symbol-table.js';
 import type { NamedImportBinding } from './import-processor.js';
-export type ResolutionTier = 'tsgo-resolved' | 'same-file' | 'import-scoped' | 'global';
+export type ResolutionTier = 'same-file' | 'import-scoped' | 'global';
 export interface TieredCandidates {
     readonly candidates: readonly SymbolDefinition[];
     readonly tier: ResolutionTier;

package/dist/core/ingestion/resolution-context.js

@@ -15,7 +15,6 @@ import { isFileInPackageDir } from './import-processor.js';
 import { walkBindingChain } from './named-binding-extraction.js';
 // Confidence scores per resolution tier
 export const TIER_CONFIDENCE = {
-    'tsgo-resolved': 0.99,
     'same-file': 0.95,
     'import-scoped': 0.9,
     'global': 0.5,

package/dist/core/ingestion/utils.d.ts

@@ -46,6 +46,11 @@ export declare const CLASS_CONTAINER_TYPES: Set<string>;
 export declare const CONTAINER_TYPE_TO_LABEL: Record<string, string>;
 /** Walk up AST to find enclosing class/struct/impl and return its generateId (handles Go receivers) */
 export declare const findEnclosingClassId: (node: any, filePath: string) => string | null;
+/** Self-receiver keywords that should resolve to the enclosing class */
+export declare const SELF_RECEIVER_KEYWORDS: Set<string>;
+/** Walk up AST to find enclosing class/struct/impl and return its NAME (not ID).
+ *  Used to resolve `this.method()` / `self.method()` receiver type. */
+export declare const findEnclosingClassName: (node: any) => string | null;
 /** Extract function name and label from a function/method AST node (handles C/C++ qualified_identifier) */
 export declare const extractFunctionName: (node: any) => {
     funcName: string | null;

package/dist/core/ingestion/utils.js

@@ -369,6 +369,23 @@ export const findEnclosingClassId = (node, filePath) => {
     }
     return null;
 };
+/** Self-receiver keywords that should resolve to the enclosing class */
+export const SELF_RECEIVER_KEYWORDS = new Set(['this', 'self', 'base', 'parent']);
+/** Walk up AST to find enclosing class/struct/impl and return its NAME (not ID).
+ *  Used to resolve `this.method()` / `self.method()` receiver type. */
+export const findEnclosingClassName = (node) => {
+    let current = node.parent;
+    while (current) {
+        if (CLASS_CONTAINER_TYPES.has(current.type)) {
+            const nameNode = current.childForFieldName?.('name')
+                ?? current.children?.find((c) => c.type === 'type_identifier' || c.type === 'identifier' || c.type === 'name' || c.type === 'constant');
+            if (nameNode)
+                return nameNode.text;
+        }
+        current = current.parent;
+    }
+    return null;
+};
 /** Extract function name and label from a function/method AST node (handles C/C++ qualified_identifier) */
 export const extractFunctionName = (node) => {
     let funcName = null;

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

@@ -34,7 +34,7 @@ try {
     Kotlin = _require('tree-sitter-kotlin');
 }
 catch { }
-import { getLanguageFromFilename, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature, countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, CALL_EXPRESSION_TYPES, extractCallChain, } from '../utils.js';
+import { getLanguageFromFilename, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, getDefinitionNodeFromCaptures, findEnclosingClassId, findEnclosingClassName, SELF_RECEIVER_KEYWORDS, extractMethodSignature, countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, CALL_EXPRESSION_TYPES, extractCallChain, } from '../utils.js';
 import { buildTypeEnv } from '../type-env.js';
 import { isNodeExported } from '../export-detection.js';
 import { detectFrameworkFromAST } from '../framework-detection.js';
@@ -851,6 +851,12 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                         const callForm = callForm_pre;
                         let receiverName = callForm === 'member' ? extractReceiverName(callNameNode) : undefined;
                         let receiverTypeName = receiverName ? typeEnv.lookup(receiverName, callNode) : undefined;
+                        // Resolve this/self/base to enclosing class name
+                        if (!receiverTypeName && receiverName && SELF_RECEIVER_KEYWORDS.has(receiverName)) {
+                            const className = findEnclosingClassName(callNode);
+                            if (className)
+                                receiverTypeName = className;
+                        }
                         let receiverCallChain;
                         // When the receiver is complex (call chain or member chain),
                         // extractReceiverName returns undefined. Walk the AST to extract

package/dist/core/semantic/tsgo-service.d.ts

@@ -44,7 +44,7 @@ export declare class TsgoService {
     /** Whether the server is running and ready for queries */
     isReady(): boolean;
     /** Resolve what a symbol at a given position points to (go-to-definition) */
-    resolveDefinition(absFilePath: string, line: number, character: number): Promise<TsgoDefinition | null>;
+    resolveDefinition(absFilePath: string, line: number, character: number, timeoutMs?: number): Promise<TsgoDefinition | null>;
     /** Find all references to the symbol at the given position */
     findReferences(absFilePath: string, line: number, character: number): Promise<TsgoReference[]>;
     /** Get the type signature at a position (hover) */

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

@@ -68,7 +68,7 @@ export class TsgoService {
         return this.ready;
     }
     /** Resolve what a symbol at a given position points to (go-to-definition) */
-    async resolveDefinition(absFilePath, line, character) {
+    async resolveDefinition(absFilePath, line, character, timeoutMs = 3000) {
         if (!this.ready) {
             console.error('[tsgo-service] resolveDefinition called but not ready');
             return null;
@@ -77,7 +77,7 @@ export class TsgoService {
         const resp = await this.request('textDocument/definition', {
             textDocument: { uri: this.fileUri(absFilePath) },
             position: { line, character },
-        }, 3000);
+        }, timeoutMs);
         if (!resp) {
             verbose('definition timeout', absFilePath, line, character);
             return null;

package/dist/mcp/local/local-backend.d.ts

@@ -38,14 +38,10 @@ export declare class LocalBackend {
     /** Per-repo promise chain that serializes ensureFresh calls.
      *  Prevents race: Call 2 skipping refresh while Call 1 is still writing. */
     private refreshLocks;
-    /** Per-repo tsgo LSP service instances for live semantic enrichment */
-    private tsgoServices;
     /** Per-repo in-memory embedding cache: nodeId → Float32Array (256-dim) */
     private embeddingCaches;
     /** Per-repo in-memory NL embedding cache: includes source text for match_reason */
     private nlEmbeddingCaches;
-    /** Get (or lazily start) a tsgo LSP service for a repo. Returns null if unavailable. */
-    private getTsgo;
     /** Get (or lazily open) the SQLite database for a repo. */
     private getDb;
     /** Load all embeddings into memory for fast vector search */
@@ -104,7 +100,7 @@ export declare class LocalBackend {
         lastCommit: string;
         stats?: any;
     }>>;
-    /** Find the narrowest symbol node enclosing a given file position (for tsgo ref merging) */
+    /** Find the narrowest symbol node enclosing a given file position */
     private findNodeAtPosition;
     /** Extract signature from content. For interfaces/types, returns the full body (fields ARE the signature). */
     private extractSignature;

package/dist/mcp/local/local-backend.js

@@ -12,7 +12,6 @@ import * as queries from '../../core/db/queries.js';
 import { refreshFiles, refreshEmbeddings } from '../../core/incremental/refresh.js';
 import { FileSystemWatcher } from '../../core/incremental/watcher.js';
 import { toRepoRoot, toRelativeFilePath } from '../../core/incremental/types.js';
-import { getTsgoService, stopTsgoService } from '../../core/semantic/tsgo-service.js';
 import {} from '../../core/search/types.js';
 import { listRegisteredRepos, } from '../../storage/repo-manager.js';
 /** Quick test-file detection for filtering impact results across all supported languages */
@@ -53,29 +52,10 @@ export class LocalBackend {
     /** Per-repo promise chain that serializes ensureFresh calls.
      *  Prevents race: Call 2 skipping refresh while Call 1 is still writing. */
     refreshLocks = new Map();
-    /** Per-repo tsgo LSP service instances for live semantic enrichment */
-    tsgoServices = new Map();
     /** Per-repo in-memory embedding cache: nodeId → Float32Array (256-dim) */
     embeddingCaches = new Map();
     /** Per-repo in-memory NL embedding cache: includes source text for match_reason */
     nlEmbeddingCaches = new Map();
-    /** Get (or lazily start) a tsgo LSP service for a repo. Returns null if unavailable. */
-    async getTsgo(repo) {
-        const existing = this.tsgoServices.get(repo.id);
-        if (existing?.isReady())
-            return existing;
-        try {
-            const service = getTsgoService(repo.repoPath);
-            if (await service.start()) {
-                this.tsgoServices.set(repo.id, service);
-                return service;
-            }
-        }
-        catch {
-            // tsgo not available — completely fine, graph-only mode
-        }
-        return null;
-    }
     /** Get (or lazily open) the SQLite database for a repo. */
     getDb(repoId) {
         const handle = this.repos.get(repoId);
@@ -491,7 +471,7 @@ export class LocalBackend {
             stats: h.stats,
         }));
     }
-    /** Find the narrowest symbol node enclosing a given file position (for tsgo ref merging) */
+    /** Find the narrowest symbol node enclosing a given file position */
     findNodeAtPosition(db, filePath, line) {
         try {
             const rows = rawQuery(db, `SELECT name, label, filePath FROM nodes
@@ -968,11 +948,6 @@ export class LocalBackend {
             }
         }
         catch { }
-        // Warn if tsgo is unavailable — agents should know call resolution is heuristic-only
-        const tsgo = this.tsgoServices.get(repo.id);
-        if (!tsgo?.isReady()) {
-            warnings.push('⚠ tsgo unavailable — call resolution uses heuristic matching (install @typescript/native-preview for compiler-verified accuracy)');
-        }
         return warnings.length > 0 ? warnings.join('\n') + '\n\n' : '';
     }
     // ── Tool Dispatch ─────────────────────────────────────────────────
@@ -983,11 +958,6 @@ export class LocalBackend {
         // Resolve repo from optional param (re-reads registry on miss)
         const repo = await this.resolveRepo(params?.repo);
         await this.ensureFresh(repo);
-        // Eagerly attempt tsgo start so the staleness warning is accurate
-        // Agents can opt out with tsgo: false for faster responses
-        if (params?.tsgo !== false) {
-            await this.getTsgo(repo);
-        }
         // C3: Prepend staleness warning to all tool responses
         const staleWarning = this.getStalenessWarning(repo);
         switch (method) {
@@ -1933,7 +1903,7 @@ export class LocalBackend {
      * File overview: list all symbols in a file with signatures and caller/callee counts.
      * Triggered when context() is called with file_path only (no name/uid).
      */
-    async fileOverview(repo, filePath, includeContent, enableTsgo) {
+    async fileOverview(repo, filePath, includeContent) {
         const db = this.getDb(repo.id);
         // Find the file node and all symbols in it
         const fileNodes = findNodesByFile(db, filePath);
@@ -1955,7 +1925,7 @@ export class LocalBackend {
                 };
             }
             // Exact single match — re-query
-            return this.fileOverview(repo, allFiles[0].filePath, includeContent, enableTsgo);
+            return this.fileOverview(repo, allFiles[0].filePath, includeContent);
         }
         const symbols = fileNodes.filter(n => n.label !== 'File' && n.label !== 'Folder');
         // Fallback: file has no extractable symbols (e.g., imperative entry points, config files)
@@ -2004,23 +1974,13 @@ export class LocalBackend {
             for (const r of memberRows)
                 communityMap.set(r.sourceId, r.heuristicLabel);
         }
-        // Optionally enrich with tsgo hover for real type signatures
+        // Extract signatures from stored content using regex-based extraction
         const signatures = new Map();
-        if (enableTsgo !== false) {
-            const tsgo = await this.getTsgo(repo);
-            if (tsgo) {
-                const absBase = repo.repoPath;
-                for (const sym of symbols.slice(0, 30)) { // cap to avoid slow
-                    if (sym.startLine != null && /\.(ts|tsx|js|jsx|mts|mjs)$/.test(sym.filePath)) {
-                        try {
-                            const hover = await tsgo.getHover(path.resolve(absBase, sym.filePath), sym.startLine - 1, 0);
-                            if (hover) {
-                                const clean = hover.replace(/```\w*\n?/g, '').replace(/```/g, '').trim();
-                                signatures.set(sym.id, clean);
-                            }
-                        }
-                        catch { }
-                    }
+        for (const sym of symbols) {
+            if (sym.content) {
+                const sig = this.extractSignature(String(sym.content), sym.name, sym.label);
+                if (sig && sig !== sym.name) {
+                    signatures.set(sym.id, sig);
                 }
             }
         }
@@ -2061,7 +2021,7 @@ export class LocalBackend {
         const { name, uid, file_path, include_content } = params;
         // File overview mode: file_path only, no symbol name
         if (file_path && !name && !uid) {
-            return this.fileOverview(repo, file_path, include_content, params.tsgo);
+            return this.fileOverview(repo, file_path, include_content);
         }
         if (!name && !uid) {
             return { error: 'Either "name", "uid", or "file_path" parameter is required.' };
@@ -2088,47 +2048,7 @@ export class LocalBackend {
             }
             symbols = matchedNodes.map(n => ({ id: n.id, name: n.name, type: n.label, filePath: n.filePath, startLine: n.startLine, endLine: n.endLine, content: n.content }));
         }
-        // Symbol not found in graph — try tsgo live lookup for recently created symbols
         if (symbols.length === 0) {
-            try {
-                const tsgoFallback = params?.tsgo !== false ? await this.getTsgo(repo) : null;
-                if (tsgoFallback && name) {
-                    // Search FTS for files that mention this symbol, then ask tsgo for the type
-                    const searchResults = searchFTS(db, name, 5);
-                    for (const sr of searchResults) {
-                        if (sr.filePath && /\.(ts|tsx|js|jsx|mts|mjs)$/.test(sr.filePath)) {
-                            // Look up the full node to get startLine/endLine
-                            const fullNode = getNode(db, sr.id);
-                            const startLine = fullNode?.startLine ?? 1;
-                            const absPath = path.resolve(repo.repoPath, sr.filePath);
-                            const hover = await tsgoFallback.getHover(absPath, startLine - 1, 0);
-                            if (hover) {
-                                // Found it via tsgo — return a minimal context with live data
-                                const cleaned = hover.replace(/^```\w*\n?/, '').replace(/\n?```$/, '').trim();
-                                return {
-                                    status: 'found',
-                                    symbol: {
-                                        uid: sr.id,
-                                        name: sr.name ?? name,
-                                        kind: sr.label ?? 'Symbol',
-                                        filePath: sr.filePath,
-                                        startLine: fullNode?.startLine ?? null,
-                                        endLine: fullNode?.endLine ?? null,
-                                        signature: cleaned || name,
-                                        _source: 'tsgo-live',
-                                    },
-                                    incoming: {},
-                                    outgoing: {},
-                                    processes: [],
-                                };
-                            }
-                        }
-                    }
-                }
-            }
-            catch {
-                // tsgo fallback lookup failed — return normal not-found error
-            }
             return { error: `Symbol '${name || uid}' not found` };
         }
         // Step 2: Disambiguation
@@ -2160,41 +2080,6 @@ export class LocalBackend {
                 });
             }
         }
-        // Enrich incoming refs with tsgo live references (supplements stale graph)
-        // Agents can disable with tsgo: false for faster responses
-        const tsgo = params?.tsgo !== false ? await this.getTsgo(repo) : null;
-        if (tsgo && sym.filePath && /\.(ts|tsx|js|jsx|mts|mjs)$/.test(sym.filePath)) {
-            try {
-                const absPath = path.resolve(repo.repoPath, sym.filePath);
-                const liveRefs = await tsgo.findReferences(absPath, (sym.startLine ?? 1) - 1, 0);
-                // Merge live refs with graph refs — live refs may contain callers not in the graph
-                for (const ref of liveRefs) {
-                    // Skip self-references (same file, same line as the symbol definition)
-                    if (ref.filePath === sym.filePath && Math.abs(ref.line - ((sym.startLine ?? 1) - 1)) <= 1)
-                        continue;
-                    // Check if this reference is already known from the graph
-                    const alreadyKnown = incomingRows.some(row => row.filePath === ref.filePath && Math.abs((row.startLine ?? 0) - (ref.line + 1)) <= 2);
-                    if (!alreadyKnown) {
-                        // Find the enclosing function at this reference location
-                        const refNode = this.findNodeAtPosition(db, ref.filePath, ref.line);
-                        if (refNode) {
-                            incomingRows.push({
-                                relType: 'CALLS',
-                                uid: '',
-                                name: refNode.name,
-                                filePath: ref.filePath,
-                                kind: refNode.label,
-                                startLine: ref.line + 1,
-                                reason: 'tsgo-live',
-                            });
-                        }
-                    }
-                }
-            }
-            catch {
-                // tsgo reference lookup failed — non-fatal, graph results still available
-            }
-        }
         // Supplement callers from refs table (catches callers the graph missed)
         try {
             const refCallers = findRefsBySymbol(db, sym.name, 200);
@@ -2266,25 +2151,9 @@ export class LocalBackend {
             }
             return cats;
         };
-        // Always extract signature for compact display
+        // Extract signature for compact display
         const rawContent = sym.content || '';
-        let signature = rawContent ? this.extractSignature(String(rawContent), sym.name, sym.type) : sym.name;
-        // Enrich with tsgo for live type information (TS/JS files only)
-        if (tsgo && sym.filePath && /\.(ts|tsx|js|jsx|mts|mjs)$/.test(sym.filePath)) {
-            try {
-                const absPath = path.resolve(repo.repoPath, sym.filePath);
-                const hover = await tsgo.getHover(absPath, (sym.startLine ?? 1) - 1, 0);
-                if (hover) {
-                    // Strip markdown code fences if present (```typescript ... ```)
-                    const cleaned = hover.replace(/^```\w*\n?/, '').replace(/\n?```$/, '').trim();
-                    if (cleaned)
-                        signature = cleaned;
-                }
-            }
-            catch {
-                // tsgo hover failed — non-fatal, use regex-based signature
-            }
-        }
+        const signature = rawContent ? this.extractSignature(String(rawContent), sym.name, sym.type) : sym.name;
         return {
             status: 'found',
             symbol: {
@@ -2954,12 +2823,6 @@ export class LocalBackend {
         for (const watcher of this.watchers.values())
             watcher.stop();
         this.watchers.clear();
-        // Stop all per-repo tsgo LSP services
-        for (const service of this.tsgoServices.values()) {
-            service.stop();
-        }
-        this.tsgoServices.clear();
-        stopTsgoService(); // also stop the global singleton
         closeDb(); // close all SQLite connections
         // Note: we intentionally do NOT call disposeEmbedder() here.
         // ONNX Runtime's native cleanup segfaults on macOS and some Linux configs,

package/dist/mcp/tools.js

@@ -113,7 +113,6 @@ Handles disambiguation: if multiple symbols share the same name, returns candida
                 uid: { type: 'string', description: 'Direct symbol UID from prior tool results (zero-ambiguity lookup)' },
                 file_path: { type: 'string', description: 'File path to disambiguate common names' },
                 include_content: { type: 'boolean', description: 'Include full symbol source code (default: false)', default: false },
-                tsgo: { type: 'boolean', description: 'Enable tsgo LSP for live compiler-verified callers and type signatures. More accurate but adds ~1-2s latency. Default: true. Set false for speed.', default: true },
                 repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
             },
             required: [],

package/dist/types/pipeline.d.ts

@@ -24,8 +24,6 @@ export interface PipelineResult {
     totalFileCount: number;
     communityResult?: CommunityDetectionResult;
     processResult?: ProcessDetectionResult;
-    /** Whether tsgo LSP was used for high-confidence call resolution */
-    tsgoEnabled: boolean;
 }
 export interface SerializablePipelineResult {
     nodes: GraphNode[];

package/dist/types/pipeline.js

@@ -20,6 +20,5 @@ export const deserializePipelineResult = (serialized, createGraph) => {
         graph,
         repoPath: serialized.repoPath,
         totalFileCount: serialized.totalFileCount,
-        tsgoEnabled: false,
     };
 };

package/package.json

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