gitnexus 1.4.10 → 1.5.1

package/dist/cli/serve.js

@@ -1,6 +1,34 @@
 import { createServer } from '../server/api.js';
+// Catch anything that would cause a silent exit
+process.on('uncaughtException', (err) => {
+    console.error('\n[gitnexus serve] Uncaught exception:', err.message);
+    if (process.env.DEBUG)
+        console.error(err.stack);
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason) => {
+    console.error('\n[gitnexus serve] Unhandled rejection:', reason?.message || reason);
+    if (process.env.DEBUG)
+        console.error(reason?.stack);
+    process.exit(1);
+});
 export const serveCommand = async (options) => {
     const port = Number(options?.port ?? 4747);
     const host = options?.host ?? '127.0.0.1';
-    await createServer(port, host);
+    try {
+        await createServer(port, host);
+    }
+    catch (err) {
+        console.error(`\nFailed to start GitNexus server:\n`);
+        console.error(`  ${err.message || err}\n`);
+        if (err.code === 'EADDRINUSE') {
+            console.error(`  Port ${port} is already in use. Either:`);
+            console.error(`    1. Stop the other process using port ${port}`);
+            console.error(`    2. Use a different port: gitnexus serve --port 4748\n`);
+        }
+        if (err.stack && process.env.DEBUG) {
+            console.error(err.stack);
+        }
+        process.exit(1);
+    }
 };

package/dist/cli/setup.js

