@zuvia-software-solutions/code-mapper 1.4.0

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

@@ -0,0 +1,131 @@
+// code-mapper/src/core/search/hybrid-search.ts
+/**
+ * @file hybrid-search.ts
+ * @description Combines BM25 (keyword) and semantic (embedding) search using
+ * weighted Reciprocal Rank Fusion (RRF) to merge rankings without score normalization
+ *
+ * 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 { DEFAULT_RRF_CONFIG, } from './types.js';
+/**
+ * Merge BM25 and semantic results using weighted Reciprocal Rank Fusion
+ *
+ * Formula: rrfScore = weight * (1 / (k + rank))
+ * Results found by both methods get both scores summed (consensus boost)
+ *
+ * @param bm25Results - BM25 keyword search results (pre-sorted by score desc)
+ * @param semanticResults - Semantic embedding search results (pre-sorted by distance asc)
+ * @param config - RRF configuration (weights, k, limit)
+ */
+export function mergeWithRRF(bm25Results, semanticResults, config = {}) {
+    const { bm25Weight, semanticWeight, k, limit } = { ...DEFAULT_RRF_CONFIG, ...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
+        const key = r.nodeId || r.filePath; // symbol-level key when available
+        merged.set(key, {
+            filePath: r.filePath,
+            score: rrfScore,
+            sources: ['bm25'],
+            bm25Score: r.score,
+            nodeId: r.nodeId,
+            name: r.name,
+            label: r.type,
+            startLine: r.startLine,
+            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));
+        const key = r.nodeId || r.filePath;
+        const existing = merged.get(key);
+        if (existing) {
+            // Same symbol found by both methods — consensus boost
+            existing.score += rrfScore;
+            existing.sources.push('semantic');
+            existing.semanticScore = 1 - r.distance;
+            // Prefer semantic metadata (has startLine/endLine from embedding table)
+            if (!existing.nodeId)
+                existing.nodeId = r.nodeId;
+            if (!existing.name)
+                existing.name = r.name;
+            if (!existing.label)
+                existing.label = r.label;
+            if (r.startLine != null)
+                existing.startLine = r.startLine;
+            if (r.endLine != null)
+                existing.endLine = r.endLine;
+        }
+        else {
+            merged.set(key, {
+                filePath: r.filePath,
+                score: rrfScore,
+                sources: ['semantic'],
+                semanticScore: 1 - r.distance,
+                nodeId: r.nodeId,
+                name: r.name,
+                label: r.label,
+                startLine: r.startLine,
+                endLine: r.endLine,
+            });
+        }
+    }
+    // Sort by combined RRF score descending, assign final ranks
+    const sorted = Array.from(merged.values())
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+    return sorted.map((r, i) => ({
+        filePath: r.filePath,
+        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,
+    }));
+}
+// Hybrid search convenience functions
+/** Check if hybrid search is available (FTS always available when DB is open) */
+export function isHybridSearchReady() {
+    return true;
+}
+/** Format hybrid results for LLM consumption */
+export function formatHybridResults(results) {
+    if (results.length === 0)
+        return 'No results found.';
+    const formatted = results.map((r, i) => {
+        const sources = r.sources.join(' + ');
+        const location = r.startLine ? ` (lines ${r.startLine}-${r.endLine})` : '';
+        const label = r.label ? `${r.label}: ` : 'File: ';
+        const name = r.name || r.filePath.split('/').pop() || r.filePath;
+        return `[${i + 1}] ${label}${name}
+    File: ${r.filePath}${location}
+    Found by: ${sources}
+    Relevance: ${r.score.toFixed(4)}`;
+    });
+    return `Found ${results.length} results:\n\n${formatted.join('\n\n')}`;
+}
+/**
+ * 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
+ */
+export async function hybridSearch(query, limit, executeQuery, semanticSearchFn) {
+    const [bm25Results, semanticResults] = await Promise.all([
+        searchFTSFromLbug(query, limit),
+        semanticSearchFn(executeQuery, query, limit),
+    ]);
+    return mergeWithRRF(bm25Results, semanticResults, { limit });
+}

