gitnexus 1.4.10 → 1.5.1

package/dist/cli/analyze.js

@@ -2,21 +2,19 @@
  * Analyze Command
  *
  * Indexes a repository and stores the knowledge graph in .gitnexus/
+ *
+ * Delegates core analysis to the shared runFullAnalysis orchestrator.
+ * This CLI wrapper handles: heap management, progress bar, SIGINT,
+ * skill generation (--skills), summary output, and process.exit().
  */
 import path from 'path';
 import { execFileSync } from 'child_process';
 import v8 from 'v8';
 import cliProgress from 'cli-progress';
-import { runPipelineFromRepo } from '../core/ingestion/pipeline.js';
-import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, createFTSIndex, loadCachedEmbeddings } from '../core/lbug/lbug-adapter.js';
-// Embedding imports are lazy (dynamic import) so onnxruntime-node is never
-// loaded when embeddings are not requested. This avoids crashes on Node
-// versions whose ABI is not yet supported by the native binary (#89).
-// disposeEmbedder intentionally not called — ONNX Runtime segfaults on cleanup (see #38)
-import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, getGlobalRegistryPath, cleanupOldKuzuFiles } from '../storage/repo-manager.js';
-import { getCurrentCommit, getGitRoot, hasGitDir } from '../storage/git.js';
-import { generateAIContextFiles } from './ai-context.js';
-import { generateSkillFiles } from './skill-gen.js';
+import { closeLbug } from '../core/lbug/lbug-adapter.js';
+import { getStoragePaths, getGlobalRegistryPath } from '../storage/repo-manager.js';
+import { getGitRoot, hasGitDir } from '../storage/git.js';
+import { runFullAnalysis } from '../core/run-analyze.js';
 import fs from 'fs/promises';
 const HEAP_MB = 8192;
 const HEAP_FLAG = `--max-old-space-size=${HEAP_MB}`;
@@ -39,23 +37,6 @@ function ensureHeap() {
     }
     return true;
 }
