gitnexus 1.4.7 → 1.4.9

package/README.md

@@ -2,7 +2,7 @@
 
 **Graph-powered code intelligence for AI agents.** Index any codebase into a knowledge graph, then query it via MCP or CLI.
 
-Works with **Cursor**, **Claude Code**, **Windsurf**, **Cline**, **OpenCode**, and any MCP-compatible tool.
+Works with **Cursor**, **Claude Code**, **Codex**, **Windsurf**, **Cline**, **OpenCode**, and any MCP-compatible tool.
 
 [![npm version](https://img.shields.io/npm/v/gitnexus.svg)](https://www.npmjs.com/package/gitnexus)
 [![License: PolyForm Noncommercial](https://img.shields.io/badge/License-PolyForm%20Noncommercial-blue.svg)](https://polyformproject.org/licenses/noncommercial/1.0.0/)
@@ -34,6 +34,7 @@ To configure MCP for your editor, run `npx gitnexus setup` once — or set it up
 |--------|-----|--------|---------------------|---------|
 | **Claude Code** | Yes | Yes | Yes (PreToolUse) | **Full** |
 | **Cursor** | Yes | Yes | — | MCP + Skills |
+| **Codex** | Yes | Yes | — | MCP + Skills |
 | **Windsurf** | Yes | — | — | MCP |
 | **OpenCode** | Yes | Yes | — | MCP + Skills |
 
@@ -52,7 +53,17 @@ If you prefer to configure manually instead of using `gitnexus setup`:
 ### Claude Code (full support — MCP + skills + hooks)
 
 ```bash
+# macOS / Linux
 claude mcp add gitnexus -- npx -y gitnexus@latest mcp
+
+# Windows
+claude mcp add gitnexus -- cmd /c npx -y gitnexus@latest mcp
+```
+
+### Codex (full support — MCP + skills)
+
+```bash
+codex mcp add gitnexus -- npx -y gitnexus@latest mcp
 ```
 
 ### Cursor / Windsurf
@@ -92,6 +103,8 @@ GitNexus builds a complete knowledge graph of your codebase through a multi-phas
 1. **Structure** — Walks the file tree and maps folder/file relationships
 2. **Parsing** — Extracts functions, classes, methods, and interfaces using Tree-sitter ASTs
 3. **Resolution** — Resolves imports and function calls across files with language-aware logic
+   - **Field & Property Type Resolution** — Tracks field types across classes and interfaces for deep chain resolution (e.g., `user.address.city.getName()`)
+   - **Return-Type-Aware Variable Binding** — Infers variable types from function return types, enabling accurate call-result binding
 4. **Clustering** — Groups related symbols into functional communities
 5. **Processes** — Traces execution flows from entry points through call chains
 6. **Search** — Builds hybrid search indexes for fast retrieval
@@ -143,6 +156,7 @@ gitnexus analyze --embeddings     # Enable embedding generation (slower, better
 gitnexus analyze --verbose        # Log skipped files when parsers are unavailable
 gitnexus mcp                     # Start MCP server (stdio) — serves all indexed repos
 gitnexus serve                   # Start local HTTP server (multi-repo) for web UI
+gitnexus index                   # Register an existing .gitnexus/ folder into the global registry
 gitnexus list                    # List all indexed repositories
 gitnexus status                  # Show index status for current repo
 gitnexus clean                   # Delete index for current repo
@@ -151,6 +165,20 @@ gitnexus wiki [path]             # Generate LLM-powered docs from knowledge grap
 gitnexus wiki --model <model>    # Wiki with custom LLM model (default: gpt-4o-mini)
 ```
 
+## Remote Embeddings
+
+Set these env vars to use a remote OpenAI-compatible `/v1/embeddings` endpoint instead of the local model:
+
+```bash
+export GITNEXUS_EMBEDDING_URL=http://your-server:8080/v1
+export GITNEXUS_EMBEDDING_MODEL=BAAI/bge-large-en-v1.5
+export GITNEXUS_EMBEDDING_DIMS=1024          # optional, default 384
+export GITNEXUS_EMBEDDING_API_KEY=your-key   # optional, default: "unused"
+gitnexus analyze . --embeddings
+```
+
+Works with Infinity, vLLM, TEI, llama.cpp, Ollama, LM Studio, or OpenAI. When unset, local embeddings are used unchanged.
+
 ## Multi-Repo Support
 
 GitNexus supports indexing multiple repositories. Each `gitnexus analyze` registers the repo in a global registry (`~/.gitnexus/registry.json`). The MCP server serves all indexed repos automatically.

package/dist/cli/ai-context.d.ts

@@ -2,7 +2,7 @@
  * AI Context Generator
  *
  * Creates AGENTS.md and CLAUDE.md with full inline GitNexus context.
- * AGENTS.md is the standard read by Cursor, Windsurf, OpenCode, Cline, etc.
+ * AGENTS.md is the standard read by Cursor, Windsurf, OpenCode, Codex, Cline, etc.
  * CLAUDE.md is for Claude Code which only reads that file.
  */
 import { type GeneratedSkillInfo } from './skill-gen.js';

package/dist/cli/ai-context.js

@@ -2,7 +2,7 @@
  * AI Context Generator
  *
  * Creates AGENTS.md and CLAUDE.md with full inline GitNexus context.
- * AGENTS.md is the standard read by Cursor, Windsurf, OpenCode, Cline, etc.
+ * AGENTS.md is the standard read by Cursor, Windsurf, OpenCode, Codex, Cline, etc.
  * CLAUDE.md is for Claude Code which only reads that file.
  */
 import fs from 'fs/promises';

package/dist/cli/analyze.d.ts

@@ -8,5 +8,7 @@ export interface AnalyzeOptions {
     embeddings?: boolean;
     skills?: boolean;
     verbose?: boolean;
+    /** Index the folder even when no .git directory is present. */
+    skipGit?: boolean;
 }
 export declare const analyzeCommand: (inputPath?: string, options?: AnalyzeOptions) => Promise<void>;

package/dist/cli/analyze.js

@@ -14,7 +14,7 @@ import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReuse
 // 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, isGitRepo, getGitRoot } from '../storage/git.js';
+import { getCurrentCommit, getGitRoot, hasGitDir } from '../storage/git.js';
 import { generateAIContextFiles } from './ai-context.js';
 import { generateSkillFiles } from './skill-gen.js';
 import fs from 'fs/promises';
@@ -70,17 +70,27 @@ export const analyzeCommand = async (inputPath, options) => {
     else {
         const gitRoot = getGitRoot(process.cwd());
         if (!gitRoot) {
-            console.log('  Not inside a git repository\n');
-            process.exitCode = 1;
-            return;
+            if (!options?.skipGit) {
+                console.log('  Not inside a git repository.\n  Tip: pass --skip-git to index any folder without a .git directory.\n');
+                process.exitCode = 1;
+                return;
+            }
+            // --skip-git: fall back to cwd as the root
+            repoPath = path.resolve(process.cwd());
+        }
+        else {
+            repoPath = gitRoot;
         }
-        repoPath = gitRoot;
     }
-    if (!isGitRepo(repoPath)) {
-        console.log('  Not a git repository\n');
+    const repoHasGit = hasGitDir(repoPath);
+    if (!repoHasGit && !options?.skipGit) {
+        console.log('  Not a git repository.\n  Tip: pass --skip-git to index any folder without a .git directory.\n');
         process.exitCode = 1;
         return;
     }
+    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.
@@ -88,11 +98,14 @@ export const analyzeCommand = async (inputPath, options) => {
     if (kuzuResult.found && kuzuResult.needsReindex) {
         console.log('  Migrating from KuzuDB to LadybugDB — rebuilding index...\n');
     }
-    const currentCommit = getCurrentCommit(repoPath);
+    const currentCommit = repoHasGit ? getCurrentCommit(repoPath) : '';
     const existingMeta = await loadMeta(storagePath);
     if (existingMeta && !options?.force && !options?.skills && existingMeta.lastCommit === currentCommit) {
-        console.log('  Already up to date\n');
-        return;
+        // Non-git folders have currentCommit = '' — always rebuild since we can't detect changes
+        if (currentCommit !== '') {
+            console.log('  Already up to date\n');
+            return;
+        }
     }
     if (process.env.GITNEXUS_NO_GITIGNORE) {
         console.log('  GITNEXUS_NO_GITIGNORE is set — skipping .gitignore (still reading .gitnexusignore)\n');
@@ -218,15 +231,26 @@ export const analyzeCommand = async (inputPath, options) => {
     const ftsTime = ((Date.now() - t0Fts) / 1000).toFixed(1);
     // ── Phase 3.5: Re-insert cached embeddings ────────────────────────
     if (cachedEmbeddings.length > 0) {
-        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);
+        // 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();
+        }
+        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);
+                }
+                catch { /* some may fail if node was removed, that's fine */ }
             }
-            catch { /* some may fail if node was removed, that's fine */ }
         }
     }
     // ── Phase 4: Embeddings (90–98%) ──────────────────────────────────
@@ -243,12 +267,16 @@ export const analyzeCommand = async (inputPath, options) => {
         }
     }
     if (!embeddingSkipped) {
-        updateBar(90, 'Loading embedding model...');
+        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' ? 'Loading embedding model...' : `Embedding ${progress.nodesProcessed || 0}/${progress.totalNodes || '?'}`;
+            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);
@@ -277,7 +305,12 @@ export const analyzeCommand = async (inputPath, options) => {
     };
     await saveMeta(storagePath, meta);
     await registerRepo(repoPath, meta);
-    await addToGitignore(repoPath);
+    // 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) {

package/dist/cli/index-repo.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Index Command
+ *
+ * Registers an existing .gitnexus/ folder into the global registry so the
+ * MCP server can discover the repo without running a full `gitnexus analyze`.
+ *
+ * Useful when a pre-built .gitnexus/ directory is already present (e.g. after
+ * cloning a repo that ships its index, restoring from backup, or using a
+ * shared team index).
+ */
+export interface IndexOptions {
+    force?: boolean;
+    allowNonGit?: boolean;
+}
+export declare const indexCommand: (inputPathParts?: string[], options?: IndexOptions) => Promise<void>;

package/dist/cli/index-repo.js

@@ -0,0 +1,115 @@
+/**
+ * Index Command
+ *
+ * Registers an existing .gitnexus/ folder into the global registry so the
+ * MCP server can discover the repo without running a full `gitnexus analyze`.
+ *
+ * Useful when a pre-built .gitnexus/ directory is already present (e.g. after
+ * 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";
+export const indexCommand = async (inputPathParts, options) => {
+    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("");
+            process.exitCode = 1;
+            return;
+        }
+    }
+    let repoPath;
+    if (inputPath) {
+        repoPath = path.resolve(inputPath);
+    }
+    else {
+        const gitRoot = getGitRoot(process.cwd());
+        if (!gitRoot) {
+            console.log("  Not inside a git repository, try to run git init\n");
+            process.exitCode = 1;
+            return;
+        }
+        repoPath = gitRoot;
+    }
+    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");
+        process.exitCode = 1;
+        return;
+    }
+    const { storagePath, lbugPath } = getStoragePaths(repoPath);
+    // ── Verify .gitnexus/ exists ──────────────────────────────────────
+    try {
+        await fs.access(storagePath);
+    }
+    catch {
+        console.log(`  No .gitnexus/ folder found at: ${storagePath}`);
+        console.log("  Run `gitnexus analyze` to build the index first.\n");
+        process.exitCode = 1;
+        return;
+    }
+    // ── Verify lbug database exists ───────────────────────────────────
+    try {
+        await fs.access(lbugPath);
+    }
+    catch {
+        console.log(`  .gitnexus/ folder exists but contains no LadybugDB index.`);
+        console.log("  Run `gitnexus analyze` to build the index.\n");
+        process.exitCode = 1;
+        return;
+    }
+    // ── Load or reconstruct meta ──────────────────────────────────────
+    let meta = await loadMeta(storagePath);
+    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");
+            process.exitCode = 1;
+            return;
+        }
+        // --force: build a minimal meta so the repo can be registered
+        meta = {
+            repoPath,
+            lastCommit: "",
+            indexedAt: new Date().toISOString(),
+        };
+    }
+    // ── Register in global registry ───────────────────────────────────
+    await registerRepo(repoPath, meta);
+    await addToGitignore(repoPath);
+    const projectName = path.basename(repoPath);
+    const { stats } = meta;
+    console.log(`  Repository registered: ${projectName}`);
+    if (stats) {
+        const parts = [];
+        if (stats.nodes != null) {
+            parts.push(`${stats.nodes.toLocaleString()} nodes`);
+        }
+        if (stats.edges != null) {
+            parts.push(`${stats.edges.toLocaleString()} edges`);
+        }
+        if (stats.communities != null)
+            parts.push(`${stats.communities} clusters`);
+        if (stats.processes != null)
+            parts.push(`${stats.processes} flows`);
+        if (parts.length)
+            console.log(`  ${parts.join(" | ")}`);
+    }
+    console.log(`  ${repoPath}`);
+    console.log("");
+};

package/dist/cli/index.js

@@ -13,7 +13,7 @@ program
     .version(pkg.version);
 program
     .command('setup')
-    .description('One-time setup: configure MCP for Cursor, Claude Code, OpenCode')
+    .description('One-time setup: configure MCP for Cursor, Claude Code, OpenCode, Codex')
     .action(createLazyAction(() => import('./setup.js'), 'setupCommand'));
 program
     .command('analyze [path]')
@@ -21,9 +21,16 @@ 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-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)')
     .action(createLazyAction(() => import('./analyze.js'), 'analyzeCommand'));
+program
+    .command('index [path...]')
+    .description('Register an existing .gitnexus/ folder into the global registry (no re-analysis needed)')
+    .option('-f, --force', 'Register even if meta.json is missing (stats will be empty)')
+    .option('--allow-non-git', 'Allow registering folders that are not Git repositories')
+    .action(createLazyAction(() => import('./index-repo.js'), 'indexCommand'));
 program
     .command('serve')
     .description('Start local HTTP server for web UI connection')
@@ -52,11 +59,14 @@ program
     .command('wiki [path]')
     .description('Generate repository wiki from knowledge graph')
     .option('-f, --force', 'Force full regeneration even if up to date')
-    .option('--model <model>', 'LLM model name (default: minimax/minimax-m2.5)')
-    .option('--base-url <url>', 'LLM API base URL (default: OpenAI)')
+    .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('--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)')
+    .option('--review', 'Stop after grouping to review module structure before generating pages')
     .action(createLazyAction(() => import('./wiki.js'), 'wikiCommand'));
 program
     .command('augment <pattern>')

package/dist/cli/setup.js

@@ -8,11 +8,14 @@
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
 import { fileURLToPath } from 'url';
 import { glob } from 'glob';
 import { getGlobalDir } from '../storage/repo-manager.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+const execFileAsync = promisify(execFile);
 /**
  * The MCP server entry for all editors.
  * On Windows, npx must be invoked via cmd /c since it's a .cmd script.
@@ -94,18 +97,21 @@ async function setupCursor(result) {
 }
 async function setupClaudeCode(result) {
     const claudeDir = path.join(os.homedir(), '.claude');
-    const hasClaude = await dirExists(claudeDir);
-    if (!hasClaude) {
+    if (!(await dirExists(claudeDir))) {
         result.skipped.push('Claude Code (not installed)');
         return;
     }
-    // Claude Code uses a JSON settings file at ~/.claude.json or claude mcp add
-    console.log('');
-    console.log('  Claude Code detected. Run this command to add GitNexus MCP:');
-    console.log('');
-    console.log('    claude mcp add gitnexus -- npx -y gitnexus mcp');
-    console.log('');
-    result.configured.push('Claude Code (MCP manual step printed)');
+    // Claude Code stores MCP config in ~/.claude.json
+    const mcpPath = path.join(os.homedir(), '.claude.json');
+    try {
+        const existing = await readJsonFile(mcpPath);
+        const updated = mergeMcpConfig(existing);
+        await writeJsonFile(mcpPath, updated);
+        result.configured.push('Claude Code');
+    }
+    catch (err) {
+        result.errors.push(`Claude Code: ${err.message}`);
+    }
 }
 /**
  * Install GitNexus skills to ~/.claude/skills/ for Claude Code.
@@ -201,11 +207,65 @@ async function setupOpenCode(result) {
         result.errors.push(`OpenCode: ${err.message}`);
     }
 }
+/**
+ * Build a TOML section for Codex MCP config (~/.codex/config.toml).
+ */
+function getCodexMcpTomlSection() {
+    const entry = getMcpEntry();
+    const command = JSON.stringify(entry.command);
+    const args = `[${entry.args.map(arg => JSON.stringify(arg)).join(', ')}]`;
+    return `[mcp_servers.gitnexus]\ncommand = ${command}\nargs = ${args}\n`;
+}
+/**
+ * Append GitNexus MCP server config to Codex's config.toml if missing.
+ */
+async function upsertCodexConfigToml(configPath) {
+    let existing = '';
+    try {
+        existing = await fs.readFile(configPath, 'utf-8');
+    }
+    catch {
+        existing = '';
+    }
+    if (existing.includes('[mcp_servers.gitnexus]')) {
+        return;
+    }
+    const section = getCodexMcpTomlSection();
+    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');
+}
+async function setupCodex(result) {
+    const codexDir = path.join(os.homedir(), '.codex');
+    if (!(await dirExists(codexDir))) {
+        result.skipped.push('Codex (not installed)');
+        return;
+    }
+    try {
+        const entry = getMcpEntry();
+        await execFileAsync('codex', ['mcp', 'add', 'gitnexus', '--', entry.command, ...entry.args], { shell: process.platform === 'win32' });
+        result.configured.push('Codex');
+        return;
+    }
+    catch {
+        // Fallback for environments where `codex` binary isn't on PATH.
+    }
+    try {
+        const configPath = path.join(codexDir, 'config.toml');
+        await upsertCodexConfigToml(configPath);
+        result.configured.push('Codex (MCP added to ~/.codex/config.toml)');
+    }
+    catch (err) {
+        result.errors.push(`Codex: ${err.message}`);
+    }
+}
 // ─── Skill Installation ───────────────────────────────────────────
 /**
  * Install GitNexus skills to a target directory.
  * Each skill is installed as {targetDir}/gitnexus-{skillName}/SKILL.md
- * following the Agent Skills standard (both Cursor and Claude Code).
+ * following the Agent Skills standard (Cursor, Claude Code, and Codex).
  *
  * Supports two source layouts:
  *   - Flat file:  skills/{name}.md           → copied as SKILL.md
@@ -310,6 +370,24 @@ async function installOpenCodeSkills(result) {
         result.errors.push(`OpenCode skills: ${err.message}`);
     }
 }
+/**
+ * Install global Codex skills to ~/.agents/skills/gitnexus/
+ */
+async function installCodexSkills(result) {
+    const codexDir = path.join(os.homedir(), '.codex');
+    if (!(await dirExists(codexDir)))
+        return;
+    const skillsDir = path.join(os.homedir(), '.agents', 'skills');
+    try {
+        const installed = await installSkillsTo(skillsDir);
+        if (installed.length > 0) {
+            result.configured.push(`Codex skills (${installed.length} skills → ~/.agents/skills/)`);
+        }
+    }
+    catch (err) {
+        result.errors.push(`Codex skills: ${err.message}`);
+    }
+}
 // ─── Main command ──────────────────────────────────────────────────
 export const setupCommand = async () => {
     console.log('');
@@ -328,11 +406,13 @@ export const setupCommand = async () => {
     await setupCursor(result);
     await setupClaudeCode(result);
     await setupOpenCode(result);
+    await setupCodex(result);
     // Install global skills for platforms that support them
     await installClaudeCodeSkills(result);
     await installClaudeCodeHooks(result);
     await installCursorSkills(result);
     await installOpenCodeSkills(result);
+    await installCodexSkills(result);
     // Print results
     if (result.configured.length > 0) {
         console.log('  Configured:');

package/dist/cli/wiki.d.ts

@@ -4,6 +4,7 @@
  * Generates repository documentation from the knowledge graph.
  * Usage: gitnexus wiki [path] [options]
  */
+import { type LLMProvider } from '../core/wiki/llm-client.js';
 export interface WikiCommandOptions {
     force?: boolean;
     model?: string;
@@ -11,5 +12,8 @@ export interface WikiCommandOptions {
     apiKey?: string;
     concurrency?: string;
     gist?: boolean;
+    provider?: LLMProvider;
+    verbose?: boolean;
+    review?: boolean;
 }
 export declare const wikiCommand: (inputPath?: string, options?: WikiCommandOptions) => Promise<void>;