gitnexus 1.0.0

package/README.md

@@ -0,0 +1,181 @@
+# GitNexus
+
+**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.
+
+[![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/)
+
+---
+
+## Why?
+
+AI coding tools don't understand your codebase structure. They edit a function without knowing 47 other functions depend on it. GitNexus fixes this by **precomputing every dependency, call chain, and relationship** into a queryable graph.
+
+**One command to index. One MCP connection to give your AI agent full codebase awareness.**
+
+## Quick Start
+
+```bash
+# Index your repository
+npx gitnexus analyze
+
+# Start MCP server (for Cursor, Claude Code, etc.)
+npx gitnexus mcp
+```
+
+Or install globally:
+
+```bash
+npm install -g gitnexus
+gitnexus analyze
+gitnexus mcp
+```
+
+## MCP Setup
+
+### Cursor / Windsurf
+
+Add to your MCP config (`.cursor/mcp.json` or equivalent):
+
+```json
+{
+  "mcpServers": {
+    "gitnexus": {
+      "command": "npx",
+      "args": ["-y", "gitnexus", "mcp"],
+      "env": {
+        "GITNEXUS_CWD": "/path/to/your/repo"
+      }
+    }
+  }
+}
+```
+
+### Claude Code
+
+```bash
+claude mcp add gitnexus -- npx -y gitnexus mcp
+```
+
+### OpenCode
+
+Add to your `opencode.json`:
+
+```json
+{
+  "mcp": {
+    "gitnexus": {
+      "command": "npx",
+      "args": ["-y", "gitnexus", "mcp"]
+    }
+  }
+}
+```
+
+## What It Does
+
+GitNexus indexes your codebase through 7 phases:
+
+1. **Structure** — File/folder tree
+2. **Parse** — AST extraction via Tree-sitter (9 languages)
+3. **Imports** — Resolve import paths (including TS path aliases, Rust modules, Java wildcards, Go packages)
+4. **Calls** — Function call resolution with confidence scoring (0.3-0.9)
+5. **Heritage** — Class extends/implements chains
+6. **Communities** — Leiden algorithm clusters related code into functional groups
+7. **Processes** — Entry point detection and execution flow tracing
+
+The result is a **KuzuDB graph database** stored locally in `.gitnexus/` with full-text search and semantic embeddings.
+
+## MCP Tools
+
+Your AI agent gets these tools automatically:
+
+| Tool | What It Does | Example |
+|------|-------------|---------|
+| `search` | Hybrid search (BM25 + semantic) with cluster context | "Find authentication logic" |
+| `overview` | List all clusters and processes | "Show me the codebase structure" |
+| `explore` | Deep dive on a symbol, cluster, or process | "Tell me about UserService" |
+| `impact` | Blast radius analysis | "What breaks if I change validateUser?" |
+| `cypher` | Raw Cypher graph queries | Complex relationship queries |
+| `read` | Smart file reader with fuzzy path matching | Read specific files |
+| `grep` | Regex pattern search | Find TODOs, error codes |
+
+## MCP Resources
+
+| Resource | Purpose |
+|----------|---------|
+| `gitnexus://context` | Codebase stats and overview |
+| `gitnexus://clusters` | All functional clusters |
+| `gitnexus://cluster/{name}` | Cluster members and details |
+| `gitnexus://processes` | All execution flows |
+| `gitnexus://process/{name}` | Full process trace |
+| `gitnexus://schema` | Graph schema for Cypher queries |
+
+## CLI Commands
+
+```bash
+gitnexus analyze [path]    # Index a repository (or update stale index)
+gitnexus analyze --force   # Force full re-index
+gitnexus mcp               # Start MCP server (stdio)
+gitnexus serve              # Start HTTP server for web UI
+gitnexus list              # List all indexed repositories
+gitnexus status            # Show index status for current repo
+gitnexus clean             # Delete index for current repo
+```
+
+## Supported Languages
+
+TypeScript, JavaScript, Python, Java, C, C++, C#, Go, Rust
+
+## How Impact Analysis Works
+
+```
+gitnexus_impact("UserService", "upstream")
+
+TARGET: Class UserService (src/services/user.ts)
+
+UPSTREAM (what depends on this):
+  Depth 1 (direct callers):
+    handleLogin [CALLS 90%] → src/api/auth.ts:45
+    handleRegister [CALLS 90%] → src/api/auth.ts:78
+  Depth 2:
+    authRouter [IMPORTS] → src/routes/auth.ts
+
+8 files affected, 3 clusters touched
+```
+
+Options: `maxDepth`, `minConfidence`, `relationTypes`, `includeTests`
+
+## Agent Skills
+
+GitNexus ships with skill files that teach AI agents how to use the tools effectively:
+
+- **Exploring** — Navigate unfamiliar code using the knowledge graph
+- **Debugging** — Trace bugs through call chains
+- **Impact Analysis** — Analyze blast radius before changes
+- **Refactoring** — Plan safe refactors using dependency mapping
+
+These are installed automatically to `.claude/skills/` when you run `gitnexus analyze`.
+
+## Requirements
+
+- Node.js >= 18
+- Git repository (uses git for commit tracking)
+
+## Privacy
+
+- All processing happens locally on your machine
+- No code is sent to any server
+- Index stored in `.gitnexus/` inside your repo (gitignored)
+
+## Web UI
+
+GitNexus also has a browser-based UI at [gitnexus.vercel.app](https://gitnexus.vercel.app) — 100% client-side, your code never leaves the browser.
+
+## License
+
+[PolyForm Noncommercial 1.0.0](https://polyformproject.org/licenses/noncommercial/1.0.0/)
+
+Free for non-commercial use. Contact for commercial licensing.

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

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ * CLAUDE.md is for Claude Code which only reads that file.
+ */
+interface RepoStats {
+    files?: number;
+    nodes?: number;
+    edges?: number;
+    communities?: number;
+    processes?: number;
+}
+/**
+ * Generate AI context files after indexing
+ */
+export declare function generateAIContextFiles(repoPath: string, _storagePath: string, projectName: string, stats: RepoStats): Promise<{
+    files: string[];
+}>;
+export {};

package/dist/cli/ai-context.js

@@ -0,0 +1,219 @@
+/**
+ * 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.
+ * CLAUDE.md is for Claude Code which only reads that file.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+// ESM equivalent of __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const GITNEXUS_START_MARKER = '<!-- gitnexus:start -->';
+const GITNEXUS_END_MARKER = '<!-- gitnexus:end -->';
+/**
+ * Generate the full GitNexus context content (resources-first approach)
+ */
+function generateGitNexusContent(projectName, stats) {
+    return `${GITNEXUS_START_MARKER}
+# GitNexus MCP
+
+This project is indexed by GitNexus, providing AI agents with deep code intelligence.
+
+## Project: ${projectName}
+
+| Metric | Count |
+|--------|-------|
+| Files | ${stats.files || 0} |
+| Symbols | ${stats.nodes || 0} |
+| Relationships | ${stats.edges || 0} |
+| Communities | ${stats.communities || 0} |
+| Processes | ${stats.processes || 0} |
+
+## Quick Start
+
+\`\`\`
+1. READ gitnexus://context        → Get codebase overview (~150 tokens)
+2. READ gitnexus://clusters       → See all functional clusters
+3. READ gitnexus://cluster/{name} → Deep dive on specific cluster
+4. gitnexus_search(query)         → Find code by query
+\`\`\`
+
+## Available Resources
+
+| Resource | Purpose |
+|----------|---------|
+| \`gitnexus://context\` | Codebase stats, tools, and resources overview |
+| \`gitnexus://clusters\` | All clusters with symbol counts and cohesion |
+| \`gitnexus://cluster/{name}\` | Cluster members and details |
+| \`gitnexus://processes\` | All execution flows with types |
+| \`gitnexus://process/{name}\` | Full process trace with steps |
+| \`gitnexus://schema\` | Graph schema for Cypher queries |
+
+## Available Tools
+
+| Tool | Purpose | When to Use |
+|------|---------|-------------|
+| \`search\` | Semantic + keyword search | Finding code by query |
+| \`overview\` | List clusters & processes | Understanding architecture |
+| \`explore\` | Deep dive on symbol/cluster/process | Detailed investigation |
+| \`impact\` | Blast radius analysis | Before making changes |
+| \`cypher\` | Raw graph queries | Complex analysis |
+
+## Workflow Examples
+
+### Exploring the Codebase
+\`\`\`
+READ gitnexus://context           → Stats and overview
+READ gitnexus://clusters          → Find relevant cluster
+READ gitnexus://cluster/Auth      → Explore Auth cluster
+gitnexus_explore("validateUser", "symbol") → Detailed symbol info
+\`\`\`
+
+### Planning a Change
+\`\`\`
+gitnexus_impact("UserService", "upstream") → See what breaks
+READ gitnexus://processes         → Check affected flows
+gitnexus_explore("LoginFlow", "process") → Trace execution
+\`\`\`
+
+## Graph Schema
+
+**Nodes:** File, Function, Class, Interface, Method, Community, Process
+
+**Relationships:** CALLS, IMPORTS, EXTENDS, IMPLEMENTS, DEFINES, MEMBER_OF, STEP_IN_PROCESS
+
+\`\`\`cypher
+// Example: Find callers of a function
+MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "myFunc"})
+RETURN caller.name, caller.filePath
+\`\`\`
+
+${GITNEXUS_END_MARKER}`;
+}
+/**
+ * Check if a file exists
+ */
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create or update GitNexus section in a file
+ * - If file doesn't exist: create with GitNexus content
+ * - If file exists without GitNexus section: append
+ * - If file exists with GitNexus section: replace that section
+ */
+async function upsertGitNexusSection(filePath, content) {
+    const exists = await fileExists(filePath);
+    if (!exists) {
+        await fs.writeFile(filePath, content, 'utf-8');
+        return 'created';
+    }
+    const existingContent = await fs.readFile(filePath, 'utf-8');
+    // Check if GitNexus section already exists
+    const startIdx = existingContent.indexOf(GITNEXUS_START_MARKER);
+    const endIdx = existingContent.indexOf(GITNEXUS_END_MARKER);
+    if (startIdx !== -1 && endIdx !== -1) {
+        // Replace existing section
+        const before = existingContent.substring(0, startIdx);
+        const after = existingContent.substring(endIdx + GITNEXUS_END_MARKER.length);
+        const newContent = before + content + after;
+        await fs.writeFile(filePath, newContent.trim() + '\n', 'utf-8');
+        return 'updated';
+    }
+    // Append new section
+    const newContent = existingContent.trim() + '\n\n' + content + '\n';
+    await fs.writeFile(filePath, newContent, 'utf-8');
+    return 'appended';
+}
+/**
+ * Install GitNexus skills to .claude/skills/gitnexus/
+ * Works natively with Claude Code, Cursor, and GitHub Copilot
+ */
+async function installSkills(repoPath) {
+    const skillsDir = path.join(repoPath, '.claude', 'skills', 'gitnexus');
+    const installedSkills = [];
+    // Skill definitions bundled with the package
+    const skills = [
+        {
+            name: 'exploring',
+            description: 'Navigate unfamiliar code using GitNexus knowledge graph',
+        },
+        {
+            name: 'debugging',
+            description: 'Trace bugs through call chains using knowledge graph',
+        },
+        {
+            name: 'impact-analysis',
+            description: 'Analyze blast radius before making code changes',
+        },
+        {
+            name: 'refactoring',
+            description: 'Plan safe refactors using blast radius and dependency mapping',
+        },
+    ];
+    for (const skill of skills) {
+        const skillDir = path.join(skillsDir, skill.name);
+        const skillPath = path.join(skillDir, 'SKILL.md');
+        try {
+            // Create skill directory
+            await fs.mkdir(skillDir, { recursive: true });
+            // Try to read from package skills directory
+            const packageSkillPath = path.join(__dirname, '..', '..', 'skills', `${skill.name}.md`);
+            let skillContent;
+            try {
+                skillContent = await fs.readFile(packageSkillPath, 'utf-8');
+            }
+            catch {
+                // Fallback: generate minimal skill content
+                skillContent = `---
+name: gitnexus-${skill.name}
+description: ${skill.description}
+---
+
+# ${skill.name.charAt(0).toUpperCase() + skill.name.slice(1)}
+
+${skill.description}
+
+Use GitNexus tools to accomplish this task.
+`;
+            }
+            await fs.writeFile(skillPath, skillContent, 'utf-8');
+            installedSkills.push(skill.name);
+        }
+        catch (err) {
+            // Skip on error, don't fail the whole process
+            console.warn(`Warning: Could not install skill ${skill.name}:`, err);
+        }
+    }
+    return installedSkills;
+}
+/**
+ * Generate AI context files after indexing
+ */
+export async function generateAIContextFiles(repoPath, _storagePath, projectName, stats) {
+    const content = generateGitNexusContent(projectName, stats);
+    const createdFiles = [];
+    // Create AGENTS.md (standard for Cursor, Windsurf, OpenCode, Cline, etc.)
+    const agentsPath = path.join(repoPath, 'AGENTS.md');
+    const agentsResult = await upsertGitNexusSection(agentsPath, content);
+    createdFiles.push(`AGENTS.md (${agentsResult})`);
+    // Create CLAUDE.md (for Claude Code)
+    const claudePath = path.join(repoPath, 'CLAUDE.md');
+    const claudeResult = await upsertGitNexusSection(claudePath, content);
+    createdFiles.push(`CLAUDE.md (${claudeResult})`);
+    // Install skills to .claude/skills/gitnexus/
+    const installedSkills = await installSkills(repoPath);
+    if (installedSkills.length > 0) {
+        createdFiles.push(`.claude/skills/gitnexus/ (${installedSkills.length} skills)`);
+    }
+    return { files: createdFiles };
+}

package/dist/cli/analyze.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Analyze Command
+ *
+ * Indexes a repository and stores the knowledge graph in .gitnexus/
+ */
+export interface AnalyzeOptions {
+    force?: boolean;
+    skipEmbeddings?: boolean;
+}
+export declare const analyzeCommand: (inputPath?: string, options?: AnalyzeOptions) => Promise<void>;

package/dist/cli/analyze.js

@@ -0,0 +1,118 @@
+/**
+ * Analyze Command
+ *
+ * Indexes a repository and stores the knowledge graph in .gitnexus/
+ */
+import path from 'path';
+import ora from 'ora';
+import { runPipelineFromRepo } from '../core/ingestion/pipeline.js';
+import { initKuzu, loadGraphToKuzu, getKuzuStats, executeQuery, executeWithReusedStatement, closeKuzu, createFTSIndex } from '../core/kuzu/kuzu-adapter.js';
+import { runEmbeddingPipeline } from '../core/embeddings/embedding-pipeline.js';
+import { getStoragePaths, saveMeta, loadMeta, addToGitignore } from '../storage/repo-manager.js';
+import { getCurrentCommit, isGitRepo, getGitRoot } from '../storage/git.js';
+import { generateAIContextFiles } from './ai-context.js';
+export const analyzeCommand = async (inputPath, options) => {
+    const spinner = ora('Checking repository...').start();
+    // If path provided, use it directly. Otherwise, find git root from cwd.
+    let repoPath;
+    if (inputPath) {
+        repoPath = path.resolve(inputPath);
+    }
+    else {
+        const gitRoot = getGitRoot(process.cwd());
+        if (!gitRoot) {
+            spinner.fail('Not inside a git repository');
+            process.exitCode = 1;
+            return;
+        }
+        repoPath = gitRoot;
+    }
+    if (!isGitRepo(repoPath)) {
+        spinner.fail('Not a git repository');
+        process.exitCode = 1;
+        return;
+    }
+    const { storagePath, kuzuPath } = getStoragePaths(repoPath);
+    const currentCommit = getCurrentCommit(repoPath);
+    const existingMeta = await loadMeta(storagePath);
+    // Skip if already indexed at same commit
+    if (existingMeta && !options?.force && existingMeta.lastCommit === currentCommit) {
+        spinner.succeed('Repository already up to date');
+        return;
+    }
+    // Run ingestion pipeline
+    spinner.text = 'Running ingestion pipeline...';
+    const pipelineResult = await runPipelineFromRepo(repoPath, (progress) => {
+        spinner.text = `${progress.phase}: ${progress.percent}%`;
+    });
+    // Load graph into KuzuDB
+    // Always start fresh - remove existing kuzu DB to avoid stale/corrupt data
+    spinner.text = 'Loading graph into KuzuDB...';
+    await closeKuzu();
+    // Kuzu 0.11 stores databases as: <name> (main file) + <name>.wal (WAL file)
+    // BOTH must be deleted or kuzu will find the orphaned WAL and corrupt the database
+    const fsClean = await import('fs/promises');
+    const kuzuFiles = [kuzuPath, `${kuzuPath}.wal`, `${kuzuPath}.lock`];
+    for (const f of kuzuFiles) {
+        try {
+            await fsClean.rm(f, { recursive: true, force: true });
+        }
+        catch { /* may not exist */ }
+    }
+    await initKuzu(kuzuPath);
+    await loadGraphToKuzu(pipelineResult.graph, pipelineResult.fileContents, storagePath);
+    // Create FTS indexes for keyword search
+    // Indexes searchable content on: File, Function, Class, Method
+    spinner.text = 'Creating FTS 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']);
+    }
+    catch (e) {
+        // FTS index creation may fail if tables are empty (no data for that type)
+        console.error('Note: Some FTS indexes may not have been created:', e.message);
+    }
+    // Generate embeddings
+    if (!options?.skipEmbeddings) {
+        spinner.text = 'Generating embeddings...';
+        await runEmbeddingPipeline(executeQuery, executeWithReusedStatement, (progress) => {
+            spinner.text = `Embeddings: ${progress.percent}%`;
+        });
+    }
+    // Save metadata
+    const stats = await getKuzuStats();
+    await saveMeta(storagePath, {
+        repoPath,
+        lastCommit: currentCommit,
+        indexedAt: new Date().toISOString(),
+        stats: {
+            files: pipelineResult.fileContents.size,
+            nodes: stats.nodes,
+            edges: stats.edges,
+            communities: pipelineResult.communityResult?.stats.totalCommunities,
+            processes: pipelineResult.processResult?.stats.totalProcesses,
+        },
+    });
+    // Add .gitnexus to .gitignore
+    await addToGitignore(repoPath);
+    // Generate AI context files
+    const projectName = path.basename(repoPath);
+    const aiContext = await generateAIContextFiles(repoPath, storagePath, projectName, {
+        files: pipelineResult.fileContents.size,
+        nodes: stats.nodes,
+        edges: stats.edges,
+        communities: pipelineResult.communityResult?.stats.totalCommunities,
+        processes: pipelineResult.processResult?.stats.totalProcesses,
+    });
+    // Close database
+    await closeKuzu();
+    spinner.succeed('Repository indexed successfully');
+    console.log(`  Path: ${repoPath}`);
+    console.log(`  Storage: ${storagePath}`);
+    console.log(`  Stats: ${stats.nodes} nodes, ${stats.edges} edges`);
+    if (aiContext.files.length > 0) {
+        console.log(`  AI Context: ${aiContext.files.join(', ')}`);
+    }
+};

