gitnexus 1.2.4 → 1.2.5

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "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",