gitnexus 1.5.2 → 1.6.0

package/dist/core/lbug/lbug-adapter.d.ts

@@ -49,6 +49,7 @@ export declare const batchInsertNodesToLbug: (nodes: Array<{
     failed: number;
 }>;
 export declare const executeQuery: (cypher: string) => Promise<any[]>;
+export declare const streamQuery: (cypher: string, onRow: (row: any) => void | Promise<void>) => Promise<number>;
 /**
  * Execute a single parameterized query (prepare/execute pattern).
  * Prevents Cypher injection by binding values as parameters.
@@ -88,6 +89,11 @@ export declare const getEmbeddingTableName: () => string;
  * Safe to call multiple times — tracks loaded state via module-level ftsLoaded.
  */
 export declare const loadFTSExtension: () => Promise<void>;
+/**
+ * Load the VECTOR extension (required before using QUERY_VECTOR_INDEX).
+ * Safe to call multiple times -- tracks loaded state via module-level vectorExtensionLoaded.
+ */
+export declare const loadVectorExtension: () => Promise<void>;
 /**
  * Create a full-text search index on a table
  * @param tableName - The node table name (e.g., 'File', 'CodeSymbol')

package/dist/core/lbug/lbug-adapter.js

@@ -9,6 +9,7 @@ let db = null;
 let conn = null;
 let currentDbPath = null;
 let ftsLoaded = false;
+let vectorExtensionLoaded = false;
 /** Expose the current Database for pool adapter reuse in tests. */
 export const getDatabase = () => db;
 // Global session lock for operations that touch module-level lbug globals.
@@ -91,6 +92,7 @@ export const withLbugDb = async (dbPath, operation) => {
                 db = null;
                 currentDbPath = null;
                 ftsLoaded = false;
+                vectorExtensionLoaded = false;
             });
             // Sleep outside the lock — no need to block others while waiting
             await new Promise((resolve) => setTimeout(resolve, DB_LOCK_RETRY_DELAY_MS * attempt));
@@ -124,6 +126,7 @@ const doInitLbug = async (dbPath) => {
         db = null;
         currentDbPath = null;
         ftsLoaded = false;
+        vectorExtensionLoaded = false;
     }
     // LadybugDB stores the database as a single file (not a directory).
     // If the path already exists, it must be a valid LadybugDB database file.
@@ -167,6 +170,8 @@ const doInitLbug = async (dbPath) => {
             }
         }
     }
+    // Load VECTOR extension for semantic search support
+    await loadVectorExtension();
     currentDbPath = dbPath;
     return { db, conn };
 };
@@ -589,6 +594,30 @@ export const executeQuery = async (cypher) => {
     const rows = await result.getAll();
     return rows;
 };
+export const streamQuery = async (cypher, onRow) => {
+    if (!conn) {
+        throw new Error('LadybugDB not initialized. Call initLbug first.');
+    }
+    const queryResult = await conn.query(cypher);
+    const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
+    let rowCount = 0;
+    try {
+        while (await result.hasNext()) {
+            const row = await result.getNext();
+            await onRow(row);
+            rowCount++;
+        }
+        return rowCount;
+    }
+    finally {
+        try {
+            await result.close();
+        }
+        catch {
+            // Best-effort cleanup only.
+        }
+    }
+};
 /**
  * Execute a single parameterized query (prepare/execute pattern).
  * Prevents Cypher injection by binding values as parameters.
@@ -715,6 +744,7 @@ export const closeLbug = async () => {
     }
     currentDbPath = null;
     ftsLoaded = false;
+    vectorExtensionLoaded = false;
 };
 export const isLbugReady = () => conn !== null && db !== null;
 /**
@@ -803,19 +833,54 @@ export const loadFTSExtension = async () => {
         throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
     try {
-        await conn.query('INSTALL fts');
+        // Try loading locally first (no network required)
         await conn.query('LOAD EXTENSION fts');
         ftsLoaded = true;
     }
+    catch {
+        // Fall back to install + load (requires network)
+        try {
+            await conn.query('INSTALL fts');
+            await conn.query('LOAD EXTENSION fts');
+            ftsLoaded = true;
+        }
+        catch (err) {
+            const msg = err?.message || '';
+            if (msg.includes('already loaded') ||
+                msg.includes('already installed') ||
+                msg.includes('already exists')) {
+                ftsLoaded = true;
+            }
+            else {
+                console.error('GitNexus: FTS extension load failed:', msg);
+            }
+        }
+    }
+};
+/**
+ * Load the VECTOR extension (required before using QUERY_VECTOR_INDEX).
+ * Safe to call multiple times -- tracks loaded state via module-level vectorExtensionLoaded.
+ */
+export const loadVectorExtension = async () => {
+    if (vectorExtensionLoaded)
+        return;
+    if (!conn) {
+        throw new Error('LadybugDB not initialized. Call initLbug first.');
+    }
+    try {
+        await conn.query('INSTALL VECTOR');
+        await conn.query('LOAD EXTENSION VECTOR');
+        vectorExtensionLoaded = true;
+    }
     catch (err) {
         const msg = err?.message || '';
         if (msg.includes('already loaded') ||
             msg.includes('already installed') ||
             msg.includes('already exists')) {
-            ftsLoaded = true;
+            vectorExtensionLoaded = true;
         }
         else {
-            console.error('GitNexus: FTS extension load failed:', msg);
+            console.error('GitNexus: VECTOR extension load failed:', msg);
         }
     }
 };