-/** Threshold: auto-skip embeddings for repos with more nodes than this */
-const EMBEDDING_NODE_LIMIT = 50_000;
-const PHASE_LABELS = {
-    extracting: 'Scanning files',
-    structure: 'Building structure',
-    parsing: 'Parsing code',
-    imports: 'Resolving imports',
-    calls: 'Tracing calls',
-    heritage: 'Extracting inheritance',
-    communities: 'Detecting communities',
-    processes: 'Detecting processes',
-    complete: 'Pipeline complete',
-    lbug: 'Loading into LadybugDB',
-    fts: 'Creating search indexes',
-    embeddings: 'Generating embeddings',
-    done: 'Done',
-};
 export const analyzeCommand = async (inputPath, options) => {
     if (ensureHeap())
         return;
@@ -91,26 +72,12 @@ export const analyzeCommand = async (inputPath, options) => {
     if (!repoHasGit) {
         console.log('  Warning: no .git directory found \u2014 commit-tracking and incremental updates disabled.\n');
     }
-    const { storagePath, lbugPath } = getStoragePaths(repoPath);
-    // Clean up stale KuzuDB files from before the LadybugDB migration.
-    // If kuzu existed but lbug doesn't, we're doing a migration re-index — say so.
-    const kuzuResult = await cleanupOldKuzuFiles(storagePath);
-    if (kuzuResult.found && kuzuResult.needsReindex) {
-        console.log('  Migrating from KuzuDB to LadybugDB — rebuilding index...\n');
-    }
-    const currentCommit = repoHasGit ? getCurrentCommit(repoPath) : '';
-    const existingMeta = await loadMeta(storagePath);
-    if (existingMeta && !options?.force && !options?.skills && existingMeta.lastCommit === currentCommit) {
-        // Non-git folders have currentCommit = '' — always rebuild since we can't detect changes
-        if (currentCommit !== '') {
-            console.log('  Already up to date\n');
-            return;
-        }
-    }
+    // KuzuDB migration cleanup is handled by runFullAnalysis internally.
+    // Note: --skills is handled after runFullAnalysis using the returned pipelineResult.
     if (process.env.GITNEXUS_NO_GITIGNORE) {
         console.log('  GITNEXUS_NO_GITIGNORE is set — skipping .gitignore (still reading .gitnexusignore)\n');
     }
-    // Single progress bar for entire pipeline
+    // ── CLI progress bar setup ─────────────────────────────────────────
     const bar = new cliProgress.SingleBar({
         format: '  {bar} {percentage}% | {phase}',
         barCompleteChar: '\u2588',
@@ -122,35 +89,33 @@ export const analyzeCommand = async (inputPath, options) => {
         stopOnComplete: false,
     }, cliProgress.Presets.shades_grey);
     bar.start(100, 0, { phase: 'Initializing...' });
-    // Graceful SIGINT handling — clean up resources and exit
+    // Graceful SIGINT handling
     let aborted = false;
     const sigintHandler = () => {
         if (aborted)
-            process.exit(1); // Second Ctrl-C: force exit
+            process.exit(1);
         aborted = true;
         bar.stop();
         console.log('\n  Interrupted — cleaning up...');
-        closeLbug().catch(() => { }).finally(() => process.exit(130));
+        closeLbug()
+            .catch(() => { })
+            .finally(() => process.exit(130));
     };
     process.on('SIGINT', sigintHandler);
-    // Route all console output through bar.log() so the bar doesn't stamp itself
-    // multiple times when other code writes to stdout/stderr mid-render.
+    // Route console output through bar.log() to prevent progress bar corruption
     const origLog = console.log.bind(console);
     const origWarn = console.warn.bind(console);
     const origError = console.error.bind(console);
     const barLog = (...args) => {
-        // Clear the bar line, print the message, then let the next bar.update redraw
         process.stdout.write('\x1b[2K\r');
-        origLog(args.map(a => (typeof a === 'string' ? a : String(a))).join(' '));
+        origLog(args.map((a) => (typeof a === 'string' ? a : String(a))).join(' '));
     };
     console.log = barLog;
     console.warn = barLog;
     console.error = barLog;
-    // Track elapsed time per phase — both updateBar and the interval use the
-    // same format so they don't flicker against each other.
+    // Track elapsed time per phase
     let lastPhaseLabel = 'Initializing...';
     let phaseStart = Date.now();
-    /** Update bar with phase label + elapsed seconds (shown after 3s). */
     const updateBar = (value, phaseLabel) => {
         if (phaseLabel !== lastPhaseLabel) {
             lastPhaseLabel = phaseLabel;
@@ -160,217 +125,106 @@ export const analyzeCommand = async (inputPath, options) => {
         const display = elapsed >= 3 ? `${phaseLabel} (${elapsed}s)` : phaseLabel;
         bar.update(value, { phase: display });
     };
-    // Tick elapsed seconds for phases with infrequent progress callbacks
-    // (e.g. CSV streaming, FTS indexing). Uses the same display format as
-    // updateBar so there's no flickering.
     const elapsedTimer = setInterval(() => {
         const elapsed = Math.round((Date.now() - phaseStart) / 1000);
         if (elapsed >= 3) {
             bar.update({ phase: `${lastPhaseLabel} (${elapsed}s)` });
         }
     }, 1000);
-    const t0Global = Date.now();
-    // ── Cache embeddings from existing index before rebuild ────────────
-    let cachedEmbeddingNodeIds = new Set();
-    let cachedEmbeddings = [];
-    if (options?.embeddings && existingMeta && !options?.force) {
-        try {
-            updateBar(0, 'Caching embeddings...');
-            await initLbug(lbugPath);
-            const cached = await loadCachedEmbeddings();
-            cachedEmbeddingNodeIds = cached.embeddingNodeIds;
-            cachedEmbeddings = cached.embeddings;
-            await closeLbug();
-        }
-        catch {
-            try {
-                await closeLbug();
-            }
-            catch { }
-        }
-    }
-    // ── Phase 1: Full Pipeline (0–60%) ─────────────────────────────────
-    const pipelineResult = await runPipelineFromRepo(repoPath, (progress) => {
-        const phaseLabel = PHASE_LABELS[progress.phase] || progress.phase;
-        const scaled = Math.round(progress.percent * 0.6);
-        updateBar(scaled, phaseLabel);
-    });
-    // ── Phase 2: LadybugDB (60–85%) ──────────────────────────────────────
-    updateBar(60, 'Loading into LadybugDB...');
-    await closeLbug();
-    const lbugFiles = [lbugPath, `${lbugPath}.wal`, `${lbugPath}.lock`];
-    for (const f of lbugFiles) {
-        try {
-            await fs.rm(f, { recursive: true, force: true });
-        }
-        catch { }
-    }
-    const t0Lbug = Date.now();
-    await initLbug(lbugPath);
-    let lbugMsgCount = 0;
-    const lbugResult = await loadGraphToLbug(pipelineResult.graph, pipelineResult.repoPath, storagePath, (msg) => {
-        lbugMsgCount++;
-        const progress = Math.min(84, 60 + Math.round((lbugMsgCount / (lbugMsgCount + 10)) * 24));
-        updateBar(progress, msg);
-    });
-    const lbugTime = ((Date.now() - t0Lbug) / 1000).toFixed(1);
-    const lbugWarnings = lbugResult.warnings;
-    // ── Phase 3: FTS (85–90%) ─────────────────────────────────────────
-    updateBar(85, 'Creating search indexes...');
-    const t0Fts = Date.now();
+    const t0 = Date.now();
+    // ── Run shared analysis orchestrator ───────────────────────────────
     try {
-        await createFTSIndex('File', 'file_fts', ['name', 'content']);
-        await createFTSIndex('Function', 'function_fts', ['name', 'content']);
-        await createFTSIndex('Class', 'class_fts', ['name', 'content']);
-        await createFTSIndex('Method', 'method_fts', ['name', 'content']);
-        await createFTSIndex('Interface', 'interface_fts', ['name', 'content']);
-    }
-    catch (e) {
-        // Non-fatal — FTS is best-effort
-    }
-    const ftsTime = ((Date.now() - t0Fts) / 1000).toFixed(1);
-    // ── Phase 3.5: Re-insert cached embeddings ────────────────────────
-    if (cachedEmbeddings.length > 0) {
-        // Check if cached embedding dimensions match current schema
-        const cachedDims = cachedEmbeddings[0].embedding.length;
-        const { EMBEDDING_DIMS } = await import('../core/lbug/schema.js');
-        if (cachedDims !== EMBEDDING_DIMS) {
-            // Dimensions changed (e.g. switched embedding model) — discard cache and re-embed all
-            console.error(`⚠️  Embedding dimensions changed (${cachedDims}d → ${EMBEDDING_DIMS}d), discarding cache`);
-            cachedEmbeddings = [];
-            cachedEmbeddingNodeIds = new Set();
+        const result = await runFullAnalysis(repoPath, {
+            force: options?.force || options?.skills,
+            embeddings: options?.embeddings,
+            skipGit: options?.skipGit,
+            skipAgentsMd: options?.skipAgentsMd,
+        }, {
+            onProgress: (_phase, percent, message) => {
+                updateBar(percent, message);
+            },
+            onLog: barLog,
+        });
+        if (result.alreadyUpToDate) {
+            clearInterval(elapsedTimer);
+            process.removeListener('SIGINT', sigintHandler);
+            console.log = origLog;
+            console.warn = origWarn;
+            console.error = origError;
+            bar.stop();
+            console.log('  Already up to date\n');
+            // Safe to return without process.exit(0) — the early-return path in
+            // runFullAnalysis never opens LadybugDB, so no native handles prevent exit.
+            return;
         }
-        else {
-            updateBar(88, `Restoring ${cachedEmbeddings.length} cached embeddings...`);
-            const EMBED_BATCH = 200;
-            for (let i = 0; i < cachedEmbeddings.length; i += EMBED_BATCH) {
-                const batch = cachedEmbeddings.slice(i, i + EMBED_BATCH);
-                const paramsList = batch.map(e => ({ nodeId: e.nodeId, embedding: e.embedding }));
-                try {
-                    await executeWithReusedStatement(`CREATE (e:CodeEmbedding {nodeId: $nodeId, embedding: $embedding})`, paramsList);
+        // Skill generation (CLI-only, uses pipeline result from analysis)
+        if (options?.skills && result.pipelineResult) {
+            updateBar(99, 'Generating skill files...');
+            try {
+                const { generateSkillFiles } = await import('./skill-gen.js');
+                const { generateAIContextFiles } = await import('./ai-context.js');
+                const skillResult = await generateSkillFiles(repoPath, result.repoName, result.pipelineResult);
+                if (skillResult.skills.length > 0) {
+                    barLog(`  Generated ${skillResult.skills.length} skill files`);
+                    // Re-generate AI context files now that we have skill info
+                    const s = result.stats;
+                    const communityResult = result.pipelineResult?.communityResult;
+                    let aggregatedClusterCount = 0;
+                    if (communityResult?.communities) {
+                        const groups = new Map();
+                        for (const c of communityResult.communities) {
+                            const label = c.heuristicLabel || c.label || 'Unknown';
+                            groups.set(label, (groups.get(label) || 0) + c.symbolCount);
+                        }
+                        aggregatedClusterCount = Array.from(groups.values()).filter((count) => count >= 5).length;
+                    }
+                    const { storagePath: sp } = getStoragePaths(repoPath);
+                    await generateAIContextFiles(repoPath, sp, result.repoName, {
+                        files: s.files ?? 0,
+                        nodes: s.nodes ?? 0,
+                        edges: s.edges ?? 0,
+                        communities: s.communities,
+                        clusters: aggregatedClusterCount,
+                        processes: s.processes,
+                    }, skillResult.skills, { skipAgentsMd: options?.skipAgentsMd });
                 }
-                catch { /* some may fail if node was removed, that's fine */ }
+            }
+            catch {
+                /* best-effort */
             }
         }
-    }
-    // ── Phase 4: Embeddings (90–98%) ──────────────────────────────────
-    const stats = await getLbugStats();
-    let embeddingTime = '0.0';
-    let embeddingSkipped = true;
-    let embeddingSkipReason = 'off (use --embeddings to enable)';
-    if (options?.embeddings) {
-        if (stats.nodes > EMBEDDING_NODE_LIMIT) {
-            embeddingSkipReason = `skipped (${stats.nodes.toLocaleString()} nodes > ${EMBEDDING_NODE_LIMIT.toLocaleString()} limit)`;
-        }
-        else {
-            embeddingSkipped = false;
+        const totalTime = ((Date.now() - t0) / 1000).toFixed(1);
+        clearInterval(elapsedTimer);
+        process.removeListener('SIGINT', sigintHandler);
+        console.log = origLog;
+        console.warn = origWarn;
+        console.error = origError;
+        bar.update(100, { phase: 'Done' });
+        bar.stop();
+        // ── Summary ────────────────────────────────────────────────────
+        const s = result.stats;
+        console.log(`\n  Repository indexed successfully (${totalTime}s)\n`);
+        console.log(`  ${(s.nodes ?? 0).toLocaleString()} nodes | ${(s.edges ?? 0).toLocaleString()} edges | ${s.communities ?? 0} clusters | ${s.processes ?? 0} flows`);
+        console.log(`  ${repoPath}`);
+        try {
+            await fs.access(getGlobalRegistryPath());
         }
-    }
-    if (!embeddingSkipped) {
-        const { isHttpMode } = await import('../core/embeddings/http-client.js');
-        const httpMode = isHttpMode();
-        updateBar(90, httpMode ? 'Connecting to embedding endpoint...' : 'Loading embedding model...');
-        const t0Emb = Date.now();
-        const { runEmbeddingPipeline } = await import('../core/embeddings/embedding-pipeline.js');
-        await runEmbeddingPipeline(executeQuery, executeWithReusedStatement, (progress) => {
-            const scaled = 90 + Math.round((progress.percent / 100) * 8);
-            const label = progress.phase === 'loading-model'
-                ? (httpMode ? 'Connecting to embedding endpoint...' : 'Loading embedding model...')
-                : `Embedding ${progress.nodesProcessed || 0}/${progress.totalNodes || '?'}`;
-            updateBar(scaled, label);
-        }, {}, cachedEmbeddingNodeIds.size > 0 ? cachedEmbeddingNodeIds : undefined);
-        embeddingTime = ((Date.now() - t0Emb) / 1000).toFixed(1);
-    }
-    // ── Phase 5: Finalize (98–100%) ───────────────────────────────────
-    updateBar(98, 'Saving metadata...');
-    // Count embeddings in the index (cached + newly generated)
-    let embeddingCount = 0;
-    try {
-        const embResult = await executeQuery(`MATCH (e:CodeEmbedding) RETURN count(e) AS cnt`);
-        embeddingCount = embResult?.[0]?.cnt ?? 0;
-    }
-    catch { /* table may not exist if embeddings never ran */ }
-    const meta = {
-        repoPath,
-        lastCommit: currentCommit,
-        indexedAt: new Date().toISOString(),
-        stats: {
-            files: pipelineResult.totalFileCount,
-            nodes: stats.nodes,
-            edges: stats.edges,
-            communities: pipelineResult.communityResult?.stats.totalCommunities,
-            processes: pipelineResult.processResult?.stats.totalProcesses,
-            embeddings: embeddingCount,
-        },
-    };
-    await saveMeta(storagePath, meta);
-    await registerRepo(repoPath, meta);
-    // Only attempt to update .gitignore when a .git directory is present.
-    // Use hasGitDir (filesystem check) rather than git CLI subprocess
-    // so we skip correctly for --skip-git folders even if git CLI is available.
-    if (hasGitDir(repoPath)) {
-        await addToGitignore(repoPath);
-    }
-    const projectName = path.basename(repoPath);
-    let aggregatedClusterCount = 0;
-    if (pipelineResult.communityResult?.communities) {
-        const groups = new Map();
-        for (const c of pipelineResult.communityResult.communities) {
-            const label = c.heuristicLabel || c.label || 'Unknown';
-            groups.set(label, (groups.get(label) || 0) + c.symbolCount);
+        catch {
+            console.log('\n  Tip: Run `gitnexus setup` to configure MCP for your editor.');
         }
-        aggregatedClusterCount = Array.from(groups.values()).filter(count => count >= 5).length;
-    }
-    let generatedSkills = [];
-    if (options?.skills && pipelineResult.communityResult) {
-        updateBar(99, 'Generating skill files...');
-        const skillResult = await generateSkillFiles(repoPath, projectName, pipelineResult);
-        generatedSkills = skillResult.skills;
-    }
-    const aiContext = await generateAIContextFiles(repoPath, storagePath, projectName, {
-        files: pipelineResult.totalFileCount,
-        nodes: stats.nodes,
-        edges: stats.edges,
-        communities: pipelineResult.communityResult?.stats.totalCommunities,
-        clusters: aggregatedClusterCount,
-        processes: pipelineResult.processResult?.stats.totalProcesses,
-    }, generatedSkills);
-    await closeLbug();
-    // Note: we intentionally do NOT call disposeEmbedder() here.
-    // ONNX Runtime's native cleanup segfaults on macOS and some Linux configs.
-    // Since the process exits immediately after, Node.js reclaims everything.
-    const totalTime = ((Date.now() - t0Global) / 1000).toFixed(1);
-    clearInterval(elapsedTimer);
-    process.removeListener('SIGINT', sigintHandler);
-    console.log = origLog;
-    console.warn = origWarn;
-    console.error = origError;
-    bar.update(100, { phase: 'Done' });
-    bar.stop();
-    // ── Summary ───────────────────────────────────────────────────────
-    const embeddingsCached = cachedEmbeddings.length > 0;
-    console.log(`\n  Repository indexed successfully (${totalTime}s)${embeddingsCached ? ` [${cachedEmbeddings.length} embeddings cached]` : ''}\n`);
-    console.log(`  ${stats.nodes.toLocaleString()} nodes | ${stats.edges.toLocaleString()} edges | ${pipelineResult.communityResult?.stats.totalCommunities || 0} clusters | ${pipelineResult.processResult?.stats.totalProcesses || 0} flows`);
-    console.log(`  LadybugDB ${lbugTime}s | FTS ${ftsTime}s | Embeddings ${embeddingSkipped ? embeddingSkipReason : embeddingTime + 's'}`);
-    console.log(`  ${repoPath}`);
-    if (aiContext.files.length > 0) {
-        console.log(`  Context: ${aiContext.files.join(', ')}`);
-    }
-    // Show a quiet summary if some edge types needed fallback insertion
-    if (lbugWarnings.length > 0) {
-        const totalFallback = lbugWarnings.reduce((sum, w) => {
-            const m = w.match(/\((\d+) edges\)/);
-            return sum + (m ? parseInt(m[1]) : 0);
-        }, 0);
-        console.log(`  Note: ${totalFallback} edges across ${lbugWarnings.length} types inserted via fallback (schema will be updated in next release)`);
-    }
-    try {
-        await fs.access(getGlobalRegistryPath());
-    }
-    catch {
-        console.log('\n  Tip: Run `gitnexus setup` to configure MCP for your editor.');
+        console.log('');
+    }
+    catch (err) {
+        clearInterval(elapsedTimer);
+        process.removeListener('SIGINT', sigintHandler);
+        console.log = origLog;
+        console.warn = origWarn;
+        console.error = origError;
+        bar.stop();
+        console.error(`\n  Analysis failed: ${err.message}\n`);
+        process.exitCode = 1;
+        return;
     }
-    console.log('');
     // LadybugDB's native module holds open handles that prevent Node from exiting.
     // ONNX Runtime also registers native atexit hooks that segfault on some
     // platforms (#38, #40). Force-exit to ensure clean termination.

package/dist/cli/eval-server.js

@@ -68,7 +68,9 @@ export function formatContextResult(result) {
     if (result.error)
         return `Error: ${result.error}`;
     if (result.status === 'ambiguous') {
-        const lines = [`Multiple symbols named '${result.candidates?.[0]?.name || '?'}'. Disambiguate with file path:\n`];
+        const lines = [
+            `Multiple symbols named '${result.candidates?.[0]?.name || '?'}'. Disambiguate with file path:\n`,
+        ];
         for (const c of result.candidates || []) {
             lines.push(`  ${c.kind} ${c.name} → ${c.filePath}:${c.line || '?'}  (uid: ${c.uid})`);
         }
@@ -171,7 +173,7 @@ export function formatCypherResult(result) {
         const keys = Object.keys(result[0]);
         const lines = [`${result.length} row(s):\n`];
         for (const row of result.slice(0, 30)) {
-            const parts = keys.map(k => `${k}: ${row[k]}`);
+            const parts = keys.map((k) => `${k}: ${row[k]}`);
             lines.push(`  ${parts.join(' | ')}`);
         }
         if (result.length > 30) {
@@ -230,13 +232,20 @@ export function formatListReposResult(result) {
  */
 function formatToolResult(toolName, result) {
     switch (toolName) {
-        case 'query': return formatQueryResult(result);
-        case 'context': return formatContextResult(result);
-        case 'impact': return formatImpactResult(result);
-        case 'cypher': return formatCypherResult(result);
-        case 'detect_changes': return formatDetectChangesResult(result);
-        case 'list_repos': return formatListReposResult(result);
-        default: return typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+        case 'query':
+            return formatQueryResult(result);
+        case 'context':
+            return formatContextResult(result);
+        case 'impact':
+            return formatImpactResult(result);
+        case 'cypher':
+            return formatCypherResult(result);
+        case 'detect_changes':
+            return formatDetectChangesResult(result);
+        case 'list_repos':
+            return formatListReposResult(result);
+        default:
+            return typeof result === 'string' ? result : JSON.stringify(result, null, 2);
     }
 }
 // ─── Next-Step Hints ──────────────────────────────────────────────────
@@ -269,7 +278,7 @@ export async function evalServerCommand(options) {
         process.exit(1);
     }
     const repos = await backend.listRepos();
-    console.error(`GitNexus eval-server: ${repos.length} repo(s) loaded: ${repos.map(r => r.name).join(', ')}`);
+    console.error(`GitNexus eval-server: ${repos.length} repo(s) loaded: ${repos.map((r) => r.name).join(', ')}`);
     let idleTimer = null;
     function resetIdleTimer() {
         if (idleTimeoutSec <= 0)
@@ -289,7 +298,7 @@ export async function evalServerCommand(options) {
             if (req.method === 'GET' && req.url === '/health') {
                 res.setHeader('Content-Type', 'application/json');
                 res.writeHead(200);
-                res.end(JSON.stringify({ status: 'ok', repos: repos.map(r => r.name) }));
+                res.end(JSON.stringify({ status: 'ok', repos: repos.map((r) => r.name) }));
                 return;
             }
             // Shutdown

package/dist/cli/index-repo.js

@@ -8,25 +8,23 @@
  * cloning a repo that ships its index, restoring from backup, or using a
  * shared team index).
  */
-import path from "path";
-import fs from "fs/promises";
-import { getStoragePaths, loadMeta, addToGitignore, registerRepo, } from "../storage/repo-manager.js";
-import { getGitRoot, isGitRepo } from "../storage/git.js";
+import path from 'path';
+import fs from 'fs/promises';
+import { getStoragePaths, loadMeta, addToGitignore, registerRepo, } from '../storage/repo-manager.js';
+import { getGitRoot, isGitRepo } from '../storage/git.js';
 export const indexCommand = async (inputPathParts, options) => {
-    console.log("\n  GitNexus Index\n");
-    const inputPath = inputPathParts?.length
-        ? inputPathParts.join(" ")
-        : undefined;
+    console.log('\n  GitNexus Index\n');
+    const inputPath = inputPathParts?.length ? inputPathParts.join(' ') : undefined;
     if (inputPathParts && inputPathParts.length > 1) {
         const resolvedCombinedPath = path.resolve(inputPath);
         try {
             await fs.access(resolvedCombinedPath);
         }
         catch {
-            console.log("  The `index` command accepts a single path only.");
-            console.log("  If your path contains spaces, wrap it in quotes.");
-            console.log(`  Received multiple path parts: ${inputPathParts.join(", ")}`);
-            console.log("");
+            console.log('  The `index` command accepts a single path only.');
+            console.log('  If your path contains spaces, wrap it in quotes.');
+            console.log(`  Received multiple path parts: ${inputPathParts.join(', ')}`);
+            console.log('');
             process.exitCode = 1;
             return;
         }
@@ -38,7 +36,7 @@ export const indexCommand = async (inputPathParts, options) => {
     else {
         const gitRoot = getGitRoot(process.cwd());
         if (!gitRoot) {
-            console.log("  Not inside a git repository, try to run git init\n");
+            console.log('  Not inside a git repository, try to run git init\n');
             process.exitCode = 1;
             return;
         }
@@ -46,8 +44,8 @@ export const indexCommand = async (inputPathParts, options) => {
     }
     if (!options?.allowNonGit && !isGitRepo(repoPath)) {
         console.log(`  Not a git repository: ${repoPath}`);
-        console.log("  Initialize one with `git init` or choose a valid repo path.\n");
-        console.log("  Or use --allow-non-git to register an existing .gitnexus index anyway.\n");
+        console.log('  Initialize one with `git init` or choose a valid repo path.\n');
+        console.log('  Or use --allow-non-git to register an existing .gitnexus index anyway.\n');
         process.exitCode = 1;
         return;
     }
@@ -58,7 +56,7 @@ export const indexCommand = async (inputPathParts, options) => {
     }
     catch {
         console.log(`  No .gitnexus/ folder found at: ${storagePath}`);
-        console.log("  Run `gitnexus analyze` to build the index first.\n");
+        console.log('  Run `gitnexus analyze` to build the index first.\n');
         process.exitCode = 1;
         return;
     }
@@ -68,7 +66,7 @@ export const indexCommand = async (inputPathParts, options) => {
     }
     catch {
         console.log(`  .gitnexus/ folder exists but contains no LadybugDB index.`);
-        console.log("  Run `gitnexus analyze` to build the index.\n");
+        console.log('  Run `gitnexus analyze` to build the index.\n');
         process.exitCode = 1;
         return;
     }
@@ -77,15 +75,15 @@ export const indexCommand = async (inputPathParts, options) => {
     if (!meta) {
         if (!options?.force) {
             console.log(`  .gitnexus/ exists but meta.json is missing.`);
-            console.log("  Use --force to register anyway (stats will be empty),");
-            console.log("  or run `gitnexus analyze` to rebuild properly.\n");
+            console.log('  Use --force to register anyway (stats will be empty),');
+            console.log('  or run `gitnexus analyze` to rebuild properly.\n');
             process.exitCode = 1;
             return;
         }
         // --force: build a minimal meta so the repo can be registered
         meta = {
             repoPath,
-            lastCommit: "",
+            lastCommit: '',
             indexedAt: new Date().toISOString(),
         };
     }
@@ -108,8 +106,8 @@ export const indexCommand = async (inputPathParts, options) => {
         if (stats.processes != null)
             parts.push(`${stats.processes} flows`);
         if (parts.length)
-            console.log(`  ${parts.join(" | ")}`);
+            console.log(`  ${parts.join(' | ')}`);
     }
     console.log(`  ${repoPath}`);
-    console.log("");
+    console.log('');
 };

package/dist/cli/index.js

@@ -7,10 +7,7 @@ import { createLazyAction } from './lazy-action.js';
 const _require = createRequire(import.meta.url);
 const pkg = _require('../../package.json');
 const program = new Command();
-program
-    .name('gitnexus')
-    .description('GitNexus local CLI and MCP server')
-    .version(pkg.version);
+program.name('gitnexus').description('GitNexus local CLI and MCP server').version(pkg.version);
 program
     .command('setup')
     .description('One-time setup: configure MCP for Cursor, Claude Code, OpenCode, Codex')
@@ -21,6 +18,7 @@ program
     .option('-f, --force', 'Force full re-index even if up to date')
     .option('--embeddings', 'Enable embedding generation for semantic search (off by default)')
     .option('--skills', 'Generate repo-specific skill files from detected communities')
+    .option('--skip-agents-md', 'Skip updating the gitnexus section in AGENTS.md and CLAUDE.md')
     .option('--skip-git', 'Index a folder without requiring a .git directory')
     .option('-v, --verbose', 'Enable verbose ingestion warnings (default: false)')
     .addHelpText('after', '\nEnvironment variables:\n  GITNEXUS_NO_GITIGNORE=1  Skip .gitignore parsing (still reads .gitnexusignore)')
@@ -60,9 +58,12 @@ program
     .description('Generate repository wiki from knowledge graph')
     .option('-f, --force', 'Force full regeneration even if up to date')
     .option('--provider <provider>', 'LLM provider: openai or cursor (default: openai)')
-    .option('--model <model>', 'LLM model name (default depends on provider)')
-    .option('--base-url <url>', 'LLM API base URL (for openai provider)')
-    .option('--api-key <key>', 'LLM API key (saved to ~/.gitnexus/config.json)')
+    .option('--model <model>', 'LLM model or Azure deployment name (default: minimax/minimax-m2.5)')
+    .option('--base-url <url>', 'LLM API base URL. Azure v1: https://{resource}.openai.azure.com/openai/v1')
+    .option('--api-key <key>', 'LLM API key or Azure api-key (saved to ~/.gitnexus/config.json)')
+    .option('--api-version <version>', 'Azure api-version query param, e.g. 2024-10-21 (legacy Azure API only)')
+    .option('--reasoning-model', 'Mark deployment as reasoning model (o1/o3/o4-mini) — strips temperature, uses max_completion_tokens')
+    .option('--no-reasoning-model', 'Disable reasoning model mode (overrides saved config)')
     .option('--concurrency <n>', 'Parallel LLM calls (default: 3)', '3')
     .option('--gist', 'Publish wiki as a public GitHub Gist after generation')
     .option('-v, --verbose', 'Enable verbose output (show LLM commands and responses)')

package/dist/cli/mcp.js

@@ -29,7 +29,7 @@ export const mcpCommand = async () => {
         console.error('GitNexus: No indexed repos yet. Run `gitnexus analyze` in a git repo — the server will pick it up automatically.');
     }
     else {
-        console.error(`GitNexus: MCP server starting with ${repos.length} repo(s): ${repos.map(r => r.name).join(', ')}`);
+        console.error(`GitNexus: MCP server starting with ${repos.length} repo(s): ${repos.map((r) => r.name).join(', ')}`);
     }
     // Start MCP server (serves all repos, discovers new ones lazily)
     await startMCPServer(backend);