gitnexus 1.4.0 → 1.4.5

package/dist/core/{kuzu/kuzu-adapter.js → lbug/lbug-adapter.js}

@@ -2,14 +2,14 @@ import fs from 'fs/promises';
 import { createReadStream } from 'fs';
 import { createInterface } from 'readline';
 import path from 'path';
-import kuzu from 'kuzu';
+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;
-// Global session lock for operations that touch module-level kuzu globals.
+// Global session lock for operations that touch module-level lbug globals.
 // This guarantees no DB switch can happen while an operation is running.
 let sessionLock = Promise.resolve();
 const runWithSessionLock = async (operation) => {
@@ -27,27 +27,27 @@ const runWithSessionLock = async (operation) => {
     }
 };
 const normalizeCopyPath = (filePath) => filePath.replace(/\\/g, '/');
-export const initKuzu = async (dbPath) => {
-    return runWithSessionLock(() => ensureKuzuInitialized(dbPath));
+export const initLbug = async (dbPath) => {
+    return runWithSessionLock(() => ensureLbugInitialized(dbPath));
 };
 /**
  * Execute multiple queries against one repo DB atomically.
  * While the callback runs, no other request can switch the active DB.
  */
-export const withKuzuDb = async (dbPath, operation) => {
+export const withLbugDb = async (dbPath, operation) => {
     return runWithSessionLock(async () => {
-        await ensureKuzuInitialized(dbPath);
+        await ensureLbugInitialized(dbPath);
         return operation();
     });
 };
-const ensureKuzuInitialized = async (dbPath) => {
+const ensureLbugInitialized = async (dbPath) => {
     if (conn && currentDbPath === dbPath) {
         return { db, conn };
     }
-    await doInitKuzu(dbPath);
+    await doInitLbug(dbPath);
     return { db, conn };
 };
-const doInitKuzu = async (dbPath) => {
+const doInitLbug = async (dbPath) => {
     // Different database requested — close the old one first
     if (conn || db) {
         try {
@@ -65,32 +65,36 @@ const doInitKuzu = async (dbPath) => {
         currentDbPath = null;
         ftsLoaded = false;
     }
-    // kuzu v0.11 stores the database as a single file (not a directory).
-    // If the path already exists, it must be a valid kuzu database file.
+    // LadybugDB stores the database as a single file (not a directory).
+    // If the path already exists, it must be a valid LadybugDB database file.
     // Remove stale empty directories or files from older versions.
     try {
-        const stat = await fs.stat(dbPath);
-        if (stat.isDirectory()) {
-            // Old-style directory database or empty leftover - remove it
-            const files = await fs.readdir(dbPath);
-            if (files.length === 0) {
-                await fs.rmdir(dbPath);
-            }
-            else {
-                // Non-empty directory from older kuzu version - remove entire directory
-                await fs.rm(dbPath, { recursive: true, force: true });
+        const stat = await fs.lstat(dbPath);
+        if (stat.isSymbolicLink()) {
+            // Never follow symlinks — just remove the link itself
+            await fs.unlink(dbPath);
+        }
+        else if (stat.isDirectory()) {
+            // Verify path is within expected storage directory before deleting
+            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 or empty leftover - remove it
+            await fs.rm(dbPath, { recursive: true, force: true });
         }
-        // If it's a file, assume it's an existing kuzu database - kuzu will open it
+        // If it's a file, assume it's an existing LadybugDB database - LadybugDB will open it
     }
     catch {
-        // Path doesn't exist, which is what kuzu wants for a new database
+        // Path doesn't exist, which is what LadybugDB wants for a new database
     }
     // Ensure parent directory exists
     const parentDir = path.dirname(dbPath);
     await fs.mkdir(parentDir, { recursive: true });
-    db = new kuzu.Database(dbPath);
-    conn = new kuzu.Connection(db);
+    db = new lbug.Database(dbPath);
+    conn = new lbug.Connection(db);
     for (const schemaQuery of SCHEMA_QUERIES) {
         try {
             await conn.query(schemaQuery);
@@ -106,9 +110,9 @@ const doInitKuzu = async (dbPath) => {
     currentDbPath = dbPath;
     return { db, conn };
 };
-export const loadGraphToKuzu = async (graph, repoPath, storagePath, onProgress) => {
+export const loadGraphToLbug = async (graph, repoPath, storagePath, onProgress) => {
     if (!conn) {
-        throw new Error('KuzuDB not initialized. Call initKuzu first.');
+        throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
     const log = onProgress || (() => { });
     const csvDir = path.join(storagePath, 'csv');
@@ -122,7 +126,7 @@ export const loadGraphToKuzu = async (graph, repoPath, storagePath, onProgress)
             return 'Process';
         return nodeId.split(':')[0];
     };
-    // Bulk COPY all node CSVs (sequential — KuzuDB allows only one write txn at a time)
+    // Bulk COPY all node CSVs (sequential — LadybugDB allows only one write txn at a time)
     const nodeFiles = [...csvResult.nodeFiles.entries()];
     const totalSteps = nodeFiles.length + 1; // +1 for relationships
     let stepsDone = 0;
@@ -145,7 +149,7 @@ export const loadGraphToKuzu = async (graph, repoPath, storagePath, onProgress)
             }
         }
     }
-    // Bulk COPY relationships — split by FROM→TO label pair (KuzuDB requires it)
+    // Bulk COPY relationships — split by FROM→TO label pair (LadybugDB requires it)
     // Stream-read the relation CSV line by line to avoid exceeding V8 max string length
     let relHeader = '';
     const relsByPair = new Map();
@@ -254,10 +258,10 @@ export const loadGraphToKuzu = async (graph, repoPath, storagePath, onProgress)
     catch { }
     return { success: true, insertedRels, skippedRels, warnings };
 };
-// KuzuDB default ESCAPE is '\' (backslash), but our CSV uses RFC 4180 escaping ("" for literal quotes).
+// LadybugDB default ESCAPE is '\' (backslash), but our CSV uses RFC 4180 escaping ("" for literal quotes).
 // Source code content is full of backslashes which confuse the auto-detection.
 // We MUST explicitly set ESCAPE='"' to use RFC 4180 escaping, and disable auto_detect to prevent
-// KuzuDB from overriding our settings based on sample rows.
+// LadybugDB from overriding our settings based on sample rows.
 const COPY_CSV_OPTS = `(HEADER=true, ESCAPE='"', DELIM=',', QUOTE='"', PARALLEL=false, auto_detect=false)`;
 // Multi-language table names that were created with backticks in CODE_ELEMENT_BASE
 // and must always be referenced with backticks in queries
@@ -289,10 +293,11 @@ const fallbackRelationshipInserts = async (validRelLines, validTables, getNodeLa
                 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: '${fromId.replace(/'/g, "''")}' }),
-              (b:${escapeLabel(toLabel)} {id: '${toId.replace(/'/g, "''")}' })
-        CREATE (a)-[:${REL_TABLE_NAME} {type: '${relType}', confidence: ${confidence}, reason: '${reason.replace(/'/g, "''")}', step: ${step}}]->(b)
+        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 {
@@ -327,16 +332,16 @@ const getCopyQuery = (table, filePath) => {
     return `COPY ${t}(id, name, filePath, startLine, endLine, content, description) FROM "${filePath}" ${COPY_CSV_OPTS}`;
 };
 /**
- * Insert a single node to KuzuDB
+ * Insert a single node to LadybugDB
  * @param label - Node type (File, Function, Class, etc.)
  * @param properties - Node properties
- * @param dbPath - Path to KuzuDB database (optional if already initialized)
+ * @param dbPath - Path to LadybugDB database (optional if already initialized)
  */
-export const insertNodeToKuzu = async (label, properties, dbPath) => {
+export const insertNodeToLbug = async (label, properties, dbPath) => {
     // Use provided dbPath or fall back to module-level db
     const targetDbPath = dbPath || (db ? undefined : null);
     if (!targetDbPath && !db) {
-        throw new Error('KuzuDB not initialized. Provide dbPath or call initKuzu first.');
+        throw new Error('LadybugDB not initialized. Provide dbPath or call initLbug first.');
     }
     try {
         const escapeValue = (v) => {
@@ -345,7 +350,7 @@ export const insertNodeToKuzu = async (label, properties, dbPath) => {
             if (typeof v === 'number')
                 return String(v);
             // Escape backslashes first (for Windows paths), then single quotes
-            return `'${String(v).replace(/\\/g, '\\\\').replace(/'/g, "''")}'`;
+            return `'${String(v).replace(/\\/g, '\\\\').replace(/'/g, "''").replace(/\n/g, '\\n').replace(/\r/g, '\\r')}'`;
         };
         // Build INSERT query based on node type
         const t = escapeTableName(label);
@@ -367,8 +372,8 @@ export const insertNodeToKuzu = async (label, properties, dbPath) => {
         }
         // Use per-query connection if dbPath provided (avoids lock conflicts)
         if (targetDbPath) {
-            const tempDb = new kuzu.Database(targetDbPath);
-            const tempConn = new kuzu.Connection(tempDb);
+            const tempDb = new lbug.Database(targetDbPath);
+            const tempConn = new lbug.Connection(tempDb);
             try {
                 await tempConn.query(query);
                 return true;
@@ -398,12 +403,12 @@ export const insertNodeToKuzu = async (label, properties, dbPath) => {
     }
 };
 /**
- * Batch insert multiple nodes to KuzuDB using a single connection
+ * Batch insert multiple nodes to LadybugDB using a single connection
  * @param nodes - Array of {label, properties} to insert
- * @param dbPath - Path to KuzuDB database
+ * @param dbPath - Path to LadybugDB database
  * @returns Object with success count and error count
  */
-export const batchInsertNodesToKuzu = async (nodes, dbPath) => {
+export const batchInsertNodesToLbug = async (nodes, dbPath) => {
     if (nodes.length === 0)
         return { inserted: 0, failed: 0 };
     const escapeValue = (v) => {
@@ -411,12 +416,12 @@ export const batchInsertNodesToKuzu = async (nodes, dbPath) => {
             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, "''")}'`;
+        // Escape backslashes first (for Windows paths), then single quotes, then newlines
+        return `'${String(v).replace(/\\/g, '\\\\').replace(/'/g, "''").replace(/\n/g, '\\n').replace(/\r/g, '\\r')}'`;
     };
     // Open a single connection for all inserts
-    const tempDb = new kuzu.Database(dbPath);
-    const tempConn = new kuzu.Connection(tempDb);
+    const tempDb = new lbug.Database(dbPath);
+    const tempConn = new lbug.Connection(tempDb);
     let inserted = 0;
     let failed = 0;
     try {
@@ -462,10 +467,10 @@ export const batchInsertNodesToKuzu = async (nodes, dbPath) => {
 };
 export const executeQuery = async (cypher) => {
     if (!conn) {
-        throw new Error('KuzuDB not initialized. Call initKuzu first.');
+        throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
     const queryResult = await conn.query(cypher);
-    // kuzu v0.11 uses getAll() instead of hasNext()/getNext()
+    // LadybugDB uses getAll() instead of hasNext()/getNext()
     // Query returns QueryResult for single queries, QueryResult[] for multi-statement
     const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
     const rows = await result.getAll();
@@ -473,7 +478,7 @@ export const executeQuery = async (cypher) => {
 };
 export const executeWithReusedStatement = async (cypher, paramsList) => {
     if (!conn) {
-        throw new Error('KuzuDB not initialized. Call initKuzu first.');
+        throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
     if (paramsList.length === 0)
         return;
@@ -494,10 +499,10 @@ export const executeWithReusedStatement = async (cypher, paramsList) => {
             // Log the error and continue with next batch
             console.warn('Batch execution error:', e);
         }
-        // Note: kuzu 0.8.2 PreparedStatement doesn't require explicit close()
+        // Note: LadybugDB PreparedStatement doesn't require explicit close()
     }
 };
-export const getKuzuStats = async () => {
+export const getLbugStats = async () => {
     if (!conn)
         return { nodes: 0, edges: 0 };
     let totalNodes = 0;
@@ -529,7 +534,7 @@ export const getKuzuStats = async () => {
     return { nodes: totalNodes, edges: totalEdges };
 };
 /**
- * Load cached embeddings from KuzuDB before a rebuild.
+ * Load cached embeddings from LadybugDB before a rebuild.
  * Returns all embedding vectors so they can be re-inserted after the graph is reloaded,
  * avoiding expensive re-embedding of unchanged nodes.
  */
@@ -559,7 +564,7 @@ export const loadCachedEmbeddings = async () => {
     catch { /* embedding table may not exist */ }
     return { embeddingNodeIds, embeddings };
 };
-export const closeKuzu = async () => {
+export const closeLbug = async () => {
     if (conn) {
         try {
             await conn.close();
@@ -577,11 +582,11 @@ export const closeKuzu = async () => {
     currentDbPath = null;
     ftsLoaded = false;
 };
-export const isKuzuReady = () => conn !== null && db !== null;
+export const isLbugReady = () => conn !== null && db !== null;
 /**
- * Delete all nodes (and their relationships) for a specific file from KuzuDB
+ * Delete all nodes (and their relationships) for a specific file from LadybugDB
  * @param filePath - The file path to delete nodes for
- * @param dbPath - Optional path to KuzuDB for per-query connection
+ * @param dbPath - Optional path to LadybugDB for per-query connection
  * @returns Object with counts of deleted nodes
  */
 export const deleteNodesForFile = async (filePath, dbPath) => {
@@ -591,12 +596,12 @@ export const deleteNodesForFile = async (filePath, dbPath) => {
     let tempConn = null;
     let targetConn = conn;
     if (usePerQuery) {
-        tempDb = new kuzu.Database(dbPath);
-        tempConn = new kuzu.Connection(tempDb);
+        tempDb = new lbug.Database(dbPath);
+        tempConn = new lbug.Connection(tempDb);
         targetConn = tempConn;
     }
     else if (!conn) {
-        throw new Error('KuzuDB not initialized. Provide dbPath or call initKuzu first.');
+        throw new Error('LadybugDB not initialized. Provide dbPath or call initLbug first.');
     }
     try {
         let deletedNodes = 0;
@@ -661,7 +666,7 @@ export const loadFTSExtension = async () => {
     if (ftsLoaded)
         return;
     if (!conn) {
-        throw new Error('KuzuDB not initialized. Call initKuzu first.');
+        throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
     try {
         await conn.query('INSTALL fts');
@@ -687,7 +692,7 @@ export const loadFTSExtension = async () => {
  */
 export const createFTSIndex = async (tableName, indexName, properties, stemmer = 'porter') => {
     if (!conn) {
-        throw new Error('KuzuDB not initialized. Call initKuzu first.');
+        throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
     await loadFTSExtension();
     const propList = properties.map(p => `'${p}'`).join(', ');
@@ -712,7 +717,7 @@ export const createFTSIndex = async (tableName, indexName, properties, stemmer =
  */
 export const queryFTS = async (tableName, indexName, query, limit = 20, conjunctive = false) => {
     if (!conn) {
-        throw new Error('KuzuDB not initialized. Call initKuzu first.');
+        throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
     // Escape backslashes and single quotes to prevent Cypher injection
     const escapedQuery = query.replace(/\\/g, '\\\\').replace(/'/g, "''");
@@ -751,7 +756,7 @@ export const queryFTS = async (tableName, indexName, query, limit = 20, conjunct
  */
 export const dropFTSIndex = async (tableName, indexName) => {
     if (!conn) {
-        throw new Error('KuzuDB not initialized. Call initKuzu first.');
+        throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
     try {
         await conn.query(`CALL DROP_FTS_INDEX('${tableName}', '${indexName}')`);

package/dist/core/{kuzu → lbug}/schema.d.ts

@@ -1,5 +1,5 @@
 /**
- * KuzuDB Schema Definitions
+ * LadybugDB Schema Definitions
  *
  * Hybrid Schema:
  * - Separate node tables for each code element type (File, Function, Class, etc.)

package/dist/core/{kuzu → lbug}/schema.js

@@ -1,5 +1,5 @@
 /**
- * KuzuDB Schema Definitions
+ * LadybugDB Schema Definitions
  *
  * Hybrid Schema:
  * - Separate node tables for each code element type (File, Function, Class, etc.)

package/dist/core/search/bm25-index.d.ts

@@ -1,7 +1,7 @@
 /**
- * Full-Text Search via KuzuDB FTS
+ * Full-Text Search via LadybugDB FTS
  *
- * Uses KuzuDB's built-in full-text search indexes for keyword-based search.
+ * Uses LadybugDB's built-in full-text search indexes for keyword-based search.
  * Always reads from the database (no cached state to drift).
  */
 export interface BM25SearchResult {
@@ -10,7 +10,7 @@ export interface BM25SearchResult {
     rank: number;
 }
 /**
- * Search using KuzuDB's built-in FTS (always fresh, reads from disk)
+ * Search using LadybugDB's built-in FTS (always fresh, reads from disk)
  *
  * Queries multiple node tables (File, Function, Class, Method) in parallel
  * and merges results by filePath, summing scores for the same file.
@@ -20,4 +20,4 @@ export interface BM25SearchResult {
  * @param repoId - If provided, queries will be routed via the MCP connection pool
  * @returns Ranked search results from FTS indexes
  */
-export declare const searchFTSFromKuzu: (query: string, limit?: number, repoId?: string) => Promise<BM25SearchResult[]>;
+export declare const searchFTSFromLbug: (query: string, limit?: number, repoId?: string) => Promise<BM25SearchResult[]>;

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

@@ -1,13 +1,13 @@
 /**
- * Full-Text Search via KuzuDB FTS
+ * Full-Text Search via LadybugDB FTS
  *
- * Uses KuzuDB's built-in full-text search indexes for keyword-based search.
+ * Uses LadybugDB's built-in full-text search indexes for keyword-based search.
  * Always reads from the database (no cached state to drift).
  */
-import { queryFTS } from '../kuzu/kuzu-adapter.js';
+import { queryFTS } from '../lbug/lbug-adapter.js';
 /**
  * Execute a single FTS query via a custom executor (for MCP connection pool).
- * Returns the same shape as core queryFTS.
+ * Returns the same shape as core queryFTS (from LadybugDB adapter).
  */
 async function queryFTSViaExecutor(executor, tableName, indexName, query, limit) {
     // Escape single quotes and backslashes to prevent Cypher injection
@@ -34,7 +34,7 @@ async function queryFTSViaExecutor(executor, tableName, indexName, query, limit)
     }
 }
 /**
- * Search using KuzuDB's built-in FTS (always fresh, reads from disk)
+ * Search using LadybugDB's built-in FTS (always fresh, reads from disk)
  *
  * Queries multiple node tables (File, Function, Class, Method) in parallel
  * and merges results by filePath, summing scores for the same file.
@@ -44,13 +44,13 @@ async function queryFTSViaExecutor(executor, tableName, indexName, query, limit)
  * @param repoId - If provided, queries will be routed via the MCP connection pool
  * @returns Ranked search results from FTS indexes
  */
-export const searchFTSFromKuzu = async (query, limit = 20, repoId) => {
+export const searchFTSFromLbug = async (query, limit = 20, repoId) => {
     let fileResults, functionResults, classResults, methodResults, interfaceResults;
     if (repoId) {
         // Use MCP connection pool via dynamic import
-        // IMPORTANT: KuzuDB uses a single connection per repo — queries must be sequential
-        // to avoid deadlocking. Do NOT use Promise.all here.
-        const { executeQuery } = await import('../../mcp/core/kuzu-adapter.js');
+        // IMPORTANT: FTS queries run sequentially to avoid connection contention.
+        // The MCP pool supports multiple connections, but FTS is best run serially.
+        const { executeQuery } = await import('../../mcp/core/lbug-adapter.js');
         const executor = (cypher) => executeQuery(repoId, cypher);
         fileResults = await queryFTSViaExecutor(executor, 'File', 'file_fts', query, limit);
         functionResults = await queryFTSViaExecutor(executor, 'Function', 'function_fts', query, limit);
@@ -59,7 +59,7 @@ export const searchFTSFromKuzu = async (query, limit = 20, repoId) => {
         interfaceResults = await queryFTSViaExecutor(executor, 'Interface', 'interface_fts', query, limit);
     }
     else {
-        // Use core kuzu adapter (CLI / pipeline context) — also sequential for safety
+        // Use core lbug adapter (CLI / pipeline context) — also sequential for safety
         fileResults = await queryFTS('File', 'file_fts', query, limit, false).catch(() => []);
         functionResults = await queryFTS('Function', 'function_fts', query, limit, false).catch(() => []);
         classResults = await queryFTS('Class', 'class_fts', query, limit, false).catch(() => []);

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

@@ -33,7 +33,7 @@ export interface HybridSearchResult {
 export declare const mergeWithRRF: (bm25Results: BM25SearchResult[], semanticResults: SemanticSearchResult[], limit?: number) => HybridSearchResult[];
 /**
  * Check if hybrid search is available
- * KuzuDB FTS is always available once the database is initialized.
+ * LadybugDB FTS is always available once the database is initialized.
  * Semantic search is optional - hybrid works with just FTS if embeddings aren't ready.
  */
 export declare const isHybridSearchReady: () => boolean;
@@ -43,7 +43,7 @@ export declare const isHybridSearchReady: () => boolean;
 export declare const formatHybridResults: (results: HybridSearchResult[]) => string;
 /**
  * Execute BM25 + semantic search and merge with RRF.
- * Uses KuzuDB FTS for always-fresh BM25 results (no cached data).
+ * Uses LadybugDB FTS for always-fresh BM25 results (no cached data).
  * The semanticSearch function is injected to keep this module environment-agnostic.
  */
 export declare const hybridSearch: (query: string, limit: number, executeQuery: (cypher: string) => Promise<any[]>, semanticSearch: (executeQuery: (cypher: string) => Promise<any[]>, query: string, k?: number) => Promise<SemanticSearchResult[]>) => Promise<HybridSearchResult[]>;

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

@@ -7,7 +7,7 @@
  * This is the same approach used by Elasticsearch, Pinecone, and other
  * production search systems.
  */
-import { searchFTSFromKuzu } from './bm25-index.js';
+import { searchFTSFromLbug } from './bm25-index.js';
 /**
  * RRF constant - standard value used in the literature
  * Higher values give more weight to lower-ranked results
@@ -80,11 +80,11 @@ export const mergeWithRRF = (bm25Results, semanticResults, limit = 10) => {
 };
 /**
  * Check if hybrid search is available
- * KuzuDB FTS is always available once the database is initialized.
+ * LadybugDB FTS is always available once the database is initialized.
  * Semantic search is optional - hybrid works with just FTS if embeddings aren't ready.
  */
 export const isHybridSearchReady = () => {
-    return true; // FTS is always available via KuzuDB when DB is open
+    return true; // FTS is always available via LadybugDB when DB is open
 };
 /**
  * Format hybrid results for LLM consumption
@@ -107,12 +107,12 @@ export const formatHybridResults = (results) => {
 };
 /**
  * Execute BM25 + semantic search and merge with RRF.
- * Uses KuzuDB FTS for always-fresh BM25 results (no cached data).
+ * Uses LadybugDB FTS for always-fresh BM25 results (no cached data).
  * The semanticSearch function is injected to keep this module environment-agnostic.
  */
 export const hybridSearch = async (query, limit, executeQuery, semanticSearch) => {
-    // Use KuzuDB FTS for always-fresh BM25 results
-    const bm25Results = await searchFTSFromKuzu(query, limit);
+    // Use LadybugDB FTS for always-fresh BM25 results
+    const bm25Results = await searchFTSFromLbug(query, limit);
     const semanticResults = await semanticSearch(executeQuery, query, limit);
     return mergeWithRRF(bm25Results, semanticResults, limit);
 };

package/dist/core/tree-sitter/parser-loader.js

@@ -8,8 +8,8 @@ import CPP from 'tree-sitter-cpp';
 import CSharp from 'tree-sitter-c-sharp';
 import Go from 'tree-sitter-go';
 import Rust from 'tree-sitter-rust';
-import Kotlin from 'tree-sitter-kotlin';
 import PHP from 'tree-sitter-php';
+import Ruby from 'tree-sitter-ruby';
 import { createRequire } from 'node:module';
 import { SupportedLanguages } from '../../config/supported-languages.js';
 // tree-sitter-swift is an optionalDependency — may not be installed
@@ -19,6 +19,12 @@ try {
     Swift = _require('tree-sitter-swift');
 }
 catch { }
+// tree-sitter-kotlin is an optionalDependency — may not be installed
+let Kotlin = null;
+try {
+    Kotlin = _require('tree-sitter-kotlin');
+}
+catch { }
 let parser = null;
 const languageMap = {
     [SupportedLanguages.JavaScript]: JavaScript,
@@ -31,8 +37,9 @@ const languageMap = {
     [SupportedLanguages.CSharp]: CSharp,
     [SupportedLanguages.Go]: Go,
     [SupportedLanguages.Rust]: Rust,
-    [SupportedLanguages.Kotlin]: Kotlin,
+    ...(Kotlin ? { [SupportedLanguages.Kotlin]: Kotlin } : {}),
     [SupportedLanguages.PHP]: PHP.php_only,
+    [SupportedLanguages.Ruby]: Ruby,
     ...(Swift ? { [SupportedLanguages.Swift]: Swift } : {}),
 };
 export const isLanguageAvailable = (language) => language in languageMap;

package/dist/core/wiki/generator.d.ts

@@ -36,14 +36,14 @@ export declare class WikiGenerator {
     private repoPath;
     private storagePath;
     private wikiDir;
-    private kuzuPath;
+    private lbugPath;
     private llmConfig;
     private maxTokensPerModule;
     private concurrency;
     private options;
     private onProgress;
     private failedModules;
-    constructor(repoPath: string, storagePath: string, kuzuPath: string, llmConfig: LLMConfig, options?: WikiOptions, onProgress?: ProgressCallback);
+    constructor(repoPath: string, storagePath: string, lbugPath: string, llmConfig: LLMConfig, options?: WikiOptions, onProgress?: ProgressCallback);
     private lastPercent;
     /**
      * Create streaming options that report LLM progress to the progress bar.

package/dist/core/wiki/generator.js

@@ -25,18 +25,18 @@ export class WikiGenerator {
     repoPath;
     storagePath;
     wikiDir;
-    kuzuPath;
+    lbugPath;
     llmConfig;
     maxTokensPerModule;
     concurrency;
     options;
     onProgress;
     failedModules = [];
-    constructor(repoPath, storagePath, kuzuPath, llmConfig, options = {}, onProgress) {
+    constructor(repoPath, storagePath, lbugPath, llmConfig, options = {}, onProgress) {
         this.repoPath = repoPath;
         this.storagePath = storagePath;
         this.wikiDir = path.join(storagePath, WIKI_DIR);
-        this.kuzuPath = kuzuPath;
+        this.lbugPath = lbugPath;
         this.options = options;
         this.llmConfig = llmConfig;
         this.maxTokensPerModule = options.maxTokensPerModule ?? DEFAULT_MAX_TOKENS_PER_MODULE;
@@ -95,7 +95,7 @@ export class WikiGenerator {
         }
         // Init graph
         this.onProgress('init', 2, 'Connecting to knowledge graph...');
-        await initWikiDb(this.kuzuPath);
+        await initWikiDb(this.lbugPath);
         let result;
         try {
             if (!forceMode && existingMeta && existingMeta.fromCommit) {

package/dist/core/wiki/graph-queries.d.ts

@@ -2,7 +2,7 @@
  * Graph Queries for Wiki Generation
  *
  * Encapsulated Cypher queries against the GitNexus knowledge graph.
- * Uses the MCP-style pooled kuzu-adapter for connection management.
+ * Uses the MCP-style pooled lbug-adapter for connection management.
  */
 export interface FileWithExports {
     filePath: string;
@@ -30,11 +30,11 @@ export interface ProcessInfo {
     }>;
 }
 /**
- * Initialize the KuzuDB connection for wiki generation.
+ * Initialize the LadybugDB connection for wiki generation.
  */
-export declare function initWikiDb(kuzuPath: string): Promise<void>;
+export declare function initWikiDb(lbugPath: string): Promise<void>;
 /**
- * Close the KuzuDB connection.
+ * Close the LadybugDB connection.
  */
 export declare function closeWikiDb(): Promise<void>;
 /**

package/dist/core/wiki/graph-queries.js

@@ -2,21 +2,21 @@
  * Graph Queries for Wiki Generation
  *
  * Encapsulated Cypher queries against the GitNexus knowledge graph.
- * Uses the MCP-style pooled kuzu-adapter for connection management.
+ * Uses the MCP-style pooled lbug-adapter for connection management.
  */
-import { initKuzu, executeQuery, closeKuzu } from '../../mcp/core/kuzu-adapter.js';
+import { initLbug, executeQuery, closeLbug } from '../../mcp/core/lbug-adapter.js';
 const REPO_ID = '__wiki__';
 /**
- * Initialize the KuzuDB connection for wiki generation.
+ * Initialize the LadybugDB connection for wiki generation.
  */
-export async function initWikiDb(kuzuPath) {
-    await initKuzu(REPO_ID, kuzuPath);
+export async function initWikiDb(lbugPath) {
+    await initLbug(REPO_ID, lbugPath);
 }
 /**
- * Close the KuzuDB connection.
+ * Close the LadybugDB connection.
  */
 export async function closeWikiDb() {
-    await closeKuzu(REPO_ID);
+    await closeLbug(REPO_ID);
 }
 /**
  * Get all source files with their exported symbol names and types.