@zuvia-software-solutions/code-mapper 1.4.0

package/dist/core/ingestion/workers/worker-pool.d.ts

@@ -0,0 +1,15 @@
+/** @file Generic worker thread pool with sub-batch streaming for bounded memory usage */
+export interface WorkerPool {
+    /**
+     * Dispatch items across workers with sub-batch streaming
+     * @param items - Items to process (split into chunks, one per worker)
+     * @param onProgress - Optional callback for progress reporting
+     */
+    dispatch<TInput, TResult>(items: TInput[], onProgress?: (filesProcessed: number) => void): Promise<TResult[]>;
+    /** Terminate all workers (must be called when done) */
+    terminate(): Promise<void>;
+    /** Number of workers in the pool */
+    readonly size: number;
+}
+/** Create a pool of worker threads */
+export declare const createWorkerPool: (workerUrl: URL, poolSize?: number) => WorkerPool;

package/dist/core/ingestion/workers/worker-pool.js

@@ -0,0 +1,123 @@
+// code-mapper/src/core/ingestion/workers/worker-pool.ts
+/** @file Generic worker thread pool with sub-batch streaming for bounded memory usage */
+import { Worker } from 'node:worker_threads';
+import os from 'node:os';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+// Max files per postMessage to keep structured-clone memory bounded
+const SUB_BATCH_SIZE = 1500;
+// Per sub-batch timeout (likely a pathological file if exceeded)
+const SUB_BATCH_TIMEOUT_MS = 30_000;
+/** Create a pool of worker threads */
+export const createWorkerPool = (workerUrl, poolSize) => {
+    // Validate worker script exists before spawning to prevent MODULE_NOT_FOUND crashes
+    const workerPath = fileURLToPath(workerUrl);
+    if (!fs.existsSync(workerPath)) {
+        throw new Error(`Worker script not found: ${workerPath}`);
+    }
+    const size = poolSize ?? Math.min(8, Math.max(1, os.cpus().length - 1));
+    const workers = [];
+    for (let i = 0; i < size; i++) {
+        workers.push(new Worker(workerUrl));
+    }
+    const dispatch = (items, onProgress) => {
+        if (items.length === 0)
+            return Promise.resolve([]);
+        const chunkSize = Math.ceil(items.length / size);
+        const chunks = [];
+        for (let i = 0; i < items.length; i += chunkSize) {
+            chunks.push(items.slice(i, i + chunkSize));
+        }
+        const workerProgress = new Array(chunks.length).fill(0);
+        const promises = chunks.map((chunk, i) => {
+            const worker = workers[i];
+            return new Promise((resolve, reject) => {
+                let settled = false;
+                let subBatchTimer = null;
+                const cleanup = () => {
+                    if (subBatchTimer)
+                        clearTimeout(subBatchTimer);
+                    worker.removeListener('message', handler);
+                    worker.removeListener('error', errorHandler);
+                    worker.removeListener('exit', exitHandler);
+                };
+                const resetSubBatchTimer = () => {
+                    if (subBatchTimer)
+                        clearTimeout(subBatchTimer);
+                    subBatchTimer = setTimeout(() => {
+                        if (!settled) {
+                            settled = true;
+                            cleanup();
+                            reject(new Error(`Worker ${i} sub-batch timed out after ${SUB_BATCH_TIMEOUT_MS / 1000}s (chunk: ${chunk.length} items).`));
+                        }
+                    }, SUB_BATCH_TIMEOUT_MS);
+                };
+                let subBatchIdx = 0;
+                const sendNextSubBatch = () => {
+                    const start = subBatchIdx * SUB_BATCH_SIZE;
+                    if (start >= chunk.length) {
+                        worker.postMessage({ type: 'flush' });
+                        return;
+                    }
+                    const subBatch = chunk.slice(start, start + SUB_BATCH_SIZE);
+                    subBatchIdx++;
+                    resetSubBatchTimer();
+                    worker.postMessage({ type: 'sub-batch', files: subBatch });
+                };
+                const handler = (msg) => {
+                    if (settled)
+                        return;
+                    if (msg && msg.type === 'progress') {
+                        workerProgress[i] = msg.filesProcessed;
+                        if (onProgress) {
+                            const total = workerProgress.reduce((a, b) => a + b, 0);
+                            onProgress(total);
+                        }
+                    }
+                    else if (msg && msg.type === 'sub-batch-done') {
+                        sendNextSubBatch();
+                    }
+                    else if (msg && msg.type === 'error') {
+                        settled = true;
+                        cleanup();
+                        reject(new Error(`Worker ${i} error: ${msg.error}`));
+                    }
+                    else if (msg && msg.type === 'result') {
+                        settled = true;
+                        cleanup();
+                        resolve(msg.data);
+                    }
+                    else {
+                        settled = true;
+                        cleanup();
+                        resolve(msg);
+                    }
+                };
+                const errorHandler = (err) => {
+                    if (!settled) {
+                        settled = true;
+                        cleanup();
+                        reject(err);
+                    }
+                };
+                const exitHandler = (code) => {
+                    if (!settled) {
+                        settled = true;
+                        cleanup();
+                        reject(new Error(`Worker ${i} exited with code ${code}. Likely OOM or native addon failure.`));
+                    }
+                };
+                worker.on('message', handler);
+                worker.once('error', errorHandler);
+                worker.once('exit', exitHandler);
+                sendNextSubBatch();
+            });
+        });
+        return Promise.all(promises);
+    };
+    const terminate = async () => {
+        await Promise.all(workers.map(w => w.terminate()));
+        workers.length = 0;
+    };
+    return { dispatch, terminate, size };
+};

