gitnexus 1.1.9 → 1.2.0

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

@@ -0,0 +1,111 @@
+/**
+ * LLM Client for Wiki Generation
+ *
+ * OpenAI-compatible API client using native fetch.
+ * Supports OpenAI, Azure, LiteLLM, Ollama, and any OpenAI-compatible endpoint.
+ *
+ * Config priority: CLI flags > env vars > defaults
+ */
+/**
+ * Resolve LLM configuration from env vars, saved config, and optional overrides.
+ * Priority: overrides (CLI flags) > env vars > ~/.gitnexus/config.json > error
+ *
+ * If no API key is found, returns config with empty apiKey (caller should handle).
+ */
+export async function resolveLLMConfig(overrides) {
+    const { loadCLIConfig } = await import('../../storage/repo-manager.js');
+    const savedConfig = await loadCLIConfig();
+    const apiKey = overrides?.apiKey
+        || process.env.GITNEXUS_API_KEY
+        || process.env.OPENAI_API_KEY
+        || savedConfig.apiKey
+        || '';
+    return {
+        apiKey,
+        baseUrl: overrides?.baseUrl
+            || process.env.GITNEXUS_LLM_BASE_URL
+            || savedConfig.baseUrl
+            || 'https://api.openai.com/v1',
+        model: overrides?.model
+            || process.env.GITNEXUS_MODEL
+            || savedConfig.model
+            || 'gpt-4o-mini',
+        maxTokens: overrides?.maxTokens ?? 16_384,
+        temperature: overrides?.temperature ?? 0,
+    };
+}
+/**
+ * Estimate token count from text (rough heuristic: ~4 chars per token).
+ */
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Call an OpenAI-compatible LLM API.
+ * Retries once on transient failures (5xx, network errors).
+ */
+export async function callLLM(prompt, config, systemPrompt) {
+    const messages = [];
+    if (systemPrompt) {
+        messages.push({ role: 'system', content: systemPrompt });
+    }
+    messages.push({ role: 'user', content: prompt });
+    const url = `${config.baseUrl.replace(/\/+$/, '')}/chat/completions`;
+    const body = {
+        model: config.model,
+        messages,
+        max_tokens: config.maxTokens,
+        temperature: config.temperature,
+    };
+    let lastError = null;
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${config.apiKey}`,
+                },
+                body: JSON.stringify(body),
+            });
+            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);
+                    continue;
+                }
+                // Server error — retry once
+                if (response.status >= 500 && attempt === 0) {
+                    await sleep(2000);
+                    continue;
+                }
+                throw new Error(`LLM API error (${response.status}): ${errorText.slice(0, 500)}`);
+            }
+            const json = await response.json();
+            const choice = json.choices?.[0];
+            if (!choice?.message?.content) {
+                throw new Error('LLM returned empty response');
+            }
+            return {
+                content: choice.message.content,
+                promptTokens: json.usage?.prompt_tokens,
+                completionTokens: json.usage?.completion_tokens,
+            };
+        }
+        catch (err) {
+            lastError = err;
+            // Network error — retry once
+            if (attempt === 0 && (err.code === 'ECONNREFUSED' || err.code === 'ETIMEDOUT' || err.message?.includes('fetch'))) {
+                await sleep(3000);
+                continue;
+            }
+            throw err;
+        }
+    }
+    throw lastError || new Error('LLM call failed after retries');
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

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

@@ -0,0 +1,53 @@
+/**
+ * LLM Prompt Templates for Wiki Generation
+ *
+ * All prompts produce deterministic, source-grounded documentation.
+ * Templates use {{PLACEHOLDER}} substitution.
+ */
+export declare const GROUPING_SYSTEM_PROMPT = "You are a documentation architect. Given a list of source files with their exported symbols, group them into logical documentation modules.\n\nRules:\n- Each module should represent a cohesive feature, layer, or domain\n- Every file must appear in exactly one module\n- Module names should be human-readable (e.g. \"Authentication\", \"Database Layer\", \"API Routes\")\n- Aim for 5-15 modules for a typical project. Fewer for small projects, more for large ones\n- Group by functionality, not by file type or directory structure alone\n- Do NOT create modules for tests, configs, or non-source files";
+export declare const GROUPING_USER_PROMPT = "Group these source files into documentation modules.\n\n**Files and their exports:**\n{{FILE_LIST}}\n\n**Directory structure:**\n{{DIRECTORY_TREE}}\n\nRespond with ONLY a JSON object mapping module names to file path arrays. No markdown, no explanation.\nExample format:\n{\n  \"Authentication\": [\"src/auth/login.ts\", \"src/auth/session.ts\"],\n  \"Database\": [\"src/db/connection.ts\", \"src/db/models.ts\"]\n}";
+export declare const MODULE_SYSTEM_PROMPT = "You are a technical documentation writer. Write clear, developer-focused documentation for a code module.\n\nRules:\n- Reference actual function names, class names, and code patterns \u2014 do NOT invent APIs\n- Use the call graph and execution flow data for accuracy, but do NOT mechanically list every edge\n- Include Mermaid diagrams only when they genuinely help understanding. Keep them small (5-10 nodes max)\n- Structure the document however makes sense for this module \u2014 there is no mandatory format\n- Write for a developer who needs to understand and contribute to this code";
+export declare const MODULE_USER_PROMPT = "Write documentation for the **{{MODULE_NAME}}** module.\n\n## Source Code\n\n{{SOURCE_CODE}}\n\n## Call Graph & Execution Flows (reference for accuracy)\n\nInternal calls: {{INTRA_CALLS}}\nOutgoing calls: {{OUTGOING_CALLS}}\nIncoming calls: {{INCOMING_CALLS}}\nExecution flows: {{PROCESSES}}\n\n---\n\nWrite comprehensive documentation for this module. Cover its purpose, how it works, its key components, and how it connects to the rest of the codebase. Use whatever structure best fits this module \u2014 you decide the sections and headings. Include a Mermaid diagram only if it genuinely clarifies the architecture.";
+export declare const PARENT_SYSTEM_PROMPT = "You are a technical documentation writer. Write a summary page for a module that contains sub-modules. Synthesize the children's documentation \u2014 do not re-read source code.\n\nRules:\n- Reference actual components from the child modules\n- Focus on how the sub-modules work together, not repeating their individual docs\n- Keep it concise \u2014 the reader can click through to child pages for detail\n- Include a Mermaid diagram only if it genuinely clarifies how the sub-modules relate";
+export declare const PARENT_USER_PROMPT = "Write documentation for the **{{MODULE_NAME}}** module, which contains these sub-modules:\n\n{{CHILDREN_DOCS}}\n\nCross-module calls: {{CROSS_MODULE_CALLS}}\nShared execution flows: {{CROSS_PROCESSES}}\n\n---\n\nWrite a concise overview of this module group. Explain its purpose, how the sub-modules fit together, and the key workflows that span them. Link to sub-module pages (e.g. `[Sub-module Name](sub-module-slug.md)`) rather than repeating their content. Use whatever structure fits best.";
+export declare const OVERVIEW_SYSTEM_PROMPT = "You are a technical documentation writer. Write the top-level overview page for a repository wiki. This is the first page a new developer sees.\n\nRules:\n- Be clear and welcoming \u2014 this is the entry point to the entire codebase\n- Reference actual module names so readers can navigate to their docs\n- Include a high-level Mermaid architecture diagram showing only the most important modules and their relationships (max 10 nodes). A new dev should grasp it in 10 seconds\n- Do NOT create module index tables or list every module with descriptions \u2014 just link to module pages naturally within the text\n- Use the inter-module edges and execution flow data for accuracy, but do NOT dump them raw";
+export declare const OVERVIEW_USER_PROMPT = "Write the overview page for this repository's wiki.\n\n## Project Info\n\n{{PROJECT_INFO}}\n\n## Module Summaries\n\n{{MODULE_SUMMARIES}}\n\n## Reference Data (for accuracy \u2014 do not reproduce verbatim)\n\nInter-module call edges: {{MODULE_EDGES}}\nKey system flows: {{TOP_PROCESSES}}\n\n---\n\nWrite a clear overview of this project: what it does, how it's architected, and the key end-to-end flows. Include a simple Mermaid architecture diagram (max 10 nodes, big-picture only). Link to module pages (e.g. `[Module Name](module-slug.md)`) naturally in the text rather than listing them in a table. If project config was provided, include brief setup instructions. Structure the page however reads best.";
+/**
+ * Replace {{PLACEHOLDER}} tokens in a template string.
+ */
+export declare function fillTemplate(template: string, vars: Record<string, string>): string;
+/**
+ * Format file list with exports for the grouping prompt.
+ */
+export declare function formatFileListForGrouping(files: Array<{
+    filePath: string;
+    symbols: Array<{
+        name: string;
+        type: string;
+    }>;
+}>): string;
+/**
+ * Build a directory tree string from file paths.
+ */
+export declare function formatDirectoryTree(filePaths: string[]): string;
+/**
+ * Format call edges as readable text.
+ */
+export declare function formatCallEdges(edges: Array<{
+    fromFile: string;
+    fromName: string;
+    toFile: string;
+    toName: string;
+}>): string;
+/**
+ * Format process traces as readable text.
+ */
+export declare function formatProcesses(processes: Array<{
+    label: string;
+    type: string;
+    steps: Array<{
+        step: number;
+        name: string;
+        filePath: string;
+    }>;
+}>): string;

package/dist/core/wiki/prompts.js

@@ -0,0 +1,174 @@
+/**
+ * LLM Prompt Templates for Wiki Generation
+ *
+ * All prompts produce deterministic, source-grounded documentation.
+ * Templates use {{PLACEHOLDER}} substitution.
+ */
+// ─── Grouping Prompt ──────────────────────────────────────────────────
+export const GROUPING_SYSTEM_PROMPT = `You are a documentation architect. Given a list of source files with their exported symbols, group them into logical documentation modules.
+
+Rules:
+- Each module should represent a cohesive feature, layer, or domain
+- Every file must appear in exactly one module
+- Module names should be human-readable (e.g. "Authentication", "Database Layer", "API Routes")
+- Aim for 5-15 modules for a typical project. Fewer for small projects, more for large ones
+- Group by functionality, not by file type or directory structure alone
+- Do NOT create modules for tests, configs, or non-source files`;
+export const GROUPING_USER_PROMPT = `Group these source files into documentation modules.
+
+**Files and their exports:**
+{{FILE_LIST}}
+
+**Directory structure:**
+{{DIRECTORY_TREE}}
+
+Respond with ONLY a JSON object mapping module names to file path arrays. No markdown, no explanation.
+Example format:
+{
+  "Authentication": ["src/auth/login.ts", "src/auth/session.ts"],
+  "Database": ["src/db/connection.ts", "src/db/models.ts"]
+}`;
+// ─── Leaf Module Prompt ───────────────────────────────────────────────
+export const MODULE_SYSTEM_PROMPT = `You are a technical documentation writer. Write clear, developer-focused documentation for a code module.
+
+Rules:
+- Reference actual function names, class names, and code patterns — do NOT invent APIs
+- Use the call graph and execution flow data for accuracy, but do NOT mechanically list every edge
+- Include Mermaid diagrams only when they genuinely help understanding. Keep them small (5-10 nodes max)
+- Structure the document however makes sense for this module — there is no mandatory format
+- Write for a developer who needs to understand and contribute to this code`;
+export const MODULE_USER_PROMPT = `Write documentation for the **{{MODULE_NAME}}** module.
+
+## Source Code
+
+{{SOURCE_CODE}}
+
+## Call Graph & Execution Flows (reference for accuracy)
+
+Internal calls: {{INTRA_CALLS}}
+Outgoing calls: {{OUTGOING_CALLS}}
+Incoming calls: {{INCOMING_CALLS}}
+Execution flows: {{PROCESSES}}
+
+---
+
+Write comprehensive documentation for this module. Cover its purpose, how it works, its key components, and how it connects to the rest of the codebase. Use whatever structure best fits this module — you decide the sections and headings. Include a Mermaid diagram only if it genuinely clarifies the architecture.`;
+// ─── Parent Module Prompt ─────────────────────────────────────────────
+export const PARENT_SYSTEM_PROMPT = `You are a technical documentation writer. Write a summary page for a module that contains sub-modules. Synthesize the children's documentation — do not re-read source code.
+
+Rules:
+- Reference actual components from the child modules
+- Focus on how the sub-modules work together, not repeating their individual docs
+- Keep it concise — the reader can click through to child pages for detail
+- Include a Mermaid diagram only if it genuinely clarifies how the sub-modules relate`;
+export const PARENT_USER_PROMPT = `Write documentation for the **{{MODULE_NAME}}** module, which contains these sub-modules:
+
+{{CHILDREN_DOCS}}
+
+Cross-module calls: {{CROSS_MODULE_CALLS}}
+Shared execution flows: {{CROSS_PROCESSES}}
+
+---
+
+Write a concise overview of this module group. Explain its purpose, how the sub-modules fit together, and the key workflows that span them. Link to sub-module pages (e.g. \`[Sub-module Name](sub-module-slug.md)\`) rather than repeating their content. Use whatever structure fits best.`;
+// ─── Overview Prompt ──────────────────────────────────────────────────
+export const OVERVIEW_SYSTEM_PROMPT = `You are a technical documentation writer. Write the top-level overview page for a repository wiki. This is the first page a new developer sees.
+
+Rules:
+- Be clear and welcoming — this is the entry point to the entire codebase
+- Reference actual module names so readers can navigate to their docs
+- Include a high-level Mermaid architecture diagram showing only the most important modules and their relationships (max 10 nodes). A new dev should grasp it in 10 seconds
+- Do NOT create module index tables or list every module with descriptions — just link to module pages naturally within the text
+- Use the inter-module edges and execution flow data for accuracy, but do NOT dump them raw`;
+export const OVERVIEW_USER_PROMPT = `Write the overview page for this repository's wiki.
+
+## Project Info
+
+{{PROJECT_INFO}}
+
+## Module Summaries
+
+{{MODULE_SUMMARIES}}
+
+## Reference Data (for accuracy — do not reproduce verbatim)
+
+Inter-module call edges: {{MODULE_EDGES}}
+Key system flows: {{TOP_PROCESSES}}
+
+---
+
+Write a clear overview of this project: what it does, how it's architected, and the key end-to-end flows. Include a simple Mermaid architecture diagram (max 10 nodes, big-picture only). Link to module pages (e.g. \`[Module Name](module-slug.md)\`) naturally in the text rather than listing them in a table. If project config was provided, include brief setup instructions. Structure the page however reads best.`;
+// ─── Template Substitution Helper ─────────────────────────────────────
+/**
+ * Replace {{PLACEHOLDER}} tokens in a template string.
+ */
+export function fillTemplate(template, vars) {
+    let result = template;
+    for (const [key, value] of Object.entries(vars)) {
+        result = result.replaceAll(`{{${key}}}`, value);
+    }
+    return result;
+}
+// ─── Formatting Helpers ───────────────────────────────────────────────
+/**
+ * Format file list with exports for the grouping prompt.
+ */
+export function formatFileListForGrouping(files) {
+    return files
+        .map(f => {
+        const exports = f.symbols.length > 0
+            ? f.symbols.map(s => `${s.name} (${s.type})`).join(', ')
+            : 'no exports';
+        return `- ${f.filePath}: ${exports}`;
+    })
+        .join('\n');
+}
+/**
+ * Build a directory tree string from file paths.
+ */
+export function formatDirectoryTree(filePaths) {
+    const dirs = new Set();
+    for (const fp of filePaths) {
+        const parts = fp.replace(/\\/g, '/').split('/');
+        for (let i = 1; i < parts.length; i++) {
+            dirs.add(parts.slice(0, i).join('/'));
+        }
+    }
+    const sorted = Array.from(dirs).sort();
+    if (sorted.length === 0)
+        return '(flat structure)';
+    return sorted.slice(0, 50).join('\n') + (sorted.length > 50 ? `\n... and ${sorted.length - 50} more directories` : '');
+}
+/**
+ * Format call edges as readable text.
+ */
+export function formatCallEdges(edges) {
+    if (edges.length === 0)
+        return 'None';
+    return edges
+        .slice(0, 30)
+        .map(e => `${e.fromName} (${shortPath(e.fromFile)}) → ${e.toName} (${shortPath(e.toFile)})`)
+        .join('\n');
+}
+/**
+ * Format process traces as readable text.
+ */
+export function formatProcesses(processes) {
+    if (processes.length === 0)
+        return 'No execution flows detected for this module.';
+    return processes
+        .map(p => {
+        const stepsText = p.steps
+            .map(s => `  ${s.step}. ${s.name} (${shortPath(s.filePath)})`)
+            .join('\n');
+        return `**${p.label}** (${p.type}):\n${stepsText}`;
+    })
+        .join('\n\n');
+}
+/**
+ * Shorten a file path for readability.
+ */
+function shortPath(fp) {
+    const parts = fp.replace(/\\/g, '/').split('/');
+    return parts.length > 3 ? parts.slice(-3).join('/') : fp;
+}

package/dist/mcp/core/embedder.js

@@ -27,8 +27,10 @@ export const initEmbedder = async () => {
         try {
             env.allowLocalModels = false;
             console.error('GitNexus: Loading embedding model (first search may take a moment)...');
-            // Try WebGPU first (Windows DirectX12), fall back to CPU
-            const devicesToTry = ['webgpu', 'cpu'];
+            // Try GPU first (DirectML on Windows, CUDA on Linux), fall back to CPU
+            const isWindows = process.platform === 'win32';
+            const gpuDevice = isWindows ? 'dml' : 'cuda';
+            const devicesToTry = [gpuDevice, 'cpu'];
             for (const device of devicesToTry) {
                 try {
                     // Silence stdout during model load — ONNX Runtime and transformers.js

package/dist/mcp/core/kuzu-adapter.d.ts

@@ -6,7 +6,8 @@
  * after idle timeout or when pool exceeds max size (LRU).
  */
 /**
- * Initialize (or reuse) a connection for a specific repo
+ * Initialize (or reuse) a connection for a specific repo.
+ * Retries on lock errors (e.g., when `gitnexus analyze` is running).
  */
 export declare const initKuzu: (repoId: string, dbPath: string) => Promise<void>;
 /**

package/dist/mcp/core/kuzu-adapter.js

@@ -65,8 +65,11 @@ function closeOne(repoId) {
     catch { }
     pool.delete(repoId);
 }
+const LOCK_RETRY_ATTEMPTS = 3;
+const LOCK_RETRY_DELAY_MS = 2000;
 /**
- * Initialize (or reuse) a connection for a specific repo
+ * Initialize (or reuse) a connection for a specific repo.
+ * Retries on lock errors (e.g., when `gitnexus analyze` is running).
  */
 export const initKuzu = async (repoId, dbPath) => {
     const existing = pool.get(repoId);
@@ -82,21 +85,38 @@ export const initKuzu = async (repoId, dbPath) => {
         throw new Error(`KuzuDB not found at ${dbPath}. Run: gitnexus analyze`);
     }
     evictLRU();
-    // Silence stdout during KuzuDB init — native module may write to stdout
-    // which corrupts the MCP stdio protocol.
-    const origWrite = process.stdout.write;
-    process.stdout.write = (() => true);
-    let db;
-    let conn;
-    try {
-        db = new kuzu.Database(dbPath);
-        conn = new kuzu.Connection(db);
-    }
-    finally {
-        process.stdout.write = origWrite;
+    // Open in read-only mode — MCP server never writes to the database.
+    // This allows multiple MCP server instances to read concurrently, and
+    // avoids lock conflicts when `gitnexus analyze` is writing.
+    let lastError = null;
+    for (let attempt = 1; attempt <= LOCK_RETRY_ATTEMPTS; attempt++) {
+        // Silence stdout during KuzuDB init — native module may write to stdout
+        // which corrupts the MCP stdio protocol.
+        const origWrite = process.stdout.write;
+        process.stdout.write = (() => true);
+        try {
+            const db = new kuzu.Database(dbPath, 0, // bufferManagerSize (default)
+            false, // enableCompression (default)
+            true);
+            const conn = new kuzu.Connection(db);
+            process.stdout.write = origWrite;
+            pool.set(repoId, { db, conn, lastUsed: Date.now(), dbPath });
+            ensureIdleTimer();
+            return;
+        }
+        catch (err) {
+            process.stdout.write = origWrite;
+            lastError = err instanceof Error ? err : new Error(String(err));
+            const isLockError = lastError.message.includes('Could not set lock')
+                || lastError.message.includes('lock');
+            if (!isLockError || attempt === LOCK_RETRY_ATTEMPTS)
+                break;
+            // Wait before retrying — analyze may be mid-rebuild
+            await new Promise(resolve => setTimeout(resolve, LOCK_RETRY_DELAY_MS * attempt));
+        }
     }
-    pool.set(repoId, { db, conn, lastUsed: Date.now(), dbPath });
-    ensureIdleTimer();
+    throw new Error(`KuzuDB unavailable for ${repoId}. Another process may be rebuilding the index. ` +
+        `Retry later. (${lastError?.message || 'unknown error'})`);
 };
 /**
  * Execute a query on a specific repo's connection

package/dist/mcp/local/local-backend.js

@@ -139,8 +139,15 @@ export class LocalBackend {
         const handle = this.repos.get(repoId);
         if (!handle)
             throw new Error(`Unknown repo: ${repoId}`);
-        await initKuzu(repoId, handle.kuzuPath);
-        this.initializedRepos.add(repoId);
+        try {
+            await initKuzu(repoId, handle.kuzuPath);
+            this.initializedRepos.add(repoId);
+        }
+        catch (err) {
+            // If lock error, mark as not initialized so next call retries
+            this.initializedRepos.delete(repoId);
+            throw err;
+        }
     }
     // ─── Public Getters ──────────────────────────────────────────────
     /**

package/dist/mcp/server.js

@@ -57,7 +57,7 @@ function getNextStepHint(toolName, args) {
 export async function startMCPServer(backend) {
     const server = new Server({
         name: 'gitnexus',
-        version: '1.1.0',
+        version: '1.1.9',
     }, {
         capabilities: {
             tools: {},

package/dist/storage/git.d.ts

@@ -1,6 +1,5 @@
 export declare const isGitRepo: (repoPath: string) => boolean;
 export declare const getCurrentCommit: (repoPath: string) => string;
-export declare const getStatusPorcelain: (repoPath: string) => string;
 /**
  * Find the git repository root from any path inside the repo
  */

package/dist/storage/git.js

@@ -1,4 +1,5 @@
 import { execSync } from 'child_process';
+// Git utilities for repository detection, commit tracking, and diff analysis
 export const isGitRepo = (repoPath) => {
     try {
         execSync('git rev-parse --is-inside-work-tree', { cwd: repoPath, stdio: 'ignore' });
@@ -16,14 +17,6 @@ export const getCurrentCommit = (repoPath) => {
         return '';
     }
 };
-export const getStatusPorcelain = (repoPath) => {
-    try {
-        return execSync('git status --porcelain', { cwd: repoPath }).toString();
-    }
-    catch {
-        return '';
-    }
-};
 /**
  * Find the git repository root from any path inside the repo
  */

package/dist/storage/repo-manager.d.ts

@@ -101,3 +101,20 @@ export declare const unregisterRepo: (repoPath: string) => Promise<void>;
 export declare const listRegisteredRepos: (opts?: {
     validate?: boolean;
 }) => Promise<RegistryEntry[]>;
+export interface CLIConfig {
+    apiKey?: string;
+    model?: string;
+    baseUrl?: string;
+}
+/**
+ * Get the path to the global CLI config file
+ */
+export declare const getGlobalConfigPath: () => string;
+/**
+ * Load CLI config from ~/.gitnexus/config.json
+ */
+export declare const loadCLIConfig: () => Promise<CLIConfig>;
+/**
+ * Save CLI config to ~/.gitnexus/config.json
+ */
+export declare const saveCLIConfig: (config: CLIConfig) => Promise<void>;

package/dist/storage/repo-manager.js

@@ -203,3 +203,29 @@ export const listRegisteredRepos = async (opts) => {
     }
     return valid;
 };
+/**
+ * Get the path to the global CLI config file
+ */
+export const getGlobalConfigPath = () => {
+    return path.join(getGlobalDir(), 'config.json');
+};
+/**
+ * Load CLI config from ~/.gitnexus/config.json
+ */
+export const loadCLIConfig = async () => {
+    try {
+        const raw = await fs.readFile(getGlobalConfigPath(), 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+};
+/**
+ * Save CLI config to ~/.gitnexus/config.json
+ */
+export const saveCLIConfig = async (config) => {
+    const dir = getGlobalDir();
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(getGlobalConfigPath(), JSON.stringify(config, null, 2), 'utf-8');
+};

package/package.json

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