gitnexus 1.4.9 → 1.5.0

package/dist/core/run-analyze.js

@@ -0,0 +1,257 @@
+/**
+ * Shared Analysis Orchestrator
+ *
+ * Extracts the core analysis pipeline from the CLI analyze command into a
+ * reusable function that can be called from both the CLI and a server-side
+ * worker process.
+ *
+ * IMPORTANT: This module must NEVER call process.exit(). The caller (CLI
+ * wrapper or server worker) is responsible for process lifecycle.
+ */
+import path from 'path';
+import fs from 'fs/promises';
+import { runPipelineFromRepo } from './ingestion/pipeline.js';
+import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, createFTSIndex, loadCachedEmbeddings, } from './lbug/lbug-adapter.js';
+import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, cleanupOldKuzuFiles, } from '../storage/repo-manager.js';
+import { getCurrentCommit, hasGitDir } from '../storage/git.js';
+import { generateAIContextFiles } from '../cli/ai-context.js';
+/** Threshold: auto-skip embeddings for repos with more nodes than this */
+const EMBEDDING_NODE_LIMIT = 50_000;
+export 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',
+};
+// ---------------------------------------------------------------------------
+// Main orchestrator
+// ---------------------------------------------------------------------------
+/**
+ * Run the full GitNexus analysis pipeline.
+ *
+ * This is the shared core extracted from the CLI `analyze` command. It
+ * handles: pipeline execution, LadybugDB loading, FTS indexing, embedding
+ * generation, metadata persistence, and AI context file generation.
+ *
+ * The function communicates progress and log messages exclusively through
+ * the {@link AnalyzeCallbacks} interface — it never writes to stdout/stderr
+ * directly and never calls `process.exit()`.
+ */
+export async function runFullAnalysis(repoPath, options, callbacks) {
+    const log = (msg) => callbacks.onLog?.(msg);
+    const progress = (phase, percent, message) => callbacks.onProgress(phase, percent, message);
+    const { storagePath, lbugPath } = getStoragePaths(repoPath);
+    // Clean up stale KuzuDB files from before the LadybugDB migration.
+    const kuzuResult = await cleanupOldKuzuFiles(storagePath);
+    if (kuzuResult.found && kuzuResult.needsReindex) {
+        log('Migrating from KuzuDB to LadybugDB — rebuilding index...');
+    }
+    const repoHasGit = hasGitDir(repoPath);
+    const currentCommit = repoHasGit ? getCurrentCommit(repoPath) : '';
+    const existingMeta = await loadMeta(storagePath);
+    // ── Early-return: already up to date ──────────────────────────────
+    if (existingMeta && !options.force && existingMeta.lastCommit === currentCommit) {
+        // Non-git folders have currentCommit = '' — always rebuild since we can't detect changes
+        if (currentCommit !== '') {
+            return {
+                repoName: path.basename(repoPath),
+                repoPath,
+                stats: existingMeta.stats ?? {},
+                alreadyUpToDate: true,
+            };
+        }
+    }
+    // ── Cache embeddings from existing index before rebuild ────────────
+    let cachedEmbeddingNodeIds = new Set();
+    let cachedEmbeddings = [];
+    if (options.embeddings && existingMeta && !options.force) {
+        try {
+            progress('embeddings', 0, 'Caching embeddings...');
+            await initLbug(lbugPath);
+            const cached = await loadCachedEmbeddings();
+            cachedEmbeddingNodeIds = cached.embeddingNodeIds;
+            cachedEmbeddings = cached.embeddings;
+            await closeLbug();
+        }
+        catch {
+            try {
+                await closeLbug();
+            }
+            catch {
+                /* swallow */
+            }
+        }
+    }
+    // ── Phase 1: Full Pipeline (0–60%) ────────────────────────────────
+    const pipelineResult = await runPipelineFromRepo(repoPath, (p) => {
+        const phaseLabel = PHASE_LABELS[p.phase] || p.phase;
+        const scaled = Math.round(p.percent * 0.6);
+        progress(p.phase, scaled, phaseLabel);
+    });
+    // ── Phase 2: LadybugDB (60–85%) ──────────────────────────────────
+    progress('lbug', 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 {
+            /* swallow */
+        }
+    }
+    await initLbug(lbugPath);
+    try {
+        // All work after initLbug is wrapped in try/finally to ensure closeLbug()
+        // is called even if an error occurs — the module-level singleton DB handle
+        // must be released to avoid blocking subsequent invocations.
+        let lbugMsgCount = 0;
+        await loadGraphToLbug(pipelineResult.graph, pipelineResult.repoPath, storagePath, (msg) => {
+            lbugMsgCount++;
+            const pct = Math.min(84, 60 + Math.round((lbugMsgCount / (lbugMsgCount + 10)) * 24));
+            progress('lbug', pct, msg);
+        });
+        // ── Phase 3: FTS (85–90%) ─────────────────────────────────────────
+        progress('fts', 85, 'Creating search indexes...');
+        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 {
+            // Non-fatal — FTS is best-effort
+        }
+        // ── Phase 3.5: Re-insert cached embeddings ────────────────────────
+        if (cachedEmbeddings.length > 0) {
+            const cachedDims = cachedEmbeddings[0].embedding.length;
+            const { EMBEDDING_DIMS } = await import('./lbug/schema.js');
+            if (cachedDims !== EMBEDDING_DIMS) {
+                // Dimensions changed (e.g. switched embedding model) — discard cache and re-embed all
+                log(`Embedding dimensions changed (${cachedDims}d -> ${EMBEDDING_DIMS}d), discarding cache`);
+                cachedEmbeddings = [];
+                cachedEmbeddingNodeIds = new Set();
+            }
+            else {
+                progress('embeddings', 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);
+                    }
+                    catch {
+                        /* some may fail if node was removed, that's fine */
+                    }
+                }
+            }
+        }
+        // ── Phase 4: Embeddings (90–98%) ──────────────────────────────────
+        const stats = await getLbugStats();
+        let embeddingSkipped = true;
+        if (options.embeddings) {
+            if (stats.nodes <= EMBEDDING_NODE_LIMIT) {
+                embeddingSkipped = false;
+            }
+        }
+        if (!embeddingSkipped) {
+            const { isHttpMode } = await import('./embeddings/http-client.js');
+            const httpMode = isHttpMode();
+            progress('embeddings', 90, httpMode ? 'Connecting to embedding endpoint...' : 'Loading embedding model...');
+            const { runEmbeddingPipeline } = await import('./embeddings/embedding-pipeline.js');
+            await runEmbeddingPipeline(executeQuery, executeWithReusedStatement, (p) => {
+                const scaled = 90 + Math.round((p.percent / 100) * 8);
+                const label = p.phase === 'loading-model'
+                    ? httpMode
+                        ? 'Connecting to embedding endpoint...'
+                        : 'Loading embedding model...'
+                    : `Embedding ${p.nodesProcessed || 0}/${p.totalNodes || '?'}`;
+                progress('embeddings', scaled, label);
+            }, {}, cachedEmbeddingNodeIds.size > 0 ? cachedEmbeddingNodeIds : undefined);
+        }
+        // ── Phase 5: Finalize (98–100%) ───────────────────────────────────
+        progress('done', 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.
+        if (hasGitDir(repoPath)) {
+            await addToGitignore(repoPath);
+        }
+        const projectName = path.basename(repoPath);
+        // ── Generate AI context files (best-effort) ───────────────────────
+        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);
+            }
+            aggregatedClusterCount = Array.from(groups.values()).filter((count) => count >= 5).length;
+        }
+        try {
+            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,
+            }, undefined, { skipAgentsMd: options.skipAgentsMd });
+        }
+        catch {
+            // Best-effort — don't fail the entire analysis for context file issues
+        }
+        // ── Close LadybugDB ──────────────────────────────────────────────
+        await closeLbug();
+        progress('done', 100, 'Done');
+        return {
+            repoName: projectName,
+            repoPath,
+            stats: meta.stats,
+            pipelineResult,
+        };
+    }
+    catch (err) {
+        // Ensure LadybugDB is closed even on error
+        try {
+            await closeLbug();
+        }
+        catch {
+            /* swallow */
+        }
+        throw err;
+    }
+}