package/dist/cli/clean.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Clean Command
+ *
+ * Removes the .gitnexus index from the current repository.
+ */
+export declare const cleanCommand: (options?: {
+    force?: boolean;
+}) => Promise<void>;

package/dist/cli/clean.js

@@ -0,0 +1,29 @@
+/**
+ * Clean Command
+ *
+ * Removes the .gitnexus index from the current repository.
+ */
+import fs from 'fs/promises';
+import { findRepo } from '../storage/repo-manager.js';
+export const cleanCommand = async (options) => {
+    const cwd = process.cwd();
+    const repo = await findRepo(cwd);
+    if (!repo) {
+        console.log('No indexed repository found in this directory.');
+        return;
+    }
+    const repoName = repo.repoPath.split(/[/\\]/).pop() || repo.repoPath;
+    if (!options?.force) {
+        console.log(`⚠️  This will delete the GitNexus index for: ${repoName}`);
+        console.log(`   Path: ${repo.storagePath}`);
+        console.log('\nRun with --force to confirm deletion.');
+        return;
+    }
+    try {
+        await fs.rm(repo.storagePath, { recursive: true, force: true });
+        console.log(`🗑️  Deleted: ${repo.storagePath}`);
+    }
+    catch (err) {
+        console.error('Failed to delete:', err);
+    }
+};

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { analyzeCommand } from './analyze.js';
+import { serveCommand } from './serve.js';
+import { listCommand } from './list.js';
+import { statusCommand } from './status.js';
+import { mcpCommand } from './mcp.js';
+import { cleanCommand } from './clean.js';
+const program = new Command();
+program
+    .name('gitnexus')
+    .description('GitNexus local CLI and MCP server')
+    .version('1.0.0');
+program
+    .command('analyze [path]')
+    .description('Index a repository (full analysis)')
+    .option('-f, --force', 'Force full re-index even if up to date')
+    .option('--skip-embeddings', 'Skip embedding generation (faster)')
+    .action(analyzeCommand);
+program
+    .command('serve')
+    .description('Start local HTTP server for web UI connection')
+    .option('-p, --port <port>', 'Port number', '4747')
+    .action(serveCommand);
+program
+    .command('mcp')
+    .description('Start MCP server (stdio)')
+    .action(mcpCommand);
+program
+    .command('list')
+    .description('List indexed repositories')
+    .action(listCommand);
+program
+    .command('status')
+    .description('Show index status for current repo')
+    .action(statusCommand);
+program
+    .command('clean')
+    .description('Delete GitNexus index for current repo')
+    .option('-f, --force', 'Skip confirmation prompt')
+    .action(cleanCommand);
+program.parse(process.argv);

