@zuvia-software-solutions/code-mapper 1.4.0 → 2.0.1

package/dist/cli/ai-context.js

@@ -62,7 +62,7 @@ This project is indexed by Code Mapper as **${projectName}** (${stats.nodes || 0
 | \`impact\` | Blast radius before editing | \`code-mapper_impact({target: "X", direction: "upstream"})\` |
 | \`detect_changes\` | Pre-commit scope check | \`code-mapper_detect_changes({scope: "staged"})\` |
 | \`rename\` | Safe multi-file rename | \`code-mapper_rename({symbol_name: "old", new_name: "new", dry_run: true})\` |
-| \`cypher\` | Custom graph queries | \`code-mapper_cypher({query: "MATCH ..."})\` |
+| \`sql\` | Custom SQL queries | \`code-mapper_sql({query: "SELECT ..."})\` |
 
 ## Impact Risk Levels
 

package/dist/cli/analyze.d.ts

@@ -2,6 +2,7 @@
 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

@@ -5,11 +5,14 @@ import { execFileSync } from 'child_process';
 import v8 from 'v8';
 import cliProgress from 'cli-progress';
 import { runPipelineFromRepo } from '../core/ingestion/pipeline.js';
-import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, createFTSIndex, loadCachedEmbeddings } from '../core/lbug/lbug-adapter.js';
+import { openDb, closeDb, resetDb, getStats, insertEmbeddingsBatch, countEmbeddings } from '../core/db/adapter.js';
+import { loadGraphToDb } from '../core/db/graph-loader.js';
+import { stitchRoutes } from '../core/ingestion/route-stitcher.js';
+import { toNodeId } from '../core/db/schema.js';
 // Embedding imports are lazy (dynamic import) so onnxruntime-node is never loaded when
 // embeddings are not requested, avoiding crashes on unsupported Node ABIs (#89)
 // disposeEmbedder intentionally not called — ONNX Runtime segfaults on cleanup (#38)
-import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, getGlobalRegistryPath, cleanupOldKuzuFiles } from '../storage/repo-manager.js';
+import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, getGlobalRegistryPath } from '../storage/repo-manager.js';
 import { getCurrentCommit, isGitRepo, getGitRoot } from '../storage/git.js';
 import { generateAIContextFiles } from './ai-context.js';
 import fs from 'fs/promises';
@@ -17,7 +20,7 @@ const HEAP_MB = 8192;
 const HEAP_FLAG = `--max-old-space-size=${HEAP_MB}`;
 /** Re-exec the process with an 8 GB heap if currently below that */
 function ensureHeap() {
-    const nodeOpts = process.env.NODE_OPTIONS || '';
+    const nodeOpts = process.env['NODE_OPTIONS'] || '';
     if (nodeOpts.includes('--max-old-space-size'))
         return false;
     const v8Heap = v8.getHeapStatistics().heap_size_limit;
@@ -34,7 +37,9 @@ function ensureHeap() {
     }
     return true;
 }
+const ANALYZE_PHASES = ['db', 'fts', 'embeddings', 'done'];
 const PHASE_LABELS = {
+    idle: 'Initializing...',
     extracting: 'Scanning files',
     structure: 'Building structure',
     parsing: 'Parsing code',
@@ -43,8 +48,10 @@ const PHASE_LABELS = {
     heritage: 'Extracting inheritance',
     communities: 'Detecting communities',
     processes: 'Detecting processes',
+    enriching: 'Enriching clusters',
     complete: 'Pipeline complete',
-    lbug: 'Loading into LadybugDB',
+    error: 'Error',
+    db: 'Loading into database',
     fts: 'Creating search indexes',
     embeddings: 'Generating embeddings',
     done: 'Done',
@@ -53,7 +60,7 @@ export const analyzeCommand = async (inputPath, options) => {
     if (ensureHeap())
         return;
     if (options?.verbose) {
-        process.env.CODE_MAPPER_VERBOSE = '1';
+        process.env['CODE_MAPPER_VERBOSE'] = '1';
     }
     console.log('\n  Code Mapper Analyzer\n');
     let repoPath;
@@ -74,20 +81,14 @@ export const analyzeCommand = async (inputPath, options) => {
         process.exitCode = 1;
         return;
     }
-    const { storagePath, lbugPath } = getStoragePaths(repoPath);
-    // Clean up stale KuzuDB files from before the LadybugDB migration
-    // If kuzu existed but lbug doesn't, we're doing a migration re-index
-    const kuzuResult = await cleanupOldKuzuFiles(storagePath);
-    if (kuzuResult.found && kuzuResult.needsReindex) {
-        console.log('  Migrating from KuzuDB to LadybugDB — rebuilding index...\n');
-    }
+    const { storagePath, dbPath } = getStoragePaths(repoPath);
     const currentCommit = getCurrentCommit(repoPath);
     const existingMeta = await loadMeta(storagePath);
     if (existingMeta && !options?.force && existingMeta.lastCommit === currentCommit) {
         console.log('  Already up to date\n');
         return;
     }
-    if (process.env.CODE_MAPPER_NO_GITIGNORE) {
+    if (process.env['CODE_MAPPER_NO_GITIGNORE']) {
         console.log('  CODE_MAPPER_NO_GITIGNORE is set — skipping .gitignore (still reading .code-mapperignore)\n');
     }
     // Single progress bar for the entire pipeline
@@ -110,7 +111,11 @@ export const analyzeCommand = async (inputPath, options) => {
         aborted = true;
         bar.stop();
         console.log('\n  Interrupted — cleaning up...');
-        closeLbug().catch(() => { }).finally(() => process.exit(130));
+        try {
+            closeDb(dbPath);
+        }
+        catch { }
+        process.exit(130);
     };
     process.on('SIGINT', sigintHandler);
     // Route all console output through bar.log() so the bar doesn't redraw
@@ -155,58 +160,50 @@ export const analyzeCommand = async (inputPath, options) => {
     if (options?.embeddings && existingMeta && !options?.force) {
         try {
             updateBar(0, 'Caching embeddings...');
-            await initLbug(lbugPath);
-            const cached = await loadCachedEmbeddings();
-            cachedEmbeddingNodeIds = cached.embeddingNodeIds;
-            cachedEmbeddings = cached.embeddings;
-            await closeLbug();
+            const oldDb = openDb(dbPath);
+            const rows = oldDb.prepare('SELECT nodeId, embedding FROM embeddings').all();
+            for (const row of rows) {
+                const nodeId = row.nodeId;
+                if (!nodeId)
+                    continue;
+                cachedEmbeddingNodeIds.add(nodeId);
+                const vec = new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4);
+                cachedEmbeddings.push({ nodeId, embedding: Array.from(vec) });
+            }
+            closeDb(dbPath);
         }
         catch {
             try {
-                await closeLbug();
+                closeDb(dbPath);
             }
             catch { }
         }
     }
-    // Phase 1: Full Pipeline (0–60%)
+    // Phase 1: Full Pipeline (0-60%)
     const pipelineResult = await runPipelineFromRepo(repoPath, (progress) => {
         const phaseLabel = PHASE_LABELS[progress.phase] || progress.phase;
         const scaled = Math.round(progress.percent * 0.6);
         updateBar(scaled, phaseLabel);
-    });
-    // Phase 2: LadybugDB (60–85%)
-    updateBar(60, 'Loading into LadybugDB...');
-    await closeLbug();
-    const lbugFiles = [lbugPath, `${lbugPath}.wal`, `${lbugPath}.lock`];
-    for (const f of lbugFiles) {
-        try {
-            await fs.rm(f, { recursive: true, force: true });
-        }
-        catch { }
-    }
-    const t0Lbug = Date.now();
-    await initLbug(lbugPath);
-    let lbugMsgCount = 0;
-    const lbugResult = await loadGraphToLbug(pipelineResult.graph, pipelineResult.repoPath, storagePath, (msg) => {
-        lbugMsgCount++;
-        const progress = Math.min(84, 60 + Math.round((lbugMsgCount / (lbugMsgCount + 10)) * 24));
+    }, options?.tsgo === false ? { tsgo: false } : {});
+    // Phase 2: SQLite (60-85%)
+    updateBar(60, 'Loading into database...');
+    // Reset the database (delete and recreate)
+    const t0Db = Date.now();
+    const db = resetDb(dbPath);
+    let dbMsgCount = 0;
+    const dbResult = loadGraphToDb(db, pipelineResult.graph, pipelineResult.repoPath, (msg) => {
+        dbMsgCount++;
+        const progress = Math.min(84, 60 + Math.round((dbMsgCount / (dbMsgCount + 10)) * 24));
         updateBar(progress, msg);
     });
-    const lbugTime = ((Date.now() - t0Lbug) / 1000).toFixed(1);
-    const lbugWarnings = lbugResult.warnings;
-    // Phase 3: FTS (85–90%)
-    updateBar(85, 'Creating search indexes...');
+    const dbTime = ((Date.now() - t0Db) / 1000).toFixed(1);
+    const dbWarnings = dbResult.warnings;
+    // Phase 2.5: HTTP route stitching (post-DB-load, needs content field)
+    stitchRoutes(db);
+    // Phase 3: FTS (85-90%)
+    // FTS5 is auto-created by schema triggers — no manual index creation needed
+    updateBar(85, 'Search indexes ready');
     const t0Fts = Date.now();
-    try {
-        await createFTSIndex('File', 'file_fts', ['name', 'content']);
-        await createFTSIndex('Function', 'function_fts', ['name', 'content']);
-        await createFTSIndex('Class', 'class_fts', ['name', 'content']);
-        await createFTSIndex('Method', 'method_fts', ['name', 'content']);
-        await createFTSIndex('Interface', 'interface_fts', ['name', 'content']);
-    }
-    catch (e) {
-        // Non-fatal — FTS is best-effort; silently continue
-    }
     const ftsTime = ((Date.now() - t0Fts) / 1000).toFixed(1);
     // Phase 3.5: Re-insert cached embeddings
     if (cachedEmbeddings.length > 0) {
@@ -214,15 +211,17 @@ export const analyzeCommand = async (inputPath, options) => {
         const EMBED_BATCH = 200;
         for (let i = 0; i < cachedEmbeddings.length; i += EMBED_BATCH) {
             const batch = cachedEmbeddings.slice(i, i + EMBED_BATCH);
-            const paramsList = batch.map(e => ({ nodeId: e.nodeId, embedding: e.embedding }));
             try {
-                await executeWithReusedStatement(`CREATE (e:CodeEmbedding {nodeId: $nodeId, embedding: $embedding})`, paramsList);
+                insertEmbeddingsBatch(db, batch.map(e => ({
+                    nodeId: toNodeId(e.nodeId),
+                    embedding: e.embedding,
+                })));
             }
             catch { /* some may fail if node was removed, that's fine */ }
         }
     }
-    // Phase 4: Embeddings (90–98%)
-    const stats = await getLbugStats();
+    // Phase 4: Embeddings (90-98%)
+    const stats = getStats(db);
     let embeddingTime = '0.0';
     let embeddingSkipped = true;
     let embeddingSkipReason = 'off (use --no-embeddings to skip)';
@@ -233,22 +232,19 @@ export const analyzeCommand = async (inputPath, options) => {
         updateBar(90, 'Loading embedding model...');
         const t0Emb = Date.now();
         const { runEmbeddingPipeline } = await import('../core/embeddings/embedding-pipeline.js');
-        await runEmbeddingPipeline(executeQuery, executeWithReusedStatement, (progress) => {
+        await runEmbeddingPipeline(db, (progress) => {
             const scaled = 90 + Math.round((progress.percent / 100) * 8);
             const label = progress.phase === 'loading-model' ? 'Loading embedding model...' : `Embedding ${progress.nodesProcessed || 0}/${progress.totalNodes || '?'}`;
             updateBar(scaled, label);
         }, {}, cachedEmbeddingNodeIds.size > 0 ? cachedEmbeddingNodeIds : undefined);
         embeddingTime = ((Date.now() - t0Emb) / 1000).toFixed(1);
     }
-    // Phase 5: Finalize (98–100%)
+    // Phase 5: Finalize (98-100%)
     updateBar(98, 'Saving metadata...');
     // Count embeddings in the index (cached + newly generated) for metadata
-    let embeddingCount = 0;
-    try {
-        const embResult = await executeQuery(`MATCH (e:CodeEmbedding) RETURN count(e) AS cnt`);
-        embeddingCount = embResult?.[0]?.cnt ?? 0;
-    }
-    catch { /* table may not exist if embeddings never ran */ }
+    const embeddingCount = countEmbeddings(db);
+    const communityCount = pipelineResult.communityResult?.stats.totalCommunities;
+    const processCount = pipelineResult.processResult?.stats.totalProcesses;
     const meta = {
         repoPath,
         lastCommit: currentCommit,
@@ -257,8 +253,8 @@ export const analyzeCommand = async (inputPath, options) => {
             files: pipelineResult.totalFileCount,
             nodes: stats.nodes,
             edges: stats.edges,
-            communities: pipelineResult.communityResult?.stats.totalCommunities,
-            processes: pipelineResult.processResult?.stats.totalProcesses,
+            ...(communityCount !== undefined ? { communities: communityCount } : {}),
+            ...(processCount !== undefined ? { processes: processCount } : {}),
             embeddings: embeddingCount,
         },
     };
@@ -279,13 +275,11 @@ export const analyzeCommand = async (inputPath, options) => {
         files: pipelineResult.totalFileCount,
         nodes: stats.nodes,
         edges: stats.edges,
-        communities: pipelineResult.communityResult?.stats.totalCommunities,
+        ...(communityCount !== undefined ? { communities: communityCount } : {}),
         clusters: aggregatedClusterCount,
-        processes: pipelineResult.processResult?.stats.totalProcesses,
+        ...(processCount !== undefined ? { processes: processCount } : {}),
     });
-    await closeLbug();
-    // NOTE: disposeEmbedder() is intentionally skipped — ONNX Runtime's native cleanup
-    // segfaults on macOS and some Linux configs; the process exits immediately after
+    closeDb(dbPath);
     const totalTime = ((Date.now() - t0Global) / 1000).toFixed(1);
     clearInterval(elapsedTimer);
     process.removeListener('SIGINT', sigintHandler);
@@ -298,18 +292,15 @@ export const analyzeCommand = async (inputPath, options) => {
     const embeddingsCached = cachedEmbeddings.length > 0;
     console.log(`\n  Repository indexed successfully (${totalTime}s)${embeddingsCached ? ` [${cachedEmbeddings.length} embeddings cached]` : ''}\n`);
     console.log(`  ${stats.nodes.toLocaleString()} nodes | ${stats.edges.toLocaleString()} edges | ${pipelineResult.communityResult?.stats.totalCommunities || 0} clusters | ${pipelineResult.processResult?.stats.totalProcesses || 0} flows`);
-    console.log(`  LadybugDB ${lbugTime}s | FTS ${ftsTime}s | Embeddings ${embeddingSkipped ? embeddingSkipReason : embeddingTime + 's'}`);
+    console.log(`  SQLite ${dbTime}s | FTS ${ftsTime}s | Embeddings ${embeddingSkipped ? embeddingSkipReason : embeddingTime + 's'}`);
+    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(', ')}`);
     }