@@ -164,13 +164,13 @@ async function installClaudeCodeHooks(result) {
         const hookPath = path.join(destHooksDir, 'gitnexus-hook.cjs').replace(/\\/g, '/');
         const hookCmd = `node "${hookPath.replace(/"/g, '\\"')}"`;
         // Merge hook config into ~/.claude/settings.json
-        const existing = await readJsonFile(settingsPath) || {};
+        const existing = (await readJsonFile(settingsPath)) || {};
         if (!existing.hooks)
             existing.hooks = {};
         function ensureHookEntry(eventName, matcher, timeout, statusMessage) {
             if (!existing.hooks[eventName])
                 existing.hooks[eventName] = [];
-            const hasHook = existing.hooks[eventName].some((h) => h.hooks?.some(hh => hh.command?.includes('gitnexus-hook')));
+            const hasHook = existing.hooks[eventName].some((h) => h.hooks?.some((hh) => hh.command?.includes('gitnexus-hook')));
             if (!hasHook) {
                 existing.hooks[eventName].push({
                     matcher,
@@ -213,7 +213,7 @@ async function setupOpenCode(result) {
 function getCodexMcpTomlSection() {
     const entry = getMcpEntry();
     const command = JSON.stringify(entry.command);
-    const args = `[${entry.args.map(arg => JSON.stringify(arg)).join(', ')}]`;
+    const args = `[${entry.args.map((arg) => JSON.stringify(arg)).join(', ')}]`;
     return `[mcp_servers.gitnexus]\ncommand = ${command}\nargs = ${args}\n`;
 }
 /**
@@ -231,9 +231,7 @@ async function upsertCodexConfigToml(configPath) {
         return;
     }
     const section = getCodexMcpTomlSection();
-    const nextContent = existing.trim().length > 0
-        ? `${existing.trimEnd()}\n\n${section}`
-        : section;
+    const nextContent = existing.trim().length > 0 ? `${existing.trimEnd()}\n\n${section}` : section;
     await fs.mkdir(path.dirname(configPath), { recursive: true });
     await fs.writeFile(configPath, `${nextContent.trimEnd()}\n`, 'utf-8');
 }
@@ -245,7 +243,9 @@ async function setupCodex(result) {
     }
     try {
         const entry = getMcpEntry();
-        await execFileAsync('codex', ['mcp', 'add', 'gitnexus', '--', entry.command, ...entry.args], { shell: process.platform === 'win32' });
+        await execFileAsync('codex', ['mcp', 'add', 'gitnexus', '--', entry.command, ...entry.args], {
+            shell: process.platform === 'win32',
+        });
         result.configured.push('Codex');
         return;
     }
@@ -436,8 +436,8 @@ export const setupCommand = async () => {
     }
     console.log('');
     console.log('  Summary:');
-    console.log(`    MCP configured for: ${result.configured.filter(c => !c.includes('skills')).join(', ') || 'none'}`);
-    console.log(`    Skills installed to: ${result.configured.filter(c => c.includes('skills')).length > 0 ? result.configured.filter(c => c.includes('skills')).join(', ') : 'none'}`);
+    console.log(`    MCP configured for: ${result.configured.filter((c) => !c.includes('skills')).join(', ') || 'none'}`);
+    console.log(`    Skills installed to: ${result.configured.filter((c) => c.includes('skills')).length > 0 ? result.configured.filter((c) => c.includes('skills')).join(', ') : 'none'}`);
     console.log('');
     console.log('  Next steps:');
     console.log('    1. cd into any git repo');

package/dist/cli/skill-gen.js

@@ -37,7 +37,7 @@ export const generateSkillFiles = async (repoPath, projectName, pipelineResult)
     // Step 2: Filter to significant communities
     // Keep communities with >= 3 symbols after aggregation.
     const significant = aggregated
-        .filter(c => c.symbolCount >= 3)
+        .filter((c) => c.symbolCount >= 3)
         .sort((a, b) => b.symbolCount - a.symbolCount)
         .slice(0, 20);
     if (significant.length === 0) {
@@ -51,7 +51,9 @@ export const generateSkillFiles = async (repoPath, projectName, pipelineResult)
     try {
         await fs.rm(outputDir, { recursive: true, force: true });
     }
-    catch { /* may not exist */ }
+    catch {
+        /* may not exist */
+    }
     await fs.mkdir(outputDir, { recursive: true });
     // Step 5: Generate skill files
     const skills = [];
@@ -146,7 +148,7 @@ const buildCommunitiesFromMemberships = (memberships, graph, repoPath) => {
         const nodeSet = new Set(nodeIds);
         let internalEdges = 0;
         let totalEdges = 0;
-        graph.forEachRelationship(rel => {
+        graph.forEachRelationship((rel) => {
             if (nodeSet.has(rel.sourceId)) {
                 totalEdges++;
                 if (nodeSet.has(rel.targetId))
@@ -311,7 +313,7 @@ const gatherEntryPoints = (members) => {
         Interface: 3,
     };
     return members
-        .filter(m => m.isExported)
+        .filter((m) => m.isExported)
         .sort((a, b) => {
         const pa = typePriority[a.label] ?? 99;
         const pb = typePriority[b.label] ?? 99;
@@ -327,7 +329,7 @@ const gatherEntryPoints = (members) => {
 const gatherFlows = (rawIds, processes) => {
     const rawIdSet = new Set(rawIds);
     return processes
-        .filter(proc => proc.communities.some(cid => rawIdSet.has(cid)))
+        .filter((proc) => proc.communities.some((cid) => rawIdSet.has(cid)))
         .sort((a, b) => b.stepCount - a.stepCount);
 };
 /**
@@ -350,7 +352,7 @@ const gatherCrossConnections = (rawIds, ownLabel, membershipsByComm, nodeIdToCom
     }
     // Count outgoing CALLS to nodes in different communities
     const targetCounts = new Map();
-    graph.forEachRelationship(rel => {
+    graph.forEachRelationship((rel) => {
         if (rel.type !== 'CALLS')
             return;
         if (!ownNodeIds.has(rel.sourceId))
@@ -386,10 +388,10 @@ const renderSkillMarkdown = (community, projectName, members, files, entryPoints
     // Dominant directory: most common top-level directory
     const dominantDir = getDominantDirectory(files);
     // Top symbol names for "When to Use"
-    const topNames = entryPoints.slice(0, 3).map(e => e.name);
+    const topNames = entryPoints.slice(0, 3).map((e) => e.name);
     if (topNames.length === 0) {
         // Fallback to any members
-        topNames.push(...members.slice(0, 3).map(m => m.name));
+        topNames.push(...members.slice(0, 3).map((m) => m.name));
     }
     const lines = [];
     // Frontmatter
@@ -473,7 +475,11 @@ const renderSkillMarkdown = (community, projectName, members, files, entryPoints
         lines.push('');
     }
     // How to Explore
-    const firstEntry = entryPoints.length > 0 ? entryPoints[0].name : (members.length > 0 ? members[0].name : community.label);
+    const firstEntry = entryPoints.length > 0
+        ? entryPoints[0].name
+        : members.length > 0
+            ? members[0].name
+            : community.label;
     lines.push('## How to Explore');
     lines.push('');
     lines.push(`1. \`gitnexus_context({name: "${firstEntry}"})\` \u2014 see callers and callees`);

package/dist/cli/wiki.d.ts

@@ -10,6 +10,8 @@ export interface WikiCommandOptions {
     model?: string;
     baseUrl?: string;
     apiKey?: string;
+    apiVersion?: string;
+    reasoningModel?: boolean;
     concurrency?: string;
     gist?: boolean;
     provider?: LLMProvider;

package/dist/cli/wiki.js

@@ -9,7 +9,7 @@ import readline from 'readline';
 import { execSync, execFileSync } from 'child_process';
 import cliProgress from 'cli-progress';
 import { getGitRoot, isGitRepo } from '../storage/git.js';
-import { getStoragePaths, loadMeta, loadCLIConfig, saveCLIConfig } from '../storage/repo-manager.js';
+import { getStoragePaths, loadMeta, loadCLIConfig, saveCLIConfig, } from '../storage/repo-manager.js';
 import { WikiGenerator } from '../core/wiki/generator.js';
 import { resolveLLMConfig } from '../core/wiki/llm-client.js';
 import { detectCursorCLI } from '../core/wiki/cursor-client.js';
@@ -101,7 +101,12 @@ export const wikiCommand = async (inputPath, options) => {
     }
     // ── Resolve LLM config (with interactive fallback) ─────────────────
     // Save any CLI overrides immediately
-    if (options?.apiKey || options?.model || options?.baseUrl || options?.provider) {
+    if (options?.apiKey ||
+        options?.model ||
+        options?.baseUrl ||
+        options?.provider ||
+        options?.apiVersion ||
+        options?.reasoningModel !== undefined) {
         const existing = await loadCLIConfig();
         const updates = {};
         if (options.apiKey)
@@ -110,6 +115,10 @@ export const wikiCommand = async (inputPath, options) => {
             updates.baseUrl = options.baseUrl;
         if (options.provider)
             updates.provider = options.provider;
+        if (options.apiVersion)
+            updates.apiVersion = options.apiVersion;
+        if (options.reasoningModel !== undefined)
+            updates.isReasoningModel = options.reasoningModel;
         // Save model to appropriate field based on provider
         if (options.model) {
             if (options.provider === 'cursor') {
@@ -123,13 +132,21 @@ export const wikiCommand = async (inputPath, options) => {
         console.log('  Config saved to ~/.gitnexus/config.json\n');
     }
     const savedConfig = await loadCLIConfig();
-    const hasSavedConfig = !!(savedConfig.provider === 'cursor' || (savedConfig.apiKey && savedConfig.baseUrl));
-    const hasCLIOverrides = !!(options?.apiKey || options?.model || options?.baseUrl || options?.provider);
+    const hasSavedConfig = !!(savedConfig.provider === 'cursor' ||
+        (savedConfig.apiKey && savedConfig.baseUrl));
+    const hasCLIOverrides = !!(options?.apiKey ||
+        options?.model ||
+        options?.baseUrl ||
+        options?.provider ||
+        options?.apiVersion ||
+        options?.reasoningModel !== undefined);
     let llmConfig = await resolveLLMConfig({
         model: options?.model,
         baseUrl: options?.baseUrl,
         apiKey: options?.apiKey,
         provider: options?.provider,
+        apiVersion: options?.apiVersion,
+        isReasoningModel: options?.reasoningModel,
     });
     // Run interactive setup if no saved config and no CLI flags provided
     // (even if env vars exist — let user explicitly choose their provider)
@@ -146,25 +163,26 @@ export const wikiCommand = async (inputPath, options) => {
             // Non-interactive with env var or cursor — just use it
         }
         else {
-            console.log('  No LLM configured. Let\'s set it up.\n');
-            console.log('  Supports OpenAI, OpenRouter, any OpenAI-compatible API, or Cursor CLI.\n');
+            console.log("  No LLM configured. Let's set it up.\n");
+            console.log('  Supports OpenAI, OpenRouter, Azure, any OpenAI-compatible API, or Cursor CLI.\n');
             // Check if Cursor CLI is available
             const hasCursor = detectCursorCLI();
             // Provider selection
             console.log('  [1] OpenAI (api.openai.com)');
             console.log('  [2] OpenRouter (openrouter.ai)');
-            console.log('  [3] Custom endpoint');
+            console.log('  [3] Azure OpenAI');
+            console.log('  [4] Custom endpoint');
             if (hasCursor) {
-                console.log('  [4] Cursor CLI (local, uses your Cursor subscription)');
+                console.log('  [5] Cursor CLI (local, uses your Cursor subscription)');
             }
             console.log('');
-            const maxChoice = hasCursor ? '4' : '3';
+            const maxChoice = hasCursor ? '5' : '4';
             const choice = await prompt(`  Select provider (1/${maxChoice}): `);
             let baseUrl;
             let defaultModel;
             let provider = 'openai';
             let key = '';
-            if (choice === '4' && hasCursor) {
+            if (choice === '5' && hasCursor) {
                 // Cursor CLI selected - model defaults to 'auto' (Cursor's default)
                 provider = 'cursor';
                 baseUrl = '';
@@ -178,13 +196,98 @@ export const wikiCommand = async (inputPath, options) => {
                 console.log('  Config saved to ~/.gitnexus/config.json\n');
                 llmConfig = { ...llmConfig, provider: 'cursor', model, apiKey: '', baseUrl: '' };
             }
+            else if (choice === '3') {
+                // Azure OpenAI guided setup
+                console.log('\n  Azure OpenAI setup.');
+                console.log('  You need: your resource name, deployment name, and API key from the Azure portal.\n');
+                const resourceName = (await prompt('  Azure resource name (e.g. my-openai-resource): ')).trim();
+                if (!resourceName) {
+                    console.log('\n  No resource name provided. Aborting.\n');
+                    process.exitCode = 1;
+                    return;
+                }
+                const deploymentName = (await prompt('  Deployment name (the name you gave your model deployment): ')).trim();
+                if (!deploymentName) {
+                    console.log('\n  No deployment name provided. Aborting.\n');
+                    process.exitCode = 1;
+                    return;
+                }
+                // Offer v1 or legacy URL
+                console.log('\n  API format:');
+                console.log('  [1] v1 API — recommended (no api-version needed)');
+                console.log('  [2] Legacy — uses api-version query param\n');
+                const apiFormat = await prompt('  Select format (1/2, default: 1): ');
+                let azureApiVersion;
+                let azureBaseUrl;
+                if (apiFormat === '2') {
+                    const versionInput = await prompt('  api-version (default: 2024-10-21): ');
+                    azureApiVersion = versionInput || '2024-10-21';
+                    azureBaseUrl = `https://${resourceName}.openai.azure.com/openai/deployments/${deploymentName}`;
+                }
+                else {
+                    azureBaseUrl = `https://${resourceName}.openai.azure.com/openai/v1`;
+                    azureApiVersion = undefined;
+                }
+                defaultModel = deploymentName;
+                // Ask if this is a reasoning model deployment
+                const reasoningAnswer = await prompt('  Is this a reasoning model (o1, o3, o4-mini)? (y/N): ');
+                const isReasoningModelDeployment = ['y', 'yes'].includes(reasoningAnswer.toLowerCase());
+                if (isReasoningModelDeployment) {
+                    console.log('  Note: temperature and max_tokens will be omitted for this deployment (Azure reasoning model requirement).\n');
+                }
+                const modelInput = await prompt(`  Model / deployment name (default: ${defaultModel}): `);
+                const model = modelInput || defaultModel;
+                // API key
+                const envKey = process.env.GITNEXUS_API_KEY || process.env.OPENAI_API_KEY || '';
+                let azureKey;
+                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') {
+                        azureKey = envKey;
+                    }
+                    else {
+                        azureKey = await prompt('  API key: ', true);
+                    }
+                }
+                else {
+                    azureKey = await prompt('  API key: ', true);
+                }
+                if (!azureKey) {
+                    console.log('\n  No key provided. Aborting.\n');
+                    process.exitCode = 1;
+                    return;
+                }
+                // Save Azure config including optional apiVersion and isReasoningModel
+                const azureConfig = {
+                    apiKey: azureKey,
+                    baseUrl: azureBaseUrl,
+                    model,
+                    provider: 'azure',
+                    isReasoningModel: isReasoningModelDeployment,
+                };
+                if (azureApiVersion)
+                    azureConfig.apiVersion = azureApiVersion;
+                await saveCLIConfig(azureConfig);
+                console.log('  Config saved to ~/.gitnexus/config.json\n');
+                llmConfig = {
+                    ...llmConfig,
+                    apiKey: azureKey,
+                    baseUrl: azureBaseUrl,
+                    model,
+                    provider: 'azure',
+                    apiVersion: azureApiVersion,
+                    isReasoningModel: isReasoningModelDeployment,
+                };
+            }
             else {
-                // OpenAI-compatible provider
+                // OpenAI-compatible provider (OpenAI, OpenRouter, Custom)
                 if (choice === '2') {
                     baseUrl = 'https://openrouter.ai/api/v1';
                     defaultModel = 'minimax/minimax-m2.5';
+                    provider = 'openrouter';
                 }
-                else if (choice === '3') {
+                else if (choice === '4') {
                     baseUrl = await prompt('  Base URL (e.g. http://localhost:11434/v1): ');
                     if (!baseUrl) {
                         console.log('\n  No URL provided. Aborting.\n');
@@ -192,10 +295,12 @@ export const wikiCommand = async (inputPath, options) => {
                         return;
                     }
                     defaultModel = 'gpt-4o-mini';
+                    provider = 'custom';
                 }
                 else {
                     baseUrl = 'https://api.openai.com/v1';
                     defaultModel = 'gpt-4o-mini';
+                    provider = 'openai';
                 }
                 // Model
                 const modelInput = await prompt(`  Model (default: ${defaultModel}): `);
@@ -221,9 +326,9 @@ export const wikiCommand = async (inputPath, options) => {
                     return;
                 }
                 // Save
-                await saveCLIConfig({ apiKey: key, baseUrl, model, provider: 'openai' });
+                await saveCLIConfig({ apiKey: key, baseUrl, model, provider });
                 console.log('  Config saved to ~/.gitnexus/config.json\n');
-                llmConfig = { ...llmConfig, apiKey: key, baseUrl, model, provider: 'openai' };
+                llmConfig = { ...llmConfig, apiKey: key, baseUrl, model, provider };
             }
         }
     }
@@ -282,7 +387,11 @@ export const wikiCommand = async (inputPath, options) => {
                     const prefix = '  '.repeat(indent + 2);
                     const fileCount = node.files?.length || 0;
                     const childCount = node.children?.length || 0;
-                    const suffix = fileCount > 0 ? ` (${fileCount} files)` : childCount > 0 ? ` (${childCount} children)` : '';
+                    const suffix = fileCount > 0
+                        ? ` (${fileCount} files)`
+                        : childCount > 0
+                            ? ` (${childCount} children)`
+                            : '';
                     console.log(`${prefix}- ${node.name}${suffix}`);
                     if (node.children && node.children.length > 0) {
                         printTree(node.children, indent + 1);
@@ -310,7 +419,7 @@ export const wikiCommand = async (inputPath, options) => {
                 console.log(`\n  Opening ${treeFile} in ${editor}...`);
                 console.log('  Save and close the editor when done.\n');
                 try {
-                    execSync(`${editor} "${treeFile}"`, { stdio: 'inherit' });
+                    execFileSync(editor, [treeFile], { stdio: 'inherit' });
                 }
                 catch {
                     console.log(`  Could not open editor. Please edit manually:\n  ${treeFile}\n`);
@@ -381,16 +490,26 @@ export const wikiCommand = async (inputPath, options) => {
         if (err.message?.includes('No source files')) {
             console.log(`\n  ${err.message}\n`);
         }
+        else if (err.message?.includes('content filter')) {
+            // Content filter block — actionable message
+            console.log(`\n  Content Filter: ${err.message}\n`);
+            console.log('  To resolve: rephrase your prompt or adjust the content filter policy for your deployment.\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');
+            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()); });
+                    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
@@ -420,14 +539,10 @@ function hasGhCLI() {
 }
 function publishGist(htmlPath) {
     try {
-        const output = execFileSync('gh', [
-            'gist', 'create', htmlPath,
-            '--desc', 'Repository Wiki — generated by GitNexus',
-            '--public',
-        ], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        const output = execFileSync('gh', ['gist', 'create', htmlPath, '--desc', 'Repository Wiki — generated by GitNexus', '--public'], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
         // gh gist create prints the gist URL as the last line
         const lines = output.split('\n');
-        const gistUrl = lines.find(l => l.includes('gist.github.com')) || lines[lines.length - 1];
+        const gistUrl = lines.find((l) => l.includes('gist.github.com')) || lines[lines.length - 1];
         if (!gistUrl || !gistUrl.includes('gist.github.com'))
             return null;
         // Build a raw viewer URL via gist.githack.com

package/dist/config/ignore-service.js

@@ -92,41 +92,122 @@ const DEFAULT_IGNORE_LIST = new Set([
 ]);
 const IGNORED_EXTENSIONS = new Set([
     // Images
-    '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico', '.webp', '.bmp', '.tiff', '.tif',
-    '.psd', '.ai', '.sketch', '.fig', '.xd',
+    '.png',
+    '.jpg',
+    '.jpeg',
+    '.gif',
+    '.svg',
+    '.ico',
+    '.webp',
+    '.bmp',
+    '.tiff',
+    '.tif',
+    '.psd',
+    '.ai',
+    '.sketch',
+    '.fig',
+    '.xd',
     // Archives
-    '.zip', '.tar', '.gz', '.rar', '.7z', '.bz2', '.xz', '.tgz',
+    '.zip',
+    '.tar',
+    '.gz',
+    '.rar',
+    '.7z',
+    '.bz2',
+    '.xz',
+    '.tgz',
     // Binary/Compiled
-    '.exe', '.dll', '.so', '.dylib', '.a', '.lib', '.o', '.obj',
-    '.class', '.jar', '.war', '.ear',
-    '.pyc', '.pyo', '.pyd',
+    '.exe',
+    '.dll',
+    '.so',
+    '.dylib',
+    '.a',
+    '.lib',
+    '.o',
+    '.obj',
+    '.class',
+    '.jar',
+    '.war',
+    '.ear',
+    '.pyc',
+    '.pyo',
+    '.pyd',
     '.beam', // Erlang
     '.wasm', // WebAssembly - important!
     '.node', // Native Node addons
     // Documents
-    '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
-    '.odt', '.ods', '.odp',
+    '.pdf',
+    '.doc',
+    '.docx',
+    '.xls',
+    '.xlsx',
+    '.ppt',
+    '.pptx',
+    '.odt',
+    '.ods',
+    '.odp',
     // Media
-    '.mp4', '.mp3', '.wav', '.mov', '.avi', '.mkv', '.flv', '.wmv',
-    '.ogg', '.webm', '.flac', '.aac', '.m4a',
+    '.mp4',
+    '.mp3',
+    '.wav',
+    '.mov',
+    '.avi',
+    '.mkv',
+    '.flv',
+    '.wmv',
+    '.ogg',
+    '.webm',
+    '.flac',
+    '.aac',
+    '.m4a',
     // Fonts
-    '.woff', '.woff2', '.ttf', '.eot', '.otf',
+    '.woff',
+    '.woff2',
+    '.ttf',
+    '.eot',
+    '.otf',
     // Databases
-    '.db', '.sqlite', '.sqlite3', '.mdb', '.accdb',
+    '.db',
+    '.sqlite',
+    '.sqlite3',
+    '.mdb',
+    '.accdb',
     // Minified/Bundled files
-    '.min.js', '.min.css', '.bundle.js', '.chunk.js',
+    '.min.js',
+    '.min.css',
+    '.bundle.js',
+    '.chunk.js',
     // Source maps (debug files, not source)
     '.map',
     // Lock files (handled separately, but also here)
     '.lock',
     // Certificates & Keys (security - don't index!)
-    '.pem', '.key', '.crt', '.cer', '.p12', '.pfx',
+    '.pem',
+    '.key',
+    '.crt',
+    '.cer',
+    '.p12',
+    '.pfx',
     // Data files (often large/binary)
-    '.csv', '.tsv', '.parquet', '.avro', '.feather',
-    '.npy', '.npz', '.pkl', '.pickle', '.h5', '.hdf5',
+    '.csv',
+    '.tsv',
+    '.parquet',
+    '.avro',
+    '.feather',
+    '.npy',
+    '.npz',
+    '.pkl',
+    '.pickle',
+    '.h5',
+    '.hdf5',
     // Misc binary
-    '.bin', '.dat', '.data', '.raw',
-    '.iso', '.img', '.dmg',
+    '.bin',
+    '.dat',
+    '.data',
+    '.raw',
+    '.iso',
+    '.img',
+    '.dmg',
 ]);
 // Files to ignore by exact name
 const IGNORED_FILES = new Set([
@@ -208,7 +289,8 @@ export const shouldIgnorePath = (filePath) => {
     if (fileNameLower.includes('.bundle.') ||
         fileNameLower.includes('.chunk.') ||
         fileNameLower.includes('.generated.') ||
-        fileNameLower.endsWith('.d.ts')) { // TypeScript declaration files
+        fileNameLower.endsWith('.d.ts')) {
+        // TypeScript declaration files
         return true;
     }
     return false;
@@ -222,9 +304,7 @@ export const loadIgnoreRules = async (repoPath, options) => {
     let hasRules = false;
     // Allow users to bypass .gitignore parsing (e.g. when .gitignore accidentally excludes source files)
     const skipGitignore = options?.noGitignore ?? !!process.env.GITNEXUS_NO_GITIGNORE;
-    const filenames = skipGitignore
-        ? ['.gitnexusignore']
-        : ['.gitignore', '.gitnexusignore'];
+    const filenames = skipGitignore ? ['.gitnexusignore'] : ['.gitignore', '.gitnexusignore'];
     for (const filename of filenames) {
         try {
             const content = await fs.readFile(nodePath.join(repoPath, filename), 'utf-8');