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

package/dist/core/search/bm25-index.js

@@ -1,109 +1,65 @@
 // code-mapper/src/core/search/bm25-index.ts
 /**
  * @file bm25-index.ts
- * @description Symbol-level full-text search via LadybugDB FTS indexes.
+ * @description Symbol-level full-text search via SQLite FTS5 index.
  *
  * Returns individual symbols (functions, classes, methods, interfaces, files)
- * with their nodeId, name, type — NOT just filePaths.
+ * with their nodeId, name, type -- NOT just filePaths.
  * This gives the RRF merge symbol-level granularity for accurate ranking.
  *
- * All FTS tables are driven from FTS_TABLES in types.ts — single source of truth.
+ * Backed by the unified FTS5 index on the `nodes` table (see adapter.searchFTS).
  */
-import { queryFTS } from '../lbug/lbug-adapter.js';
-import { FTS_TABLES } from './types.js';
-/**
- * Execute a single FTS query returning symbol-level results.
- * Each result has nodeId + name + type, not just filePath.
- */
-async function queryFTSSymbols(executor, tableName, indexName, query, limit) {
-    const escapedQuery = query.replace(/\\/g, '\\\\').replace(/'/g, "''");
-    // Return node.id and node.name alongside filePath so we get symbol-level results
-    const isFile = tableName === 'File';
-    const returnFields = isFile
-        ? `node.id AS nodeId, node.name AS name, '${tableName}' AS type, node.filePath AS filePath, score`
-        : `node.id AS nodeId, node.name AS name, '${tableName}' AS type, node.filePath AS filePath, node.startLine AS startLine, node.endLine AS endLine, score`;
-    const cypher = `
-    CALL QUERY_FTS_INDEX('${tableName}', '${indexName}', '${escapedQuery}', conjunctive := false)
-    RETURN ${returnFields}
-    ORDER BY score DESC
-    LIMIT ${limit}
-  `;
-    try {
-        const rows = await executor(cypher);
-        return rows.map((row) => {
-            const r = row;
-            const rawScore = r.score ?? 0;
-            const score = typeof rawScore === 'number' ? rawScore : parseFloat(String(rawScore)) || 0;
-            return {
-                nodeId: String(r.nodeId ?? ''),
-                name: String(r.name ?? ''),
-                type: String(r.type ?? tableName),
-                filePath: String(r.filePath ?? ''),
-                score,
-                ...(!isFile && r.startLine != null ? { startLine: Number(r.startLine) } : {}),
-                ...(!isFile && r.endLine != null ? { endLine: Number(r.endLine) } : {}),
-            };
-        });
-    }
-    catch {
-        return [];
-    }
-}
+import { searchFTS } from '../db/adapter.js';
+import {} from './types.js';
+// ============================================================================
+// SYMBOL-TYPE WEIGHT MULTIPLIERS
+// ============================================================================
+/** Functions/methods are more actionable than files in search results */
+const TYPE_WEIGHTS = {
+    Function: 1.5,
+    Method: 1.5,
+    Class: 1.3,
+    Interface: 1.3,
+    File: 1.0,
+};
 // ============================================================================
 // MAIN SEARCH FUNCTION
 // ============================================================================
 /**
- * Symbol-level BM25 search via LadybugDB FTS.
+ * Symbol-level BM25 search via SQLite FTS5.
  *
- * Queries all FTS_TABLES in parallel. Returns individual symbols (not filePaths).
- * Deduplicates by nodeId — if the same symbol matches in multiple indexes,
- * take the highest score.
+ * Queries the unified `nodes_fts` virtual table, deduplicates by nodeId,
+ * applies type-based weighting, and returns ranked results.
+ *
+ * Synchronous under the hood (better-sqlite3), but the function is sync --
+ * callers that `await` it still work (await on a non-Promise is a no-op).
+ *
+ * @param query - Search text
+ * @param limit - Max results to return (default 20)
+ * @param db - Open SQLite database instance (required; returns [] if undefined)
  */
-export async function searchFTSFromLbug(query, limit = 20, repoId) {
-    const queryAll = [];
-    if (repoId) {
-        const { executeQuery } = await import('../../mcp/core/lbug-adapter.js');
-        const executor = (cypher) => executeQuery(repoId, cypher);
-        for (const { table, index } of FTS_TABLES) {
-            queryAll.push(queryFTSSymbols(executor, table, index, query, limit));
-        }
-    }
-    else {
-        for (const { table, index } of FTS_TABLES) {
-            queryAll.push(queryFTS(table, index, query, limit, false)
-                .then((rows) => rows.map(r => ({
-                nodeId: String(r.nodeId ?? r.id ?? ''),
-                name: String(r.name ?? ''),
-                type: table,
-                filePath: String(r.filePath ?? ''),
-                score: typeof r.score === 'number' ? r.score : 0,
-                ...(r.startLine != null ? { startLine: Number(r.startLine) } : {}),
-                ...(r.endLine != null ? { endLine: Number(r.endLine) } : {}),
-            })))
-                .catch(() => []));
-        }
-    }
-    const allResults = await Promise.all(queryAll);
-    // Symbol-type weight multipliers: functions/methods are more actionable than files
-    const TYPE_WEIGHTS = {
-        Function: 1.5,
-        Method: 1.5,
-        Class: 1.3,
-        Interface: 1.3,
-        File: 1.0,
-    };
-    // Deduplicate by nodeId — keep highest score per symbol, apply type weighting
+export function searchFTSSymbols(query, limit = 20, db) {
+    if (!db)
+        return [];
+    const ftsResults = searchFTS(db, query, limit * 2); // over-fetch for dedup headroom
+    // Deduplicate by node ID, apply type weighting, keep highest score per symbol
     const byNodeId = new Map();
-    for (const tableResults of allResults) {
-        for (const r of tableResults) {
-            if (!r.nodeId)
-                continue;
-            const weight = TYPE_WEIGHTS[r.type] ?? 1.0;
-            const weighted = { ...r, score: r.score * weight };
-            const existing = byNodeId.get(r.nodeId);
-            if (!existing || weighted.score > existing.score) {
-                byNodeId.set(r.nodeId, weighted);
-            }
+    for (const r of ftsResults) {
+        const id = r.id;
+        if (!id)
+            continue;
+        const weight = TYPE_WEIGHTS[r.label] ?? 1.0;
+        const weightedScore = r.score * weight;
+        const existing = byNodeId.get(id);
+        if (!existing || weightedScore > existing.score) {
+            byNodeId.set(id, {
+                nodeId: id,
+                name: r.name,
+                type: r.label,
+                filePath: r.filePath,
+                score: weightedScore,
+                rank: 0, // assigned below after sorting
+            });
         }
     }
     // Sort by score descending, assign rank
@@ -111,13 +67,7 @@ export async function searchFTSFromLbug(query, limit = 20, repoId) {
         .sort((a, b) => b.score - a.score)
         .slice(0, limit);
     return sorted.map((r, index) => ({
-        nodeId: r.nodeId,
-        name: r.name,
-        type: r.type,
-        filePath: r.filePath,
-        score: r.score,
+        ...r,
         rank: index + 1,
-        ...(r.startLine != null ? { startLine: r.startLine } : {}),
-        ...(r.endLine != null ? { endLine: r.endLine } : {}),
     }));
 }

package/dist/core/search/hybrid-search.d.ts

@@ -6,6 +6,7 @@
  * All constants come from types.ts (single source of truth)
  * This is the ONLY RRF implementation — local-backend.ts must import this, never reimplement
  */
+import type Database from 'better-sqlite3';
 import { type BM25SearchResult, type SemanticSearchResult, type HybridSearchResult, type RRFConfig } from './types.js';
 export type { HybridSearchResult, RRFConfig } from './types.js';
 /**
@@ -26,7 +27,12 @@ export declare function formatHybridResults(results: readonly HybridSearchResult
 /**
  * Execute BM25 + semantic search and merge with weighted RRF
  *
- * Uses LadybugDB FTS for always-fresh BM25 results
- * The semanticSearch function is injected to keep this module environment-agnostic
+ * Uses SQLite FTS5 for always-fresh BM25 results.
+ * The semanticSearch function is injected to keep this module environment-agnostic.
+ *
+ * @param db - Open SQLite database instance
+ * @param query - Search text
+ * @param limit - Max results to return
+ * @param semanticSearchFn - Async function that performs vector search given a db + query
  */
-export declare function hybridSearch(query: string, limit: number, executeQuery: (cypher: string) => Promise<unknown[]>, semanticSearchFn: (executeQuery: (cypher: string) => Promise<unknown[]>, query: string, k?: number) => Promise<SemanticSearchResult[]>): Promise<HybridSearchResult[]>;
+export declare function hybridSearch(db: Database.Database, query: string, limit: number, semanticSearchFn: (db: Database.Database, query: string, k?: number) => Promise<SemanticSearchResult[]>): Promise<HybridSearchResult[]>;

package/dist/core/search/hybrid-search.js

@@ -7,7 +7,7 @@
  * All constants come from types.ts (single source of truth)
  * This is the ONLY RRF implementation — local-backend.ts must import this, never reimplement
  */
-import { searchFTSFromLbug } from './bm25-index.js';
+import { searchFTSSymbols } from './bm25-index.js';
 import { DEFAULT_RRF_CONFIG, } from './types.js';
 /**
  * Merge BM25 and semantic results using weighted Reciprocal Rank Fusion
@@ -24,9 +24,10 @@ export function mergeWithRRF(bm25Results, semanticResults, config = {}) {
     // Mutable accumulator for building results
     const merged = new Map();
     // Score BM25 results — key by nodeId for symbol-level merging
-    for (let i = 0; i < bm25Results.length; i++) {
-        const r = bm25Results[i];
-        const rrfScore = bm25Weight * (1 / (k + i + 1)); // rank is 1-indexed
+    let bm25Rank = 0;
+    for (const r of bm25Results) {
+        bm25Rank++;
+        const rrfScore = bm25Weight * (1 / (k + bm25Rank)); // rank is 1-indexed
         const key = r.nodeId || r.filePath; // symbol-level key when available
         merged.set(key, {
             filePath: r.filePath,
@@ -36,14 +37,15 @@ export function mergeWithRRF(bm25Results, semanticResults, config = {}) {
             nodeId: r.nodeId,
             name: r.name,
             label: r.type,
-            startLine: r.startLine,
-            endLine: r.endLine,
+            ...(r.startLine != null ? { startLine: r.startLine } : {}),
+            ...(r.endLine != null ? { endLine: r.endLine } : {}),
         });
     }
     // Score and merge semantic results — same symbol-level keying
-    for (let i = 0; i < semanticResults.length; i++) {
-        const r = semanticResults[i];
-        const rrfScore = semanticWeight * (1 / (k + i + 1));
+    let semRank = 0;
+    for (const r of semanticResults) {
+        semRank++;
+        const rrfScore = semanticWeight * (1 / (k + semRank));
         const key = r.nodeId || r.filePath;
         const existing = merged.get(key);
         if (existing) {
@@ -72,8 +74,8 @@ export function mergeWithRRF(bm25Results, semanticResults, config = {}) {
                 nodeId: r.nodeId,
                 name: r.name,
                 label: r.label,
-                startLine: r.startLine,
-                endLine: r.endLine,
+                ...(r.startLine != null ? { startLine: r.startLine } : {}),
+                ...(r.endLine != null ? { endLine: r.endLine } : {}),
             });
         }
     }
@@ -86,13 +88,13 @@ export function mergeWithRRF(bm25Results, semanticResults, config = {}) {
         score: r.score,
         rank: i + 1,
         sources: r.sources,
-        bm25Score: r.bm25Score,
-        semanticScore: r.semanticScore,
-        nodeId: r.nodeId,
-        name: r.name,
-        label: r.label,
-        startLine: r.startLine,
-        endLine: r.endLine,
+        ...(r.bm25Score != null ? { bm25Score: r.bm25Score } : {}),
+        ...(r.semanticScore != null ? { semanticScore: r.semanticScore } : {}),
+        ...(r.nodeId != null ? { nodeId: r.nodeId } : {}),
+        ...(r.name != null ? { name: r.name } : {}),
+        ...(r.label != null ? { label: r.label } : {}),
+        ...(r.startLine != null ? { startLine: r.startLine } : {}),
+        ...(r.endLine != null ? { endLine: r.endLine } : {}),
     }));
 }
 // Hybrid search convenience functions
@@ -119,13 +121,16 @@ export function formatHybridResults(results) {
 /**
  * Execute BM25 + semantic search and merge with weighted RRF
  *
- * Uses LadybugDB FTS for always-fresh BM25 results
- * The semanticSearch function is injected to keep this module environment-agnostic
+ * Uses SQLite FTS5 for always-fresh BM25 results.
+ * The semanticSearch function is injected to keep this module environment-agnostic.
+ *
+ * @param db - Open SQLite database instance
+ * @param query - Search text
+ * @param limit - Max results to return
+ * @param semanticSearchFn - Async function that performs vector search given a db + query
  */
-export async function hybridSearch(query, limit, executeQuery, semanticSearchFn) {
-    const [bm25Results, semanticResults] = await Promise.all([
-        searchFTSFromLbug(query, limit),
-        semanticSearchFn(executeQuery, query, limit),
-    ]);
+export async function hybridSearch(db, query, limit, semanticSearchFn) {
+    const bm25Results = searchFTSSymbols(query, limit, db);
+    const semanticResults = await semanticSearchFn(db, query, limit);
     return mergeWithRRF(bm25Results, semanticResults, { limit });
 }

package/dist/core/search/reranker.js

@@ -15,7 +15,7 @@
 // ============================================================================
 // BGE reranker base — cross-encoder that understands code structure.
 // 278M params, ONNX, runs on CPU via transformers.js.
-// Tested: correctly ranks "initLbug" > "checkout" > "parseCode" > "README" for "database connection pool".
+// Tested: correctly ranks "openDb" > "checkout" > "parseCode" > "README" for "database connection pool".
 const RERANKER_MODEL_ID = 'Xenova/bge-reranker-base';
 let rerankerState = null;
 let initPromise = null;
@@ -69,7 +69,10 @@ export async function rerank(query, passages) {
     if (passages.length === 0)
         return [];
     if (passages.length === 1) {
-        return [{ id: passages[0].id, score: 1, originalRank: 1 }];
+        const first = passages[0];
+        if (first === undefined)
+            return [];
+        return [{ id: first.id, score: 1, originalRank: 1 }];
     }
     let state;
     try {
@@ -86,11 +89,10 @@ export async function rerank(query, passages) {
     }
     const { tokenizer, model } = state;
     const tok = tokenizer;
-    const mod = model;
     // Tokenize all (query, passage) pairs
     const queries = passages.map(() => query);
     const texts = passages.map(p => p.text);
-    const inputs = tok.call
+    const inputs = tok['call']
         ? await tokenizer(queries, { text_pair: texts, padding: true, truncation: true })
         : await tok.__call__(queries, { text_pair: texts, padding: true, truncation: true });
     const output = await model(inputs);
@@ -100,7 +102,7 @@ export async function rerank(query, passages) {
     return passages
         .map((p, i) => ({
         id: p.id,
-        score: scores[i],
+        score: scores[i] ?? 0,
         originalRank: i + 1,
     }))
         .sort((a, b) => b.score - a.score);
@@ -113,8 +115,8 @@ export function isRerankerReady() {
 export async function disposeReranker() {
     if (rerankerState) {
         const model = rerankerState.model;
-        if (typeof model.dispose === 'function') {
-            await model.dispose();
+        if (typeof model['dispose'] === 'function') {
+            await model['dispose']();
         }
         rerankerState = null;
         initPromise = null;

package/dist/core/search/types.d.ts

@@ -139,10 +139,6 @@ export interface RerankResult {
     readonly score: number;
     readonly originalRank: number;
 }
-/** Execute a raw Cypher query and return rows */
-export type CypherExecutor = (cypher: string) => Promise<readonly Record<string, unknown>[]>;
-/** Execute a parameterized Cypher query */
-export type ParameterizedCypherExecutor = (repoId: string, cypher: string, params: Record<string, unknown>) => Promise<readonly Record<string, unknown>[]>;
 export interface SearchPipelineItem {
     readonly nodeId?: string;
     readonly name: string;

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

@@ -24,8 +24,9 @@ export interface TsgoReference {
 }
 export declare class TsgoService {
     private process;
-    private buf;
     private responses;
+    /** Pending resolve callbacks keyed by request ID — event-driven, no polling */
+    private pending;
     private nextId;
     private projectRoot;
     private tsgoPath;
@@ -50,10 +51,13 @@ export declare class TsgoService {
     notifyFileChanged(absFilePath: string): Promise<void>;
     /** Notify tsgo that a file was deleted */
     notifyFileDeleted(absFilePath: string): Promise<void>;
+    /** Pre-open multiple files in one batch (fire-and-forget, no await per file) */
+    preOpenFiles(absFilePaths: readonly string[]): void;
     /** Stop the tsgo process */
     stop(): void;
     private doStart;
     private findTsgoBinary;
+    private rawBuf;
     private onData;
     private send;
     private request;