package/dist/cli/list.d.ts

@@ -0,0 +1,6 @@
+/**
+ * List Command
+ *
+ * Shows info about the indexed repo in the current directory.
+ */
+export declare const listCommand: () => Promise<void>;

package/dist/cli/list.js

@@ -0,0 +1,27 @@
+/**
+ * List Command
+ *
+ * Shows info about the indexed repo in the current directory.
+ */
+import { findRepo } from '../storage/repo-manager.js';
+export const listCommand = async () => {
+    const cwd = process.cwd();
+    const repo = await findRepo(cwd);
+    if (!repo) {
+        console.log('No indexed repository found in this directory.');
+        console.log('Run `gitnexus analyze` to index your codebase.');
+        return;
+    }
+    const stats = repo.meta.stats || {};
+    const repoName = repo.repoPath.split(/[/\\]/).pop() || repo.repoPath;
+    const indexedDate = new Date(repo.meta.indexedAt).toLocaleString();
+    console.log(`\n📁 ${repoName}`);
+    console.log(`   Path: ${repo.repoPath}`);
+    console.log(`   Indexed: ${indexedDate}`);
+    console.log(`   Stats: ${stats.files ?? 0} files, ${stats.nodes ?? 0} nodes, ${stats.edges ?? 0} edges`);
+    console.log(`   Commit: ${repo.meta.lastCommit?.slice(0, 7) || 'unknown'}`);
+    if (stats.communities)
+        console.log(`   Communities: ${stats.communities}`);
+    if (stats.processes)
+        console.log(`   Processes: ${stats.processes}`);
+};

package/dist/cli/mcp.d.ts

@@ -0,0 +1,7 @@
+/**
+ * MCP Command
+ *
+ * Starts the MCP server in standalone mode using local .gitnexus/ index.
+ * Auto-detects repository by searching for .gitnexus/ folder.
+ */
+export declare const mcpCommand: () => Promise<void>;