@veewo/gitnexus 1.3.11 → 1.4.6-rc

package/dist/cli/tool.js

@@ -10,9 +10,11 @@
  *   gitnexus impact --target "AuthService" --direction upstream
  *   gitnexus cypher "MATCH (n:Function) RETURN n.name LIMIT 10"
  *
- * Note: Output goes to stderr because KuzuDB's native module captures stdout
- * at the OS level during init. This is consistent with augment.ts.
+ * Note: Output goes to stdout via fs.writeSync(fd 1), bypassing LadybugDB's
+ * native module which captures the Node.js process.stdout stream during init.
+ * See the output() function for details (#324).
  */
+import { writeSync } from 'node:fs';
 import { LocalBackend } from '../mcp/local/local-backend.js';
 let _backend = null;
 async function getBackend() {
@@ -26,10 +28,30 @@ async function getBackend() {
     }
     return _backend;
 }
+/**
+ * Write tool output to stdout using low-level fd write.
+ *
+ * LadybugDB's native module captures Node.js process.stdout during init,
+ * but the underlying OS file descriptor 1 (stdout) remains intact.
+ * By using fs.writeSync(1, ...) we bypass the Node.js stream layer
+ * and write directly to the real stdout fd (#324).
+ *
+ * Falls back to stderr if the fd write fails (e.g., broken pipe).
+ */
 function output(data) {
     const text = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
-    // stderr because KuzuDB captures stdout at OS level
-    process.stderr.write(text + '\n');
+    try {
+        writeSync(1, text + '\n');
+    }
+    catch (err) {
+        if (err?.code === 'EPIPE') {
+            // Consumer closed the pipe (e.g., `gitnexus cypher ... | head -1`)
+            // Exit cleanly per Unix convention
+            process.exit(0);
+        }
+        // Fallback: stderr (previous behavior, works on all platforms)
+        process.stderr.write(text + '\n');
+    }
 }
 export async function queryCommand(queryText, options) {
     if (!queryText?.trim()) {
@@ -71,18 +93,30 @@ export async function impactCommand(target, options) {
         console.error('Usage: gitnexus impact <symbol_name> [--direction upstream|downstream]');
         process.exit(1);
     }
-    const backend = await getBackend();
-    const result = await backend.callTool('impact', {
-        target,
-        target_uid: options?.uid,
-        file_path: options?.file,
-        direction: options?.direction || 'upstream',
-        maxDepth: options?.depth ? parseInt(options.depth) : undefined,
-        minConfidence: options?.minConfidence ? parseFloat(options.minConfidence) : undefined,
-        includeTests: options?.includeTests ?? false,
-        repo: options?.repo,
-    });
-    output(result);
+    try {
+        const backend = await getBackend();
+        const result = await backend.callTool('impact', {
+            target,
+            target_uid: options?.uid,
+            file_path: options?.file,
+            direction: options?.direction || 'upstream',
+            maxDepth: options?.depth ? parseInt(options.depth, 10) : undefined,
+            minConfidence: options?.minConfidence ? parseFloat(options.minConfidence) : undefined,
+            includeTests: options?.includeTests ?? false,
+            repo: options?.repo,
+        });
+        output(result);
+    }
+    catch (err) {
+        // Belt-and-suspenders: catch infrastructure failures (getBackend, callTool transport)
+        // The backend's impact() already returns structured errors for graph query failures
+        output({
+            error: (err instanceof Error ? err.message : String(err)) || 'Impact analysis failed unexpectedly',
+            target: { name: target },
+            direction: options?.direction || 'upstream',
+            suggestion: 'Try reducing --depth or using gitnexus context <symbol> as a fallback',
+        });
+    }
 }
 export async function cypherCommand(query, options) {
     if (!query?.trim()) {

package/dist/cli/wiki.js

@@ -6,7 +6,7 @@
  */
 import path from 'path';
 import readline from 'readline';
-import { execSync } from 'child_process';
+import { execSync, execFileSync } from 'child_process';
 import cliProgress from 'cli-progress';
 import { getGitRoot, isGitRepo } from '../storage/git.js';
 import { getStoragePaths, loadMeta, loadCLIConfig, saveCLIConfig } from '../storage/repo-manager.js';
@@ -86,7 +86,7 @@ export const wikiCommand = async (inputPath, options) => {
         return;
     }
     // ── Check for existing index ────────────────────────────────────────
-    const { storagePath, kuzuPath } = getStoragePaths(repoPath);
+    const { storagePath, lbugPath } = getStoragePaths(repoPath);
     const meta = await loadMeta(storagePath);
     if (!meta) {
         console.log('  Error: No GitNexus index found.');
@@ -217,7 +217,7 @@ export const wikiCommand = async (inputPath, options) => {
         baseUrl: options?.baseUrl,
         concurrency: options?.concurrency ? parseInt(options.concurrency, 10) : undefined,
     };
-    const generator = new WikiGenerator(repoPath, storagePath, kuzuPath, llmConfig, wikiOptions, (phase, percent, detail) => {
+    const generator = new WikiGenerator(repoPath, storagePath, lbugPath, llmConfig, wikiOptions, (phase, percent, detail) => {
         const label = detail || phase;
         if (label !== lastPhase) {
             lastPhase = label;
@@ -299,7 +299,11 @@ function hasGhCLI() {
 }
 function publishGist(htmlPath) {
     try {
-        const output = execSync(`gh gist create "${htmlPath}" --desc "Repository Wiki — generated by GitNexus" --public`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        const output = execFileSync('gh', [
+            'gist', 'create', htmlPath,
+            '--desc', 'Repository Wiki — generated by GitNexus',
+            '--public',
+        ], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
         // gh gist create prints the gist URL as the last line
         const lines = output.split('\n');
         const gistUrl = lines.find(l => l.includes('gist.github.com')) || lines[lines.length - 1];

package/dist/config/ignore-service.d.ts

@@ -1 +1,26 @@
+import { type Ignore } from 'ignore';
+import type { Path } from 'path-scurry';
 export declare const shouldIgnorePath: (filePath: string) => boolean;
+/** Check if a directory name is in the hardcoded ignore list */
+export declare const isHardcodedIgnoredDirectory: (name: string) => boolean;
+/**
+ * Load .gitignore and .gitnexusignore rules from the repo root.
+ * Returns an `ignore` instance with all patterns, or null if no files found.
+ */
+export interface IgnoreOptions {
+    /** Skip .gitignore parsing, only read .gitnexusignore. Defaults to GITNEXUS_NO_GITIGNORE env var. */
+    noGitignore?: boolean;
+}
+export declare const loadIgnoreRules: (repoPath: string, options?: IgnoreOptions) => Promise<Ignore | null>;
+/**
+ * Create a glob-compatible ignore filter combining:
+ * - .gitignore / .gitnexusignore patterns (via `ignore` package)
+ * - Hardcoded DEFAULT_IGNORE_LIST, IGNORED_EXTENSIONS, IGNORED_FILES
+ *
+ * Returns an IgnoreLike object for glob's `ignore` option,
+ * enabling directory-level pruning during traversal.
+ */
+export declare const createIgnoreFilter: (repoPath: string, options?: IgnoreOptions) => Promise<{
+    ignored(p: Path): boolean;
+    childrenIgnored(p: Path): boolean;
+}>;

package/dist/config/ignore-service.js

@@ -1,3 +1,6 @@
+import ignore from 'ignore';
+import fs from 'fs/promises';
+import nodePath from 'path';
 const DEFAULT_IGNORE_LIST = new Set([
     // Version Control
     '.git',
@@ -163,6 +166,10 @@ const IGNORED_FILES = new Set([
     '.env.test',
     '.env.example',
 ]);
+// NOTE: Negation patterns in .gitnexusignore (e.g. `!vendor/`) cannot override
+// entries in DEFAULT_IGNORE_LIST — this is intentional. The hardcoded list protects
+// against indexing directories that are almost never source code (node_modules, .git, etc.).
+// Users who need to include such directories should remove them from the hardcoded list.
 export const shouldIgnorePath = (filePath) => {
     const normalizedPath = filePath.replace(/\\/g, '/');
     const parts = normalizedPath.split('/');
@@ -208,3 +215,72 @@ export const shouldIgnorePath = (filePath) => {
     }
     return false;
 };
+/** Check if a directory name is in the hardcoded ignore list */
+export const isHardcodedIgnoredDirectory = (name) => {
+    return DEFAULT_IGNORE_LIST.has(name);
+};
+export const loadIgnoreRules = async (repoPath, options) => {
+    const ig = ignore();
+    let hasRules = false;
+    // Allow users to bypass .gitignore parsing (e.g. when .gitignore accidentally excludes source files)
+    const skipGitignore = options?.noGitignore ?? !!process.env.GITNEXUS_NO_GITIGNORE;
+    const filenames = skipGitignore
+        ? ['.gitnexusignore']
+        : ['.gitignore', '.gitnexusignore'];
+    for (const filename of filenames) {
+        try {
+            const content = await fs.readFile(nodePath.join(repoPath, filename), 'utf-8');
+            ig.add(content);
+            hasRules = true;
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== 'ENOENT') {
+                console.warn(`  Warning: could not read ${filename}: ${err.message}`);
+            }
+        }
+    }
+    return hasRules ? ig : null;
+};
+/**
+ * Create a glob-compatible ignore filter combining:
+ * - .gitignore / .gitnexusignore patterns (via `ignore` package)
+ * - Hardcoded DEFAULT_IGNORE_LIST, IGNORED_EXTENSIONS, IGNORED_FILES
+ *
+ * Returns an IgnoreLike object for glob's `ignore` option,
+ * enabling directory-level pruning during traversal.
+ */
+export const createIgnoreFilter = async (repoPath, options) => {
+    const ig = await loadIgnoreRules(repoPath, options);
+    return {
+        ignored(p) {
+            // path-scurry's Path.relative() returns POSIX paths on all platforms,
+            // which is what the `ignore` package expects. No explicit normalization needed.
+            const rel = p.relative();
+            if (!rel)
+                return false;
+            // Check .gitignore / .gitnexusignore patterns
+            if (ig && ig.ignores(rel))
+                return true;
+            // Fall back to hardcoded rules
+            return shouldIgnorePath(rel);
+        },
+        childrenIgnored(p) {
+            // Fast path: check directory name against hardcoded list.
+            // Note: dot-directories (.git, .vscode, etc.) are primarily excluded by
+            // glob's `dot: false` option in filesystem-walker.ts. This check is
+            // defense-in-depth — do not remove `dot: false` assuming this covers it.
+            if (DEFAULT_IGNORE_LIST.has(p.name))
+                return true;
+            // Check against .gitignore / .gitnexusignore patterns.
+            // Test both bare path and path with trailing slash to handle
+            // bare-name patterns (e.g. `local`) and dir-only patterns (e.g. `local/`).
+            if (ig) {
+                const rel = p.relative();
+                if (rel && (ig.ignores(rel) || ig.ignores(rel + '/')))
+                    return true;
+            }
+            return false;
+        },
+    };
+};

package/dist/config/supported-languages.d.ts

@@ -7,6 +7,9 @@ export declare enum SupportedLanguages {
     CPlusPlus = "cpp",
     CSharp = "csharp",
     Go = "go",
+    Ruby = "ruby",
     Rust = "rust",
-    PHP = "php"
+    PHP = "php",
+    Kotlin = "kotlin",
+    Swift = "swift"
 }

package/dist/config/supported-languages.js

@@ -8,8 +8,9 @@ export var SupportedLanguages;
     SupportedLanguages["CPlusPlus"] = "cpp";
     SupportedLanguages["CSharp"] = "csharp";
     SupportedLanguages["Go"] = "go";
+    SupportedLanguages["Ruby"] = "ruby";
     SupportedLanguages["Rust"] = "rust";
     SupportedLanguages["PHP"] = "php";
-    // Ruby = 'ruby',
-    // Swift = 'swift',
+    SupportedLanguages["Kotlin"] = "kotlin";
+    SupportedLanguages["Swift"] = "swift";
 })(SupportedLanguages || (SupportedLanguages = {}));

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;
 };
 /**