package/dist/core/search/query-cache.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @file query-cache.ts
+ * @description LRU cache for embedding query vectors.
+ *
+ * Same query text always produces the same embedding vector.
+ * Caching avoids redundant model inference (~50-100ms per embed).
+ */
+export declare class QueryEmbeddingCache {
+    private readonly cache;
+    private readonly maxSize;
+    constructor(maxSize?: number);
+    get(query: string): readonly number[] | undefined;
+    set(query: string, embedding: readonly number[]): void;
+    get size(): number;
+    clear(): void;
+}
+/** Singleton cache for MCP server lifetime */
+export declare const queryEmbeddingCache: QueryEmbeddingCache;

package/dist/core/search/query-cache.js

@@ -0,0 +1,47 @@
+// code-mapper/src/core/search/query-cache.ts
+/**
+ * @file query-cache.ts
+ * @description LRU cache for embedding query vectors.
+ *
+ * Same query text always produces the same embedding vector.
+ * Caching avoids redundant model inference (~50-100ms per embed).
+ */
+const DEFAULT_MAX_SIZE = 128;
+export class QueryEmbeddingCache {
+    cache = new Map();
+    maxSize;
+    constructor(maxSize = DEFAULT_MAX_SIZE) {
+        this.maxSize = maxSize;
+    }
+    get(query) {
+        const cached = this.cache.get(query);
+        if (cached !== undefined) {
+            // Move to end (most recently used) by re-inserting
+            this.cache.delete(query);
+            this.cache.set(query, cached);
+        }
+        return cached;
+    }
+    set(query, embedding) {
+        // If already exists, delete first to refresh order
+        if (this.cache.has(query)) {
+            this.cache.delete(query);
+        }
+        // Evict oldest if at capacity
+        if (this.cache.size >= this.maxSize) {
+            const oldest = this.cache.keys().next().value;
+            if (oldest !== undefined) {
+                this.cache.delete(oldest);
+            }
+        }
+        this.cache.set(query, embedding);
+    }
+    get size() {
+        return this.cache.size;
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+/** Singleton cache for MCP server lifetime */
+export const queryEmbeddingCache = new QueryEmbeddingCache();

package/dist/core/search/query-expansion.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @file query-expansion.ts
+ * @description Pseudo-Relevance Feedback (PRF) for BM25 query expansion.
+ *
+ * Takes top-k BM25 results, extracts high-value terms (function/class names),
+ * and appends them to the original query for a second search pass.
+ * This helps BM25 find synonyms and related terms it would otherwise miss
+ * (e.g. "auth" expands to include "validateToken", "session").
+ *
+ * Fully local, no external dependencies.
+ */
+/**
+ * Expand a query using pseudo-relevance feedback.
+ *
+ * @param originalQuery - The user's original search query
+ * @param topResultNames - Names of symbols from top BM25 results
+ * @returns Expanded query string with additional terms appended
+ */
+export declare function expandQuery(originalQuery: string, topResultNames: readonly string[]): string;

package/dist/core/search/query-expansion.js

@@ -0,0 +1,75 @@
+// code-mapper/src/core/search/query-expansion.ts
+/**
+ * @file query-expansion.ts
+ * @description Pseudo-Relevance Feedback (PRF) for BM25 query expansion.
+ *
+ * Takes top-k BM25 results, extracts high-value terms (function/class names),
+ * and appends them to the original query for a second search pass.
+ * This helps BM25 find synonyms and related terms it would otherwise miss
+ * (e.g. "auth" expands to include "validateToken", "session").
+ *
+ * Fully local, no external dependencies.
+ */
+/** Number of top results to use for expansion */
+const PRF_TOP_K = 3;
+/** Max terms to add from PRF */
+const PRF_MAX_TERMS = 5;
+/** Minimum term length to consider */
+const PRF_MIN_TERM_LENGTH = 3;
+/** Common noise words to exclude from expansion */
+const STOP_WORDS = new Set([
+    'function', 'class', 'method', 'interface', 'const', 'let', 'var',
+    'return', 'import', 'export', 'from', 'async', 'await', 'this',
+    'true', 'false', 'null', 'undefined', 'new', 'type', 'string',
+    'number', 'boolean', 'void', 'any', 'object', 'array', 'file',
+    'index', 'test', 'spec', 'module', 'default', 'private', 'public',
+    'static', 'readonly', 'abstract', 'extends', 'implements',
+]);
+/**
+ * Extract expansion terms from top BM25 results.
+ *
+ * Splits symbol names by camelCase/PascalCase/snake_case boundaries,
+ * deduplicates, and filters noise.
+ */
+function extractTerms(symbolNames) {
+    const termCounts = new Map();
+    for (const name of symbolNames) {
+        // Split camelCase/PascalCase: "validateUserToken" → ["validate", "user", "token"]
+        const parts = name
+            .replace(/([a-z])([A-Z])/g, '$1 $2')
+            .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+            .replace(/[_\-./]/g, ' ')
+            .toLowerCase()
+            .split(/\s+/)
+            .filter(t => t.length >= PRF_MIN_TERM_LENGTH && !STOP_WORDS.has(t));
+        for (const part of parts) {
+            termCounts.set(part, (termCounts.get(part) ?? 0) + 1);
+        }
+    }
+    // Sort by frequency, take top terms
+    return Array.from(termCounts.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, PRF_MAX_TERMS)
+        .map(([term]) => term);
+}
+/**
+ * Expand a query using pseudo-relevance feedback.
+ *
+ * @param originalQuery - The user's original search query
+ * @param topResultNames - Names of symbols from top BM25 results
+ * @returns Expanded query string with additional terms appended
+ */
+export function expandQuery(originalQuery, topResultNames) {
+    if (topResultNames.length === 0)
+        return originalQuery;
+    const topK = topResultNames.slice(0, PRF_TOP_K);
+    const expansionTerms = extractTerms(topK);
+    if (expansionTerms.length === 0)
+        return originalQuery;
+    // Filter out terms already in the query
+    const queryLower = originalQuery.toLowerCase();
+    const newTerms = expansionTerms.filter(t => !queryLower.includes(t));
+    if (newTerms.length === 0)
+        return originalQuery;
+    return `${originalQuery} ${newTerms.join(' ')}`;
+}

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

@@ -0,0 +1,29 @@
+/**
+ * @file reranker.ts
+ * @description Cross-encoder re-ranker for improving top-k precision.
+ *
+ * Uses bge-reranker-v2-m3 (ONNX) via transformers.js — fully local, no external APIs.
+ * Lazy-loaded on first use to avoid blocking MCP server startup.
+ *
+ * Pipeline: BM25 + semantic → RRF merge (top N) → re-rank (top K)
+ * The re-ranker scores (query, passage) pairs jointly, giving much higher precision
+ * than bi-encoder similarity for the final ranking.
+ */
+import type { RerankResult } from './types.js';
+interface RerankInput {
+    readonly id: string;
+    readonly text: string;
+}
+/**
+ * Re-rank passages against a query using a cross-encoder model.
+ *
+ * @param query - The search query
+ * @param passages - Array of {id, text} to score against the query
+ * @returns Passages sorted by cross-encoder score (highest first)
+ */
+export declare function rerank(query: string, passages: readonly RerankInput[]): Promise<RerankResult[]>;
+/** Check if the re-ranker model is loaded */
+export declare function isRerankerReady(): boolean;
+/** Dispose the re-ranker model */
+export declare function disposeReranker(): Promise<void>;
+export {};

package/dist/core/search/reranker.js

@@ -0,0 +1,122 @@
+// code-mapper/src/core/search/reranker.ts
+/**
+ * @file reranker.ts
+ * @description Cross-encoder re-ranker for improving top-k precision.
+ *
+ * Uses bge-reranker-v2-m3 (ONNX) via transformers.js — fully local, no external APIs.
+ * Lazy-loaded on first use to avoid blocking MCP server startup.
+ *
+ * Pipeline: BM25 + semantic → RRF merge (top N) → re-rank (top K)
+ * The re-ranker scores (query, passage) pairs jointly, giving much higher precision
+ * than bi-encoder similarity for the final ranking.
+ */
+// ============================================================================
+// MODEL CONFIGURATION
+// ============================================================================
+// 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".
+const RERANKER_MODEL_ID = 'Xenova/bge-reranker-base';
+let rerankerState = null;
+let initPromise = null;
+// ============================================================================
+// INITIALIZATION
+// ============================================================================
+async function initReranker() {
+    if (rerankerState)
+        return rerankerState;
+    if (initPromise)
+        return initPromise;
+    initPromise = (async () => {
+        try {
+            console.error('Code Mapper: Loading re-ranker model (first use may take a moment)...');
+            const { AutoModelForSequenceClassification, AutoTokenizer } = await import('@huggingface/transformers');
+            // Silence stdout during model load (prevents ONNX output from corrupting MCP stdio)
+            const origStdout = process.stdout.write;
+            const origStderr = process.stderr.write;
+            process.stdout.write = (() => true);
+            process.stderr.write = (() => true);
+            let tokenizer;
+            let model;
+            try {
+                tokenizer = await AutoTokenizer.from_pretrained(RERANKER_MODEL_ID);
+                model = await AutoModelForSequenceClassification.from_pretrained(RERANKER_MODEL_ID);
+            }
+            finally {
+                process.stdout.write = origStdout;
+                process.stderr.write = origStderr;
+            }
+            console.error('Code Mapper: Re-ranker model loaded');
+            rerankerState = { model, tokenizer };
+            return rerankerState;
+        }
+        catch (error) {
+            initPromise = null;
+            rerankerState = null;
+            throw error;
+        }
+    })();
+    return initPromise;
+}
+/**
+ * Re-rank passages against a query using a cross-encoder model.
+ *
+ * @param query - The search query
+ * @param passages - Array of {id, text} to score against the query
+ * @returns Passages sorted by cross-encoder score (highest first)
+ */
+export async function rerank(query, passages) {
+    if (passages.length === 0)
+        return [];
+    if (passages.length === 1) {
+        return [{ id: passages[0].id, score: 1, originalRank: 1 }];
+    }
+    let state;
+    try {
+        state = await initReranker();
+    }
+    catch {
+        // If re-ranker fails to load, return original order with synthetic scores
+        console.error('Code Mapper: Re-ranker unavailable, using original ranking');
+        return passages.map((p, i) => ({
+            id: p.id,
+            score: passages.length - i,
+            originalRank: i + 1,
+        }));
+    }
+    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
+        ? 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);
+    const logits = output.logits;
+    const scores = Array.from(logits.data);
+    // Pair with original info and sort by score descending
+    return passages
+        .map((p, i) => ({
+        id: p.id,
+        score: scores[i],
+        originalRank: i + 1,
+    }))
+        .sort((a, b) => b.score - a.score);
+}
+/** Check if the re-ranker model is loaded */
+export function isRerankerReady() {
+    return rerankerState !== null;
+}
+/** Dispose the re-ranker model */
+export async function disposeReranker() {
+    if (rerankerState) {
+        const model = rerankerState.model;
+        if (typeof model.dispose === 'function') {
+            await model.dispose();
+        }
+        rerankerState = null;
+        initPromise = null;
+    }
+}

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

@@ -0,0 +1,154 @@
+/**
+ * @file types.ts
+ * @description Single source of truth for all search system types and constants.
+ *
+ * Every search-related type, constant, and configuration lives here.
+ * No other file should declare search constants — import from here.
+ * Compiler enforces this via branded types and exhaustive checks.
+ */
+/** RRF fusion constant. Higher = more weight to lower-ranked results. */
+export declare const RRF_K: 60;
+/** Default max cosine distance for semantic search — filters noise before RRF merge */
+export declare const DEFAULT_MAX_SEMANTIC_DISTANCE: 0.85;
+/** Default number of processes to return */
+export declare const DEFAULT_PROCESS_LIMIT: 5;
+/** Default max symbols per process */
+export declare const DEFAULT_MAX_SYMBOLS_PER_PROCESS: 10;
+/** Max standalone definitions to return (keep tight — File-type noise is filtered separately) */
+export declare const DEFAULT_MAX_DEFINITIONS: 5;
+/** Cohesion boost weight in process ranking (0-1). Higher = prefer tight functional units. */
+export declare const COHESION_WEIGHT: 0.25;
+/** Max candidates to pass to batch DB lookups (process/cluster/content) after reranking */
+export declare const MAX_BATCH_CANDIDATES: 25;
+/** BM25 PRF expansion threshold — expand when top score is weak OR results are sparse */
+export declare const PRF_SPARSE_THRESHOLD: 5;
+export declare const PRF_WEAK_SCORE_THRESHOLD: 1;
+/**
+ * FTS-indexed node tables and their index names.
+ * Adding a table here automatically includes it in BM25 search.
+ * Removing one is a compile error wherever it's referenced.
+ */
+export declare const FTS_TABLES: readonly [{
+    readonly table: "File";
+    readonly index: "file_fts";
+}, {
+    readonly table: "Function";
+    readonly index: "function_fts";
+}, {
+    readonly table: "Class";
+    readonly index: "class_fts";
+}, {
+    readonly table: "Method";
+    readonly index: "method_fts";
+}, {
+    readonly table: "Interface";
+    readonly index: "interface_fts";
+}];
+export type FTSTableName = typeof FTS_TABLES[number]['table'];
+export type FTSIndexName = typeof FTS_TABLES[number]['index'];
+export type SearchSource = 'bm25' | 'semantic';
+export interface BM25SearchResult {
+    readonly nodeId: string;
+    readonly name: string;
+    readonly type: string;
+    readonly filePath: string;
+    readonly score: number;
+    readonly rank: number;
+    readonly startLine?: number;
+    readonly endLine?: number;
+}
+export interface SemanticSearchResult {
+    readonly nodeId: string;
+    readonly name: string;
+    readonly label: string;
+    readonly filePath: string;
+    readonly distance: number;
+    readonly startLine?: number;
+    readonly endLine?: number;
+}
+export interface HybridSearchResult {
+    readonly filePath: string;
+    readonly score: number;
+    readonly rank: number;
+    readonly sources: readonly SearchSource[];
+    readonly nodeId?: string;
+    readonly name?: string;
+    readonly label?: string;
+    readonly startLine?: number;
+    readonly endLine?: number;
+    readonly bm25Score?: number;
+    readonly semanticScore?: number;
+}
+export interface SymbolEntry {
+    readonly id: string;
+    readonly name: string;
+    readonly type: string;
+    readonly filePath: string;
+    readonly startLine?: number;
+    readonly endLine?: number;
+    readonly module?: string;
+    readonly content?: string;
+}
+export interface ProcessSymbolEntry extends SymbolEntry {
+    readonly process_id: string;
+    readonly step_index: number;
+}
+export interface ProcessEntry {
+    readonly id: string;
+    readonly label: string;
+    readonly heuristicLabel: string;
+    readonly processType: string;
+    readonly stepCount: number;
+    readonly totalScore: number;
+    readonly cohesionBoost: number;
+    readonly symbols: ProcessSymbolEntry[];
+}
+export interface QueryResponse {
+    readonly processes: ReadonlyArray<{
+        readonly id: string;
+        readonly summary: string;
+        readonly priority: number;
+        readonly symbol_count: number;
+        readonly process_type: string;
+        readonly step_count: number;
+    }>;
+    readonly process_symbols: readonly ProcessSymbolEntry[];
+    readonly definitions: readonly SymbolEntry[];
+}
+export interface QueryParams {
+    readonly query: string;
+    readonly task_context?: string;
+    readonly goal?: string;
+    readonly limit?: number;
+    readonly max_symbols?: number;
+    readonly include_content?: boolean;
+}
+export interface RRFConfig {
+    /** Weight for BM25 results (0-1). Default 0.6. */
+    readonly bm25Weight: number;
+    /** Weight for semantic results (0-1). Default 0.4. */
+    readonly semanticWeight: number;
+    /** RRF constant K. Default 60. */
+    readonly k: number;
+    /** Max results to return. */
+    readonly limit: number;
+}
+export declare const DEFAULT_RRF_CONFIG: RRFConfig;
+export interface RerankResult {
+    readonly id: string;
+    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;
+    readonly type: string;
+    readonly filePath: string;
+    readonly startLine?: number;
+    readonly endLine?: number;
+    readonly score: number;
+}

package/dist/core/search/types.js

@@ -0,0 +1,51 @@
+// code-mapper/src/core/search/types.ts
+/**
+ * @file types.ts
+ * @description Single source of truth for all search system types and constants.
+ *
+ * Every search-related type, constant, and configuration lives here.
+ * No other file should declare search constants — import from here.
+ * Compiler enforces this via branded types and exhaustive checks.
+ */
+// ============================================================================
+// SEARCH CONFIGURATION — single source of truth
+// ============================================================================
+/** RRF fusion constant. Higher = more weight to lower-ranked results. */
+export const RRF_K = 60;
+/** Default max cosine distance for semantic search — filters noise before RRF merge */
+export const DEFAULT_MAX_SEMANTIC_DISTANCE = 0.85;
+/** Default number of processes to return */
+export const DEFAULT_PROCESS_LIMIT = 5;
+/** Default max symbols per process */
+export const DEFAULT_MAX_SYMBOLS_PER_PROCESS = 10;
+/** Max standalone definitions to return (keep tight — File-type noise is filtered separately) */
+export const DEFAULT_MAX_DEFINITIONS = 5;
+/** Cohesion boost weight in process ranking (0-1). Higher = prefer tight functional units. */
+export const COHESION_WEIGHT = 0.25;
+/** Max candidates to pass to batch DB lookups (process/cluster/content) after reranking */
+export const MAX_BATCH_CANDIDATES = 25;
+// RERANKER_BLEND_WEIGHT removed — C4 simplified to alpha blending in local-backend.ts
+/** BM25 PRF expansion threshold — expand when top score is weak OR results are sparse */
+export const PRF_SPARSE_THRESHOLD = 5;
+export const PRF_WEAK_SCORE_THRESHOLD = 1.0;
+// ============================================================================
+// FTS TABLE REGISTRY — exhaustive, compiler-checked
+// ============================================================================
+/**
+ * FTS-indexed node tables and their index names.
+ * Adding a table here automatically includes it in BM25 search.
+ * Removing one is a compile error wherever it's referenced.
+ */
+export const FTS_TABLES = [
+    { table: 'File', index: 'file_fts' },
+    { table: 'Function', index: 'function_fts' },
+    { table: 'Class', index: 'class_fts' },
+    { table: 'Method', index: 'method_fts' },
+    { table: 'Interface', index: 'interface_fts' },
+];
+export const DEFAULT_RRF_CONFIG = {
+    bm25Weight: 0.6,
+    semanticWeight: 0.4,
+    k: RRF_K,
+    limit: 10,
+};