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

package/dist/core/lbug/lbug-adapter.js

@@ -1,753 +0,0 @@
-// code-mapper/src/core/lbug/lbug-adapter.ts
-/**
- * @file lbug-adapter.ts
- * @description Core LadybugDB adapter — manages singleton DB connection, schema
- * creation, bulk CSV import, FTS indexing, and Cypher query execution
- */
-import fs from 'fs/promises';
-import { createReadStream } from 'fs';
-import { createInterface } from 'readline';
-import path from 'path';
-import lbug from '@ladybugdb/core';
-import { NODE_TABLES, REL_TABLE_NAME, SCHEMA_QUERIES, EMBEDDING_TABLE_NAME, } from './schema.js';
-import { streamAllCSVsToDisk } from './csv-generator.js';
-let db = null;
-let conn = null;
-let currentDbPath = null;
-let ftsLoaded = false;
-// Session lock — guarantees no DB switch during an active operation
-let sessionLock = Promise.resolve();
-const runWithSessionLock = async (operation) => {
-    const previous = sessionLock;
-    let release = null;
-    sessionLock = new Promise(resolve => {
-        release = resolve;
-    });
-    await previous;
-    try {
-        return await operation();
-    }
-    finally {
-        release?.();
-    }
-};
-const normalizeCopyPath = (filePath) => filePath.replace(/\\/g, '/');
-export const initLbug = async (dbPath) => {
-    return runWithSessionLock(() => ensureLbugInitialized(dbPath));
-};
-/** Execute multiple queries against one repo DB atomically (holds session lock) */
-export const withLbugDb = async (dbPath, operation) => {
-    return runWithSessionLock(async () => {
-        await ensureLbugInitialized(dbPath);
-        return operation();
-    });
-};
-const ensureLbugInitialized = async (dbPath) => {
-    if (conn && currentDbPath === dbPath) {
-        return { db, conn };
-    }
-    await doInitLbug(dbPath);
-    return { db, conn };
-};
-const doInitLbug = async (dbPath) => {
-    // Close old connection if switching databases
-    if (conn || db) {
-        try {
-            if (conn)
-                await conn.close();
-        }
-        catch { }
-        try {
-            if (db)
-                await db.close();
-        }
-        catch { }
-        conn = null;
-        db = null;
-        currentDbPath = null;
-        ftsLoaded = false;
-    }
-    // LadybugDB uses a single file — remove stale directories/symlinks from older versions
-    try {
-        const stat = await fs.lstat(dbPath);
-        if (stat.isSymbolicLink()) {
-            // Never follow symlinks — remove the link itself
-            await fs.unlink(dbPath);
-        }
-        else if (stat.isDirectory()) {
-            // Verify path is within expected storage directory
-            const realPath = await fs.realpath(dbPath);
-            const parentDir = path.dirname(dbPath);
-            const realParent = await fs.realpath(parentDir);
-            if (!realPath.startsWith(realParent + path.sep) && realPath !== realParent) {
-                throw new Error(`Refusing to delete ${dbPath}: resolved path ${realPath} is outside storage directory`);
-            }
-            // Old-style directory database — remove it
-            await fs.rm(dbPath, { recursive: true, force: true });
-        }
-        // If it's a file, assume it's an existing LadybugDB database
-    }
-    catch {
-        // Path doesn't exist — LadybugDB will create a new database
-    }
-    // Ensure parent directory exists
-    const parentDir = path.dirname(dbPath);
-    await fs.mkdir(parentDir, { recursive: true });
-    db = new lbug.Database(dbPath);
-    conn = new lbug.Connection(db);
-    for (const schemaQuery of SCHEMA_QUERIES) {
-        try {
-            await conn.query(schemaQuery);
-        }
-        catch (err) {
-            // Only ignore "already exists" errors — log everything else
-            const msg = err instanceof Error ? err.message : String(err);
-            if (!msg.includes('already exists')) {
-                console.warn(`⚠️ Schema creation warning: ${msg.slice(0, 120)}`);
-            }
-        }
-    }
-    currentDbPath = dbPath;
-    return { db, conn };
-};
-export const loadGraphToLbug = async (graph, repoPath, storagePath, onProgress) => {
-    if (!conn) {
-        throw new Error('LadybugDB not initialized. Call initLbug first.');
-    }
-    const log = onProgress || (() => { });
-    const csvDir = path.join(storagePath, 'csv');
-    log('Streaming CSVs to disk...');
-    const csvResult = await streamAllCSVsToDisk(graph, repoPath, csvDir);
-    const validTables = new Set(NODE_TABLES);
-    const getNodeLabel = (nodeId) => {
-        if (nodeId.startsWith('comm_'))
-            return 'Community';
-        if (nodeId.startsWith('proc_'))
-            return 'Process';
-        return nodeId.split(':')[0];
-    };
-    // Bulk COPY node CSVs (sequential — LadybugDB allows one write txn at a time)
-    const nodeFiles = [...csvResult.nodeFiles.entries()];
-    const totalSteps = nodeFiles.length + 1; // +1 for relationships
-    let stepsDone = 0;
-    for (const [table, { csvPath, rows }] of nodeFiles) {
-        stepsDone++;
-        log(`Loading nodes ${stepsDone}/${totalSteps}: ${table} (${rows.toLocaleString()} rows)`);
-        const normalizedPath = normalizeCopyPath(csvPath);
-        const copyQuery = getCopyQuery(table, normalizedPath);
-        try {
-            await conn.query(copyQuery);
-        }
-        catch (err) {
-            try {
-                const retryQuery = copyQuery.replace('auto_detect=false)', 'auto_detect=false, IGNORE_ERRORS=true)');
-                await conn.query(retryQuery);
-            }
-            catch (retryErr) {
-                const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
-                throw new Error(`COPY failed for ${table}: ${retryMsg.slice(0, 200)}`);
-            }
-        }
-    }
-    // Bulk COPY relationships — split by FROM→TO label pair
-    // Stream-read line by line to avoid exceeding V8 max string length
-    let relHeader = '';
-    const relsByPair = new Map();
-    let skippedRels = 0;
-    let totalValidRels = 0;
-    await new Promise((resolve, reject) => {
-        const rl = createInterface({ input: createReadStream(csvResult.relCsvPath, 'utf-8'), crlfDelay: Infinity });
-        let isFirst = true;
-        rl.on('line', (line) => {
-            if (isFirst) {
-                relHeader = line;
-                isFirst = false;
-                return;
-            }
-            if (!line.trim())
-                return;
-            const match = line.match(/"([^"]*)","([^"]*)"/);
-            if (!match) {
-                skippedRels++;
-                return;
-            }
-            const fromLabel = getNodeLabel(match[1]);
-            const toLabel = getNodeLabel(match[2]);
-            if (!validTables.has(fromLabel) || !validTables.has(toLabel)) {
-                skippedRels++;
-                return;
-            }
-            const pairKey = `${fromLabel}|${toLabel}`;
-            let list = relsByPair.get(pairKey);
-            if (!list) {
-                list = [];
-                relsByPair.set(pairKey, list);
-            }
-            list.push(line);
-            totalValidRels++;
-        });
-        rl.on('close', resolve);
-        rl.on('error', reject);
-    });
-    const insertedRels = totalValidRels;
-    const warnings = [];
-    if (insertedRels > 0) {
-        log(`Loading edges: ${insertedRels.toLocaleString()} across ${relsByPair.size} types`);
-        let pairIdx = 0;
-        let failedPairEdges = 0;
-        const failedPairLines = [];
-        for (const [pairKey, lines] of relsByPair) {
-            pairIdx++;
-            const [fromLabel, toLabel] = pairKey.split('|');
-            const pairCsvPath = path.join(csvDir, `rel_${fromLabel}_${toLabel}.csv`);
-            await fs.writeFile(pairCsvPath, relHeader + '\n' + lines.join('\n'), 'utf-8');
-            const normalizedPath = normalizeCopyPath(pairCsvPath);
-            const copyQuery = `COPY ${REL_TABLE_NAME} FROM "${normalizedPath}" (from="${fromLabel}", to="${toLabel}", HEADER=true, ESCAPE='"', DELIM=',', QUOTE='"', PARALLEL=false, auto_detect=false)`;
-            if (pairIdx % 5 === 0 || lines.length > 1000) {
-                log(`Loading edges: ${pairIdx}/${relsByPair.size} types (${fromLabel} -> ${toLabel})`);
-            }
-            try {
-                await conn.query(copyQuery);
-            }
-            catch (err) {
-                try {
-                    const retryQuery = copyQuery.replace('auto_detect=false)', 'auto_detect=false, IGNORE_ERRORS=true)');
-                    await conn.query(retryQuery);
-                }
-                catch (retryErr) {
-                    const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
-                    warnings.push(`${fromLabel}->${toLabel} (${lines.length} edges): ${retryMsg.slice(0, 80)}`);
-                    failedPairEdges += lines.length;
-                    failedPairLines.push(...lines);
-                }
-            }
-            try {
-                await fs.unlink(pairCsvPath);
-            }
-            catch { }
-        }
-        if (failedPairLines.length > 0) {
-            log(`Inserting ${failedPairEdges} edges individually (missing schema pairs)`);
-            await fallbackRelationshipInserts([relHeader, ...failedPairLines], validTables, getNodeLabel);
-        }
-    }
-    // Clean up all CSV files
-    try {
-        await fs.unlink(csvResult.relCsvPath);
-    }
-    catch { }
-    for (const [, { csvPath }] of csvResult.nodeFiles) {
-        try {
-            await fs.unlink(csvPath);
-        }
-        catch { }
-    }
-    try {
-        const remaining = await fs.readdir(csvDir);
-        for (const f of remaining) {
-            try {
-                await fs.unlink(path.join(csvDir, f));
-            }
-            catch { }
-        }
-    }
-    catch { }
-    try {
-        await fs.rmdir(csvDir);
-    }
-    catch { }
-    return { success: true, insertedRels, skippedRels, warnings };
-};
-// Force RFC 4180 escaping (ESCAPE='"') and disable auto_detect
-// Source code content has backslashes that confuse LadybugDB's default '\' escape
-const COPY_CSV_OPTS = `(HEADER=true, ESCAPE='"', DELIM=',', QUOTE='"', PARALLEL=false, auto_detect=false)`;
-// Multi-language tables created with backticks — must always use backticks in queries
-const BACKTICK_TABLES = new Set([
-    'Struct', 'Enum', 'Macro', 'Typedef', 'Union', 'Namespace', 'Trait', 'Impl',
-    'TypeAlias', 'Const', 'Static', 'Property', 'Record', 'Delegate', 'Annotation',
-    'Constructor', 'Template', 'Module',
-]);
-const escapeTableName = (table) => {
-    return BACKTICK_TABLES.has(table) ? `\`${table}\`` : table;
-};
-/** Fallback: insert relationships one-by-one when COPY fails */
-const fallbackRelationshipInserts = async (validRelLines, validTables, getNodeLabel) => {
-    if (!conn)
-        return;
-    const escapeLabel = (label) => {
-        return BACKTICK_TABLES.has(label) ? `\`${label}\`` : label;
-    };
-    for (let i = 1; i < validRelLines.length; i++) {
-        const line = validRelLines[i];
-        try {
-            const match = line.match(/"([^"]*)","([^"]*)","([^"]*)",([0-9.]+),"([^"]*)",([0-9-]+)/);
-            if (!match)
-                continue;
-            const [, fromId, toId, relType, confidenceStr, reason, stepStr] = match;
-            const fromLabel = getNodeLabel(fromId);
-            const toLabel = getNodeLabel(toId);
-            if (!validTables.has(fromLabel) || !validTables.has(toLabel))
-                continue;
-            const confidence = parseFloat(confidenceStr) || 1.0;
-            const step = parseInt(stepStr) || 0;
-            const esc = (s) => s.replace(/'/g, "''").replace(/\\/g, '\\\\').replace(/\n/g, '\\n').replace(/\r/g, '\\r');
-            await conn.query(`
-        MATCH (a:${escapeLabel(fromLabel)} {id: '${esc(fromId)}' }),
-              (b:${escapeLabel(toLabel)} {id: '${esc(toId)}' })
-        CREATE (a)-[:${REL_TABLE_NAME} {type: '${esc(relType)}', confidence: ${confidence}, reason: '${esc(reason)}', step: ${step}}]->(b)
-      `);
-        }
-        catch {
-            // skip
-        }
-    }
-};
-// Tables with isExported column (TypeScript/JS-native types)
-const TABLES_WITH_EXPORTED = new Set(['Function', 'Class', 'Interface', 'Method', 'CodeElement']);
-const getCopyQuery = (table, filePath) => {
-    const t = escapeTableName(table);
-    if (table === 'File') {
-        return `COPY ${t}(id, name, filePath, content) FROM "${filePath}" ${COPY_CSV_OPTS}`;
-    }
-    if (table === 'Folder') {
-        return `COPY ${t}(id, name, filePath) FROM "${filePath}" ${COPY_CSV_OPTS}`;
-    }
-    if (table === 'Community') {
-        return `COPY ${t}(id, label, heuristicLabel, keywords, description, enrichedBy, cohesion, symbolCount) FROM "${filePath}" ${COPY_CSV_OPTS}`;
-    }
-    if (table === 'Process') {
-        return `COPY ${t}(id, label, heuristicLabel, processType, stepCount, communities, entryPointId, terminalId) FROM "${filePath}" ${COPY_CSV_OPTS}`;
-    }
-    if (table === 'Method') {
-        return `COPY ${t}(id, name, filePath, startLine, endLine, isExported, content, description, parameterCount, returnType) FROM "${filePath}" ${COPY_CSV_OPTS}`;
-    }
-    // TS/JS tables have isExported; multi-language tables do not
-    if (TABLES_WITH_EXPORTED.has(table)) {
-        return `COPY ${t}(id, name, filePath, startLine, endLine, isExported, content, description) FROM "${filePath}" ${COPY_CSV_OPTS}`;
-    }
-    // Multi-language tables (Struct, Impl, Trait, Macro, etc)
-    return `COPY ${t}(id, name, filePath, startLine, endLine, content, description) FROM "${filePath}" ${COPY_CSV_OPTS}`;
-};
-/**
- * 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 const insertNodeToLbug = async (label, properties, dbPath) => {
-    // Use provided dbPath or fall back to persistent connection
-    const targetDbPath = dbPath || (db ? undefined : null);
-    if (!targetDbPath && !db) {
-        throw new Error('LadybugDB not initialized. Provide dbPath or call initLbug first.');
-    }
-    try {
-        const escapeValue = (v) => {
-            if (v === null || v === undefined)
-                return 'NULL';
-            if (typeof v === 'number')
-                return String(v);
-            // Escape backslashes first (for Windows paths), then single quotes
-            return `'${String(v).replace(/\\/g, '\\\\').replace(/'/g, "''").replace(/\n/g, '\\n').replace(/\r/g, '\\r')}'`;
-        };
-        // Build INSERT query by node type
-        const t = escapeTableName(label);
-        let query;
-        if (label === 'File') {
-            query = `CREATE (n:File {id: ${escapeValue(properties.id)}, name: ${escapeValue(properties.name)}, filePath: ${escapeValue(properties.filePath)}, content: ${escapeValue(properties.content || '')}})`;
-        }
-        else if (label === 'Folder') {
-            query = `CREATE (n:Folder {id: ${escapeValue(properties.id)}, name: ${escapeValue(properties.name)}, filePath: ${escapeValue(properties.filePath)}})`;
-        }
-        else if (TABLES_WITH_EXPORTED.has(label)) {
-            const descPart = properties.description ? `, description: ${escapeValue(properties.description)}` : '';
-            query = `CREATE (n:${t} {id: ${escapeValue(properties.id)}, name: ${escapeValue(properties.name)}, filePath: ${escapeValue(properties.filePath)}, startLine: ${properties.startLine || 0}, endLine: ${properties.endLine || 0}, isExported: ${!!properties.isExported}, content: ${escapeValue(properties.content || '')}${descPart}})`;
-        }
-        else {
-            // Multi-language tables — no isExported
-            const descPart = properties.description ? `, description: ${escapeValue(properties.description)}` : '';
-            query = `CREATE (n:${t} {id: ${escapeValue(properties.id)}, name: ${escapeValue(properties.name)}, filePath: ${escapeValue(properties.filePath)}, startLine: ${properties.startLine || 0}, endLine: ${properties.endLine || 0}, content: ${escapeValue(properties.content || '')}${descPart}})`;
-        }
-        // Per-query connection to avoid lock conflicts
-        if (targetDbPath) {
-            const tempDb = new lbug.Database(targetDbPath);
-            const tempConn = new lbug.Connection(tempDb);
-            try {
-                await tempConn.query(query);
-                return true;
-            }
-            finally {
-                try {
-                    await tempConn.close();
-                }
-                catch { }
-                try {
-                    await tempDb.close();
-                }
-                catch { }
-            }
-        }
-        else if (conn) {
-            // Use existing persistent connection
-            await conn.query(query);
-            return true;
-        }
-        return false;
-    }
-    catch (e) {
-        // Node may already exist
-        console.error(`Failed to insert ${label} node:`, e.message);
-        return false;
-    }
-};
-/**
- * Batch insert multiple nodes using a single connection
- * @param nodes - Array of {label, properties} to insert
- * @param dbPath - Path to LadybugDB database
- */
-export const batchInsertNodesToLbug = async (nodes, dbPath) => {
-    if (nodes.length === 0)
-        return { inserted: 0, failed: 0 };
-    const escapeValue = (v) => {
-        if (v === null || v === undefined)
-            return 'NULL';
-        if (typeof v === 'number')
-            return String(v);
-        // Escape backslashes, single quotes, and newlines
-        return `'${String(v).replace(/\\/g, '\\\\').replace(/'/g, "''").replace(/\n/g, '\\n').replace(/\r/g, '\\r')}'`;
-    };
-    // Single connection for all inserts
-    const tempDb = new lbug.Database(dbPath);
-    const tempConn = new lbug.Connection(tempDb);
-    let inserted = 0;
-    let failed = 0;
-    try {
-        for (const { label, properties } of nodes) {
-            try {
-                let query;
-                // MERGE for upsert behavior (handles duplicates)
-                const t = escapeTableName(label);
-                if (label === 'File') {
-                    query = `MERGE (n:File {id: ${escapeValue(properties.id)}}) SET n.name = ${escapeValue(properties.name)}, n.filePath = ${escapeValue(properties.filePath)}, n.content = ${escapeValue(properties.content || '')}`;
-                }
-                else if (label === 'Folder') {
-                    query = `MERGE (n:Folder {id: ${escapeValue(properties.id)}}) SET n.name = ${escapeValue(properties.name)}, n.filePath = ${escapeValue(properties.filePath)}`;
-                }
-                else if (TABLES_WITH_EXPORTED.has(label)) {
-                    const descPart = properties.description ? `, n.description = ${escapeValue(properties.description)}` : '';
-                    query = `MERGE (n:${t} {id: ${escapeValue(properties.id)}}) SET n.name = ${escapeValue(properties.name)}, n.filePath = ${escapeValue(properties.filePath)}, n.startLine = ${properties.startLine || 0}, n.endLine = ${properties.endLine || 0}, n.isExported = ${!!properties.isExported}, n.content = ${escapeValue(properties.content || '')}${descPart}`;
-                }
-                else {
-                    const descPart = properties.description ? `, n.description = ${escapeValue(properties.description)}` : '';
-                    query = `MERGE (n:${t} {id: ${escapeValue(properties.id)}}) SET n.name = ${escapeValue(properties.name)}, n.filePath = ${escapeValue(properties.filePath)}, n.startLine = ${properties.startLine || 0}, n.endLine = ${properties.endLine || 0}, n.content = ${escapeValue(properties.content || '')}${descPart}`;
-                }
-                await tempConn.query(query);
-                inserted++;
-            }
-            catch (e) {
-                // Don't log to stderr — corrupts MCP JSON-RPC
-                failed++;
-            }
-        }
-    }
-    finally {
-        try {
-            await tempConn.close();
-        }
-        catch { }
-        try {
-            await tempDb.close();
-        }
-        catch { }
-    }
-    return { inserted, failed };
-};
-export const executeQuery = async (cypher) => {
-    if (!conn) {
-        throw new Error('LadybugDB not initialized. Call initLbug first.');
-    }
-    const queryResult = await conn.query(cypher);
-    // LadybugDB uses getAll(); returns QueryResult or QueryResult[] for multi-statement
-    const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
-    const rows = await result.getAll();
-    return rows;
-};
-export const executeWithReusedStatement = async (cypher, paramsList) => {
-    if (!conn) {
-        throw new Error('LadybugDB not initialized. Call initLbug first.');
-    }
-    if (paramsList.length === 0)
-        return;
-    const SUB_BATCH_SIZE = 4;
-    for (let i = 0; i < paramsList.length; i += SUB_BATCH_SIZE) {
-        const subBatch = paramsList.slice(i, i + SUB_BATCH_SIZE);
-        const stmt = await conn.prepare(cypher);
-        if (!stmt.isSuccess()) {
-            const errMsg = await stmt.getErrorMessage();
-            throw new Error(`Prepare failed: ${errMsg}`);
-        }
-        try {
-            for (const params of subBatch) {
-                await conn.execute(stmt, params);
-            }
-        }
-        catch (e) {
-            // Log and continue with next batch
-            console.warn('Batch execution error:', e);
-        }
-        // LadybugDB PreparedStatement doesn't require explicit close()
-    }
-};
-export const getLbugStats = async () => {
-    if (!conn)
-        return { nodes: 0, edges: 0 };
-    let totalNodes = 0;
-    for (const tableName of NODE_TABLES) {
-        try {
-            const queryResult = await conn.query(`MATCH (n:${escapeTableName(tableName)}) RETURN count(n) AS cnt`);
-            const nodeResult = Array.isArray(queryResult) ? queryResult[0] : queryResult;
-            const nodeRows = await nodeResult.getAll();
-            if (nodeRows.length > 0) {
-                totalNodes += Number(nodeRows[0]?.cnt ?? nodeRows[0]?.[0] ?? 0);
-            }
-        }
-        catch {
-            // ignore
-        }
-    }
-    let totalEdges = 0;
-    try {
-        const queryResult = await conn.query(`MATCH ()-[r:${REL_TABLE_NAME}]->() RETURN count(r) AS cnt`);
-        const edgeResult = Array.isArray(queryResult) ? queryResult[0] : queryResult;
-        const edgeRows = await edgeResult.getAll();
-        if (edgeRows.length > 0) {
-            totalEdges = Number(edgeRows[0]?.cnt ?? edgeRows[0]?.[0] ?? 0);
-        }
-    }
-    catch {
-        // ignore
-    }
-    return { nodes: totalNodes, edges: totalEdges };
-};
-/**
- * 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 const loadCachedEmbeddings = async () => {
-    if (!conn) {
-        return { embeddingNodeIds: new Set(), embeddings: [] };
-    }
-    const embeddingNodeIds = new Set();
-    const embeddings = [];
-    try {
-        const rows = await conn.query(`MATCH (e:${EMBEDDING_TABLE_NAME}) RETURN e.nodeId AS nodeId, e.embedding AS embedding`);
-        const result = Array.isArray(rows) ? rows[0] : rows;
-        for (const row of await result.getAll()) {
-            const nodeId = String(row.nodeId ?? row[0] ?? '');
-            if (!nodeId)
-                continue;
-            embeddingNodeIds.add(nodeId);
-            const embedding = row.embedding ?? row[1];
-            if (embedding) {
-                embeddings.push({
-                    nodeId,
-                    embedding: Array.isArray(embedding) ? embedding.map(Number) : Array.from(embedding).map(Number),
-                });
-            }
-        }
-    }
-    catch { /* embedding table may not exist */ }
-    return { embeddingNodeIds, embeddings };
-};
-export const closeLbug = async () => {
-    if (conn) {
-        try {
-            await conn.close();
-        }
-        catch { }
-        conn = null;
-    }
-    if (db) {
-        try {
-            await db.close();
-        }
-        catch { }
-        db = null;
-    }
-    currentDbPath = null;
-    ftsLoaded = false;
-};
-export const isLbugReady = () => conn !== null && db !== null;
-/**
- * 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 const deleteNodesForFile = async (filePath, dbPath) => {
-    const usePerQuery = !!dbPath;
-    // Use existing connection or create per-query one
-    let tempDb = null;
-    let tempConn = null;
-    let targetConn = conn;
-    if (usePerQuery) {
-        tempDb = new lbug.Database(dbPath);
-        tempConn = new lbug.Connection(tempDb);
-        targetConn = tempConn;
-    }
-    else if (!conn) {
-        throw new Error('LadybugDB not initialized. Provide dbPath or call initLbug first.');
-    }
-    try {
-        let deletedNodes = 0;
-        const escapedPath = filePath.replace(/'/g, "''");
-        // DETACH DELETE from each table with filePath
-        for (const tableName of NODE_TABLES) {
-            // Community and Process don't have filePath
-            if (tableName === 'Community' || tableName === 'Process')
-                continue;
-            try {
-                // Count, then delete
-                const tn = escapeTableName(tableName);
-                const countResult = await targetConn.query(`MATCH (n:${tn}) WHERE n.filePath = '${escapedPath}' RETURN count(n) AS cnt`);
-                const result = Array.isArray(countResult) ? countResult[0] : countResult;
-                const rows = await result.getAll();
-                const count = Number(rows[0]?.cnt ?? rows[0]?.[0] ?? 0);
-                if (count > 0) {
-                    // DETACH DELETE removes node + all relationships
-                    await targetConn.query(`MATCH (n:${tn}) WHERE n.filePath = '${escapedPath}' DETACH DELETE n`);
-                    deletedNodes += count;
-                }
-            }
-            catch (e) {
-                // Table may not support this query — skip
-            }
-        }
-        // Delete embeddings for nodes in this file
-        try {
-            await targetConn.query(`MATCH (e:${EMBEDDING_TABLE_NAME}) WHERE e.nodeId STARTS WITH '${escapedPath}' DELETE e`);
-        }
-        catch {
-            // Embedding table may not exist
-        }
-        return { deletedNodes };
-    }
-    finally {
-        // Close per-query connection
-        if (tempConn) {
-            try {
-                await tempConn.close();
-            }
-            catch { }
-        }
-        if (tempDb) {
-            try {
-                await tempDb.close();
-            }
-            catch { }
-        }
-    }
-};
-export const getEmbeddingTableName = () => EMBEDDING_TABLE_NAME;
-// Full-Text Search (FTS) functions
-/** Load the FTS extension (idempotent — tracks loaded state) */
-export const loadFTSExtension = async () => {
-    if (ftsLoaded)
-        return;
-    if (!conn) {
-        throw new Error('LadybugDB not initialized. Call initLbug first.');
-    }
-    try {
-        await conn.query('INSTALL fts');
-        await conn.query('LOAD EXTENSION fts');
-        ftsLoaded = true;
-    }
-    catch (err) {
-        const msg = err?.message || '';
-        if (msg.includes('already loaded') || msg.includes('already installed') || msg.includes('already exists')) {
-            ftsLoaded = true;
-        }
-        else {
-            console.error('Code Mapper: FTS extension load failed:', msg);
-        }
-    }
-};
-/**
- * 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 const createFTSIndex = async (tableName, indexName, properties, stemmer = 'porter') => {
-    if (!conn) {
-        throw new Error('LadybugDB not initialized. Call initLbug first.');
-    }
-    await loadFTSExtension();
-    const propList = properties.map(p => `'${p}'`).join(', ');
-    const query = `CALL CREATE_FTS_INDEX('${tableName}', '${indexName}', [${propList}], stemmer := '${stemmer}')`;
-    try {
-        await conn.query(query);
-    }
-    catch (e) {
-        if (!e.message?.includes('already exists')) {
-            throw e;
-        }
-    }
-};
-/**
- * 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 const queryFTS = async (tableName, indexName, query, limit = 20, conjunctive = false) => {
-    if (!conn) {
-        throw new Error('LadybugDB not initialized. Call initLbug first.');
-    }
-    // Escape to prevent Cypher injection
-    const escapedQuery = query.replace(/\\/g, '\\\\').replace(/'/g, "''");
-    const cypher = `
-    CALL QUERY_FTS_INDEX('${tableName}', '${indexName}', '${escapedQuery}', conjunctive := ${conjunctive})
-    RETURN node, score
-    ORDER BY score DESC
-    LIMIT ${limit}
-  `;
-    try {
-        const queryResult = await conn.query(cypher);
-        const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
-        const rows = await result.getAll();
-        return rows.map((row) => {
-            const node = row.node || row[0] || {};
-            const score = row.score ?? row[1] ?? 0;
-            return {
-                nodeId: node.nodeId || node.id || '',
-                name: node.name || '',
-                filePath: node.filePath || '',
-                score: typeof score === 'number' ? score : parseFloat(score) || 0,
-                ...node,
-            };
-        });
-    }
-    catch (e) {
-        // Return empty if index doesn't exist
-        if (e.message?.includes('does not exist')) {
-            return [];
-        }
-        throw e;
-    }
-};
-/** Drop an FTS index */
-export const dropFTSIndex = async (tableName, indexName) => {
-    if (!conn) {
-        throw new Error('LadybugDB not initialized. Call initLbug first.');
-    }
-    try {
-        await conn.query(`CALL DROP_FTS_INDEX('${tableName}', '${indexName}')`);
-    }
-    catch {
-        // Index may not exist — ignore
-    }
-};