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

package/dist/cli/tool.d.ts

@@ -1,8 +1,7 @@
 /**
  * @file tool.ts
- * @description Direct CLI tool commands (query, context, impact, cypher). Bypasses MCP
- * entirely and invokes LocalBackend directly for minimal overhead. Output goes to stderr
- * because LadybugDB's native module captures stdout at the OS level during init
+ * @description Direct CLI tool commands (query, context, impact, sql). Bypasses MCP
+ * entirely and invokes LocalBackend directly for minimal overhead.
  */
 export declare function queryCommand(queryText: string, options?: {
     repo?: string;
@@ -16,13 +15,15 @@ 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 cypherCommand(query: string, options?: {
+export declare function sqlCommand(query: string, options?: {
     repo?: string;
 }): Promise<void>;

package/dist/cli/tool.js

@@ -1,9 +1,8 @@
 // code-mapper/src/cli/tool.ts
 /**
  * @file tool.ts
- * @description Direct CLI tool commands (query, context, impact, cypher). Bypasses MCP
- * entirely and invokes LocalBackend directly for minimal overhead. Output goes to stderr
- * because LadybugDB's native module captures stdout at the OS level during init
+ * @description Direct CLI tool commands (query, context, impact, sql). Bypasses MCP
+ * entirely and invokes LocalBackend directly for minimal overhead.
  */
 import { LocalBackend } from '../mcp/local/local-backend.js';
 let _backend = null;
@@ -20,11 +19,8 @@ async function getBackend() {
 }
 function output(data) {
     const text = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
-    // stderr because LadybugDB captures stdout at OS level
     process.stderr.write(text + '\n');
-    // Force exit — LadybugDB native module crashes on cleanup (mutex error)
-    // and prevents the process from exiting. This is safe because CLI is
-    // single-shot: once output is written, we're done.
+    // Force exit to ensure clean termination — CLI is single-shot.
     setTimeout(() => process.exit(0), 50);
 }
 export async function queryCommand(queryText, options) {
@@ -54,6 +50,7 @@ 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);
@@ -69,17 +66,18 @@ 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);
 }
-export async function cypherCommand(query, options) {
+export async function sqlCommand(query, options) {
     if (!query?.trim()) {
-        console.error('Usage: code-mapper cypher <cypher_query>');
+        console.error('Usage: code-mapper sql <sql_query>');
         process.exit(1);
     }
     const backend = await getBackend();
-    const result = await backend.callTool('cypher', {
+    const result = await backend.callTool('sql', {
         query,
         repo: options?.repo,
     });

package/dist/config/ignore-service.js

@@ -1,15 +1,15 @@
 // code-mapper/src/config/ignore-service.ts
 /** @file ignore-service.ts @description Hardcoded and user-configurable ignore rules for file/directory filtering during repo traversal */
-import ignore from 'ignore';
+import ignore, {} from 'ignore';
 import fs from 'fs/promises';
 import nodePath from 'path';
 const DEFAULT_IGNORE_LIST = new Set([
-    // Version control
+    // Version control internals
     '.git',
     '.svn',
     '.hg',
     '.bzr',
-    // IDEs and editors
+    // IDE/editor config (not source code)
     '.idea',
     '.vscode',
     '.vs',
@@ -17,16 +17,12 @@ const DEFAULT_IGNORE_LIST = new Set([
     '.settings',
     '.DS_Store',
     'Thumbs.db',
-    // Dependencies
+    // Downloaded dependencies (not your code)
     'node_modules',
     'bower_components',
     'jspm_packages',
-    'vendor', // PHP/Go
-    // 'packages' not ignored — commonly used for monorepo source code
     'venv',
     '.venv',
-    'env',
-    '.env',
     '__pycache__',
     '.pytest_cache',
     '.mypy_cache',
@@ -35,17 +31,14 @@ const DEFAULT_IGNORE_LIST = new Set([
     'eggs',
     '.eggs',
     'lib64',
-    'parts',
     'sdist',
     'wheels',
-    // Build outputs
+    // Compiled/bundled output (derived from source)
     'dist',
     'build',
     'out',
-    'output',
-    'bin',
     'obj',
-    'target', // Java, Rust
+    'target', // Java/Rust compiled output
     '.next',
     '.nuxt',
     '.output',
@@ -57,37 +50,26 @@ const DEFAULT_IGNORE_LIST = new Set([
     '.parcel-cache',
     '.turbo',
     '.svelte-kit',
-    // Test and coverage
+    // Coverage reports (not source code)
     'coverage',
     '.nyc_output',
     'htmlcov',
     '.coverage',
-    '__tests__',
-    '__mocks__',
     '.jest',
-    // Logs and temp
-    'logs',
-    'log',
+    // Temp/cache (ephemeral)
     'tmp',
     'temp',
     'cache',
     '.cache',
     '.tmp',
     '.temp',
-    // Generated and compiled
-    '.generated',
-    'generated',
-    'auto-generated',
+    // Infrastructure config (not source code)
     '.terraform',
-    '.serverless',
-    // Misc
+    // CI config (not source code)
     '.husky',
     '.github',
     '.circleci',
     '.gitlab',
-    'fixtures',
-    'snapshots',
-    '__snapshots__',
 ]);
 const IGNORED_EXTENSIONS = new Set([
     // Images
@@ -174,7 +156,7 @@ const IGNORED_FILES = new Set([
 export const shouldIgnorePath = (filePath) => {
     const normalizedPath = filePath.replace(/\\/g, '/');
     const parts = normalizedPath.split('/');
-    const fileName = parts[parts.length - 1];
+    const fileName = parts.at(-1) ?? '';
     const fileNameLower = fileName.toLowerCase();
     // Check if any path segment matches the ignore list
     for (const part of parts) {
@@ -202,11 +184,9 @@ export const shouldIgnorePath = (filePath) => {
     }
     // TODO: dot-file filtering intentionally skipped — many are important configs
     // Relies on explicit IGNORED_FILES list above instead
-    // Ignore generated/bundled code and TypeScript declaration files
+    // Ignore bundled/minified code (derived output, not source)
     if (fileNameLower.includes('.bundle.') ||
-        fileNameLower.includes('.chunk.') ||
-        fileNameLower.includes('.generated.') ||
-        fileNameLower.endsWith('.d.ts')) {
+        fileNameLower.includes('.chunk.')) {
         return true;
     }
     return false;
@@ -224,7 +204,7 @@ export const loadIgnoreRules = async (repoPath, options) => {
     const ig = ignore();
     let hasRules = false;
     // Allow users to bypass .gitignore parsing (e.g. when .gitignore accidentally excludes source files)
-    const skipGitignore = options?.noGitignore ?? !!process.env.CODE_MAPPER_NO_GITIGNORE;
+    const skipGitignore = options?.noGitignore ?? !!process.env['CODE_MAPPER_NO_GITIGNORE'];
     const filenames = skipGitignore
         ? ['.code-mapperignore']
         : ['.gitignore', '.code-mapperignore'];

package/dist/core/augmentation/engine.js

@@ -49,7 +49,6 @@ async function findRepoForCwd(cwd) {
         return {
             name: bestMatch.name,
             storagePath: bestMatch.storagePath,
-            lbugPath: path.join(bestMatch.storagePath, 'lbug'),
         };
     }
     catch {
@@ -74,64 +73,40 @@ export async function augment(pattern, cwd) {
         const repo = await findRepoForCwd(workDir);
         if (!repo)
             return '';
-        // Lazy-load lbug adapter
-        const { initLbug, executeQuery, isLbugReady } = await import('../../mcp/core/lbug-adapter.js');
-        const { searchFTSFromLbug } = await import('../search/bm25-index.js');
-        const repoId = repo.name.toLowerCase();
-        // Init LadybugDB if needed
-        if (!isLbugReady(repoId)) {
-            await initLbug(repoId, repo.lbugPath);
-        }
+        // Lazy-load SQLite adapter and search
+        const { openDb } = await import('../db/adapter.js');
+        const { toNodeId } = await import('../db/schema.js');
+        const { searchFTSSymbols } = await import('../search/bm25-index.js');
+        const { rawQuery } = await import('../db/adapter.js');
+        const dbPath = path.join(repo.storagePath, 'index.db');
+        const db = openDb(dbPath);
         // Step 1: BM25 search (fast, no embeddings needed)
-        const bm25Results = await searchFTSFromLbug(pattern, 10, repoId);
+        const bm25Results = searchFTSSymbols(pattern, 10, db);
         if (bm25Results.length === 0)
             return '';
-        // Step 2: Map BM25 file results to code symbols
-        const symbolMatches = [];
-        for (const result of bm25Results.slice(0, 5)) {
-            const escaped = result.filePath.replace(/'/g, "''");
-            try {
-                const symbols = await executeQuery(repoId, `
-          MATCH (n) WHERE n.filePath = '${escaped}'
-          AND n.name CONTAINS '${pattern.replace(/'/g, "''").split(/\s+/)[0]}'
-          RETURN n.id AS id, n.name AS name, labels(n) AS type, n.filePath AS filePath
-          LIMIT 3
-        `);
-                for (const sym of symbols) {
-                    symbolMatches.push({
-                        nodeId: sym.id || sym[0],
-                        name: sym.name || sym[1],
-                        type: sym.type || sym[2],
-                        filePath: sym.filePath || sym[3],
-                        score: result.score,
-                    });
-                }
-            }
-            catch { /* skip */ }
-        }
-        if (symbolMatches.length === 0)
-            return '';
-        // Step 3: Batch-fetch callers/callees/processes/cohesion (WHERE n.id IN [...])
-        const uniqueSymbols = symbolMatches.slice(0, 5).filter((sym, i, arr) => arr.findIndex(s => s.nodeId === sym.nodeId) === i);
+        // BM25 already returns symbol-level results (nodeId, name, type, filePath)
+        // so we skip the old "map file results to symbols" step.
+        const uniqueSymbols = bm25Results.slice(0, 5).filter((sym, i, arr) => arr.findIndex(s => s.nodeId === sym.nodeId) === i);
         if (uniqueSymbols.length === 0)
             return '';
-        const idList = uniqueSymbols.map(s => `'${s.nodeId.replace(/'/g, "''")}'`).join(', ');
+        const nodeIds = uniqueSymbols.map(s => toNodeId(s.nodeId));
+        const ph = nodeIds.map(() => '?').join(',');
+        // Step 2: Batch-fetch callers/callees/processes/cohesion via SQL
         // Callers
         const callersMap = new Map();
         try {
-            const rows = await executeQuery(repoId, `
-        MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(n)
-        WHERE n.id IN [${idList}]
-        RETURN n.id AS targetId, caller.name AS name
+            const rows = rawQuery(db, `
+        SELECT e.targetId AS targetId, n.name AS name
+        FROM edges e
+        JOIN nodes n ON n.id = e.sourceId
+        WHERE e.targetId IN (${ph}) AND e.type = 'CALLS'
         LIMIT 15
-      `);
+      `, [...nodeIds]);
             for (const r of rows) {
-                const tid = r.targetId || r[0];
-                const name = r.name || r[1];
-                if (tid && name) {
-                    if (!callersMap.has(tid))
-                        callersMap.set(tid, []);
-                    callersMap.get(tid).push(name);
+                if (r.targetId && r.name) {
+                    if (!callersMap.has(r.targetId))
+                        callersMap.set(r.targetId, []);
+                    callersMap.get(r.targetId)?.push(r.name);
                 }
             }
         }
@@ -139,19 +114,18 @@ export async function augment(pattern, cwd) {
         // Callees
         const calleesMap = new Map();
         try {
-            const rows = await executeQuery(repoId, `
-        MATCH (n)-[:CodeRelation {type: 'CALLS'}]->(callee)
-        WHERE n.id IN [${idList}]
-        RETURN n.id AS sourceId, callee.name AS name
+            const rows = rawQuery(db, `
+        SELECT e.sourceId AS sourceId, n.name AS name
+        FROM edges e
+        JOIN nodes n ON n.id = e.targetId
+        WHERE e.sourceId IN (${ph}) AND e.type = 'CALLS'
         LIMIT 15
-      `);
+      `, [...nodeIds]);
             for (const r of rows) {
-                const sid = r.sourceId || r[0];
-                const name = r.name || r[1];
-                if (sid && name) {
-                    if (!calleesMap.has(sid))
-                        calleesMap.set(sid, []);
-                    calleesMap.get(sid).push(name);
+                if (r.sourceId && r.name) {
+                    if (!calleesMap.has(r.sourceId))
+                        calleesMap.set(r.sourceId, []);
+                    calleesMap.get(r.sourceId)?.push(r.name);
                 }
             }
         }
@@ -159,20 +133,17 @@ export async function augment(pattern, cwd) {
         // Processes
         const processesMap = new Map();
         try {
-            const rows = await executeQuery(repoId, `
-        MATCH (n)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
-        WHERE n.id IN [${idList}]
-        RETURN n.id AS nodeId, p.heuristicLabel AS label, r.step AS step, p.stepCount AS stepCount
-      `);
+            const rows = rawQuery(db, `
+        SELECT e.sourceId AS nodeId, p.heuristicLabel AS label, e.step AS step, p.stepCount AS stepCount
+        FROM edges e
+        JOIN nodes p ON p.id = e.targetId
+        WHERE e.sourceId IN (${ph}) AND e.type = 'STEP_IN_PROCESS' AND p.label = 'Process'
+      `, [...nodeIds]);
             for (const r of rows) {
-                const nid = r.nodeId || r[0];
-                const label = r.label || r[1];
-                const step = r.step || r[2];
-                const stepCount = r.stepCount || r[3];
-                if (nid && label) {
-                    if (!processesMap.has(nid))
-                        processesMap.set(nid, []);
-                    processesMap.get(nid).push(`${label} (step ${step}/${stepCount})`);
+                if (r.nodeId && r.label) {
+                    if (!processesMap.has(r.nodeId))
+                        processesMap.set(r.nodeId, []);
+                    processesMap.get(r.nodeId)?.push(`${r.label} (step ${r.step}/${r.stepCount})`);
                 }
             }
         }
@@ -180,16 +151,15 @@ export async function augment(pattern, cwd) {
         // Cohesion (internal ranking signal)
         const cohesionMap = new Map();
         try {
-            const rows = await executeQuery(repoId, `
-        MATCH (n)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
-        WHERE n.id IN [${idList}]
-        RETURN n.id AS nodeId, c.cohesion AS cohesion
-      `);
+            const rows = rawQuery(db, `
+        SELECT e.sourceId AS nodeId, c.cohesion AS cohesion
+        FROM edges e
+        JOIN nodes c ON c.id = e.targetId
+        WHERE e.sourceId IN (${ph}) AND e.type = 'MEMBER_OF' AND c.label = 'Community'
+      `, [...nodeIds]);
             for (const r of rows) {
-                const nid = r.nodeId || r[0];
-                const coh = r.cohesion ?? r[1] ?? 0;
-                if (nid)
-                    cohesionMap.set(nid, coh);
+                if (r.nodeId)
+                    cohesionMap.set(r.nodeId, r.cohesion ?? 0);
             }
         }
         catch { /* skip */ }
@@ -207,7 +177,7 @@ export async function augment(pattern, cwd) {
         }
         if (enriched.length === 0)
             return '';
-        // Step 4: Rank by cohesion and format output
+        // Step 3: Rank by cohesion and format output
         enriched.sort((a, b) => b.cohesion - a.cohesion);
         const lines = [`[Code Mapper] ${enriched.length} related symbols found:`, ''];
         for (const item of enriched) {

package/dist/core/db/adapter.d.ts

@@ -0,0 +1,99 @@
+/**
+ * @file Unified SQLite database adapter for code-mapper.
+ *
+ * Single module for both CLI and MCP database access.
+ * WAL mode: concurrent readers + single writer, zero lock conflicts.
+ * Synchronous better-sqlite3 API: no connection pools needed.
+ *
+ * All public functions are typed with branded IDs and schema types
+ * from schema.ts — the compiler prevents passing wrong ID types
+ * or invalid labels/edge types.
+ */
+import Database from 'better-sqlite3';
+import { type NodeId, type NodeLabel, type EdgeType, type NodeRow, type EdgeRow, type NodeInsert, type EdgeInsert } from './schema.js';
+/** Open (or reuse) a SQLite database. Creates schema if new. */
+export declare function openDb(dbPath: string): Database.Database;
+/** Close one or all databases. */
+export declare function closeDb(dbPath?: string): void;
+/** Delete and recreate a database (full re-analyze). */
+export declare function resetDb(dbPath: string): Database.Database;
+/** Check if a database is open. */
+export declare function isDbOpen(dbPath: string): boolean;
+/**
+ * Expand an identifier into natural language words for FTS matching.
+ * camelCase, PascalCase, snake_case, UPPER_CASE → space-separated words.
+ *
+ * Examples:
+ *   buildTestGraph → "build test graph"
+ *   processCallsFromExtracted → "process calls from extracted"
+ *   MAX_CHAIN_DEPTH → "max chain depth"
+ *   deleteNodesByFile → "delete nodes by file"
+ */
+export declare function expandIdentifier(name: string): string;
+/** Insert or replace a node. Automatically expands name for FTS natural language matching. */
+export declare function insertNode(db: Database.Database, node: NodeInsert): void;
+/** Get a node by ID. Returns undefined if not found. */
+export declare function getNode(db: Database.Database, id: NodeId): NodeRow | undefined;
+/** Find nodes by name (optionally filtered by label). */
+export declare function findNodesByName(db: Database.Database, name: string, label?: NodeLabel, limit?: number): NodeRow[];
+/** Find nodes by file path. */
+export declare function findNodesByFile(db: Database.Database, filePath: string): NodeRow[];
+/** Find the node containing a given line in a file (best match). */
+export declare function findNodeAtLine(db: Database.Database, filePath: string, line: number, excludeLabel?: NodeLabel): NodeRow | undefined;
+/** Count nodes, optionally by label. */
+export declare function countNodes(db: Database.Database, label?: NodeLabel): number;
+/** Delete all nodes (and related edges/embeddings) for a file path. Returns count deleted. */
+export declare function deleteNodesByFile(db: Database.Database, filePath: string): number;
+/** Insert an edge (ignores duplicates). */
+export declare function insertEdge(db: Database.Database, edge: EdgeInsert): void;
+/** Find edges from a source node, optionally filtered by type. */
+export declare function findEdgesFrom(db: Database.Database, sourceId: NodeId, type?: EdgeType, minConfidence?: number): EdgeRow[];
+/** Find edges to a target node, optionally filtered by type. */
+export declare function findEdgesTo(db: Database.Database, targetId: NodeId, type?: EdgeType, minConfidence?: number): EdgeRow[];
+/** Count edges. */
+export declare function countEdges(db: Database.Database): number;
+/** Insert or replace an embedding (stores as binary Float32Array). */
+export declare function insertEmbedding(db: Database.Database, nodeId: NodeId, embedding: number[]): void;
+/** Delete embeddings for nodes in a given file. */
+export declare function deleteEmbeddingsByFile(db: Database.Database, filePath: string): void;
+/** Count embeddings. */
+export declare function countEmbeddings(db: Database.Database): number;
+/** Vector similarity search (brute-force cosine). Fast enough for <200K vectors at 256 dims. */
+export declare function searchVector(db: Database.Database, queryVec: number[], limit?: number, maxDistance?: number): Array<{
+    nodeId: NodeId;
+    distance: number;
+}>;
+/** Full-text search across nodes. FTS5 auto-maintains the index. */
+export declare function searchFTS(db: Database.Database, query: string, limit?: number): Array<{
+    id: NodeId;
+    name: string;
+    label: NodeLabel;
+    filePath: string;
+    score: number;
+}>;
+/** Get node count, edge count, and embedding count. */
+export declare function getStats(db: Database.Database): {
+    nodes: number;
+    edges: number;
+    embeddings: number;
+};
+/** Batch insert nodes in a single transaction. */
+export declare function insertNodesBatch(db: Database.Database, nodes: readonly NodeInsert[]): void;
+/** Batch insert edges in a single transaction. */
+export declare function insertEdgesBatch(db: Database.Database, edges: readonly EdgeInsert[]): void;
+/** Batch insert embeddings in a single transaction. */
+export declare function insertEmbeddingsBatch(db: Database.Database, items: readonly {
+    nodeId: NodeId;
+    embedding: number[];
+    textHash?: string;
+}[]): void;
+/** Get all textHashes from the embeddings table for hash-based skip on re-index */
+export declare function getEmbeddingHashes(db: Database.Database): Map<string, string>;
+/** Escape a string for use in SQL single-quoted literals. */
+export declare function escapeSql(value: string): string;
+/** Execute a raw SQL query and return rows. */
+export declare function rawQuery(db: Database.Database, sql: string, params?: unknown[]): unknown[];
+/** Execute a raw SQL statement (no return). */
+export declare function rawRun(db: Database.Database, sql: string, params?: unknown[]): {
+    changes: number;
+};