package/dist/core/tree-sitter/parser-loader.d.ts

@@ -1,5 +1,5 @@
 import Parser from 'tree-sitter';
-import { SupportedLanguages } from '../../config/supported-languages.js';
+import { SupportedLanguages } from 'gitnexus-shared';
 export declare const isLanguageAvailable: (language: SupportedLanguages) => boolean;
 export declare const loadParser: () => Promise<Parser>;
 export declare const loadLanguage: (language: SupportedLanguages, filePath?: string) => Promise<void>;

package/dist/core/tree-sitter/parser-loader.js

@@ -11,7 +11,7 @@ import Rust from 'tree-sitter-rust';
 import PHP from 'tree-sitter-php';
 import Ruby from 'tree-sitter-ruby';
 import { createRequire } from 'node:module';
-import { SupportedLanguages } from '../../config/supported-languages.js';
+import { SupportedLanguages } from 'gitnexus-shared';
 // tree-sitter-swift and tree-sitter-dart are optionalDependencies — may not be installed
 const _require = createRequire(import.meta.url);
 let Swift = null;

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

@@ -57,13 +57,8 @@ export async function callCursorLLM(prompt, config, systemPrompt, options) {
     // Always use text format to get clean output without agent narration/thinking.
     // stream-json captures assistant messages which include "Let me explore..." narration
     // that pollutes the actual content when using thinking models.
-    const fullPrompt = systemPrompt
-        ? `${systemPrompt}\n\n---\n\n${prompt}`
-        : prompt;
-    const args = [
-        '-p',
-        '--output-format', 'text',
-    ];
+    const fullPrompt = systemPrompt ? `${systemPrompt}\n\n---\n\n${prompt}` : prompt;
+    const args = ['-p', '--output-format', 'text'];
     if (config.model) {
         args.push('--model', config.model);
     }

package/dist/core/wiki/generator.js

@@ -15,7 +15,7 @@ import { execSync, execFileSync } from 'child_process';
 import { initWikiDb, closeWikiDb, touchWikiDb, getFilesWithExports, getAllFiles, getIntraModuleCallEdges, getInterModuleCallEdges, getProcessesForFiles, getAllProcesses, getInterModuleEdgesForOverview, } from './graph-queries.js';
 import { generateHTMLViewer } from './html-viewer.js';
 import { callLLM, estimateTokens, } from './llm-client.js';
-import { callCursorLLM, resolveCursorConfig, } from './cursor-client.js';
+import { callCursorLLM, resolveCursorConfig } from './cursor-client.js';
 import { GROUPING_SYSTEM_PROMPT, GROUPING_USER_PROMPT, MODULE_SYSTEM_PROMPT, MODULE_USER_PROMPT, PARENT_SYSTEM_PROMPT, PARENT_USER_PROMPT, OVERVIEW_SYSTEM_PROMPT, OVERVIEW_USER_PROMPT, fillTemplate, formatFileListForGrouping, formatDirectoryTree, formatCallEdges, formatProcesses, } from './prompts.js';
 import { shouldIgnorePath } from '../../config/ignore-service.js';
 // ─── Constants ────────────────────────────────────────────────────────
@@ -72,7 +72,7 @@ export class WikiGenerator {
                 if (hasFixedStart) {
                     // For fixed phases (like grouping), show incremental progress
                     const progress = Math.min(1, tokens / expectedTokens);
-                    const pct = Math.round(startPercent + (progress * percentRange));
+                    const pct = Math.round(startPercent + progress * percentRange);
                     this.onProgress('stream', pct, `${label} (${tokens} tok)`);
                 }
                 else {
@@ -155,7 +155,7 @@ export class WikiGenerator {
     async ensureHTMLViewer() {
         // Only generate if there are markdown pages to bundle
         const dirEntries = await fs.readdir(this.wikiDir).catch(() => []);
-        const hasMd = dirEntries.some(f => f.endsWith('.md'));
+        const hasMd = dirEntries.some((f) => f.endsWith('.md'));
         if (!hasMd)
             return;
         this.onProgress('html', 98, 'Building HTML viewer...');
@@ -170,13 +170,13 @@ export class WikiGenerator {
         const filesWithExports = await getFilesWithExports();
         const allFiles = await getAllFiles();
         // Filter to source files only
-        const sourceFiles = allFiles.filter(f => !shouldIgnorePath(f));
+        const sourceFiles = allFiles.filter((f) => !shouldIgnorePath(f));
         if (sourceFiles.length === 0) {
             throw new Error('No source files found in the knowledge graph. Nothing to document.');
         }
         // Build enriched file list (merge exports into all source files)
-        const exportMap = new Map(filesWithExports.map(f => [f.filePath, f]));
-        const enrichedFiles = sourceFiles.map(fp => {
+        const exportMap = new Map(filesWithExports.map((f) => [f.filePath, f]));
+        const enrichedFiles = sourceFiles.map((fp) => {
             return exportMap.get(fp) || { filePath: fp, symbols: [] };
         });
         this.onProgress('gather', 10, `Found ${sourceFiles.length} source files`);
@@ -187,7 +187,12 @@ export class WikiGenerator {
         if (this.options.reviewOnly) {
             await this.saveModuleTree(moduleTree);
             this.onProgress('review', 30, 'Module tree ready for review');
-            const reviewResult = { pagesGenerated: 0, mode: 'full', failedModules: [], moduleTree };
+            const reviewResult = {
+                pagesGenerated: 0,
+                mode: 'full',
+                failedModules: [],
+                moduleTree,
+            };
             return reviewResult;
         }
         // Phase 2: Generate module pages (parallel with concurrency limit)
@@ -287,7 +292,7 @@ export class WikiGenerator {
         }
         this.onProgress('grouping', 15, 'Grouping files into modules (LLM)...');
         const fileList = formatFileListForGrouping(files);
-        const dirTree = formatDirectoryTree(files.map(f => f.filePath));
+        const dirTree = formatDirectoryTree(files.map((f) => f.filePath));
         const prompt = fillTemplate(GROUPING_USER_PROMPT, {
             FILE_LIST: fileList,
             DIRECTORY_TREE: dirTree,
@@ -340,13 +345,13 @@ export class WikiGenerator {
             return this.fallbackGrouping(files);
         }
         // Validate — ensure all files are assigned
-        const allFilePaths = new Set(files.map(f => f.filePath));
+        const allFilePaths = new Set(files.map((f) => f.filePath));
         const assignedFiles = new Set();
         const validGrouping = {};
         for (const [mod, paths] of Object.entries(parsed)) {
             if (!Array.isArray(paths))
                 continue;
-            const validPaths = paths.filter(p => {
+            const validPaths = paths.filter((p) => {
                 if (allFilePaths.has(p) && !assignedFiles.has(p)) {
                     assignedFiles.add(p);
                     return true;
@@ -358,15 +363,11 @@ export class WikiGenerator {
             }
         }
         // Assign unassigned files to a "Miscellaneous" module
-        const unassigned = files
-            .map(f => f.filePath)
-            .filter(fp => !assignedFiles.has(fp));
+        const unassigned = files.map((f) => f.filePath).filter((fp) => !assignedFiles.has(fp));
         if (unassigned.length > 0) {
             validGrouping['Other'] = unassigned;
         }
-        return Object.keys(validGrouping).length > 0
-            ? validGrouping
-            : this.fallbackGrouping(files);
+        return Object.keys(validGrouping).length > 0 ? validGrouping : this.fallbackGrouping(files);
     }
     /**
      * Fallback grouping by top-level directory when LLM parsing fails.
@@ -403,7 +404,7 @@ export class WikiGenerator {
             group.push(fp);
         }
         // Check if basenames are unique; if not, use the full subDir path
-        const basenames = Array.from(subGroups.keys()).map(s => path.basename(s));
+        const basenames = Array.from(subGroups.keys()).map((s) => path.basename(s));
         const hasCollisions = new Set(basenames).size < basenames.length;
         return Array.from(subGroups.entries()).map(([subDir, subFiles]) => {
             const label = hasCollisions ? subDir.replace(/\//g, '-') : path.basename(subDir);
@@ -469,7 +470,7 @@ export class WikiGenerator {
             }
         }
         // Get cross-child call edges
-        const allChildFiles = node.children.flatMap(c => c.files);
+        const allChildFiles = node.children.flatMap((c) => c.files);
         const crossCalls = await getIntraModuleCallEdges(allChildFiles);
         const processes = await getProcessesForFiles(allChildFiles, 3);
         const prompt = fillTemplate(PARENT_USER_PROMPT, {
@@ -506,7 +507,7 @@ export class WikiGenerator {
         // Read project config
         const projectInfo = await this.readProjectInfo();
         const edgesText = moduleEdges.length > 0
-            ? moduleEdges.map(e => `${e.from} → ${e.to} (${e.count} calls)`).join('\n')
+            ? moduleEdges.map((e) => `${e.from} → ${e.to} (${e.count} calls)`).join('\n')
             : 'No inter-module call edges detected';
         const prompt = fillTemplate(OVERVIEW_USER_PROMPT, {
             PROJECT_INFO: projectInfo,
@@ -644,7 +645,10 @@ export class WikiGenerator {
      */
     isCommitReachable(fromCommit, toCommit) {
         try {
-            execFileSync('git', ['merge-base', '--is-ancestor', fromCommit, toCommit], { cwd: this.repoPath, stdio: 'ignore' });
+            execFileSync('git', ['merge-base', '--is-ancestor', fromCommit, toCommit], {
+                cwd: this.repoPath,
+                stdio: 'ignore',
+            });
             return true;
         }
         catch {
@@ -658,7 +662,11 @@ export class WikiGenerator {
             return null; // Signal that we can't compute diff (divergent branches)
         }
         try {
-            const output = execFileSync('git', ['diff', `${fromCommit}..${toCommit}`, '--name-only'], { cwd: this.repoPath }).toString().trim();
+            const output = execFileSync('git', ['diff', `${fromCommit}..${toCommit}`, '--name-only'], {
+                cwd: this.repoPath,
+            })
+                .toString()
+                .trim();
             return output ? output.split('\n').filter(Boolean) : [];
         }
         catch {
@@ -700,7 +708,14 @@ export class WikiGenerator {
         return total;
     }
     async readProjectInfo() {
-        const candidates = ['package.json', 'Cargo.toml', 'pyproject.toml', 'go.mod', 'pom.xml', 'build.gradle'];
+        const candidates = [
+            'package.json',
+            'Cargo.toml',
+            'pyproject.toml',
+            'go.mod',
+            'pom.xml',
+            'build.gradle',
+        ];
         const lines = [`Project: ${path.basename(this.repoPath)}`];
         for (const file of candidates) {
             const fullPath = path.join(this.repoPath, file);
@@ -742,7 +757,7 @@ export class WikiGenerator {
         const result = {};
         for (const node of tree) {
             if (node.children && node.children.length > 0) {
-                result[node.name] = node.children.flatMap(c => c.files);
+                result[node.name] = node.children.flatMap((c) => c.files);
                 for (const child of node.children) {
                     result[child.name] = child.files;
                 }

package/dist/core/wiki/graph-queries.js

@@ -57,7 +57,7 @@ export async function getAllFiles() {
     RETURN f.filePath AS filePath
     ORDER BY f.filePath
   `);
-    return rows.map(r => r.filePath || r[0]);
+    return rows.map((r) => r.filePath || r[0]);
 }
 /**
  * Get inter-file call edges (calls between different files).
@@ -69,7 +69,7 @@ export async function getInterFileCallEdges() {
     RETURN DISTINCT a.filePath AS fromFile, a.name AS fromName,
            b.filePath AS toFile, b.name AS toName
   `);
-    return rows.map(r => ({
+    return rows.map((r) => ({
         fromFile: r.fromFile || r[0],
         fromName: r.fromName || r[1],
         toFile: r.toFile || r[2],
@@ -82,14 +82,14 @@ export async function getInterFileCallEdges() {
 export async function getIntraModuleCallEdges(filePaths) {
     if (filePaths.length === 0)
         return [];
-    const fileList = filePaths.map(f => `'${f.replace(/'/g, "''")}'`).join(', ');
+    const fileList = filePaths.map((f) => `'${f.replace(/'/g, "''")}'`).join(', ');
     const rows = await executeQuery(REPO_ID, `
     MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b)
     WHERE a.filePath IN [${fileList}] AND b.filePath IN [${fileList}]
     RETURN DISTINCT a.filePath AS fromFile, a.name AS fromName,
            b.filePath AS toFile, b.name AS toName
   `);
-    return rows.map(r => ({
+    return rows.map((r) => ({
         fromFile: r.fromFile || r[0],
         fromName: r.fromName || r[1],
         toFile: r.toFile || r[2],
@@ -102,7 +102,7 @@ export async function getIntraModuleCallEdges(filePaths) {
 export async function getInterModuleCallEdges(filePaths) {
     if (filePaths.length === 0)
         return { outgoing: [], incoming: [] };
-    const fileList = filePaths.map(f => `'${f.replace(/'/g, "''")}'`).join(', ');
+    const fileList = filePaths.map((f) => `'${f.replace(/'/g, "''")}'`).join(', ');
     const outRows = await executeQuery(REPO_ID, `
     MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b)
     WHERE a.filePath IN [${fileList}] AND NOT b.filePath IN [${fileList}]
@@ -118,13 +118,13 @@ export async function getInterModuleCallEdges(filePaths) {
     LIMIT 30
   `);
     return {
-        outgoing: outRows.map(r => ({
+        outgoing: outRows.map((r) => ({
             fromFile: r.fromFile || r[0],
             fromName: r.fromName || r[1],
             toFile: r.toFile || r[2],
             toName: r.toName || r[3],
         })),
-        incoming: inRows.map(r => ({
+        incoming: inRows.map((r) => ({
             fromFile: r.fromFile || r[0],
             fromName: r.fromName || r[1],
             toFile: r.toFile || r[2],
@@ -139,7 +139,7 @@ export async function getInterModuleCallEdges(filePaths) {
 export async function getProcessesForFiles(filePaths, limit = 5) {
     if (filePaths.length === 0)
         return [];
-    const fileList = filePaths.map(f => `'${f.replace(/'/g, "''")}'`).join(', ');
+    const fileList = filePaths.map((f) => `'${f.replace(/'/g, "''")}'`).join(', ');
     // Find processes that have steps in the given files
     const procRows = await executeQuery(REPO_ID, `
     MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
@@ -166,7 +166,7 @@ export async function getProcessesForFiles(filePaths, limit = 5) {
             label,
             type,
             stepCount,
-            steps: stepRows.map(s => ({
+            steps: stepRows.map((s) => ({
                 step: s.step || s[3] || 0,
                 name: s.name || s[0],
                 filePath: s.filePath || s[1],
@@ -203,7 +203,7 @@ export async function getAllProcesses(limit = 20) {
             label,
             type,
             stepCount,
-            steps: stepRows.map(s => ({
+            steps: stepRows.map((s) => ({
                 step: s.step || s[3] || 0,
                 name: s.name || s[0],
                 filePath: s.filePath || s[1],

package/dist/core/wiki/html-viewer.js

@@ -16,18 +16,22 @@ export async function generateHTMLViewer(wikiDir, projectName) {
         const raw = await fs.readFile(path.join(wikiDir, 'module_tree.json'), 'utf-8');
         moduleTree = JSON.parse(raw);
     }
-    catch { /* will show empty nav */ }
+    catch {
+        /* will show empty nav */
+    }
     // Load meta
     let meta = null;
     try {
         const raw = await fs.readFile(path.join(wikiDir, 'meta.json'), 'utf-8');
         meta = JSON.parse(raw);
     }
-    catch { /* no meta */ }
+    catch {
+        /* no meta */
+    }
     // Read all markdown files into a { slug: content } map
     const pages = {};
     const dirEntries = await fs.readdir(wikiDir);
-    for (const f of dirEntries.filter(f => f.endsWith('.md'))) {
+    for (const f of dirEntries.filter((f) => f.endsWith('.md'))) {
         const content = await fs.readFile(path.join(wikiDir, f), 'utf-8');
         pages[f.replace(/\.md$/, '')] = content;
     }

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

@@ -6,14 +6,19 @@
  *
  * Config priority: CLI flags > env vars > defaults
  */
-export type LLMProvider = 'openai' | 'cursor';
+export type LLMProvider = 'openai' | 'openrouter' | 'azure' | 'custom' | 'cursor';
 export interface LLMConfig {
     apiKey: string;
     baseUrl: string;
     model: string;
     maxTokens: number;
     temperature: number;
-    provider?: LLMProvider;
+    /** Provider type — controls auth header behaviour */
+    provider?: 'openai' | 'openrouter' | 'azure' | 'custom' | 'cursor';
+    /** Azure api-version query param (e.g. '2024-10-21'). Appended to URL when set. */
+    apiVersion?: string;
+    /** When true, strips sampling params and uses max_completion_tokens instead of max_tokens */
+    isReasoningModel?: boolean;
 }
 export interface LLMResponse {
     content: string;
@@ -31,6 +36,22 @@ 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;
+/**
+ * Returns true if the given base URL is an Azure OpenAI endpoint.
+ * Uses proper hostname matching to avoid spoofed URLs like
+ * "https://myresource.openai.azure.com.evil.com/v1".
+ */
+export declare function isAzureProvider(baseUrl: string): boolean;
+/**
+ * Returns true if the model name matches a known reasoning model pattern,
+ * or if the explicit override is true.
+ * Pass override=false to force non-reasoning even for o-series names.
+ */
+export declare function isReasoningModel(model: string, override?: boolean): boolean;
+/**
+ * Build the full chat completions URL, appending ?api-version when provided.
+ */
+export declare function buildRequestUrl(baseUrl: string, apiVersion: string | undefined): string;
 export interface CallLLMOptions {
     onChunk?: (charsReceived: number) => void;
 }