gitnexus 1.2.4 → 1.2.6

package/dist/cli/index.js

@@ -53,7 +53,7 @@ program
     .command('wiki [path]')
     .description('Generate repository wiki from knowledge graph')
     .option('-f, --force', 'Force full regeneration even if up to date')
-    .option('--model <model>', 'LLM model name (default: gpt-4o-mini)')
+    .option('--model <model>', 'LLM model name (default: minimax/minimax-m2.5)')
     .option('--base-url <url>', 'LLM API base URL (default: OpenAI)')
     .option('--api-key <key>', 'LLM API key (saved to ~/.gitnexus/config.json)')
     .option('--concurrency <n>', 'Parallel LLM calls (default: 3)', '3')

package/dist/cli/wiki.js

@@ -141,7 +141,7 @@ export const wikiCommand = async (inputPath, options) => {
             let defaultModel;
             if (choice === '2') {
                 baseUrl = 'https://openrouter.ai/api/v1';
-                defaultModel = 'openai/gpt-4o-mini';
+                defaultModel = 'minimax/minimax-m2.5';
             }
             else if (choice === '3') {
                 baseUrl = await prompt('  Base URL (e.g. http://localhost:11434/v1): ');

package/dist/core/wiki/generator.d.ts

@@ -44,6 +44,12 @@ export declare class WikiGenerator {
     private onProgress;
     private failedModules;
     constructor(repoPath: string, storagePath: string, kuzuPath: string, llmConfig: LLMConfig, options?: WikiOptions, onProgress?: ProgressCallback);
+    private lastPercent;
+    /**
+     * Create streaming options that report LLM progress to the progress bar.
+     * Uses the last known percent so streaming doesn't reset the bar backwards.
+     */
+    private streamOpts;
     /**
      * Main entry point. Runs the full pipeline or incremental update.
      */

package/dist/core/wiki/generator.js

@@ -41,7 +41,26 @@ export class WikiGenerator {
         this.llmConfig = llmConfig;
         this.maxTokensPerModule = options.maxTokensPerModule ?? DEFAULT_MAX_TOKENS_PER_MODULE;
         this.concurrency = options.concurrency ?? 3;
-        this.onProgress = onProgress || (() => { });
+        const progressFn = onProgress || (() => { });
+        this.onProgress = (phase, percent, detail) => {
+            if (percent > 0)
+                this.lastPercent = percent;
+            progressFn(phase, percent, detail);
+        };
+    }
+    lastPercent = 0;
+    /**
+     * Create streaming options that report LLM progress to the progress bar.
+     * Uses the last known percent so streaming doesn't reset the bar backwards.
+     */
+    streamOpts(label, fixedPercent) {
+        return {
+            onChunk: (chars) => {
+                const tokens = Math.round(chars / 4);
+                const pct = fixedPercent ?? this.lastPercent;
+                this.onProgress('stream', pct, `${label} (${tokens} tok)`);
+            },
+        };
     }
     /**
      * Main entry point. Runs the full pipeline or incremental update.
@@ -153,8 +172,7 @@ export class WikiGenerator {
             }
             catch (err) {
                 this.failedModules.push(node.name);
-                this.onProgress('modules', 0, `Failed: ${node.name} — ${err.message?.slice(0, 80)}`);
-                reportProgress(node.name);
+                reportProgress(`Failed: ${node.name}`);
                 return 0;
             }
         });
@@ -172,8 +190,7 @@ export class WikiGenerator {
             }
             catch (err) {
                 this.failedModules.push(node.name);
-                this.onProgress('modules', 0, `Failed: ${node.name} — ${err.message?.slice(0, 80)}`);
-                reportProgress(node.name);
+                reportProgress(`Failed: ${node.name}`);
             }
         }
         // Phase 3: Generate overview
@@ -216,7 +233,7 @@ export class WikiGenerator {
             FILE_LIST: fileList,
             DIRECTORY_TREE: dirTree,
         });
-        const response = await callLLM(prompt, this.llmConfig, GROUPING_SYSTEM_PROMPT);
+        const response = await callLLM(prompt, this.llmConfig, GROUPING_SYSTEM_PROMPT, this.streamOpts('Grouping files', 15));
         const grouping = this.parseGroupingResponse(response.content, files);
         // Convert to tree nodes
         const tree = [];
@@ -353,7 +370,7 @@ export class WikiGenerator {
             INCOMING_CALLS: formatCallEdges(interCalls.incoming),
             PROCESSES: formatProcesses(processes),
         });
-        const response = await callLLM(prompt, this.llmConfig, MODULE_SYSTEM_PROMPT);
+        const response = await callLLM(prompt, this.llmConfig, MODULE_SYSTEM_PROMPT, this.streamOpts(node.name));
         // Write page with front matter
         const pageContent = `# ${node.name}\n\n${response.content}`;
         await fs.writeFile(path.join(this.wikiDir, `${node.slug}.md`), pageContent, 'utf-8');
@@ -389,7 +406,7 @@ export class WikiGenerator {
             CROSS_MODULE_CALLS: formatCallEdges(crossCalls),
             CROSS_PROCESSES: formatProcesses(processes),
         });
-        const response = await callLLM(prompt, this.llmConfig, PARENT_SYSTEM_PROMPT);
+        const response = await callLLM(prompt, this.llmConfig, PARENT_SYSTEM_PROMPT, this.streamOpts(node.name));
         const pageContent = `# ${node.name}\n\n${response.content}`;
         await fs.writeFile(path.join(this.wikiDir, `${node.slug}.md`), pageContent, 'utf-8');
     }
@@ -425,7 +442,7 @@ export class WikiGenerator {
             MODULE_EDGES: edgesText,
             TOP_PROCESSES: formatProcesses(topProcesses),
         });
-        const response = await callLLM(prompt, this.llmConfig, OVERVIEW_SYSTEM_PROMPT);
+        const response = await callLLM(prompt, this.llmConfig, OVERVIEW_SYSTEM_PROMPT, this.streamOpts('Generating overview', 88));
         const pageContent = `# ${path.basename(this.repoPath)} — Wiki\n\n${response.content}`;
         await fs.writeFile(path.join(this.wikiDir, 'overview.md'), pageContent, 'utf-8');
     }
@@ -699,7 +716,7 @@ export class WikiGenerator {
                         // On rate limit, reduce concurrency temporarily
                         if (err.message?.includes('429')) {
                             activeConcurrency = Math.max(1, activeConcurrency - 1);
-                            this.onProgress('modules', 0, `Rate limited — reducing concurrency to ${activeConcurrency}`);
+                            this.onProgress('modules', this.lastPercent, `Rate limited — concurrency → ${activeConcurrency}`);
                             // Re-queue the item
                             idx--;
                             setTimeout(next, 5000);

package/dist/core/wiki/llm-client.d.ts

@@ -29,8 +29,12 @@ export declare function resolveLLMConfig(overrides?: Partial<LLMConfig>): Promis
  * Estimate token count from text (rough heuristic: ~4 chars per token).
  */
 export declare function estimateTokens(text: string): number;
+export interface CallLLMOptions {
+    onChunk?: (charsReceived: number) => void;
+}
 /**
  * Call an OpenAI-compatible LLM API.
- * Retries once on transient failures (5xx, network errors).
+ * Uses streaming when onChunk callback is provided for real-time progress.
+ * Retries up to 3 times on transient failures (429, 5xx, network errors).
  */
-export declare function callLLM(prompt: string, config: LLMConfig, systemPrompt?: string): Promise<LLMResponse>;
+export declare function callLLM(prompt: string, config: LLMConfig, systemPrompt?: string, options?: CallLLMOptions): Promise<LLMResponse>;

package/dist/core/wiki/llm-client.js

@@ -25,11 +25,11 @@ export async function resolveLLMConfig(overrides) {
         baseUrl: overrides?.baseUrl
             || process.env.GITNEXUS_LLM_BASE_URL
             || savedConfig.baseUrl
-            || 'https://api.openai.com/v1',
+            || 'https://openrouter.ai/api/v1',
         model: overrides?.model
             || process.env.GITNEXUS_MODEL
             || savedConfig.model
-            || 'gpt-4o-mini',
+            || 'minimax/minimax-m2.5',
         maxTokens: overrides?.maxTokens ?? 16_384,
         temperature: overrides?.temperature ?? 0,
     };
@@ -42,21 +42,25 @@ export function estimateTokens(text) {
 }
 /**
  * Call an OpenAI-compatible LLM API.
- * Retries once on transient failures (5xx, network errors).
+ * Uses streaming when onChunk callback is provided for real-time progress.
+ * Retries up to 3 times on transient failures (429, 5xx, network errors).
  */
-export async function callLLM(prompt, config, systemPrompt) {
+export async function callLLM(prompt, config, systemPrompt, options) {
     const messages = [];
     if (systemPrompt) {
         messages.push({ role: 'system', content: systemPrompt });
     }
     messages.push({ role: 'user', content: prompt });
     const url = `${config.baseUrl.replace(/\/+$/, '')}/chat/completions`;
+    const useStream = !!options?.onChunk;
     const body = {
         model: config.model,
         messages,
         max_tokens: config.maxTokens,
         temperature: config.temperature,
     };
+    if (useStream)
+        body.stream = true;
     const MAX_RETRIES = 3;
     let lastError = null;
     for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
@@ -85,6 +89,11 @@ export async function callLLM(prompt, config, systemPrompt) {
                 }
                 throw new Error(`LLM API error (${response.status}): ${errorText.slice(0, 500)}`);
             }
+            // Streaming path
+            if (useStream && response.body) {
+                return await readSSEStream(response.body, options.onChunk);
+            }
+            // Non-streaming path
             const json = await response.json();
             const choice = json.choices?.[0];
             if (!choice?.message?.content) {
@@ -108,6 +117,46 @@ export async function callLLM(prompt, config, systemPrompt) {
     }
     throw lastError || new Error('LLM call failed after retries');
 }
+/**
+ * Read an SSE stream from an OpenAI-compatible streaming response.
+ */
+async function readSSEStream(body, onChunk) {
+    const decoder = new TextDecoder();
+    const reader = body.getReader();
+    let content = '';
+    let buffer = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || !trimmed.startsWith('data: '))
+                continue;
+            const data = trimmed.slice(6);
+            if (data === '[DONE]')
+                continue;
+            try {
+                const parsed = JSON.parse(data);
+                const delta = parsed.choices?.[0]?.delta?.content;
+                if (delta) {
+                    content += delta;
+                    onChunk(content.length);
+                }
+            }
+            catch {
+                // Skip malformed SSE chunks
+            }
+        }
+    }
+    if (!content) {
+        throw new Error('LLM returned empty streaming response');
+    }
+    return { content };
+}
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }

