gitnexus 1.4.0 → 1.4.5

package/dist/core/augmentation/engine.js

@@ -56,7 +56,7 @@ async function findRepoForCwd(cwd) {
         return {
             name: bestMatch.name,
             storagePath: bestMatch.storagePath,
-            kuzuPath: path.join(bestMatch.storagePath, 'kuzu'),
+            lbugPath: path.join(bestMatch.storagePath, 'lbug'),
         };
     }
     catch {
@@ -81,16 +81,16 @@ export async function augment(pattern, cwd) {
         const repo = await findRepoForCwd(workDir);
         if (!repo)
             return '';
-        // Lazy-load kuzu adapter (skip unnecessary init)
-        const { initKuzu, executeQuery, isKuzuReady } = await import('../../mcp/core/kuzu-adapter.js');
-        const { searchFTSFromKuzu } = await import('../search/bm25-index.js');
+        // Lazy-load lbug adapter (skip unnecessary init)
+        const { initLbug, executeQuery, isLbugReady } = await import('../../mcp/core/lbug-adapter.js');
+        const { searchFTSFromLbug } = await import('../search/bm25-index.js');
         const repoId = repo.name.toLowerCase();
-        // Init KuzuDB if not already
-        if (!isKuzuReady(repoId)) {
-            await initKuzu(repoId, repo.kuzuPath);
+        // Init LadybugDB if not already
+        if (!isLbugReady(repoId)) {
+            await initLbug(repoId, repo.lbugPath);
         }
         // Step 1: BM25 search (fast, no embeddings)
-        const bm25Results = await searchFTSFromKuzu(pattern, 10, repoId);
+        const bm25Results = await searchFTSFromLbug(pattern, 10, repoId);
         if (bm25Results.length === 0)
             return '';
         // Step 2: Map BM25 file results to symbols
@@ -118,72 +118,99 @@ export async function augment(pattern, cwd) {
         }
         if (symbolMatches.length === 0)
             return '';
-        // Step 3: For top matches, fetch callers/callees/processes
-        // Also get cluster cohesion internally for ranking
-        const enriched = [];
-        const seen = new Set();
-        for (const sym of symbolMatches.slice(0, 5)) {
-            if (seen.has(sym.nodeId))
-                continue;
-            seen.add(sym.nodeId);
-            const escaped = sym.nodeId.replace(/'/g, "''");
-            // Callers
-            let callers = [];
-            try {
-                const rows = await executeQuery(repoId, `
-          MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(n {id: '${escaped}'})
-          RETURN caller.name AS name
-          LIMIT 3
-        `);
-                callers = rows.map((r) => r.name || r[0]).filter(Boolean);
-            }
-            catch { /* skip */ }
-            // Callees
-            let callees = [];
-            try {
-                const rows = await executeQuery(repoId, `
-          MATCH (n {id: '${escaped}'})-[:CodeRelation {type: 'CALLS'}]->(callee)
-          RETURN callee.name AS name
-          LIMIT 3
-        `);
-                callees = rows.map((r) => r.name || r[0]).filter(Boolean);
+        // Step 3: Batch-fetch callers/callees/processes/cohesion for top matches
+        // Uses batched WHERE n.id IN [...] queries instead of per-symbol queries
+        const uniqueSymbols = symbolMatches.slice(0, 5).filter((sym, i, arr) => arr.findIndex(s => s.nodeId === sym.nodeId) === i);
+        if (uniqueSymbols.length === 0)
+            return '';
+        const idList = uniqueSymbols.map(s => `'${s.nodeId.replace(/'/g, "''")}'`).join(', ');
+        // Batch fetch callers
+        const callersMap = new Map();
+        try {
+            const rows = await executeQuery(repoId, `
+        MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(n)
+        WHERE n.id IN [${idList}]
+        RETURN n.id AS targetId, caller.name AS name
+        LIMIT 15
+      `);
+            for (const r of rows) {
+                const tid = r.targetId || r[0];
+                const name = r.name || r[1];
+                if (tid && name) {
+                    if (!callersMap.has(tid))
+                        callersMap.set(tid, []);
+                    callersMap.get(tid).push(name);
+                }
             }
-            catch { /* skip */ }
-            // Processes
-            let processes = [];
-            try {
-                const rows = await executeQuery(repoId, `
-          MATCH (n {id: '${escaped}'})-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
-          RETURN p.heuristicLabel AS label, r.step AS step, p.stepCount AS stepCount
-        `);
-                processes = rows.map((r) => {
-                    const label = r.label || r[0];
-                    const step = r.step || r[1];
-                    const stepCount = r.stepCount || r[2];
-                    return `${label} (step ${step}/${stepCount})`;
-                }).filter(Boolean);
+        }
+        catch { /* skip */ }
+        // Batch fetch callees
+        const calleesMap = new Map();
+        try {
+            const rows = await executeQuery(repoId, `
+        MATCH (n)-[:CodeRelation {type: 'CALLS'}]->(callee)
+        WHERE n.id IN [${idList}]
+        RETURN n.id AS sourceId, callee.name AS name
+        LIMIT 15
+      `);
+            for (const r of rows) {
+                const sid = r.sourceId || r[0];
+                const name = r.name || r[1];
+                if (sid && name) {
+                    if (!calleesMap.has(sid))
+                        calleesMap.set(sid, []);
+                    calleesMap.get(sid).push(name);
+                }
             }
-            catch { /* skip */ }
-            // Cluster cohesion (internal ranking signal)
-            let cohesion = 0;
-            try {
-                const rows = await executeQuery(repoId, `
-          MATCH (n {id: '${escaped}'})-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
-          RETURN c.cohesion AS cohesion
-          LIMIT 1
-        `);
-                if (rows.length > 0) {
-                    cohesion = (rows[0].cohesion ?? rows[0][0]) || 0;
+        }
+        catch { /* skip */ }
+        // Batch fetch processes
+        const processesMap = new Map();
+        try {
+            const rows = await executeQuery(repoId, `
+        MATCH (n)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
+        WHERE n.id IN [${idList}]
+        RETURN n.id AS nodeId, p.heuristicLabel AS label, r.step AS step, p.stepCount AS stepCount
+      `);
+            for (const r of rows) {
+                const nid = r.nodeId || r[0];
+                const label = r.label || r[1];
+                const step = r.step || r[2];
+                const stepCount = r.stepCount || r[3];
+                if (nid && label) {
+                    if (!processesMap.has(nid))
+                        processesMap.set(nid, []);
+                    processesMap.get(nid).push(`${label} (step ${step}/${stepCount})`);
                 }
             }
-            catch { /* skip */ }
+        }
+        catch { /* skip */ }
+        // Batch fetch cohesion
+        const cohesionMap = new Map();
+        try {
+            const rows = await executeQuery(repoId, `
+        MATCH (n)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
+        WHERE n.id IN [${idList}]
+        RETURN n.id AS nodeId, c.cohesion AS cohesion
+      `);
+            for (const r of rows) {
+                const nid = r.nodeId || r[0];
+                const coh = r.cohesion ?? r[1] ?? 0;
+                if (nid)
+                    cohesionMap.set(nid, coh);
+            }
+        }
+        catch { /* skip */ }
+        // Assemble enriched results
+        const enriched = [];
+        for (const sym of uniqueSymbols) {
             enriched.push({
                 name: sym.name,
                 filePath: sym.filePath,
-                callers,
-                callees,
-                processes,
-                cohesion,
+                callers: (callersMap.get(sym.nodeId) || []).slice(0, 3),
+                callees: (calleesMap.get(sym.nodeId) || []).slice(0, 3),
+                processes: processesMap.get(sym.nodeId) || [],
+                cohesion: cohesionMap.get(sym.nodeId) || 0,
             });
         }
         if (enriched.length === 0)

package/dist/core/embeddings/embedder.d.ts

@@ -50,7 +50,7 @@ export declare const embedText: (text: string) => Promise<Float32Array>;
  */
 export declare const embedBatch: (texts: string[]) => Promise<Float32Array[]>;
 /**
- * Convert Float32Array to regular number array (for KuzuDB storage)
+ * Convert Float32Array to regular number array (for LadybugDB storage)
  */
 export declare const embeddingToArray: (embedding: Float32Array) => number[];
 /**

package/dist/core/embeddings/embedder.js

@@ -225,7 +225,7 @@ export const embedBatch = async (texts) => {
     return embeddings;
 };
 /**
- * Convert Float32Array to regular number array (for KuzuDB storage)
+ * Convert Float32Array to regular number array (for LadybugDB storage)
  */
 export const embeddingToArray = (embedding) => {
     return Array.from(embedding);

package/dist/core/embeddings/embedding-pipeline.d.ts

@@ -2,10 +2,10 @@
  * Embedding Pipeline Module
  *
  * Orchestrates the background embedding process:
- * 1. Query embeddable nodes from KuzuDB
+ * 1. Query embeddable nodes from LadybugDB
  * 2. Generate text representations
  * 3. Batch embed using transformers.js
- * 4. Update KuzuDB with embeddings
+ * 4. Update LadybugDB with embeddings
  * 5. Create vector index for semantic search
  */
 import { type EmbeddingProgress, type EmbeddingConfig, type SemanticSearchResult } from './types.js';
@@ -16,7 +16,7 @@ export type EmbeddingProgressCallback = (progress: EmbeddingProgress) => void;
 /**
  * Run the embedding pipeline
  *
- * @param executeQuery - Function to execute Cypher queries against KuzuDB
+ * @param executeQuery - Function to execute Cypher queries against LadybugDB
  * @param executeWithReusedStatement - Function to execute with reused prepared statement
  * @param onProgress - Callback for progress updates
  * @param config - Optional configuration override

package/dist/core/embeddings/embedding-pipeline.js

@@ -2,10 +2,10 @@
  * Embedding Pipeline Module
  *
  * Orchestrates the background embedding process:
- * 1. Query embeddable nodes from KuzuDB
+ * 1. Query embeddable nodes from LadybugDB
  * 2. Generate text representations
  * 3. Batch embed using transformers.js
- * 4. Update KuzuDB with embeddings
+ * 4. Update LadybugDB with embeddings
  * 5. Create vector index for semantic search
  */
 import { initEmbedder, embedBatch, embedText, embeddingToArray, isEmbedderReady } from './embedder.js';
@@ -13,7 +13,7 @@ import { generateBatchEmbeddingTexts } from './text-generator.js';
 import { DEFAULT_EMBEDDING_CONFIG, EMBEDDABLE_LABELS, } from './types.js';
 const isDev = process.env.NODE_ENV === 'development';
 /**
- * Query all embeddable nodes from KuzuDB
+ * Query all embeddable nodes from LadybugDB
  * Uses table-specific queries (File has different schema than code elements)
  */
 const queryEmbeddableNodes = async (executeQuery) => {
@@ -76,7 +76,20 @@ const batchInsertEmbeddings = async (executeWithReusedStatement, updates) => {
  * Create the vector index for semantic search
  * Now indexes the separate CodeEmbedding table
  */
+let vectorExtensionLoaded = false;
 const createVectorIndex = async (executeQuery) => {
+    // LadybugDB v0.15+ requires explicit VECTOR extension loading (once per session)
+    if (!vectorExtensionLoaded) {
+        try {
+            await executeQuery('INSTALL VECTOR');
+            await executeQuery('LOAD EXTENSION VECTOR');
+            vectorExtensionLoaded = true;
+        }
+        catch {
+            // Extension may already be loaded — CREATE_VECTOR_INDEX will fail clearly if not
+            vectorExtensionLoaded = true;
+        }
+    }
     const cypher = `
     CALL CREATE_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx', 'embedding', metric := 'cosine')
   `;
@@ -93,7 +106,7 @@ const createVectorIndex = async (executeQuery) => {
 /**
  * Run the embedding pipeline
  *
- * @param executeQuery - Function to execute Cypher queries against KuzuDB
+ * @param executeQuery - Function to execute Cypher queries against LadybugDB
  * @param executeWithReusedStatement - Function to execute with reused prepared statement
  * @param onProgress - Callback for progress updates
  * @param config - Optional configuration override
@@ -167,7 +180,7 @@ export const runEmbeddingPipeline = async (executeQuery, executeWithReusedStatem
             const texts = generateBatchEmbeddingTexts(batch, finalConfig);
             // Embed the batch
             const embeddings = await embedBatch(texts);
-            // Update KuzuDB with embeddings
+            // Update LadybugDB with embeddings
             const updates = batch.map((node, i) => ({
                 id: node.id,
                 embedding: embeddingToArray(embeddings[i]),
@@ -253,49 +266,63 @@ export const semanticSearch = async (executeQuery, query, k = 10, maxDistance =
     if (embResults.length === 0) {
         return [];
     }
-    // Get metadata for each result by querying each node table
-    const results = [];
+    // Group results by label for batched metadata queries
+    const byLabel = new Map();
     for (const embRow of embResults) {
         const nodeId = embRow.nodeId ?? embRow[0];
         const distance = embRow.distance ?? embRow[1];
-        // Extract label from node ID (format: Label:path:name)
         const labelEndIdx = nodeId.indexOf(':');
         const label = labelEndIdx > 0 ? nodeId.substring(0, labelEndIdx) : 'Unknown';
-        // Query the specific table for this node
-        // File nodes don't have startLine/endLine
+        if (!byLabel.has(label))
+            byLabel.set(label, []);
+        byLabel.get(label).push({ nodeId, distance });
+    }
+    // Batch-fetch metadata per label
+    const results = [];
+    for (const [label, items] of byLabel) {
+        const idList = items.map(i => `'${i.nodeId.replace(/'/g, "''")}'`).join(', ');
         try {
             let nodeQuery;
             if (label === 'File') {
                 nodeQuery = `
-          MATCH (n:File {id: '${nodeId.replace(/'/g, "''")}'}) 
-          RETURN n.name AS name, n.filePath AS filePath
+          MATCH (n:File) WHERE n.id IN [${idList}]
+          RETURN n.id AS id, n.name AS name, n.filePath AS filePath
         `;
             }
             else {
                 nodeQuery = `
-          MATCH (n:${label} {id: '${nodeId.replace(/'/g, "''")}'}) 
-          RETURN n.name AS name, n.filePath AS filePath, 
+          MATCH (n:${label}) WHERE n.id IN [${idList}]
+          RETURN n.id AS id, n.name AS name, n.filePath AS filePath,
                  n.startLine AS startLine, n.endLine AS endLine
         `;
             }
             const nodeRows = await executeQuery(nodeQuery);
-            if (nodeRows.length > 0) {
-                const nodeRow = nodeRows[0];
-                results.push({
-                    nodeId,
-                    name: nodeRow.name ?? nodeRow[0] ?? '',
-                    label,
-                    filePath: nodeRow.filePath ?? nodeRow[1] ?? '',
-                    distance,
-                    startLine: label !== 'File' ? (nodeRow.startLine ?? nodeRow[2]) : undefined,
-                    endLine: label !== 'File' ? (nodeRow.endLine ?? nodeRow[3]) : undefined,
-                });
+            const rowMap = new Map();
+            for (const row of nodeRows) {
+                const id = row.id ?? row[0];
+                rowMap.set(id, row);
+            }
+            for (const item of items) {
+                const nodeRow = rowMap.get(item.nodeId);
+                if (nodeRow) {
+                    results.push({
+                        nodeId: item.nodeId,
+                        name: nodeRow.name ?? nodeRow[1] ?? '',
+                        label,
+                        filePath: nodeRow.filePath ?? nodeRow[2] ?? '',
+                        distance: item.distance,
+                        startLine: label !== 'File' ? (nodeRow.startLine ?? nodeRow[3]) : undefined,
+                        endLine: label !== 'File' ? (nodeRow.endLine ?? nodeRow[4]) : undefined,
+                    });
+                }
             }
         }
         catch {
             // Table might not exist, skip
         }
     }
+    // Re-sort by distance since batch queries may have mixed order
+    results.sort((a, b) => a.distance - b.distance);
     return results;
 };
 /**

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

@@ -64,7 +64,7 @@ export interface SemanticSearchResult {
     endLine?: number;
 }
 /**
- * Node data for embedding (minimal structure from KuzuDB query)
+ * Node data for embedding (minimal structure from LadybugDB query)
  */
 export interface EmbeddableNode {
     id: string;

package/dist/core/ingestion/call-processor.d.ts

@@ -1,19 +1,18 @@
 import { KnowledgeGraph } from '../graph/types.js';
 import { ASTCache } from './ast-cache.js';
-import type { SymbolTable } from './symbol-table.js';
-import { ImportMap, PackageMap, NamedImportMap } from './import-processor.js';
-import type { ExtractedCall, ExtractedRoute } from './workers/parse-worker.js';
+import type { ResolutionContext } from './resolution-context.js';
+import type { ExtractedCall, ExtractedHeritage, ExtractedRoute, FileConstructorBindings } from './workers/parse-worker.js';
 export declare const processCalls: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;
-}[], astCache: ASTCache, symbolTable: SymbolTable, importMap: ImportMap, packageMap?: PackageMap, onProgress?: (current: number, total: number) => void, namedImportMap?: NamedImportMap) => Promise<void>;
+}[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<ExtractedHeritage[]>;
+export declare const extractReturnTypeName: (raw: string, depth?: number) => string | undefined;
 /**
  * Fast path: resolve pre-extracted call sites from workers.
  * No AST parsing — workers already extracted calledName + sourceId.
- * This function only does symbol table lookups + graph mutations.
  */
-export declare const processCallsFromExtracted: (graph: KnowledgeGraph, extractedCalls: ExtractedCall[], symbolTable: SymbolTable, importMap: ImportMap, packageMap?: PackageMap, onProgress?: (current: number, total: number) => void, namedImportMap?: NamedImportMap) => Promise<void>;
+export declare const processCallsFromExtracted: (graph: KnowledgeGraph, extractedCalls: ExtractedCall[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, constructorBindings?: FileConstructorBindings[]) => Promise<void>;
 /**
  * Resolve pre-extracted Laravel routes to CALLS edges from route files to controller methods.
  */
-export declare const processRoutesFromExtracted: (graph: KnowledgeGraph, extractedRoutes: ExtractedRoute[], symbolTable: SymbolTable, importMap: ImportMap, packageMap?: PackageMap, onProgress?: (current: number, total: number) => void) => Promise<void>;
+export declare const processRoutesFromExtracted: (graph: KnowledgeGraph, extractedRoutes: ExtractedRoute[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<void>;