gitnexus 1.2.2 → 1.2.4

package/dist/cli/index.js

@@ -56,6 +56,7 @@ program
     .option('--model <model>', 'LLM model name (default: gpt-4o-mini)')
     .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')
     .option('--gist', 'Publish wiki as a public GitHub Gist after generation')
     .action(wikiCommand);
 program

package/dist/cli/wiki.d.ts

@@ -9,6 +9,7 @@ export interface WikiCommandOptions {
     model?: string;
     baseUrl?: string;
     apiKey?: string;
+    concurrency?: string;
     gist?: boolean;
 }
 export declare const wikiCommand: (inputPath?: string, options?: WikiCommandOptions) => Promise<void>;

package/dist/cli/wiki.js

@@ -108,67 +108,85 @@ export const wikiCommand = async (inputPath, options) => {
         await saveCLIConfig({ ...existing, ...updates });
         console.log('  Config saved to ~/.gitnexus/config.json\n');
     }
+    const savedConfig = await loadCLIConfig();
+    const hasSavedConfig = !!(savedConfig.apiKey && savedConfig.baseUrl);
+    const hasCLIOverrides = !!(options?.apiKey || options?.model || options?.baseUrl);
     let llmConfig = await resolveLLMConfig({
         model: options?.model,
         baseUrl: options?.baseUrl,
         apiKey: options?.apiKey,
     });