package/dist/mcp/core/kuzu-adapter.d.ts

@@ -1,26 +1,34 @@
 /**
  * KuzuDB Adapter (Connection Pool)
  *
- * Manages a pool of KuzuDB connections keyed by repoId.
- * Connections are lazily opened on first query and evicted
- * after idle timeout or when pool exceeds max size (LRU).
+ * Manages a pool of KuzuDB databases keyed by repoId, each with
+ * multiple Connection objects for safe concurrent query execution.
+ *
+ * KuzuDB 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
+ * from the same Database is the officially supported concurrency pattern.
  */
 /**
- * Initialize (or reuse) a connection for a specific repo.
+ * 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) => Promise<void>;
 /**
- * Execute a query on a specific repo's connection
+ * Execute a query on a specific repo's connection pool.
+ * Automatically checks out a connection, runs the query, and returns it.
  */
 export declare const executeQuery: (repoId: string, cypher: string) => Promise<any[]>;
 /**
- * Close one or all connections.
- * If repoId is provided, close only that connection.
- * If omitted, close all connections in the pool.
+ * Close one or all repo pools.
+ * If repoId is provided, close only that repo's connections.
+ * If omitted, close all repos.
  */
 export declare const closeKuzu: (repoId?: string) => Promise<void>;
 /**
- * Check if a specific repo's connection is active
+ * Check if a specific repo's pool is active
  */
 export declare const isKuzuReady: (repoId: string) => boolean;

