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

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.1",
   "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",