package/dist/core/lbug/csv-generator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @file csv-generator.ts
+ * @description Streams RFC 4180-compliant CSV rows directly to disk in a single
+ * pass over graph nodes for LadybugDB bulk import
+ *
+ * File contents are lazy-read from disk with an LRU cache to avoid holding the
+ * entire repo in RAM. Rows are buffered (FLUSH_EVERY) to minimize Promise overhead
+ */
+import { KnowledgeGraph } from '../graph/types.js';
+import { NodeTableName } from './schema.js';
+export declare const sanitizeUTF8: (str: string) => string;
+export declare const escapeCSVField: (value: string | number | undefined | null) => string;
+export declare const escapeCSVNumber: (value: number | undefined | null, defaultValue?: number) => string;
+export declare const isBinaryContent: (content: string) => boolean;
+export interface StreamedCSVResult {
+    nodeFiles: Map<NodeTableName, {
+        csvPath: string;
+        rows: number;
+    }>;
+    relCsvPath: string;
+    relRows: number;
+}
+/**
+ * Stream all CSV data directly to disk files
+ *
+ * Iterates graph nodes exactly once — routes each node to the right writer
+ */
+export declare const streamAllCSVsToDisk: (graph: KnowledgeGraph, repoPath: string, csvDir: string) => Promise<StreamedCSVResult>;

package/dist/core/lbug/csv-generator.js