-    if (!llmConfig.apiKey) {
+    // Run interactive setup if no saved config and no CLI flags provided
+    // (even if env vars exist — let user explicitly choose their provider)
+    if (!hasSavedConfig && !hasCLIOverrides) {
         if (!process.stdin.isTTY) {
-            console.log('  Error: No LLM API key found.');
-            console.log('  Set OPENAI_API_KEY or GITNEXUS_API_KEY environment variable,');
-            console.log('  or pass --api-key <key>.\n');
-            process.exitCode = 1;
-            return;
-        }
-        console.log('  No LLM configured. Let\'s set it up.\n');
-        console.log('  Supports OpenAI, OpenRouter, or any OpenAI-compatible API.\n');
-        // Provider selection
-        console.log('  [1] OpenAI (api.openai.com)');
-        console.log('  [2] OpenRouter (openrouter.ai)');
-        console.log('  [3] Custom endpoint\n');
-        const choice = await prompt('  Select provider (1/2/3): ');
-        let baseUrl;
-        let defaultModel;
-        if (choice === '2') {
-            baseUrl = 'https://openrouter.ai/api/v1';
-            defaultModel = 'openai/gpt-4o-mini';
-        }
-        else if (choice === '3') {
-            baseUrl = await prompt('  Base URL (e.g. http://localhost:11434/v1): ');
-            if (!baseUrl) {
-                console.log('\n  No URL provided. Aborting.\n');
+            if (!llmConfig.apiKey) {
+                console.log('  Error: No LLM API key found.');
+                console.log('  Set OPENAI_API_KEY or GITNEXUS_API_KEY environment variable,');
+                console.log('  or pass --api-key <key>.\n');
                 process.exitCode = 1;
                 return;
             }
-            defaultModel = 'gpt-4o-mini';
+            // Non-interactive with env var — just use it
         }
         else {
-            baseUrl = 'https://api.openai.com/v1';
-            defaultModel = 'gpt-4o-mini';
-        }
-        // Model
-        const modelInput = await prompt(`  Model (default: ${defaultModel}): `);
-        const model = modelInput || defaultModel;
-        // API key
-        const key = await prompt('  API key: ', true);
-        if (!key) {
-            console.log('\n  No key provided. Aborting.\n');
-            process.exitCode = 1;
-            return;
-        }
-        // Save
-        const save = await prompt('\n  Save config to ~/.gitnexus/config.json? (Y/n): ');
-        if (!save || save.toLowerCase() === 'y' || save.toLowerCase() === 'yes') {
+            console.log('  No LLM configured. Let\'s set it up.\n');
+            console.log('  Supports OpenAI, OpenRouter, or any OpenAI-compatible API.\n');
+            // Provider selection
+            console.log('  [1] OpenAI (api.openai.com)');
+            console.log('  [2] OpenRouter (openrouter.ai)');
+            console.log('  [3] Custom endpoint\n');
+            const choice = await prompt('  Select provider (1/2/3): ');
+            let baseUrl;
+            let defaultModel;
+            if (choice === '2') {
+                baseUrl = 'https://openrouter.ai/api/v1';
+                defaultModel = 'openai/gpt-4o-mini';
+            }
+            else if (choice === '3') {
+                baseUrl = await prompt('  Base URL (e.g. http://localhost:11434/v1): ');
+                if (!baseUrl) {
+                    console.log('\n  No URL provided. Aborting.\n');
+                    process.exitCode = 1;
+                    return;
+                }
+                defaultModel = 'gpt-4o-mini';
+            }
+            else {
+                baseUrl = 'https://api.openai.com/v1';
+                defaultModel = 'gpt-4o-mini';
+            }
+            // Model
+            const modelInput = await prompt(`  Model (default: ${defaultModel}): `);
+            const model = modelInput || defaultModel;
+            // API key — pre-fill hint if env var exists
+            const envKey = process.env.GITNEXUS_API_KEY || process.env.OPENAI_API_KEY || '';
+            let key;
+            if (envKey) {
+                const masked = envKey.slice(0, 6) + '...' + envKey.slice(-4);
+                const useEnv = await prompt(`  Use existing env key (${masked})? (Y/n): `);
+                if (!useEnv || useEnv.toLowerCase() === 'y' || useEnv.toLowerCase() === 'yes') {
+                    key = envKey;
+                }
+                else {
+                    key = await prompt('  API key: ', true);
+                }
+            }
+            else {
+                key = await prompt('  API key: ', true);
+            }
+            if (!key) {
+                console.log('\n  No key provided. Aborting.\n');
+                process.exitCode = 1;
+                return;
+            }
+            // Save
             await saveCLIConfig({ apiKey: key, baseUrl, model });
-            console.log('  Config saved.\n');
+            console.log('  Config saved to ~/.gitnexus/config.json\n');
+            llmConfig = { ...llmConfig, apiKey: key, baseUrl, model };
         }
-        else {
-            console.log('  Config will be used for this session only.\n');
-        }
-        llmConfig = { ...llmConfig, apiKey: key, baseUrl, model };
     }
-    // ── Setup progress bar ──────────────────────────────────────────────
+    // ── Setup progress bar with elapsed timer ──────────────────────────
     const bar = new cliProgress.SingleBar({
         format: '  {bar} {percentage}% | {phase}',
         barCompleteChar: '\u2588',
@@ -181,17 +199,35 @@ export const wikiCommand = async (inputPath, options) => {
     }, cliProgress.Presets.shades_grey);
     bar.start(100, 0, { phase: 'Initializing...' });
     const t0 = Date.now();
+    let lastPhase = '';
+    let phaseStart = t0;
+    // Tick elapsed time every second while stuck on the same phase
+    const elapsedTimer = setInterval(() => {
+        if (lastPhase) {
+            const elapsed = Math.round((Date.now() - phaseStart) / 1000);
+            if (elapsed >= 3) {
+                bar.update({ phase: `${lastPhase} (${elapsed}s)` });
+            }
+        }
+    }, 1000);
     // ── Run generator ───────────────────────────────────────────────────
     const wikiOptions = {
         force: options?.force,
         model: options?.model,
         baseUrl: options?.baseUrl,
+        concurrency: options?.concurrency ? parseInt(options.concurrency, 10) : undefined,
     };
     const generator = new WikiGenerator(repoPath, storagePath, kuzuPath, llmConfig, wikiOptions, (phase, percent, detail) => {
-        bar.update(percent, { phase: detail || phase });
+        const label = detail || phase;
+        if (label !== lastPhase) {
+            lastPhase = label;
+            phaseStart = Date.now();
+        }
+        bar.update(percent, { phase: label });
     });
     try {
         const result = await generator.run();
+        clearInterval(elapsedTimer);
         bar.update(100, { phase: 'Done' });
         bar.stop();
         const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
@@ -219,12 +255,28 @@ export const wikiCommand = async (inputPath, options) => {
         await maybePublishGist(viewerPath, options?.gist);
     }
     catch (err) {
+        clearInterval(elapsedTimer);
         bar.stop();
         if (err.message?.includes('No source files')) {
             console.log(`\n  ${err.message}\n`);
         }
         else if (err.message?.includes('API key') || err.message?.includes('API error')) {
             console.log(`\n  LLM Error: ${err.message}\n`);
+            // Offer to reconfigure on auth-related failures
+            const isAuthError = err.message?.includes('401') || err.message?.includes('403')
+                || err.message?.includes('502') || err.message?.includes('authenticate')
+                || err.message?.includes('Unauthorized');
+            if (isAuthError && process.stdin.isTTY) {
+                const answer = await new Promise((resolve) => {
+                    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+                    rl.question('  Reconfigure LLM settings? (Y/n): ', (ans) => { rl.close(); resolve(ans.trim().toLowerCase()); });
+                });
+                if (!answer || answer === 'y' || answer === 'yes') {
+                    // Clear saved config so next run triggers interactive setup
+                    await saveCLIConfig({});
+                    console.log('  Config cleared. Run `gitnexus wiki` again to reconfigure.\n');
+                }
+            }
         }
         else {
             console.log(`\n  Error: ${err.message}\n`);

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

@@ -16,6 +16,7 @@ export interface WikiOptions {
     baseUrl?: string;
     apiKey?: string;
     maxTokensPerModule?: number;
+    concurrency?: number;
 }
 export interface WikiMeta {
     fromCommit: string;
@@ -38,6 +39,7 @@ export declare class WikiGenerator {
     private kuzuPath;
     private llmConfig;
     private maxTokensPerModule;
+    private concurrency;
     private options;
     private onProgress;
     private failedModules;
@@ -65,11 +67,6 @@ export declare class WikiGenerator {
      * Split a large module into sub-modules by subdirectory.
      */
     private splitBySubdirectory;
-    /**
-     * Recursively generate pages for a module tree node.
-     * Returns count of pages generated.
-     */
-    private generateModulePage;
     /**
      * Generate a leaf module page from source code + graph data.
      */
@@ -88,6 +85,16 @@ export declare class WikiGenerator {
     private readProjectInfo;
     private extractModuleFiles;
     private countModules;
+    /**
+     * Flatten the module tree into leaf nodes and parent nodes.
+     * Leaves can be processed in parallel; parents must wait for children.
+     */
+    private flattenModuleTree;
+    /**
+     * Run async tasks in parallel with a concurrency limit and adaptive rate limiting.
+     * If a 429 rate limit is hit, concurrency is temporarily reduced.
+     */
+    private runParallel;
     private findNodeBySlug;
     private slugify;
     private fileExists;

package/dist/core/wiki/generator.js

@@ -28,6 +28,7 @@ export class WikiGenerator {
     kuzuPath;
     llmConfig;
     maxTokensPerModule;
+    concurrency;
     options;
     onProgress;
     failedModules = [];
@@ -39,6 +40,7 @@ export class WikiGenerator {
         this.options = options;
         this.llmConfig = llmConfig;
         this.maxTokensPerModule = options.maxTokensPerModule ?? DEFAULT_MAX_TOKENS_PER_MODULE;
+        this.concurrency = options.concurrency ?? 3;
         this.onProgress = onProgress || (() => { });
     }
     /**
@@ -123,16 +125,56 @@ export class WikiGenerator {
         // Phase 1: Build module tree
         const moduleTree = await this.buildModuleTree(enrichedFiles);
         pagesGenerated = 0;
-        // Phase 2: Generate module pages (bottom-up)
+        // Phase 2: Generate module pages (parallel with concurrency limit)
         const totalModules = this.countModules(moduleTree);
         let modulesProcessed = 0;
-        for (const node of moduleTree) {
-            const generated = await this.generateModulePage(node, () => {
-                modulesProcessed++;
-                const percent = 30 + Math.round((modulesProcessed / totalModules) * 55);
-                this.onProgress('modules', percent, `${modulesProcessed}/${totalModules} modules`);
-            });
-            pagesGenerated += generated;
+        const reportProgress = (moduleName) => {
+            modulesProcessed++;
+            const percent = 30 + Math.round((modulesProcessed / totalModules) * 55);
+            const detail = moduleName
+                ? `${modulesProcessed}/${totalModules} — ${moduleName}`
+                : `${modulesProcessed}/${totalModules} modules`;
+            this.onProgress('modules', percent, detail);
+        };
+        // Flatten tree into layers: leaves first, then parents
+        // Leaves can run in parallel; parents must wait for their children
+        const { leaves, parents } = this.flattenModuleTree(moduleTree);
+        // Process all leaf modules in parallel
+        pagesGenerated += await this.runParallel(leaves, async (node) => {
+            const pagePath = path.join(this.wikiDir, `${node.slug}.md`);
+            if (await this.fileExists(pagePath)) {
+                reportProgress(node.name);
+                return 0;
+            }
+            try {
+                await this.generateLeafPage(node);
+                reportProgress(node.name);
+                return 1;
+            }
+            catch (err) {
+                this.failedModules.push(node.name);
+                this.onProgress('modules', 0, `Failed: ${node.name} — ${err.message?.slice(0, 80)}`);
+                reportProgress(node.name);
+                return 0;
+            }
+        });
+        // Process parent modules sequentially (they depend on child docs)
+        for (const node of parents) {
+            const pagePath = path.join(this.wikiDir, `${node.slug}.md`);
+            if (await this.fileExists(pagePath)) {
+                reportProgress(node.name);
+                continue;
+            }
+            try {
+                await this.generateParentPage(node);
+                pagesGenerated++;
+                reportProgress(node.name);
+            }
+            catch (err) {
+                this.failedModules.push(node.name);
+                this.onProgress('modules', 0, `Failed: ${node.name} — ${err.message?.slice(0, 80)}`);
+                reportProgress(node.name);
+            }
         }
         // Phase 3: Generate overview
         this.onProgress('overview', 88, 'Generating overview page...');
@@ -284,53 +326,6 @@ export class WikiGenerator {
         }));
     }
     // ─── Phase 2: Generate Module Pages ─────────────────────────────────
-    /**
-     * Recursively generate pages for a module tree node.
-     * Returns count of pages generated.
-     */
-    async generateModulePage(node, onPageDone) {
-        let count = 0;
-        // If node has children, generate children first (bottom-up)
-        if (node.children && node.children.length > 0) {
-            for (const child of node.children) {
-                count += await this.generateModulePage(child, onPageDone);
-            }
-            // Then generate parent page from children docs
-            const pagePath = path.join(this.wikiDir, `${node.slug}.md`);
-            // Resumability: skip if page already exists
-            if (await this.fileExists(pagePath)) {
-                onPageDone();
-                return count;
-            }
-            try {
-                await this.generateParentPage(node);
-                count++;
-            }
-            catch (err) {
-                this.failedModules.push(node.name);
-                this.onProgress('modules', 0, `Failed: ${node.name} — ${err.message?.slice(0, 80)}`);
-            }
-            onPageDone();
-            return count;
-        }
-        // Leaf module — generate from source code
-        const pagePath = path.join(this.wikiDir, `${node.slug}.md`);
-        // Resumability: skip if page already exists
-        if (await this.fileExists(pagePath)) {
-            onPageDone();
-            return count;
-        }
-        try {
-            await this.generateLeafPage(node);
-            count++;
-        }
-        catch (err) {
-            this.failedModules.push(node.name);
-            this.onProgress('modules', 0, `Failed: ${node.name} — ${err.message?.slice(0, 80)}`);
-        }
-        onPageDone();
-        return count;
-    }
     /**
      * Generate a leaf module page from source code + graph data.
      */
@@ -484,26 +479,43 @@ export class WikiGenerator {
             existingMeta.moduleFiles['Other'].push(...newFiles);
             affectedModules.add('Other');
         }
-        // Regenerate affected module pages
+        // Regenerate affected module pages (parallel)
         let pagesGenerated = 0;
         const moduleTree = existingMeta.moduleTree;
         const affectedArray = Array.from(affectedModules);
         this.onProgress('incremental', 20, `Regenerating ${affectedArray.length} module(s)...`);
-        for (let i = 0; i < affectedArray.length; i++) {
-            const modSlug = this.slugify(affectedArray[i]);
+        const affectedNodes = [];
+        for (const mod of affectedArray) {
+            const modSlug = this.slugify(mod);
             const node = this.findNodeBySlug(moduleTree, modSlug);
             if (node) {
-                // Delete existing page to force re-generation
                 try {
                     await fs.unlink(path.join(this.wikiDir, `${node.slug}.md`));
                 }
                 catch { }
-                await this.generateModulePage(node, () => { });
-                pagesGenerated++;
+                affectedNodes.push(node);
             }
-            const percent = 20 + Math.round(((i + 1) / affectedArray.length) * 60);
-            this.onProgress('incremental', percent, `${i + 1}/${affectedArray.length} modules`);
         }
+        let incProcessed = 0;
+        pagesGenerated += await this.runParallel(affectedNodes, async (node) => {
+            try {
+                if (node.children && node.children.length > 0) {
+                    await this.generateParentPage(node);
+                }
+                else {
+                    await this.generateLeafPage(node);
+                }
+                incProcessed++;
+                const percent = 20 + Math.round((incProcessed / affectedNodes.length) * 60);
+                this.onProgress('incremental', percent, `${incProcessed}/${affectedNodes.length} — ${node.name}`);
+                return 1;
+            }
+            catch (err) {
+                this.failedModules.push(node.name);
+                incProcessed++;
+                return 0;
+            }
+        });
         // Regenerate overview if any pages changed
         if (pagesGenerated > 0) {
             this.onProgress('incremental', 85, 'Updating overview...');
@@ -637,6 +649,80 @@ export class WikiGenerator {
         }
         return count;
     }
+    /**
+     * Flatten the module tree into leaf nodes and parent nodes.
+     * Leaves can be processed in parallel; parents must wait for children.
+     */
+    flattenModuleTree(tree) {
+        const leaves = [];
+        const parents = [];
+        for (const node of tree) {
+            if (node.children && node.children.length > 0) {
+                for (const child of node.children) {
+                    leaves.push(child);
+                }
+                parents.push(node);
+            }
+            else {
+                leaves.push(node);
+            }
+        }
+        return { leaves, parents };
+    }
+    /**
+     * Run async tasks in parallel with a concurrency limit and adaptive rate limiting.
+     * If a 429 rate limit is hit, concurrency is temporarily reduced.
+     */
+    async runParallel(items, fn) {
+        let total = 0;
+        let activeConcurrency = this.concurrency;
+        let running = 0;
+        let idx = 0;
+        return new Promise((resolve, reject) => {
+            const next = () => {
+                while (running < activeConcurrency && idx < items.length) {
+                    const item = items[idx++];
+                    running++;
+                    fn(item)
+                        .then((count) => {
+                        total += count;
+                        running--;
+                        if (idx >= items.length && running === 0) {
+                            resolve(total);
+                        }
+                        else {
+                            next();
+                        }
+                    })
+                        .catch((err) => {
+                        running--;
+                        // 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}`);
+                            // Re-queue the item
+                            idx--;
+                            setTimeout(next, 5000);
+                        }
+                        else {
+                            if (idx >= items.length && running === 0) {
+                                resolve(total);
+                            }
+                            else {
+                                next();
+                            }
+                        }
+                    });
+                }
+            };
+            if (items.length === 0) {
+                resolve(0);
+            }
+            else {
+                next();
+            }
+        });
+    }
     findNodeBySlug(tree, slug) {
         for (const node of tree) {
             if (node.slug === slug)

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

@@ -57,8 +57,9 @@ export async function callLLM(prompt, config, systemPrompt) {
         max_tokens: config.maxTokens,
         temperature: config.temperature,
     };
+    const MAX_RETRIES = 3;
     let lastError = null;
-    for (let attempt = 0; attempt < 2; attempt++) {
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
         try {
             const response = await fetch(url, {
                 method: 'POST',
@@ -70,15 +71,16 @@ export async function callLLM(prompt, config, systemPrompt) {
             });
             if (!response.ok) {
                 const errorText = await response.text().catch(() => 'unknown error');
-                // Rate limit — wait and retry
-                if (response.status === 429 && attempt === 0) {
-                    const retryAfter = parseInt(response.headers.get('retry-after') || '5', 10);
-                    await sleep(retryAfter * 1000);
+                // Rate limit — wait with exponential backoff and retry
+                if (response.status === 429 && attempt < MAX_RETRIES - 1) {
+                    const retryAfter = parseInt(response.headers.get('retry-after') || '0', 10);
+                    const delay = retryAfter > 0 ? retryAfter * 1000 : (2 ** attempt) * 3000;
+                    await sleep(delay);
                     continue;
                 }
-                // Server error — retry once
-                if (response.status >= 500 && attempt === 0) {
-                    await sleep(2000);
+                // Server error — retry with backoff
+                if (response.status >= 500 && attempt < MAX_RETRIES - 1) {
+                    await sleep((attempt + 1) * 2000);
                     continue;
                 }
                 throw new Error(`LLM API error (${response.status}): ${errorText.slice(0, 500)}`);
@@ -96,9 +98,9 @@ export async function callLLM(prompt, config, systemPrompt) {
         }
         catch (err) {
             lastError = err;
-            // Network error — retry once
-            if (attempt === 0 && (err.code === 'ECONNREFUSED' || err.code === 'ETIMEDOUT' || err.message?.includes('fetch'))) {
-                await sleep(3000);
+            // Network error — retry with backoff
+            if (attempt < MAX_RETRIES - 1 && (err.code === 'ECONNREFUSED' || err.code === 'ETIMEDOUT' || err.message?.includes('fetch'))) {
+                await sleep((attempt + 1) * 3000);
                 continue;
             }
             throw err;

package/package.json

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