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

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,10 +766,41 @@ 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);
+    // Pre-build indexes for O(1) lookups in the hot loop.
+    // Without these, interface dispatch does graph.relationships.filter() per call = O(calls × edges).
+    const implementsIndex = new Map(); // interfaceNodeId → [classNodeId, ...]
+    const hasMethodIndex = new Map(); // classNodeId → methods
+    const reverseImportIndex = new Map(); // importedFile → [importingFile, ...]
+    for (const rel of graph.iterRelationships()) {
+        if (rel.type === 'IMPLEMENTS') {
+            let arr = implementsIndex.get(rel.targetId);
+            if (!arr) {
+                arr = [];
+                implementsIndex.set(rel.targetId, arr);
+            }
+            arr.push(rel.sourceId);
+        }
+        else if (rel.type === 'HAS_METHOD') {
+            const methodNode = graph.getNode(rel.targetId);
+            if (methodNode) {
+                let arr = hasMethodIndex.get(rel.sourceId);
+                if (!arr) {
+                    arr = [];
+                    hasMethodIndex.set(rel.sourceId, arr);
+                }
+                arr.push({ targetId: rel.targetId, name: methodNode.properties.name });
+            }
+        }
+    }
+    for (const [file, importedFiles] of ctx.importMap) {
+        for (const imported of importedFiles) {
+            let arr = reverseImportIndex.get(imported);
+            if (!arr) {
+                arr = [];
+                reverseImportIndex.set(imported, arr);
+            }
+            arr.push(file);
+        }
     }
     const totalFiles = byFile.size;
     let filesProcessed = 0;
@@ -1031,16 +850,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.
@@ -1051,38 +861,29 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
                     const interfaceDefs = receiverResolved.candidates.filter(d => d.type === 'Interface' || d.type === 'Trait');
                     if (interfaceDefs.length > 0) {
                         for (const ifaceDef of interfaceDefs) {
-                            // Strategy 1: Class-based — find IMPLEMENTS edges
-                            const implRows = graph.relationships.filter(r => r.type === 'IMPLEMENTS' && r.targetId === toNodeId(ifaceDef.nodeId));
-                            for (const implRel of implRows) {
-                                const methodEdges = graph.relationships.filter(r => r.type === 'HAS_METHOD' && r.sourceId === implRel.sourceId);
-                                for (const methodEdge of methodEdges) {
-                                    const methodNode = graph.getNode(methodEdge.targetId);
-                                    if (methodNode && methodNode.properties.name === effectiveCall.calledName) {
-                                        resolved = { nodeId: methodEdge.targetId, confidence: 0.85, reason: 'interface-dispatch' };
-                                        break;
+                            // Strategy 1: Class-based — find IMPLEMENTS edges via pre-built index
+                            const implClassIds = implementsIndex.get(toNodeId(ifaceDef.nodeId));
+                            if (implClassIds) {
+                                for (const classId of implClassIds) {
+                                    const methods = hasMethodIndex.get(classId);
+                                    if (methods) {
+                                        const match = methods.find(m => m.name === effectiveCall.calledName);
+                                        if (match) {
+                                            resolved = { nodeId: match.targetId, confidence: 0.85, reason: 'interface-dispatch' };
+                                            break;
+                                        }
                                     }
                                 }
-                                if (resolved)
-                                    break;
                             }
                             if (resolved)
                                 break;
                             // Strategy 2: Factory/closure pattern — find functions returning this interface
-                            // e.g. createEventBus(): EventBus → the closure has emit/subscribe as inner functions
-                            // Look for the method name in files that import the interface's file
                             if (!resolved) {
                                 const methodName = effectiveCall.calledName;
                                 const ifaceFile = ifaceDef.filePath;
-                                // Check: which files import the interface's file?
-                                const importingFiles = [];
-                                for (const [file, importedFiles] of ctx.importMap) {
-                                    if (importedFiles.has(ifaceFile)) {
-                                        importingFiles.push(file);
-                                    }
-                                }
+                                const importingFiles = reverseImportIndex.get(ifaceFile) ?? [];
                                 // Also check the interface's own file
-                                importingFiles.push(ifaceFile);
-                                for (const file of importingFiles) {
+                                for (const file of [...importingFiles, ifaceFile]) {
                                     const method = ctx.symbols.lookupExactFull(file, methodName);
                                     if (method && (method.type === 'Function' || method.type === 'Method')) {
                                         resolved = { nodeId: method.nodeId, confidence: 0.75, reason: 'interface-factory-dispatch' };
@@ -1371,7 +1172,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;