@veewo/gitnexus 1.3.11 → 1.4.6-rc

package/dist/core/ingestion/workers/worker-pool.js

@@ -1,5 +1,7 @@
 import { Worker } from 'node:worker_threads';
 import os from 'node:os';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
 /**
  * Max files to send to a worker in a single postMessage.
  * Keeps structured-clone memory bounded per sub-batch.
@@ -12,6 +14,12 @@ const SUB_BATCH_TIMEOUT_MS = 30_000;
  * Create a pool of worker threads.
  */
 export const createWorkerPool = (workerUrl, poolSize) => {
+    // Validate worker script exists before spawning to prevent uncaught
+    // MODULE_NOT_FOUND crashes in worker threads (e.g. when running from src/ via vitest)
+    const workerPath = fileURLToPath(workerUrl);
+    if (!fs.existsSync(workerPath)) {
+        throw new Error(`Worker script not found: ${workerPath}`);
+    }
     const size = poolSize ?? Math.min(8, Math.max(1, os.cpus().length - 1));
     const workers = [];
     for (let i = 0; i < size; i++) {

package/dist/core/{kuzu → lbug}/csv-generator.d.ts

@@ -1,5 +1,5 @@
 /**
- * CSV Generator for KuzuDB Hybrid Schema
+ * CSV Generator for LadybugDB Hybrid Schema
  *
  * Streams CSV rows directly to disk files in a single pass over graph nodes.
  * File contents are lazy-read from disk per-node to avoid holding the entire
@@ -13,25 +13,27 @@
  */
 import { KnowledgeGraph, GraphNode } from '../graph/types.js';
 import { NodeTableName } from './schema.js';
+export declare const sanitizeUTF8: (str: string) => string;
+export declare const escapeCSVField: (value: string | number | undefined | null) => string;
+export declare const escapeCSVNumber: (value: number | undefined | null, defaultValue?: number) => string;
+export declare const isBinaryContent: (content: string) => boolean;
 /**
  * LRU content cache — avoids re-reading the same source file for every
  * symbol defined in it. Sized generously so most files stay cached during
  * the single-pass node iteration.
  */
 export declare class FileContentCache {
-    private repoPath;
-    private maxBytes;
     private cache;
-    private currentBytes;
-    constructor(repoPath: string, maxBytes?: number);
+    private accessOrder;
+    private maxSize;
+    private repoPath;
+    constructor(repoPath: string, maxSize?: number);
+    setForTest(relativePath: string, content: string): void;
+    hasForTest(relativePath: string): boolean;
     get(relativePath: string): Promise<string>;
-    setForTest(key: string, value: string): void;
-    hasForTest(key: string): boolean;
-    private touch;
     private set;
-    private evictIfNeeded;
 }
-export declare function toCodeElementCsvRow(node: GraphNode, contentCache?: FileContentCache): Promise<string>;
+export declare const toCodeElementCsvRow: (node: GraphNode) => Promise<string>;
 export interface StreamedCSVResult {
     nodeFiles: Map<NodeTableName, {
         csvPath: string;

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

@@ -1,5 +1,5 @@
 /**
- * CSV Generator for KuzuDB Hybrid Schema
+ * CSV Generator for LadybugDB Hybrid Schema
  *
  * Streams CSV rows directly to disk files in a single pass over graph nodes.
  * File contents are lazy-read from disk per-node to avoid holding the entire
@@ -19,7 +19,7 @@ const FLUSH_EVERY = 500;
 // ============================================================================
 // CSV ESCAPE UTILITIES
 // ============================================================================
-const sanitizeUTF8 = (str) => {
+export const sanitizeUTF8 = (str) => {
     return str
         .replace(/\r\n/g, '\n')
         .replace(/\r/g, '\n')
@@ -27,23 +27,22 @@ const sanitizeUTF8 = (str) => {
         .replace(/[\uD800-\uDFFF]/g, '')
         .replace(/[\uFFFE\uFFFF]/g, '');
 };
-const escapeCSVField = (value) => {
+export const escapeCSVField = (value) => {
     if (value === undefined || value === null)
         return '""';
     let str = String(value);
     str = sanitizeUTF8(str);
     return `"${str.replace(/"/g, '""')}"`;
 };
-const escapeCSVNumber = (value, defaultValue = -1) => {
+export const escapeCSVNumber = (value, defaultValue = -1) => {
     if (value === undefined || value === null)
         return String(defaultValue);
     return String(value);
 };
-const UNITY_RESOURCE_PATH_PATTERN = /\.(prefab|unity|asset)$/i;
 // ============================================================================
 // CONTENT EXTRACTION (lazy — reads from disk on demand)
 // ============================================================================
-const isBinaryContent = (content) => {
+export const isBinaryContent = (content) => {
     if (!content || content.length === 0)
         return false;
     const sample = content.slice(0, 1000);
@@ -61,21 +60,32 @@ const isBinaryContent = (content) => {
  * the single-pass node iteration.
  */
 export class FileContentCache {
-    repoPath;
-    maxBytes;
     cache = new Map();
-    currentBytes = 0;
-    constructor(repoPath, maxBytes = 128 * 1024 * 1024) {
+    accessOrder = [];
+    maxSize;
+    repoPath;
+    constructor(repoPath, maxSize = 3000) {
         this.repoPath = repoPath;
-        this.maxBytes = maxBytes;
+        this.maxSize = maxSize;
+    }
+    setForTest(relativePath, content) {
+        this.set(relativePath, content);
+    }
+    hasForTest(relativePath) {
+        return this.cache.has(relativePath);
     }
     async get(relativePath) {
         if (!relativePath)
             return '';
         const cached = this.cache.get(relativePath);
         if (cached !== undefined) {
-            this.touch(relativePath, cached);
-            return cached.content;
+            // Move to end of accessOrder (LRU promotion)
+            const idx = this.accessOrder.indexOf(relativePath);
+            if (idx !== -1) {
+                this.accessOrder.splice(idx, 1);
+                this.accessOrder.push(relativePath);
+            }
+            return cached;
         }
         try {
             const fullPath = path.join(this.repoPath, relativePath);
@@ -88,40 +98,28 @@ export class FileContentCache {
             return '';
         }
     }
-    setForTest(key, value) {
-        this.set(key, value);
-    }
-    hasForTest(key) {
-        return this.cache.has(key);
-    }
-    touch(key, value) {
-        this.cache.delete(key);
-        this.cache.set(key, value);
-    }
     set(key, value) {
-        const prev = this.cache.get(key);
-        if (prev) {
-            this.currentBytes -= prev.sizeBytes;
-            this.cache.delete(key);
-        }
-        const sizeBytes = Buffer.byteLength(value, 'utf-8');
-        this.cache.set(key, { content: value, sizeBytes });
-        this.currentBytes += sizeBytes;
-        this.evictIfNeeded();
-    }
-    evictIfNeeded() {
-        while (this.currentBytes > this.maxBytes && this.cache.size > 0) {
-            const oldestKey = this.cache.keys().next().value;
-            if (!oldestKey)
-                break;
-            const oldest = this.cache.get(oldestKey);
-            this.cache.delete(oldestKey);
-            if (oldest) {
-                this.currentBytes -= oldest.sizeBytes;
-            }
+        if (this.cache.size >= this.maxSize) {
+            const oldest = this.accessOrder.shift();
+            if (oldest)
+                this.cache.delete(oldest);
         }
+        this.cache.set(key, value);
+        this.accessOrder.push(key);
     }
 }
+export const toCodeElementCsvRow = async (node) => {
+    return [
+        escapeCSVField(node.id),
+        escapeCSVField(node.properties.name || ''),
+        escapeCSVField(node.properties.filePath || ''),
+        escapeCSVNumber(node.properties.startLine, -1),
+        escapeCSVNumber(node.properties.endLine, -1),
+        node.properties.isExported ? 'true' : 'false',
+        escapeCSVField(''),
+        escapeCSVField(node.properties.description || ''),
+    ].join(',');
+};
 const extractContent = async (node, contentCache) => {
     const filePath = node.properties.filePath;
     const content = await contentCache.get(filePath);
@@ -150,56 +148,6 @@ const extractContent = async (node, contentCache) => {
         ? snippet.slice(0, MAX_SNIPPET) + '\n... [truncated]'
         : snippet;
 };
-function compactUnityComponentDescription(description) {
-    const raw = typeof description === 'string' ? description : '';
-    if (!raw)
-        return '';
-    try {
-        const parsed = JSON.parse(raw);
-        const compact = {};
-        if (parsed.bindingKind)
-            compact.bindingKind = parsed.bindingKind;
-        if (parsed.componentObjectId)
-            compact.componentObjectId = parsed.componentObjectId;
-        if (parsed.lightweight)
-            compact.lightweight = true;
-        const scalarFields = parsed.serializedFields?.scalarFields || [];
-        const referenceFields = parsed.serializedFields?.referenceFields || [];
-        if (scalarFields.length > 0 || referenceFields.length > 0) {
-            compact.serializedFields = { scalarFields, referenceFields };
-        }
-        if (Array.isArray(parsed.resolvedReferences) && parsed.resolvedReferences.length > 0) {
-            compact.resolvedReferences = parsed.resolvedReferences;
-        }
-        if (Array.isArray(parsed.assetRefPaths) && parsed.assetRefPaths.length > 0) {
-            compact.assetRefPaths = parsed.assetRefPaths;
-        }
-        return JSON.stringify(Object.keys(compact).length > 0 ? compact : parsed);
-    }
-    catch {
-        return raw;
-    }
-}
-export async function toCodeElementCsvRow(node, contentCache) {
-    const filePath = String(node.properties.filePath || '');
-    const isUnityComponentRow = node.label === 'CodeElement' && UNITY_RESOURCE_PATH_PATTERN.test(filePath);
-    const content = isUnityComponentRow
-        ? ''
-        : (contentCache ? await extractContent(node, contentCache) : '');
-    const description = isUnityComponentRow
-        ? compactUnityComponentDescription(node.properties.description || '')
-        : String(node.properties.description || '');
-    return [
-        escapeCSVField(node.id),
-        escapeCSVField(node.properties.name || ''),
-        escapeCSVField(filePath),
-        escapeCSVNumber(node.properties.startLine, -1),
-        escapeCSVNumber(node.properties.endLine, -1),
-        node.properties.isExported ? 'true' : 'false',
-        escapeCSVField(content),
-        escapeCSVField(description),
-    ].join(',');
-}
 // ============================================================================
 // BUFFERED CSV WRITER
 // ============================================================================
@@ -227,11 +175,18 @@ class BufferedCSVWriter {
         const chunk = this.buffer.join('\n') + '\n';
         this.buffer.length = 0;
         return new Promise((resolve, reject) => {
+            this.ws.once('error', reject);
             const ok = this.ws.write(chunk);
-            if (ok)
+            if (ok) {
+                this.ws.removeListener('error', reject);
                 resolve();
-            else
-                this.ws.once('drain', resolve);
+            }
+            else {
+                this.ws.once('drain', () => {
+                    this.ws.removeListener('error', reject);
+                    resolve();
+                });
+            }
         });
     }
     async finish() {
@@ -266,7 +221,8 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
     const functionWriter = new BufferedCSVWriter(path.join(csvDir, 'function.csv'), codeElementHeader);
     const classWriter = new BufferedCSVWriter(path.join(csvDir, 'class.csv'), codeElementHeader);
     const interfaceWriter = new BufferedCSVWriter(path.join(csvDir, 'interface.csv'), codeElementHeader);
-    const methodWriter = new BufferedCSVWriter(path.join(csvDir, 'method.csv'), codeElementHeader);
+    const methodHeader = 'id,name,filePath,startLine,endLine,isExported,content,description,parameterCount,returnType';
+    const methodWriter = new BufferedCSVWriter(path.join(csvDir, 'method.csv'), methodHeader);
     const codeElemWriter = new BufferedCSVWriter(path.join(csvDir, 'codeelement.csv'), codeElementHeader);
     const communityWriter = new BufferedCSVWriter(path.join(csvDir, 'community.csv'), 'id,label,heuristicLabel,keywords,description,enrichedBy,cohesion,symbolCount');
     const processWriter = new BufferedCSVWriter(path.join(csvDir, 'process.csv'), 'id,label,heuristicLabel,processType,stepCount,communities,entryPointId,terminalId');
@@ -282,7 +238,6 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
         'Function': functionWriter,
         'Class': classWriter,
         'Interface': interfaceWriter,
-        'Method': methodWriter,
         'CodeElement': codeElemWriter,
     };
     const seenFileIds = new Set();
@@ -311,7 +266,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
                 break;
             case 'Community': {
                 const keywords = node.properties.keywords || [];
-                const keywordsStr = `[${keywords.map((k) => `'${k.replace(/'/g, "''")}'`).join(',')}]`;
+                const keywordsStr = `[${keywords.map((k) => `'${k.replace(/\\/g, '\\\\').replace(/'/g, "''").replace(/,/g, '\\,')}'`).join(',')}]`;
                 await communityWriter.addRow([
                     escapeCSVField(node.id),
                     escapeCSVField(node.properties.name || ''),
@@ -339,11 +294,37 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
                 ].join(','));
                 break;
             }
+            case 'Method': {
+                const content = await extractContent(node, contentCache);
+                await methodWriter.addRow([
+                    escapeCSVField(node.id),
+                    escapeCSVField(node.properties.name || ''),
+                    escapeCSVField(node.properties.filePath || ''),
+                    escapeCSVNumber(node.properties.startLine, -1),
+                    escapeCSVNumber(node.properties.endLine, -1),
+                    node.properties.isExported ? 'true' : 'false',
+                    escapeCSVField(content),
+                    escapeCSVField(node.properties.description || ''),
+                    escapeCSVNumber(node.properties.parameterCount, 0),
+                    escapeCSVField(node.properties.returnType || ''),
+                ].join(','));
+                break;
+            }
             default: {
-                // Code element nodes (Function, Class, Interface, Method, CodeElement)
+                // Code element nodes (Function, Class, Interface, CodeElement)
                 const writer = codeWriterMap[node.label];
                 if (writer) {
-                    await writer.addRow(await toCodeElementCsvRow(node, contentCache));
+                    const content = await extractContent(node, contentCache);
+                    await writer.addRow([
+                        escapeCSVField(node.id),
+                        escapeCSVField(node.properties.name || ''),
+                        escapeCSVField(node.properties.filePath || ''),
+                        escapeCSVNumber(node.properties.startLine, -1),
+                        escapeCSVNumber(node.properties.endLine, -1),
+                        node.properties.isExported ? 'true' : 'false',
+                        escapeCSVField(content),
+                        escapeCSVField(node.properties.description || ''),
+                    ].join(','));
                 }
                 else {
                     // Multi-language node types (Struct, Impl, Trait, Macro, etc.)

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

@@ -1,41 +1,36 @@
-import kuzu from 'kuzu';
+import lbug from '@ladybugdb/core';
 import { KnowledgeGraph } from '../graph/types.js';
-export declare const initKuzu: (dbPath: string) => Promise<{
-    db: kuzu.Database;
-    conn: kuzu.Connection;
+export declare const getOpenLbugDatabase: (dbPath: string) => lbug.Database | null;
+export declare const initLbug: (dbPath: string) => Promise<{
+    db: lbug.Database;
+    conn: lbug.Connection;
 }>;
 /**
  * Execute multiple queries against one repo DB atomically.
  * While the callback runs, no other request can switch the active DB.
  */
-export declare const withKuzuDb: <T>(dbPath: string, operation: () => Promise<T>) => Promise<T>;
-export type KuzuProgressCallback = (message: string) => void;
-export interface FallbackInsertStats {
-    attempted: number;
-    succeeded: number;
-    failed: number;
-}
-export declare const loadGraphToKuzu: (graph: KnowledgeGraph, repoPath: string, storagePath: string, onProgress?: KuzuProgressCallback) => Promise<{
+export declare const withLbugDb: <T>(dbPath: string, operation: () => Promise<T>) => Promise<T>;
+export type LbugProgressCallback = (message: string) => void;
+export declare const loadGraphToLbug: (graph: KnowledgeGraph, repoPath: string, storagePath: string, onProgress?: LbugProgressCallback) => Promise<{
     success: boolean;
     insertedRels: number;
     skippedRels: number;
     warnings: string[];
-    fallbackStats: FallbackInsertStats;
 }>;
 /**
- * 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 declare const insertNodeToKuzu: (label: string, properties: Record<string, any>, dbPath?: string) => Promise<boolean>;
+export declare const insertNodeToLbug: (label: string, properties: Record<string, any>, dbPath?: string) => Promise<boolean>;
 /**
- * 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 declare const batchInsertNodesToKuzu: (nodes: Array<{
+export declare const batchInsertNodesToLbug: (nodes: Array<{
     label: string;
     properties: Record<string, any>;
 }>, dbPath: string) => Promise<{
@@ -44,12 +39,12 @@ export declare const batchInsertNodesToKuzu: (nodes: Array<{
 }>;
 export declare const executeQuery: (cypher: string) => Promise<any[]>;
 export declare const executeWithReusedStatement: (cypher: string, paramsList: Array<Record<string, any>>) => Promise<void>;
-export declare const getKuzuStats: () => Promise<{
+export declare const getLbugStats: () => Promise<{
     nodes: number;
     edges: number;
 }>;
 /**
- * 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.
  */
@@ -60,12 +55,12 @@ export declare const loadCachedEmbeddings: () => Promise<{
         embedding: number[];
     }>;
 }>;
-export declare const closeKuzu: () => Promise<void>;
-export declare const isKuzuReady: () => boolean;
+export declare const closeLbug: () => Promise<void>;
+export declare const isLbugReady: () => boolean;
 /**
- * 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 declare const deleteNodesForFile: (filePath: string, dbPath?: string) => Promise<{