@@ -0,0 +1,355 @@
+// code-mapper/src/core/lbug/csv-generator.ts
+/**
+ * @file csv-generator.ts
+ * @description Streams RFC 4180-compliant CSV rows directly to disk in a single
+ * pass over graph nodes for LadybugDB bulk import
+ *
+ * File contents are lazy-read from disk with an LRU cache to avoid holding the
+ * entire repo in RAM. Rows are buffered (FLUSH_EVERY) to minimize Promise overhead
+ */
+import fs from 'fs/promises';
+import { createWriteStream } from 'fs';
+import path from 'path';
+/** Flush buffered rows to disk every N rows */
+const FLUSH_EVERY = 500;
+// CSV escape utilities
+export const sanitizeUTF8 = (str) => {
+    return str
+        .replace(/\r\n/g, '\n')
+        .replace(/\r/g, '\n')
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '')
+        .replace(/[\uD800-\uDFFF]/g, '')
+        .replace(/[\uFFFE\uFFFF]/g, '');
+};
+export const escapeCSVField = (value) => {
+    if (value === undefined || value === null)
+        return '""';
+    let str = String(value);
+    str = sanitizeUTF8(str);
+    return `"${str.replace(/"/g, '""')}"`;
+};
+export const escapeCSVNumber = (value, defaultValue = -1) => {
+    if (value === undefined || value === null)
+        return String(defaultValue);
+    return String(value);
+};
+// Content extraction (lazy — reads from disk on demand)
+export const isBinaryContent = (content) => {
+    if (!content || content.length === 0)
+        return false;
+    const sample = content.slice(0, 1000);
+    let nonPrintable = 0;
+    for (let i = 0; i < sample.length; i++) {
+        const code = sample.charCodeAt(i);
+        if ((code < 9) || (code > 13 && code < 32) || code === 127)
+            nonPrintable++;
+    }
+    return (nonPrintable / sample.length) > 0.1;
+};
+/**
+ * LRU content cache — avoids re-reading the same source file for every
+ * symbol defined in it
+ */
+class FileContentCache {
+    cache = new Map();
+    accessOrder = [];
+    maxSize;
+    repoPath;
+    constructor(repoPath, maxSize = 3000) {
+        this.repoPath = repoPath;
+        this.maxSize = maxSize;
+    }
+    async get(relativePath) {
+        if (!relativePath)
+            return '';
+        const cached = this.cache.get(relativePath);
+        if (cached !== undefined) {
+            // Move to end of accessOrder (LRU promotion)
+            const idx = this.accessOrder.indexOf(relativePath);
+            if (idx !== -1) {
+                this.accessOrder.splice(idx, 1);
+                this.accessOrder.push(relativePath);
+            }
+            return cached;
+        }
+        try {
+            const fullPath = path.join(this.repoPath, relativePath);
+            const content = await fs.readFile(fullPath, 'utf-8');
+            this.set(relativePath, content);
+            return content;
+        }
+        catch {
+            this.set(relativePath, '');
+            return '';
+        }
+    }
+    set(key, value) {
+        if (this.cache.size >= this.maxSize) {
+            const oldest = this.accessOrder.shift();
+            if (oldest)
+                this.cache.delete(oldest);
+        }
+        this.cache.set(key, value);
+        this.accessOrder.push(key);
+    }
+}
+const extractContent = async (node, contentCache) => {
+    const filePath = node.properties.filePath;
+    const content = await contentCache.get(filePath);
+    if (!content)
+        return '';
+    if (node.label === 'Folder')
+        return '';
+    if (isBinaryContent(content))
+        return '[Binary file - content not stored]';
+    if (node.label === 'File') {
+        const MAX_FILE_CONTENT = 100_000;
+        return content.length > MAX_FILE_CONTENT
+            ? content.slice(0, MAX_FILE_CONTENT) + '\n... [truncated]'
+            : content;
+    }
+    const startLine = node.properties.startLine;
+    const endLine = node.properties.endLine;
+    if (startLine === undefined || endLine === undefined)
+        return '';
+    const lines = content.split('\n');
+    const start = Math.max(0, startLine - 2);
+    const end = Math.min(lines.length - 1, endLine + 2);
+    const snippet = lines.slice(start, end + 1).join('\n');
+    const MAX_SNIPPET = 50_000;
+    return snippet.length > MAX_SNIPPET
+        ? snippet.slice(0, MAX_SNIPPET) + '\n... [truncated]'
+        : snippet;
+};
+// Buffered CSV writer
+class BufferedCSVWriter {
+    ws;
+    buffer = [];
+    rows = 0;
+    constructor(filePath, header) {
+        this.ws = createWriteStream(filePath, 'utf-8');
+        // Raise listener cap for large repos with many flushes
+        this.ws.setMaxListeners(50);
+        this.buffer.push(header);
+    }
+    addRow(row) {
+        this.buffer.push(row);
+        this.rows++;
+        if (this.buffer.length >= FLUSH_EVERY) {
+            return this.flush();
+        }
+        return Promise.resolve();
+    }
+    flush() {
+        if (this.buffer.length === 0)
+            return Promise.resolve();
+        const chunk = this.buffer.join('\n') + '\n';
+        this.buffer.length = 0;
+        return new Promise((resolve, reject) => {
+            this.ws.once('error', reject);
+            const ok = this.ws.write(chunk);
+            if (ok) {
+                this.ws.removeListener('error', reject);
+                resolve();
+            }
+            else {
+                this.ws.once('drain', () => {
+                    this.ws.removeListener('error', reject);
+                    resolve();
+                });
+            }
+        });
+    }
+    async finish() {
+        await this.flush();
+        return new Promise((resolve, reject) => {
+            this.ws.end(() => resolve());
+            this.ws.on('error', reject);
+        });
+    }
+}
+/**
+ * Stream all CSV data directly to disk files
+ *
+ * Iterates graph nodes exactly once — routes each node to the right writer
+ */
+export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
+    // Remove stale CSVs from previous runs, then recreate
+    try {
+        await fs.rm(csvDir, { recursive: true, force: true });
+    }
+    catch { }
+    await fs.mkdir(csvDir, { recursive: true });
+    // Raise listener limit for ~30 concurrent write-streams (restored at end)
+    const prevMax = process.getMaxListeners();
+    process.setMaxListeners(prevMax + 40);
+    const contentCache = new FileContentCache(repoPath);
+    // Create writers for every node type
+    const fileWriter = new BufferedCSVWriter(path.join(csvDir, 'file.csv'), 'id,name,filePath,content');
+    const folderWriter = new BufferedCSVWriter(path.join(csvDir, 'folder.csv'), 'id,name,filePath');
+    const codeElementHeader = 'id,name,filePath,startLine,endLine,isExported,content,description';
+    const functionWriter = new BufferedCSVWriter(path.join(csvDir, 'function.csv'), codeElementHeader);
+    const classWriter = new BufferedCSVWriter(path.join(csvDir, 'class.csv'), codeElementHeader);
+    const interfaceWriter = new BufferedCSVWriter(path.join(csvDir, 'interface.csv'), codeElementHeader);
+    const methodHeader = 'id,name,filePath,startLine,endLine,isExported,content,description,parameterCount,returnType';
+    const methodWriter = new BufferedCSVWriter(path.join(csvDir, 'method.csv'), methodHeader);
+    const codeElemWriter = new BufferedCSVWriter(path.join(csvDir, 'codeelement.csv'), codeElementHeader);
+    const communityWriter = new BufferedCSVWriter(path.join(csvDir, 'community.csv'), 'id,label,heuristicLabel,keywords,description,enrichedBy,cohesion,symbolCount');
+    const processWriter = new BufferedCSVWriter(path.join(csvDir, 'process.csv'), 'id,label,heuristicLabel,processType,stepCount,communities,entryPointId,terminalId');
+    // Multi-language node types share the same CSV shape (no isExported column)
+    const multiLangHeader = 'id,name,filePath,startLine,endLine,content,description';
+    const MULTI_LANG_TYPES = ['Struct', 'Enum', 'Macro', 'Typedef', 'Union', 'Namespace', 'Trait', 'Impl',
+        'TypeAlias', 'Const', 'Static', 'Property', 'Record', 'Delegate', 'Annotation', 'Constructor', 'Template', 'Module'];
+    const multiLangWriters = new Map();
+    for (const t of MULTI_LANG_TYPES) {
+        multiLangWriters.set(t, new BufferedCSVWriter(path.join(csvDir, `${t.toLowerCase()}.csv`), multiLangHeader));
+    }
+    const codeWriterMap = {
+        'Function': functionWriter,
+        'Class': classWriter,
+        'Interface': interfaceWriter,
+        'CodeElement': codeElemWriter,
+    };
+    const seenFileIds = new Set();
+    // Single pass over all nodes
+    for (const node of graph.iterNodes()) {
+        switch (node.label) {
+            case 'File': {
+                if (seenFileIds.has(node.id))
+                    break;
+                seenFileIds.add(node.id);
+                const content = await extractContent(node, contentCache);
+                await fileWriter.addRow([
+                    escapeCSVField(node.id),
+                    escapeCSVField(node.properties.name || ''),
+                    escapeCSVField(node.properties.filePath || ''),
+                    escapeCSVField(content),
+                ].join(','));
+                break;
+            }
+            case 'Folder':
+                await folderWriter.addRow([
+                    escapeCSVField(node.id),
+                    escapeCSVField(node.properties.name || ''),
+                    escapeCSVField(node.properties.filePath || ''),
+                ].join(','));
+                break;
+            case 'Community': {
+                const keywords = node.properties.keywords || [];
+                const keywordsStr = `[${keywords.map((k) => `'${k.replace(/\\/g, '\\\\').replace(/'/g, "''").replace(/,/g, '\\,')}'`).join(',')}]`;
+                await communityWriter.addRow([
+                    escapeCSVField(node.id),
+                    escapeCSVField(node.properties.name || ''),
+                    escapeCSVField(node.properties.heuristicLabel || ''),
+                    keywordsStr,
+                    escapeCSVField(node.properties.description || ''),
+                    escapeCSVField(node.properties.enrichedBy || 'heuristic'),
+                    escapeCSVNumber(node.properties.cohesion, 0),
+                    escapeCSVNumber(node.properties.symbolCount, 0),
+                ].join(','));
+                break;
+            }
+            case 'Process': {
+                const communities = node.properties.communities || [];
+                const communitiesStr = `[${communities.map((c) => `'${c.replace(/'/g, "''")}'`).join(',')}]`;
+                await processWriter.addRow([
+                    escapeCSVField(node.id),
+                    escapeCSVField(node.properties.name || ''),
+                    escapeCSVField(node.properties.heuristicLabel || ''),
+                    escapeCSVField(node.properties.processType || ''),
+                    escapeCSVNumber(node.properties.stepCount, 0),
+                    escapeCSVField(communitiesStr),
+                    escapeCSVField(node.properties.entryPointId || ''),
+                    escapeCSVField(node.properties.terminalId || ''),
+                ].join(','));
+                break;
+            }
+            case 'Method': {
+                const content = await extractContent(node, contentCache);
+                await methodWriter.addRow([
+                    escapeCSVField(node.id),
+                    escapeCSVField(node.properties.name || ''),
+                    escapeCSVField(node.properties.filePath || ''),
+                    escapeCSVNumber(node.properties.startLine, -1),
+                    escapeCSVNumber(node.properties.endLine, -1),
+                    node.properties.isExported ? 'true' : 'false',
+                    escapeCSVField(content),
+                    escapeCSVField(node.properties.description || ''),
+                    escapeCSVNumber(node.properties.parameterCount, 0),
+                    escapeCSVField(node.properties.returnType || ''),
+                ].join(','));
+                break;
+            }
+            default: {
+                // Code element nodes
+                const writer = codeWriterMap[node.label];
+                if (writer) {
+                    const content = await extractContent(node, contentCache);
+                    await writer.addRow([
+                        escapeCSVField(node.id),
+                        escapeCSVField(node.properties.name || ''),
+                        escapeCSVField(node.properties.filePath || ''),
+                        escapeCSVNumber(node.properties.startLine, -1),
+                        escapeCSVNumber(node.properties.endLine, -1),
+                        node.properties.isExported ? 'true' : 'false',
+                        escapeCSVField(content),
+                        escapeCSVField(node.properties.description || ''),
+                    ].join(','));
+                }
+                else {
+                    // Multi-language node types (Struct, Impl, Trait, Macro, etc)
+                    const mlWriter = multiLangWriters.get(node.label);
+                    if (mlWriter) {
+                        const content = await extractContent(node, contentCache);
+                        await mlWriter.addRow([
+                            escapeCSVField(node.id),
+                            escapeCSVField(node.properties.name || ''),
+                            escapeCSVField(node.properties.filePath || ''),
+                            escapeCSVNumber(node.properties.startLine, -1),
+                            escapeCSVNumber(node.properties.endLine, -1),
+                            escapeCSVField(content),
+                            escapeCSVField(node.properties.description || ''),
+                        ].join(','));
+                    }
+                }
+                break;
+            }
+        }
+    }
+    // Flush and close all node writers
+    const allWriters = [fileWriter, folderWriter, functionWriter, classWriter, interfaceWriter, methodWriter, codeElemWriter, communityWriter, processWriter, ...multiLangWriters.values()];
+    await Promise.all(allWriters.map(w => w.finish()));
+    // Stream relationship CSV
+    const relCsvPath = path.join(csvDir, 'relations.csv');
+    const relWriter = new BufferedCSVWriter(relCsvPath, 'from,to,type,confidence,reason,step,callLine');
+    for (const rel of graph.iterRelationships()) {
+        await relWriter.addRow([
+            escapeCSVField(rel.sourceId),
+            escapeCSVField(rel.targetId),
+            escapeCSVField(rel.type),
+            escapeCSVNumber(rel.confidence, 1.0),
+            escapeCSVField(rel.reason),
+            escapeCSVNumber(rel.step, 0),
+            escapeCSVNumber(rel.callLine, 0),
+        ].join(','));
+    }
+    await relWriter.finish();
+    // Build result map (only tables with rows)
+    const nodeFiles = new Map();
+    const tableMap = [
+        ['File', fileWriter], ['Folder', folderWriter],
+        ['Function', functionWriter], ['Class', classWriter],
+        ['Interface', interfaceWriter], ['Method', methodWriter],
+        ['CodeElement', codeElemWriter],
+        ['Community', communityWriter], ['Process', processWriter],
+        ...Array.from(multiLangWriters.entries()).map(([name, w]) => [name, w]),
+    ];
+    for (const [name, writer] of tableMap) {
+        if (writer.rows > 0) {
+            nodeFiles.set(name, { csvPath: path.join(csvDir, `${name.toLowerCase()}.csv`), rows: writer.rows });
+        }
+    }
+    // Restore listener limit
+    process.setMaxListeners(prevMax);
+    return { nodeFiles, relCsvPath, relRows: relWriter.rows };
+};