-    // Show a quiet summary if some edge types needed fallback insertion
-    if (lbugWarnings.length > 0) {
-        const totalFallback = lbugWarnings.reduce((sum, w) => {
-            const m = w.match(/\((\d+) edges\)/);
-            return sum + (m ? parseInt(m[1]) : 0);
-        }, 0);
-        console.log(`  Note: ${totalFallback} edges across ${lbugWarnings.length} types inserted via fallback (schema will be updated in next release)`);
+    // Show a quiet summary if some node types had warnings during load
+    if (dbWarnings.length > 0) {
+        console.log(`  Note: ${dbWarnings.length} warnings during graph load`);
     }
     try {
         await fs.access(getGlobalRegistryPath());
@@ -318,8 +309,8 @@ export const analyzeCommand = async (inputPath, options) => {
         console.log('\n  Tip: Run `code-mapper setup` to configure MCP for your editor.');
     }
     console.log('');
-    // LadybugDB's native module holds open handles that prevent Node from exiting
-    // ONNX Runtime also registers native atexit hooks that segfault (#38, #40)
-    // Force-exit to ensure clean termination
+    // better-sqlite3 is synchronous and doesn't hold native handles that prevent exit.
+    // However, the MLX embedder (Python subprocess) or ONNX Runtime may still hold
+    // native handles, so force-exit to ensure clean termination.
     process.exit(0);
 };

package/dist/cli/augment.js

@@ -14,8 +14,6 @@ export async function augmentCommand(pattern) {
         const result = await augment(pattern, process.cwd());
         if (result) {
             // IMPORTANT: Write to stderr, NOT stdout
-            // LadybugDB's native module captures stdout fd at OS level during init,
-            // making stdout permanently broken in subprocess contexts
             // The hook reads from the subprocess's stderr
             process.stderr.write(result + '\n');
         }

package/dist/cli/eval-server.d.ts

@@ -1,6 +1,6 @@
 /**
  * @file eval-server.ts
- * @description Lightweight HTTP server for SWE-bench evaluation. Keeps LadybugDB warm in
+ * @description Lightweight HTTP server for SWE-bench evaluation. Keeps the database warm in
  * memory so tool calls from the agent are near-instant. Returns LLM-friendly text (not raw
  * JSON) and appends next-step hints for productive tool chaining (query -> context -> impact)
  *
@@ -18,7 +18,7 @@ export interface EvalServerOptions {
 export declare function formatQueryResult(result: any): string;
 export declare function formatContextResult(result: any): string;
 export declare function formatImpactResult(result: any): string;
-export declare function formatCypherResult(result: any): string;
+export declare function formatSqlResult(result: any): string;
 export declare function formatDetectChangesResult(result: any): string;
 export declare function formatListReposResult(result: any): string;
 export declare function evalServerCommand(options?: EvalServerOptions): Promise<void>;

package/dist/cli/eval-server.js

@@ -1,7 +1,7 @@
 // code-mapper/src/cli/eval-server.ts
 /**
  * @file eval-server.ts
- * @description Lightweight HTTP server for SWE-bench evaluation. Keeps LadybugDB warm in
+ * @description Lightweight HTTP server for SWE-bench evaluation. Keeps the database warm in
  * memory so tool calls from the agent are near-instant. Returns LLM-friendly text (not raw
  * JSON) and appends next-step hints for productive tool chaining (query -> context -> impact)
  *
@@ -141,7 +141,7 @@ export function formatImpactResult(result) {
     }
     return lines.join('\n').trim();
 }
-export function formatCypherResult(result) {
+export function formatSqlResult(result) {
     if (result.error)
         return `Error: ${result.error}`;
     if (Array.isArray(result)) {
@@ -211,7 +211,7 @@ function formatToolResult(toolName, result) {
         case 'query': return formatQueryResult(result);
         case 'context': return formatContextResult(result);
         case 'impact': return formatImpactResult(result);
-        case 'cypher': return formatCypherResult(result);
+        case 'sql': return formatSqlResult(result);
         case 'detect_changes': return formatDetectChangesResult(result);
         case 'list_repos': return formatListReposResult(result);
         default: return typeof result === 'string' ? result : JSON.stringify(result, null, 2);
@@ -227,7 +227,7 @@ function getNextStepHint(toolName) {
             return '\n---\nNext: To check what breaks if you change this, run code-mapper-impact "<name>" upstream';
         case 'impact':
             return '\n---\nNext: Review d=1 items first (WILL BREAK). Read the source with cat to understand the code, then make your fix.';
-        case 'cypher':
+        case 'sql':
             return '\n---\nNext: To explore a result symbol in depth, run code-mapper-context "<name>"';
         case 'detect_changes':
             return '\n---\nNext: Run code-mapper-context "<symbol>" on high-risk changed symbols to check their callers.';
@@ -284,7 +284,7 @@ export async function evalServerCommand(options) {
             // POST /tool/:name
             const toolMatch = req.url?.match(/^\/tool\/(\w+)$/);
             if (req.method === 'POST' && toolMatch) {
-                const toolName = toolMatch[1];
+                const toolName = toolMatch[1] ?? '';
                 const body = await readBody(req);
                 let args = {};
                 if (body.trim()) {
@@ -323,7 +323,7 @@ export async function evalServerCommand(options) {
         console.error(`  POST /tool/query    — search execution flows`);
         console.error(`  POST /tool/context  — 360-degree symbol view`);
         console.error(`  POST /tool/impact   — blast radius analysis`);
-        console.error(`  POST /tool/cypher   — raw Cypher query`);
+        console.error(`  POST /tool/sql      — raw SQL query`);
         console.error(`  GET  /health        — health check`);
         console.error(`  POST /shutdown      — graceful shutdown`);
         if (idleTimeoutSec > 0) {

package/dist/cli/index.js

@@ -24,19 +24,13 @@ program
     .option('-f, --force', 'Force full re-index even if up to date')
     .option('--embeddings', 'Enable embedding generation for semantic search (on by default)', true)
     .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'));
-program
-    .command('serve')
-    .description('Start local HTTP server for web UI connection')
-    .option('-p, --port <port>', 'Port number', '4747')
-    .option('--host <host>', 'Bind address (default: 127.0.0.1, use 0.0.0.0 for remote access)')
-    .action(createLazyAction(() => import('./serve.js'), 'serveCommand'));
 program
     .command('mcp')
     .description('Start MCP server (stdio) — serves all indexed repos')
-    .option('--tsgo', 'Enable tsgo semantic resolution for confidence-1.0 call edges')
     .action(createLazyAction(() => import('./mcp.js'), 'mcpCommand'));
 program
     .command('list')
@@ -78,6 +72,7 @@ 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>')
@@ -86,12 +81,13 @@ 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('cypher <query>')
-    .description('Execute raw Cypher query against the knowledge graph')
+    .command('sql <query>')
+    .description('Execute raw SQL query against the knowledge graph')
     .option('-r, --repo <name>', 'Target repository')
-    .action(createLazyAction(() => import('./tool.js'), 'cypherCommand'));
+    .action(createLazyAction(() => import('./tool.js'), 'sqlCommand'));
 // Eval server — persistent daemon for SWE-bench evaluation
 program
     .command('eval-server')

package/dist/cli/mcp.d.ts

@@ -3,6 +3,4 @@
  * @description Starts the MCP server in standalone mode. Loads all indexed repos from the
  * global registry — works from any directory
  */
-export declare const mcpCommand: (opts?: {
-    tsgo?: boolean;
-}) => Promise<void>;
+export declare const mcpCommand: () => Promise<void>;

package/dist/cli/mcp.js

@@ -6,9 +6,9 @@
  */
 import { startMCPServer } from '../mcp/server.js';
 import { LocalBackend } from '../mcp/local/local-backend.js';
-export const mcpCommand = async (opts) => {
+export const mcpCommand = async () => {
     // Prevent unhandled errors from crashing the MCP server process
-    // LadybugDB lock conflicts and transient errors should degrade gracefully
+    // Transient errors should degrade gracefully
     process.on('uncaughtException', (err) => {
         console.error(`Code Mapper MCP: uncaught exception — ${err.message}`);
         // Process is in undefined state after uncaughtException — exit after flushing
@@ -22,7 +22,7 @@ export const mcpCommand = async (opts) => {
     // Starts even with 0 repos — tools call refreshRepos() lazily,
     // so repos indexed after server start are discovered automatically
     const backend = new LocalBackend();
-    await backend.init({ tsgo: opts?.tsgo });
+    await backend.init();
     const repos = await backend.listRepos();
     if (repos.length === 0) {
         console.error('Code Mapper: No indexed repos yet. Run `code-mapper analyze` in a git repo — the server will pick it up automatically.');

package/dist/cli/refresh.d.ts

@@ -1,8 +1,8 @@
 /**
  * @file refresh.ts
  * @description CLI command for incremental refresh — re-indexes only files
- * changed since the last commit. Reuses the same RefreshCoordinator + child
- * process architecture as the MCP server's auto-refresh.
+ * changed since the last commit. Calls refreshFiles directly for in-process
+ * tree-sitter parsing and SQLite updates.
  *
  * Usage: code-mapper refresh [--scope unstaged|staged|committed]
  */

package/dist/cli/refresh.js

@@ -2,18 +2,17 @@
 /**
  * @file refresh.ts
  * @description CLI command for incremental refresh — re-indexes only files
- * changed since the last commit. Reuses the same RefreshCoordinator + child
- * process architecture as the MCP server's auto-refresh.
+ * changed since the last commit. Calls refreshFiles directly for in-process
+ * tree-sitter parsing and SQLite updates.
  *
  * Usage: code-mapper refresh [--scope unstaged|staged|committed]
  */
-import path from 'path';
 import { execFileSync } from 'child_process';
-import { RefreshCoordinator } from '../core/incremental/refresh-coordinator.js';
-import { toRepoId, toRepoRoot, toDbPath, toRelativeFilePath, } from '../core/incremental/types.js';
+import { refreshFiles, refreshEmbeddings } from '../core/incremental/refresh.js';
+import { toRelativeFilePath, } from '../core/incremental/types.js';
 import { getStoragePaths, loadMeta, saveMeta, } from '../storage/repo-manager.js';
 import { getCurrentCommit, getGitRoot, isGitRepo } from '../storage/git.js';
-import { initLbug, closeLbug, getLbugStats, executeQuery } from '../core/lbug/lbug-adapter.js';
+import { openDb, closeDb, getStats } from '../core/db/adapter.js';
 export const refreshCommand = async (options) => {
     const cwd = process.cwd();
     // Find repo root
@@ -26,13 +25,12 @@ export const refreshCommand = async (options) => {
         console.error('Could not determine git root.');
         process.exit(1);
     }
-    const { storagePath, lbugPath } = getStoragePaths(repoRoot);
+    const { storagePath } = getStoragePaths(repoRoot);
     const meta = await loadMeta(storagePath);
     if (!meta) {
         console.error('No Code Mapper index found. Run: code-mapper analyze');
         process.exit(1);
     }
-    const repoName = path.basename(repoRoot);
     const scope = options?.scope || 'committed';
     // Get changed files based on scope
     let diffArgs;
@@ -104,37 +102,33 @@ export const refreshCommand = async (options) => {
         return;
     }
     console.log(`Refreshing ${entries.length} file(s) (${description})...`);
-    // Initialize LadybugDB, query existing paths, then close before child fork
-    const repoId = repoName.toLowerCase();
-    let existingPaths = [];
+    // Open SQLite database
+    const { dbPath } = getStoragePaths(repoRoot);
+    let db;
     try {
-        await initLbug(lbugPath);
-        const rows = await executeQuery('MATCH (f:File) RETURN f.filePath AS filePath');
-        existingPaths = rows.map((r) => String(r.filePath ?? ''));
-        await closeLbug();
+        db = openDb(dbPath);
     }
     catch (err) {
-        console.error(`Failed to open index: ${err.message}`);
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Failed to open index: ${message}`);
         process.exit(1);
     }
-    // Run incremental refresh via the coordinator
-    const coordinator = new RefreshCoordinator();
+    // Run incremental refresh directly via refreshFiles
     const t0 = Date.now();
     try {
-        const result = await coordinator.refresh({
-            id: toRepoId(repoId),
-            repoRoot: toRepoRoot(repoRoot),
-            dbPath: toDbPath(lbugPath),
-            storagePath,
-        }, entries, existingPaths, 60_000);
+        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
         if (scope === 'committed' || scope === 'staged') {
             try {
-                await initLbug(lbugPath);
                 const currentCommitHash = getCurrentCommit(repoRoot);
-                const stats = await getLbugStats();
+                const stats = getStats(db);
                 await saveMeta(storagePath, {
                     repoPath: repoRoot,
                     lastCommit: currentCommitHash,
@@ -145,7 +139,7 @@ export const refreshCommand = async (options) => {
                         edges: stats.edges ?? meta.stats?.edges ?? 0,
                         communities: meta.stats?.communities ?? 0,
                         processes: meta.stats?.processes ?? 0,
-                        embeddings: meta.stats?.embeddings ?? 0,
+                        embeddings: stats.embeddings ?? meta.stats?.embeddings ?? 0,
                     },
                 });
             }
@@ -153,12 +147,13 @@ export const refreshCommand = async (options) => {
         }
     }
     catch (err) {
-        console.error(`Refresh failed: ${err.message}`);
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Refresh failed: ${message}`);
         process.exit(1);
     }
     finally {
         try {
-            await closeLbug();
+            closeDb(dbPath);
         }
         catch { }
     }

package/dist/cli/status.js

@@ -1,7 +1,7 @@
 // code-mapper/src/cli/status.ts
 /** @file status.ts @description Shows the indexing status of the current repository */
-import { findRepo, getStoragePaths, hasKuzuIndex } from '../storage/repo-manager.js';
-import { getCurrentCommit, isGitRepo, getGitRoot } from '../storage/git.js';
+import { findRepo } from '../storage/repo-manager.js';
+import { getCurrentCommit, isGitRepo } from '../storage/git.js';
 export const statusCommand = async () => {
     const cwd = process.cwd();
     if (!isGitRepo(cwd)) {
@@ -10,17 +10,8 @@ export const statusCommand = async () => {
     }
     const repo = await findRepo(cwd);
     if (!repo) {
-        // Check if there's a stale KuzuDB index that needs migration
-        const repoRoot = getGitRoot(cwd) ?? cwd;
-        const { storagePath } = getStoragePaths(repoRoot);
-        if (await hasKuzuIndex(storagePath)) {
-            console.log('Repository has a stale KuzuDB index from a previous version.');
-            console.log('Run: code-mapper analyze   (rebuilds the index with LadybugDB)');
-        }
-        else {
-            console.log('Repository not indexed.');
-            console.log('Run: code-mapper analyze');
-        }
+        console.log('Repository not indexed.');
+        console.log('Run: code-mapper analyze');
         return;
     }
     const currentCommit = getCurrentCommit(repo.repoPath);