gitnexus 1.4.1 → 1.4.6

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

@@ -1,24 +1,22 @@
 /**
- * KuzuDB Adapter (Connection Pool)
+ * LadybugDB Adapter (Connection Pool)
  *
- * Manages a pool of KuzuDB databases keyed by repoId, each with
+ * Manages a pool of LadybugDB databases keyed by repoId, each with
  * multiple Connection objects for safe concurrent query execution.
  *
- * KuzuDB Connections are NOT thread-safe — a single Connection
+ * 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.kuzudb.com/concurrency — multiple Connections
+ * @see https://docs.ladybugdb.com/concurrency — multiple Connections
  * from the same Database is the officially supported concurrency pattern.
  */
 /**
  * Initialize (or reuse) a Database + connection pool for a specific repo.
  * Retries on lock errors (e.g., when `gitnexus analyze` is running).
  */
-export declare const initKuzu: (repoId: string, dbPath: string, opts?: {
-    pinned?: boolean;
-}) => Promise<void>;
+export declare const initLbug: (repoId: string, 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.
@@ -30,8 +28,8 @@ export declare const executeParameterized: (repoId: string, cypher: string, para
  * If repoId is provided, close only that repo's connections.
  * If omitted, close all repos.
  */
-export declare const closeKuzu: (repoId?: string) => Promise<void>;
+export declare const closeLbug: (repoId?: string) => Promise<void>;
 /**
  * Check if a specific repo's pool is active
  */
-export declare const isKuzuReady: (repoId: string) => boolean;
+export declare const isLbugReady: (repoId: string) => boolean;

package/dist/mcp/core/{kuzu-adapter.js → lbug-adapter.js}

@@ -1,22 +1,23 @@
 /**
- * KuzuDB Adapter (Connection Pool)
+ * LadybugDB Adapter (Connection Pool)
  *
- * Manages a pool of KuzuDB databases keyed by repoId, each with
+ * Manages a pool of LadybugDB databases keyed by repoId, each with
  * multiple Connection objects for safe concurrent query execution.
  *
- * KuzuDB Connections are NOT thread-safe — a single Connection
+ * 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.kuzudb.com/concurrency — multiple Connections
+ * @see https://docs.ladybugdb.com/concurrency — multiple Connections
  * from the same Database is the officially supported concurrency pattern.
  */
 import fs from 'fs/promises';
-import kuzu from 'kuzu';
+import lbug from '@ladybugdb/core';
 const pool = new Map();
+const dbCache = new Map();
 /** Max repos in the pool (LRU eviction) */
-const MAX_POOL_SIZE = 15;
+const MAX_POOL_SIZE = 5;
 /** Idle timeout before closing a repo's connections */
 const IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
 /** Max connections per repo (caps concurrent queries per repo) */
@@ -24,7 +25,7 @@ const MAX_CONNS_PER_REPO = 8;
 /** Connections created eagerly on init */
 const INITIAL_CONNS_PER_REPO = 2;
 let idleTimer = null;
-/** Saved real stdout.write — used to silence KuzuDB native output without race conditions */
+/** Saved real stdout.write — used to silence LadybugDB native output without race conditions */
 const realStdoutWrite = process.stdout.write.bind(process.stdout);
 let stdoutSilenceCount = 0;
 /**
@@ -36,7 +37,7 @@ function ensureIdleTimer() {
     idleTimer = setInterval(() => {
         const now = Date.now();
         for (const [repoId, entry] of pool) {
-            if (!entry.pinned && now - entry.lastUsed > IDLE_TIMEOUT_MS && entry.checkedOut === 0) {
+            if (now - entry.lastUsed > IDLE_TIMEOUT_MS && entry.checkedOut === 0) {
                 closeOne(repoId);
             }
         }
@@ -54,7 +55,7 @@ function evictLRU() {
     let oldestId = null;
     let oldestTime = Infinity;
     for (const [id, entry] of pool) {
-        if (!entry.pinned && entry.checkedOut === 0 && entry.lastUsed < oldestTime) {
+        if (entry.checkedOut === 0 && entry.lastUsed < oldestTime) {
             oldestTime = entry.lastUsed;
             oldestId = id;
         }
@@ -64,25 +65,20 @@ function evictLRU() {
     }
 }
 /**
- * Close all connections for a repo and remove it from the pool
+ * Remove a repo from the pool and release its shared Database ref.
+ *
+ * LadybugDB's native .closeSync() triggers N-API destructor hooks that
+ * segfault on Linux/macOS.  Pool databases are opened read-only, so
+ * there is no WAL to flush — just deleting the pool entry and letting
+ * the GC (or process exit) reclaim native resources is safe.
  */
 function closeOne(repoId) {
     const entry = pool.get(repoId);
-    if (!entry)
-        return;
-    for (const conn of entry.available) {
-        try {
-            conn.close();
+    if (entry) {
+        const shared = dbCache.get(entry.dbPath);
+        if (shared && shared.refCount > 0) {
+            shared.refCount--;
         }
-        catch (e) {
-            console.error('GitNexus [pool:close-conn]:', e instanceof Error ? e.message : e);
-        }
-    }
-    try {
-        entry.db.close();
-    }
-    catch (e) {
-        console.error('GitNexus [pool:close-db]:', e instanceof Error ? e.message : e);
     }
     pool.delete(repoId);
 }
@@ -104,26 +100,12 @@ function restoreStdout() {
 function createConnection(db) {
     silenceStdout();
     try {
-        return new kuzu.Connection(db);
+        return new lbug.Connection(db);
     }
     finally {
         restoreStdout();
     }
 }
-/**
- * Load the FTS extension on a connection (best-effort, idempotent).
- * Required before using QUERY_FTS_INDEX in search queries.
- */
-async function loadFTSOnConnection(conn) {
-    try {
-        await conn.query('INSTALL fts');
-    }
-    catch { /* already installed */ }
-    try {
-        await conn.query('LOAD EXTENSION fts');
-    }
-    catch { /* already loaded or unavailable */ }
-}
 /** Query timeout in milliseconds */
 const QUERY_TIMEOUT_MS = 30_000;
 /** Waiter queue timeout in milliseconds */
@@ -134,7 +116,7 @@ const LOCK_RETRY_DELAY_MS = 2000;
  * Initialize (or reuse) a Database + connection pool for a specific repo.
  * Retries on lock errors (e.g., when `gitnexus analyze` is running).
  */
-export const initKuzu = async (repoId, dbPath, opts) => {
+export const initLbug = async (repoId, dbPath) => {
     const existing = pool.get(repoId);
     if (existing) {
         existing.lastUsed = Date.now();
@@ -145,43 +127,62 @@ export const initKuzu = async (repoId, dbPath, opts) => {
         await fs.stat(dbPath);
     }
     catch {
-        throw new Error(`KuzuDB not found at ${dbPath}. Run: gitnexus analyze`);
+        throw new Error(`LadybugDB not found at ${dbPath}. Run: gitnexus analyze`);
     }
     evictLRU();
-    // Open in read-only mode — MCP server never writes to the database.
-    // This allows multiple MCP server instances to read concurrently, and
-    // avoids lock conflicts when `gitnexus analyze` is writing.
-    let lastError = null;
-    for (let attempt = 1; attempt <= LOCK_RETRY_ATTEMPTS; attempt++) {
-        silenceStdout();
-        try {
-            const db = new kuzu.Database(dbPath, 0, // bufferManagerSize (default)
-            false, // enableCompression (default)
-            true);
-            restoreStdout();
-            // Pre-create a small pool of connections
-            const available = [];
-            for (let i = 0; i < INITIAL_CONNS_PER_REPO; i++) {
-                const conn = createConnection(db);
-                await loadFTSOnConnection(conn);
-                available.push(conn);
+    // Reuse an existing native Database if another repoId already opened this path.
+    // This prevents buffer manager exhaustion from multiple mmap regions on the same file.
+    let shared = dbCache.get(dbPath);
+    if (!shared) {
+        // Open in read-only mode — MCP server never writes to the database.
+        // This allows multiple MCP server instances to read concurrently, and
+        // avoids lock conflicts when `gitnexus analyze` is writing.
+        let lastError = null;
+        for (let attempt = 1; attempt <= LOCK_RETRY_ATTEMPTS; attempt++) {
+            silenceStdout();
+            try {
+                const db = new lbug.Database(dbPath, 0, // bufferManagerSize (default)
+                false, // enableCompression (default)
+                true);
+                restoreStdout();
+                shared = { db, refCount: 0, ftsLoaded: false };
+                dbCache.set(dbPath, shared);
+                break;
+            }
+            catch (err) {
+                restoreStdout();
+                lastError = err instanceof Error ? err : new Error(String(err));
+                const isLockError = lastError.message.includes('Could not set lock')
+                    || lastError.message.includes('lock');
+                if (!isLockError || attempt === LOCK_RETRY_ATTEMPTS)
+                    break;
+                await new Promise(resolve => setTimeout(resolve, LOCK_RETRY_DELAY_MS * attempt));
             }
-            pool.set(repoId, { db, available, checkedOut: 0, waiters: [], lastUsed: Date.now(), dbPath, pinned: !!opts?.pinned });
-            ensureIdleTimer();
-            return;
         }
-        catch (err) {
-            restoreStdout();
-            lastError = err instanceof Error ? err : new Error(String(err));
-            const isLockError = lastError.message.includes('Could not set lock')
-                || lastError.message.includes('lock');
-            if (!isLockError || attempt === LOCK_RETRY_ATTEMPTS)
-                break;
-            await new Promise(resolve => setTimeout(resolve, LOCK_RETRY_DELAY_MS * attempt));
+        if (!shared) {
+            throw new Error(`LadybugDB unavailable for ${repoId}. Another process may be rebuilding the index. ` +
+                `Retry later. (${lastError?.message || 'unknown error'})`);
+        }
+    }
+    shared.refCount++;
+    const db = shared.db;
+    // Pre-create a small pool of connections
+    const available = [];
+    for (let i = 0; i < INITIAL_CONNS_PER_REPO; i++) {
+        available.push(createConnection(db));
+    }
+    pool.set(repoId, { db, available, checkedOut: 0, waiters: [], lastUsed: Date.now(), dbPath });
+    ensureIdleTimer();
+    // Load FTS extension once per shared Database
+    if (!shared.ftsLoaded) {
+        try {
+            await available[0].query('LOAD EXTENSION fts');
+            shared.ftsLoaded = true;
+        }
+        catch {
+            // Extension may not be installed — FTS queries will fail gracefully
         }
     }
-    throw new Error(`KuzuDB unavailable for ${repoId}. Another process may be rebuilding the index. ` +
-        `Retry later. (${lastError?.message || 'unknown error'})`);
 };
 /**
  * Checkout a connection from the pool.
@@ -198,10 +199,7 @@ function checkout(entry) {
     const totalConns = entry.available.length + entry.checkedOut;
     if (totalConns < MAX_CONNS_PER_REPO) {
         entry.checkedOut++;
-        const conn = createConnection(entry.db);
-        // Load FTS on new connections (best-effort, don't block on failure)
-        loadFTSOnConnection(conn).catch(() => { });
-        return Promise.resolve(conn);
+        return Promise.resolve(createConnection(entry.db));
     }
     // At capacity — queue the caller with a timeout.
     return new Promise((resolve, reject) => {
@@ -249,7 +247,7 @@ function withTimeout(promise, ms, label) {
 export const executeQuery = async (repoId, cypher) => {
     const entry = pool.get(repoId);
     if (!entry) {
-        throw new Error(`KuzuDB not initialized for repo "${repoId}". Call initKuzu first.`);
+        throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initLbug first.`);
     }
     entry.lastUsed = Date.now();
     const conn = await checkout(entry);
@@ -270,7 +268,7 @@ export const executeQuery = async (repoId, cypher) => {
 export const executeParameterized = async (repoId, cypher, params) => {
     const entry = pool.get(repoId);
     if (!entry) {
-        throw new Error(`KuzuDB not initialized for repo "${repoId}". Call initKuzu first.`);
+        throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initLbug first.`);
     }
     entry.lastUsed = Date.now();
     const conn = await checkout(entry);
@@ -294,7 +292,7 @@ export const executeParameterized = async (repoId, cypher, params) => {
  * If repoId is provided, close only that repo's connections.
  * If omitted, close all repos.
  */
-export const closeKuzu = async (repoId) => {
+export const closeLbug = async (repoId) => {
     if (repoId) {
         closeOne(repoId);
         return;
@@ -310,4 +308,4 @@ export const closeKuzu = async (repoId) => {
 /**
  * Check if a specific repo's pool is active
  */
-export const isKuzuReady = (repoId) => pool.has(repoId);
+export const isLbugReady = (repoId) => pool.has(repoId);

package/dist/mcp/local/local-backend.d.ts

@@ -3,7 +3,7 @@
  *
  * Provides tool implementations using local .gitnexus/ indexes.
  * Supports multiple indexed repositories via a global registry.
- * KuzuDB connections are opened lazily per repo on first query.
+ * LadybugDB connections are opened lazily per repo on first query.
  */
 import { type RegistryEntry } from '../../storage/repo-manager.js';
 /**
@@ -11,7 +11,7 @@ import { type RegistryEntry } from '../../storage/repo-manager.js';
  * Matches common test file patterns across all supported languages.
  */
 export declare function isTestFilePath(filePath: string): boolean;
-/** Valid KuzuDB node labels for safe Cypher query construction */
+/** Valid LadybugDB node labels for safe Cypher query construction */
 export declare const VALID_NODE_LABELS: Set<string>;
 /** Valid relation types for impact analysis filtering */
 export declare const VALID_RELATION_TYPES: Set<string>;
@@ -33,7 +33,7 @@ interface RepoHandle {
     name: string;
     repoPath: string;
     storagePath: string;
-    kuzuPath: string;
+    lbugPath: string;
     indexedAt: string;
     lastCommit: string;
     stats?: RegistryEntry['stats'];
@@ -50,7 +50,7 @@ export declare class LocalBackend {
     /**
      * Re-read the global registry and update the in-memory repo map.
      * New repos are added, existing repos are updated, removed repos are pruned.
-     * KuzuDB connections for removed repos are NOT closed (they idle-timeout naturally).
+     * LadybugDB connections for removed repos are NOT closed (they idle-timeout naturally).
      */
     private refreshRepos;
     /**
@@ -100,7 +100,7 @@ export declare class LocalBackend {
      */
     private query;
     /**
-     * BM25 keyword search helper - uses KuzuDB FTS for always-fresh results
+     * BM25 keyword search helper - uses LadybugDB FTS for always-fresh results
      */
     private bm25Search;
     /**
@@ -117,7 +117,7 @@ export declare class LocalBackend {
     /**
      * Aggregate same-named clusters: group by heuristicLabel, sum symbols,
      * weighted-average cohesion, filter out tiny clusters (<5 symbols).
-     * Raw communities stay intact in KuzuDB for Cypher queries.
+     * Raw communities stay intact in LadybugDB for Cypher queries.
      */
     private aggregateClusters;
     private overview;
@@ -144,6 +144,7 @@ export declare class LocalBackend {
      */
     private rename;
     private impact;
+    private _impactImpl;
     /**
      * Query clusters (communities) directly from graph.
      * Used by getClustersResource — avoids legacy overview() dispatch.