package/dist/core/lbug/lbug-adapter.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @file lbug-adapter.ts
+ * @description Core LadybugDB adapter — manages singleton DB connection, schema
+ * creation, bulk CSV import, FTS indexing, and Cypher query execution
+ */
+import lbug from '@ladybugdb/core';
+import { KnowledgeGraph } from '../graph/types.js';
+export declare const initLbug: (dbPath: string) => Promise<{
+    db: lbug.Database;
+    conn: lbug.Connection;
+}>;
+/** Execute multiple queries against one repo DB atomically (holds session lock) */
+export declare const withLbugDb: <T>(dbPath: string, operation: () => Promise<T>) => Promise<T>;
+export type LbugProgressCallback = (message: string) => void;
+export declare const loadGraphToLbug: (graph: KnowledgeGraph, repoPath: string, storagePath: string, onProgress?: LbugProgressCallback) => Promise<{
+    success: boolean;
+    insertedRels: number;
+    skippedRels: number;
+    warnings: string[];
+}>;
+/**
+ * Insert a single node to LadybugDB
+ * @param label - Node type (File, Function, Class, etc)
+ * @param properties - Node properties
+ * @param dbPath - Path to LadybugDB database (optional if already initialized)
+ */
+export declare const insertNodeToLbug: (label: string, properties: Record<string, any>, dbPath?: string) => Promise<boolean>;
+/**
+ * Batch insert multiple nodes using a single connection
+ * @param nodes - Array of {label, properties} to insert
+ * @param dbPath - Path to LadybugDB database
+ */
+export declare const batchInsertNodesToLbug: (nodes: Array<{
+    label: string;
+    properties: Record<string, any>;
+}>, dbPath: string) => Promise<{
+    inserted: number;
+    failed: number;
+}>;
+export declare const executeQuery: (cypher: string) => Promise<any[]>;
+export declare const executeWithReusedStatement: (cypher: string, paramsList: Array<Record<string, any>>) => Promise<void>;
+export declare const getLbugStats: () => Promise<{
+    nodes: number;
+    edges: number;
+}>;
+/**
+ * Load cached embeddings before a rebuild
+ *
+ * Returns all vectors so they can be re-inserted after the graph reloads,
+ * avoiding expensive re-embedding of unchanged nodes
+ */
+export declare const loadCachedEmbeddings: () => Promise<{
+    embeddingNodeIds: Set<string>;
+    embeddings: Array<{
+        nodeId: string;
+        embedding: number[];
+    }>;
+}>;
+export declare const closeLbug: () => Promise<void>;
+export declare const isLbugReady: () => boolean;
+/**
+ * Delete all nodes (and relationships) for a specific file
+ * @param filePath - File path to delete nodes for
+ * @param dbPath - Optional path for per-query connection
+ */
+export declare const deleteNodesForFile: (filePath: string, dbPath?: string) => Promise<{
+    deletedNodes: number;
+}>;
+export declare const getEmbeddingTableName: () => string;
+/** Load the FTS extension (idempotent — tracks loaded state) */
+export declare const loadFTSExtension: () => Promise<void>;
+/**
+ * Create a full-text search index on a table
+ * @param tableName - Node table name (e.g. 'File', 'Function')
+ * @param indexName - FTS index name
+ * @param properties - Properties to index (e.g. ['name', 'content'])
+ * @param stemmer - Stemming algorithm (default: 'porter')
+ */
+export declare const createFTSIndex: (tableName: string, indexName: string, properties: string[], stemmer?: string) => Promise<void>;
+/**
+ * Query a full-text search index
+ * @param tableName - Node table name
+ * @param indexName - FTS index name
+ * @param query - Search query string
+ * @param limit - Max results
+ * @param conjunctive - If true, all terms must match (AND); false = any term (OR)
+ */
+export declare const queryFTS: (tableName: string, indexName: string, query: string, limit?: number, conjunctive?: boolean) => Promise<Array<{
+    nodeId: string;
+    name: string;
+    filePath: string;
+    score: number;
+    [key: string]: any;
+}>>;
+/** Drop an FTS index */
+export declare const dropFTSIndex: (tableName: string, indexName: string) => Promise<void>;