package/dist/core/lbug/pool-adapter.d.ts

@@ -0,0 +1,76 @@
+/**
+ * LadybugDB connection pool (core). Used by MCP, sync, search, wiki, etc.
+ *
+ * LadybugDB Adapter (Connection Pool)
+ *
+ * Manages a pool of LadybugDB databases keyed by repoId, each with
+ * multiple Connection objects for safe concurrent query execution.
+ *
+ * LadybugDB Connections are NOT thread-safe — a single Connection
+ * segfaults if concurrent .query() calls hit it simultaneously.
+ * This adapter provides a checkout/return connection pool so each
+ * concurrent query gets its own Connection from the same Database.
+ *
+ * @see https://docs.ladybugdb.com/concurrency — multiple Connections
+ * from the same Database is the officially supported concurrency pattern.
+ */
+import lbug from '@ladybugdb/core';
+/** Saved real stdout/stderr write — used to silence native module output without race conditions */
+export declare const realStdoutWrite: any;
+export declare const realStderrWrite: any;
+/**
+ * Touch a repo to reset its idle timeout.
+ * Call this during long-running operations to prevent the connection from being closed.
+ */
+export declare const touchRepo: (repoId: string) => void;
+/**
+ * Silence stdout by replacing process.stdout.write with a no-op.
+ * Uses a reference counter so nested silence/restore pairs are safe.
+ * Exported so other modules (e.g. embedder) use the same mechanism instead
+ * of independently patching stdout, which causes restore-order conflicts.
+ */
+export declare function silenceStdout(): void;
+export declare function restoreStdout(): void;
+/**
+ * Initialize (or reuse) a Database + connection pool for a specific repo.
+ * Retries on lock errors (e.g., when `gitnexus analyze` is running).
+ *
+ * Concurrent calls for the same repoId are deduplicated — the second caller
+ * awaits the first's in-progress init rather than starting a redundant one.
+ */
+export declare const initLbug: (repoId: string, dbPath: string) => Promise<void>;
+/**
+ * Initialize a pool entry from a pre-existing Database object.
+ *
+ * Used in tests to avoid the writable→close→read-only cycle that crashes
+ * on macOS due to N-API destructor segfaults.  The pool adapter reuses
+ * the core adapter's writable Database instead of opening a new read-only one.
+ *
+ * The Database is registered in the shared dbCache so closeOne() decrements
+ * the refCount correctly.  If the Database is already cached (e.g. another
+ * repoId already injected it), the existing entry is reused.
+ */
+export declare function initLbugWithDb(repoId: string, existingDb: lbug.Database, dbPath: string): Promise<void>;
+export declare const executeQuery: (repoId: string, cypher: string) => Promise<any[]>;
+/**
+ * Execute a parameterized query on a specific repo's connection pool.
+ * Uses prepare/execute pattern to prevent Cypher injection.
+ */
+export declare const executeParameterized: (repoId: string, cypher: string, params: Record<string, any>) => Promise<any[]>;
+/**
+ * Close one or all repo pools.
+ * If repoId is provided, close only that repo's connections.
+ * If omitted, close all repos.
+ */
+export declare const closeLbug: (repoId?: string) => Promise<void>;
+/**
+ * Check if a specific repo's pool is active
+ */
+export declare const isLbugReady: (repoId: string) => boolean;
+/** Regex to detect write operations in user-supplied Cypher queries.
+ * Note: CALL is NOT blocked — it's used for read-only FTS (CALL QUERY_FTS_INDEX)
+ * and vector search (CALL QUERY_VECTOR_INDEX). The database is opened in
+ * read-only mode as defense-in-depth against write procedures. */
+export declare const CYPHER_WRITE_RE: RegExp;
+/** Check if a Cypher query contains write operations */
+export declare function isWriteQuery(query: string): boolean;