package/dist/mcp/core/kuzu-adapter.js

@@ -1,15 +1,28 @@
 /**
  * KuzuDB Adapter (Connection Pool)
  *
- * Manages a pool of KuzuDB connections keyed by repoId.
- * Connections are lazily opened on first query and evicted
- * after idle timeout or when pool exceeds max size (LRU).
+ * Manages a pool of KuzuDB databases keyed by repoId, each with
+ * multiple Connection objects for safe concurrent query execution.
+ *
+ * KuzuDB 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
+ * from the same Database is the officially supported concurrency pattern.
  */
 import fs from 'fs/promises';
 import kuzu from 'kuzu';
 const pool = new Map();
+/** Max repos in the pool (LRU eviction) */
 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) */
+const MAX_CONNS_PER_REPO = 8;
+/** Connections created eagerly on init */
+const INITIAL_CONNS_PER_REPO = 2;
 let idleTimer = null;
 /**
  * Start the idle cleanup timer (runs every 60s)
@@ -25,13 +38,12 @@ function ensureIdleTimer() {
             }
         }
     }, 60_000);
-    // Don't keep the process alive just for this timer
     if (idleTimer && typeof idleTimer === 'object' && 'unref' in idleTimer) {
         idleTimer.unref();
     }
 }
 /**
- * Evict the least-recently-used connection if pool is at capacity
+ * Evict the least-recently-used repo if pool is at capacity
  */
 function evictLRU() {
     if (pool.size < MAX_POOL_SIZE)
@@ -49,26 +61,42 @@ function evictLRU() {
     }
 }
 /**
- * Close a single pool entry
+ * Close all connections for a repo and remove it from the pool
  */
 function closeOne(repoId) {
     const entry = pool.get(repoId);
     if (!entry)
         return;
-    try {
-        entry.conn.close();
+    for (const conn of entry.available) {
+        try {
+            conn.close();
+        }
+        catch { }
     }
-    catch { }
     try {
         entry.db.close();
     }
     catch { }
     pool.delete(repoId);
 }
+/**
+ * Create a new Connection from a repo's Database.
+ * Silences stdout to prevent native module output from corrupting MCP stdio.
+ */
+function createConnection(db) {
+    const origWrite = process.stdout.write;
+    process.stdout.write = (() => true);
+    try {
+        return new kuzu.Connection(db);
+    }
+    finally {
+        process.stdout.write = origWrite;
+    }
+}
 const LOCK_RETRY_ATTEMPTS = 3;
 const LOCK_RETRY_DELAY_MS = 2000;
 /**
- * Initialize (or reuse) a connection for a specific repo.
+ * 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) => {
@@ -90,17 +118,19 @@ export const initKuzu = async (repoId, dbPath) => {
     // avoids lock conflicts when `gitnexus analyze` is writing.
     let lastError = null;
     for (let attempt = 1; attempt <= LOCK_RETRY_ATTEMPTS; attempt++) {
-        // Silence stdout during KuzuDB init — native module may write to stdout
-        // which corrupts the MCP stdio protocol.
         const origWrite = process.stdout.write;
         process.stdout.write = (() => true);
         try {
             const db = new kuzu.Database(dbPath, 0, // bufferManagerSize (default)
             false, // enableCompression (default)
             true);
-            const conn = new kuzu.Connection(db);
             process.stdout.write = origWrite;
-            pool.set(repoId, { db, conn, lastUsed: Date.now(), dbPath });
+            // 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();
             return;
         }
@@ -111,7 +141,6 @@ export const initKuzu = async (repoId, dbPath) => {
                 || lastError.message.includes('lock');
             if (!isLockError || attempt === LOCK_RETRY_ATTEMPTS)
                 break;
-            // Wait before retrying — analyze may be mid-rebuild
             await new Promise(resolve => setTimeout(resolve, LOCK_RETRY_DELAY_MS * attempt));
         }
     }
@@ -119,7 +148,47 @@ export const initKuzu = async (repoId, dbPath) => {
         `Retry later. (${lastError?.message || 'unknown error'})`);
 };
 /**
- * Execute a query on a specific repo's connection
+ * Checkout a connection from the pool.
+ * Returns an available connection, or creates a new one if under the cap.
+ * If all connections are busy and at cap, queues the caller until one is returned.
+ */
+function checkout(entry) {
+    // Fast path: grab an available connection
+    if (entry.available.length > 0) {
+        entry.checkedOut++;
+        return Promise.resolve(entry.available.pop());
+    }
+    // Grow the pool if under the cap
+    const totalConns = entry.available.length + entry.checkedOut;
+    if (totalConns < MAX_CONNS_PER_REPO) {
+        entry.checkedOut++;
+        return Promise.resolve(createConnection(entry.db));
+    }
+    // At capacity — queue the caller. checkin() will resolve this when
+    // a connection is returned, handing it directly to the next waiter.
+    return new Promise(resolve => {
+        entry.waiters.push(resolve);
+    });
+}
+/**
+ * Return a connection to the pool after use.
+ * If there are queued waiters, hand the connection directly to the next one
+ * instead of putting it back in the available array (avoids race conditions).
+ */
+function checkin(entry, conn) {
+    if (entry.waiters.length > 0) {
+        // Hand directly to the next waiter — no intermediate available state
+        const waiter = entry.waiters.shift();
+        waiter(conn);
+    }
+    else {
+        entry.checkedOut--;
+        entry.available.push(conn);
+    }
+}
+/**
+ * Execute a query on a specific repo's connection pool.
+ * Automatically checks out a connection, runs the query, and returns it.
  */
 export const executeQuery = async (repoId, cypher) => {
     const entry = pool.get(repoId);
@@ -127,22 +196,27 @@ export const executeQuery = async (repoId, cypher) => {
         throw new Error(`KuzuDB not initialized for repo "${repoId}". Call initKuzu first.`);
     }
     entry.lastUsed = Date.now();
-    const queryResult = await entry.conn.query(cypher);
-    const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
-    const rows = await result.getAll();
-    return rows;
+    const conn = await checkout(entry);
+    try {
+        const queryResult = await conn.query(cypher);
+        const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
+        const rows = await result.getAll();
+        return rows;
+    }
+    finally {
+        checkin(entry, conn);
+    }
 };
 /**
- * Close one or all connections.
- * If repoId is provided, close only that connection.
- * If omitted, close all connections in the pool.
+ * Close one or all repo pools.
+ * If repoId is provided, close only that repo's connections.
+ * If omitted, close all repos.
  */
 export const closeKuzu = async (repoId) => {
     if (repoId) {
         closeOne(repoId);
         return;
     }
-    // Close all
     for (const id of [...pool.keys()]) {
         closeOne(id);
     }
@@ -152,6 +226,6 @@ export const closeKuzu = async (repoId) => {
     }
 };
 /**
- * Check if a specific repo's connection is active
+ * Check if a specific repo's pool is active
  */
 export const isKuzuReady = (repoId) => pool.has(repoId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",