gitnexus 1.4.1 → 1.4.6

package/dist/cli/wiki.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;

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',
@@ -161,6 +164,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('/');
@@ -206,3 +213,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,7 @@ export declare enum SupportedLanguages {
     CPlusPlus = "cpp",
     CSharp = "csharp",
     Go = "go",
+    Ruby = "ruby",
     Rust = "rust",
     PHP = "php",
     Kotlin = "kotlin",

package/dist/config/supported-languages.js

@@ -8,9 +8,9 @@ export var SupportedLanguages;
     SupportedLanguages["CPlusPlus"] = "cpp";
     SupportedLanguages["CSharp"] = "csharp";
     SupportedLanguages["Go"] = "go";
+    SupportedLanguages["Ruby"] = "ruby";
     SupportedLanguages["Rust"] = "rust";
     SupportedLanguages["PHP"] = "php";
     SupportedLanguages["Kotlin"] = "kotlin";
-    // Ruby = 'ruby',
     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
@@ -98,11 +98,11 @@ export async function augment(pattern, cwd) {
         for (const result of bm25Results.slice(0, 5)) {
             const escaped = result.filePath.replace(/'/g, "''");
             try {
-                const symbols = await executeQuery(repoId, `
-          MATCH (n) WHERE n.filePath = '${escaped}'
-          AND n.name CONTAINS '${pattern.replace(/'/g, "''").split(/\s+/)[0]}'
-          RETURN n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath
-          LIMIT 3
+                const symbols = await executeQuery(repoId, `
+          MATCH (n) WHERE n.filePath = '${escaped}'
+          AND n.name CONTAINS '${pattern.replace(/'/g, "''").split(/\s+/)[0]}'
+          RETURN n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath
+          LIMIT 3
         `);
                 for (const sym of symbols) {
                     symbolMatches.push({
@@ -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) => {
@@ -24,19 +24,19 @@ const queryEmbeddableNodes = async (executeQuery) => {
             let query;
             if (label === 'File') {
                 // File nodes don't have startLine/endLine
-                query = `
-          MATCH (n:File)
-          RETURN n.id AS id, n.name AS name, 'File' AS label, 
-                 n.filePath AS filePath, n.content AS content
+                query = `
+          MATCH (n:File)
+          RETURN n.id AS id, n.name AS name, 'File' AS label, 
+                 n.filePath AS filePath, n.content AS content
         `;
             }
             else {
                 // Code elements have startLine/endLine
-                query = `
-          MATCH (n:${label})
-          RETURN n.id AS id, n.name AS name, '${label}' AS label, 
-                 n.filePath AS filePath, n.content AS content,
-                 n.startLine AS startLine, n.endLine AS endLine
+                query = `
+          MATCH (n:${label})
+          RETURN n.id AS id, n.name AS name, '${label}' AS label, 
+                 n.filePath AS filePath, n.content AS content,
+                 n.startLine AS startLine, n.endLine AS endLine
         `;
             }
             const rows = await executeQuery(query);
@@ -76,9 +76,22 @@ 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) => {
-    const cypher = `
-    CALL CREATE_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx', 'embedding', metric := 'cosine')
+    // 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')
   `;
     try {
         await executeQuery(cypher);
@@ -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]),
@@ -240,62 +253,76 @@ export const semanticSearch = async (executeQuery, query, k = 10, maxDistance =
     const queryVec = embeddingToArray(queryEmbedding);
     const queryVecStr = `[${queryVec.join(',')}]`;
     // Query the vector index on CodeEmbedding to get nodeIds and distances
-    const vectorQuery = `
-    CALL QUERY_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx', 
-      CAST(${queryVecStr} AS FLOAT[384]), ${k})
-    YIELD node AS emb, distance
-    WITH emb, distance
-    WHERE distance < ${maxDistance}
-    RETURN emb.nodeId AS nodeId, distance
-    ORDER BY distance
+    const vectorQuery = `
+    CALL QUERY_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx', 
+      CAST(${queryVecStr} AS FLOAT[384]), ${k})
+    YIELD node AS emb, distance
+    WITH emb, distance
+    WHERE distance < ${maxDistance}
+    RETURN emb.nodeId AS nodeId, distance
+    ORDER BY distance
   `;
     const embResults = await executeQuery(vectorQuery);
     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
+                nodeQuery = `
+          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, 
-                 n.startLine AS startLine, n.endLine AS endLine
+                nodeQuery = `
+          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/graph/types.d.ts

@@ -1,10 +1,11 @@
 export type NodeLabel = 'Project' | 'Package' | 'Module' | 'Folder' | 'File' | 'Class' | 'Function' | 'Method' | 'Variable' | 'Interface' | 'Enum' | 'Decorator' | 'Import' | 'Type' | 'CodeElement' | 'Community' | 'Process' | 'Struct' | 'Macro' | 'Typedef' | 'Union' | 'Namespace' | 'Trait' | 'Impl' | 'TypeAlias' | 'Const' | 'Static' | 'Property' | 'Record' | 'Delegate' | 'Annotation' | 'Constructor' | 'Template';
+import { SupportedLanguages } from '../../config/supported-languages.js';
 export type NodeProperties = {
     name: string;
     filePath: string;
     startLine?: number;
     endLine?: number;
-    language?: string;
+    language?: SupportedLanguages;
     isExported?: boolean;
     astFrameworkMultiplier?: number;
     astFrameworkReason?: string;
@@ -21,8 +22,10 @@ export type NodeProperties = {
     terminalId?: string;
     entryPointScore?: number;
     entryPointReason?: string;
+    parameterCount?: number;
+    returnType?: string;
 };
-export type RelationshipType = 'CONTAINS' | 'CALLS' | 'INHERITS' | 'OVERRIDES' | 'IMPORTS' | 'USES' | 'DEFINES' | 'DECORATES' | 'IMPLEMENTS' | 'EXTENDS' | 'MEMBER_OF' | 'STEP_IN_PROCESS';
+export type RelationshipType = 'CONTAINS' | 'CALLS' | 'INHERITS' | 'OVERRIDES' | 'IMPORTS' | 'USES' | 'DEFINES' | 'DECORATES' | 'IMPLEMENTS' | 'EXTENDS' | 'HAS_METHOD' | 'MEMBER_OF' | 'STEP_IN_PROCESS';
 export interface GraphNode {
     id: string;
     label: NodeLabel;