@veewo/gitnexus 1.3.4

package/dist/cli/index.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+// Raise Node heap limit for large repos (e.g. Linux kernel).
+// Must run before any heavy allocation. If already set by the user, respect it.
+if (!process.env.NODE_OPTIONS?.includes('--max-old-space-size')) {
+    const execArgv = process.execArgv.join(' ');
+    if (!execArgv.includes('--max-old-space-size')) {
+        // Re-spawn with a larger heap (8 GB)
+        const { execFileSync } = await import('node:child_process');
+        try {
+            execFileSync(process.execPath, ['--max-old-space-size=8192', ...process.argv.slice(1)], {
+                stdio: 'inherit',
+                env: { ...process.env, NODE_OPTIONS: `${process.env.NODE_OPTIONS || ''} --max-old-space-size=8192`.trim() },
+            });
+            process.exit(0);
+        }
+        catch (e) {
+            // If the child exited with an error code, propagate it
+            process.exit(e.status ?? 1);
+        }
+    }
+}
+import { Command } from 'commander';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+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';
+import { setupCommand } from './setup.js';
+import { augmentCommand } from './augment.js';
+import { wikiCommand } from './wiki.js';
+import { queryCommand, contextCommand, impactCommand, cypherCommand } from './tool.js';
+import { evalServerCommand } from './eval-server.js';
+import { benchmarkUnityCommand } from './benchmark-unity.js';
+import { benchmarkAgentContextCommand } from './benchmark-agent-context.js';
+function resolveCliVersion() {
+    try {
+        const currentFile = fileURLToPath(import.meta.url);
+        const packageJsonPath = path.resolve(path.dirname(currentFile), '..', '..', 'package.json');
+        const raw = fs.readFileSync(packageJsonPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.version === 'string' && parsed.version.length > 0) {
+            return parsed.version;
+        }
+    }
+    catch {
+        // fall through to default
+    }
+    return '0.0.0';
+}
+const program = new Command();
+const collectValues = (value, previous) => [...previous, value];
+program
+    .name('gitnexus')
+    .description('GitNexus local CLI and MCP server')
+    .version(resolveCliVersion());
+program
+    .command('setup')
+    .description('One-time setup: configure MCP for Cursor, Claude Code, OpenCode')
+    .action(setupCommand);
+program
+    .command('analyze [path]')
+    .description('Index a repository (full analysis)')
+    .option('-f, --force', 'Force full re-index even if up to date')
+    .option('--embeddings', 'Enable embedding generation for semantic search (off by default)')
+    .option('--extensions <list>', 'Comma-separated file extensions to include (e.g. .cs,.ts)')
+    .option('--repo-alias <name>', 'Override indexed repository name with a stable alias')
+    .option('--scope-manifest <path>', 'Manifest file with scope rules (supports comments and * wildcard)')
+    .option('--scope-prefix <pathPrefix>', 'Add a scope path prefix rule (repeatable)', collectValues, [])
+    .action(analyzeCommand);
+program
+    .command('serve')
+    .description('Start local HTTP server for web UI connection')
+    .option('-p, --port <port>', 'Port number', '4747')
+    .option('--host <host>', 'Bind address (default: 127.0.0.1, use 0.0.0.0 for remote access)')
+    .action(serveCommand);
+program
+    .command('mcp')
+    .description('Start MCP server (stdio) — serves all indexed repos')
+    .action(mcpCommand);
+program
+    .command('list')
+    .description('List all 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')
+    .option('--all', 'Clean all indexed repos')
+    .action(cleanCommand);
+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('--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')
+    .action(wikiCommand);
+program
+    .command('augment <pattern>')
+    .description('Augment a search pattern with knowledge graph context (used by hooks)')
+    .action(augmentCommand);
+// ─── Direct Tool Commands (no MCP overhead) ────────────────────────
+// These invoke LocalBackend directly for use in eval, scripts, and CI.
+program
+    .command('query <search_query>')
+    .description('Search the knowledge graph for execution flows related to a concept')
+    .option('-r, --repo <name>', 'Target repository (omit if only one indexed)')
+    .option('-c, --context <text>', 'Task context to improve ranking')
+    .option('-g, --goal <text>', 'What you want to find')
+    .option('-l, --limit <n>', 'Max processes to return (default: 5)')
+    .option('--content', 'Include full symbol source code')
+    .action(queryCommand);
+program
+    .command('context [name]')
+    .description('360-degree view of a code symbol: callers, callees, processes')
+    .option('-r, --repo <name>', 'Target repository')
+    .option('-u, --uid <uid>', 'Direct symbol UID (zero-ambiguity lookup)')
+    .option('-f, --file <path>', 'File path to disambiguate common names')
+    .option('--content', 'Include full symbol source code')
+    .action(contextCommand);
+program
+    .command('impact <target>')
+    .description('Blast radius analysis: what breaks if you change a symbol')
+    .option('-d, --direction <dir>', 'upstream (dependants) or downstream (dependencies)', 'upstream')
+    .option('-r, --repo <name>', 'Target repository')
+    .option('-u, --uid <uid>', 'Exact target UID (disambiguates same-name symbols)')
+    .option('-f, --file <path>', 'File path filter to disambiguate target name')
+    .option('--depth <n>', 'Max relationship depth (default: 3)')
+    .option('--min-confidence <n>', 'Minimum edge confidence 0-1 (default: 0.3)')
+    .option('--include-tests', 'Include test files in results')
+    .action(impactCommand);
+program
+    .command('cypher <query>')
+    .description('Execute raw Cypher query against the knowledge graph')
+    .option('-r, --repo <name>', 'Target repository')
+    .action(cypherCommand);
+// ─── Eval Server (persistent daemon for SWE-bench) ─────────────────
+program
+    .command('eval-server')
+    .description('Start lightweight HTTP server for fast tool calls during evaluation')
+    .option('-p, --port <port>', 'Port number', '4848')
+    .option('--idle-timeout <seconds>', 'Auto-shutdown after N seconds idle (0 = disabled)', '0')
+    .action(evalServerCommand);
+program
+    .command('benchmark-unity <dataset>')
+    .description('Run Unity accuracy baseline and hard-gated regression checks')
+    .option('-p, --profile <profile>', 'quick or full', 'quick')
+    .option('-r, --repo <name>', 'Target indexed repo')
+    .option('--repo-alias <name>', 'Analyze-time repo alias and default evaluation repo when --repo is omitted')
+    .option('--target-path <path>', 'Path to analyze before evaluation (required unless --skip-analyze)')
+    .option('--report-dir <path>', 'Output directory for benchmark-report.json and benchmark-summary.md', '.gitnexus/benchmark')
+    .option('--extensions <list>', 'Analyze extension filter (default: .cs)', '.cs')
+    .option('--scope-manifest <path>', 'Analyze scope manifest file')
+    .option('--scope-prefix <pathPrefix>', 'Analyze scope path prefix (repeatable)', collectValues, [])
+    .option('--skip-analyze', 'Skip analyze stage and evaluate current index only')
+    .action(benchmarkUnityCommand);
+program
+    .command('benchmark-agent-context <dataset>')
+    .description('Run scenario-based agent refactor context benchmark')
+    .option('-p, --profile <profile>', 'quick or full', 'quick')
+    .option('-r, --repo <name>', 'Target indexed repo')
+    .option('--repo-alias <name>', 'Analyze-time repo alias and default evaluation repo when --repo is omitted')
+    .option('--target-path <path>', 'Path to analyze before evaluation (required unless --skip-analyze)')
+    .option('--report-dir <path>', 'Output directory for benchmark-report.json and benchmark-summary.md', '.gitnexus/benchmark-agent-context')
+    .option('--extensions <list>', 'Analyze extension filter (default: .cs)', '.cs')
+    .option('--scope-manifest <path>', 'Analyze scope manifest file')
+    .option('--scope-prefix <pathPrefix>', 'Analyze scope path prefix (repeatable)', collectValues, [])
+    .option('--skip-analyze', 'Skip analyze stage and evaluate current index only')
+    .action(async (dataset, options) => {
+    await benchmarkAgentContextCommand(dataset, options);
+});
+program.parse(process.argv);

package/dist/cli/list.d.ts

@@ -0,0 +1,6 @@
+/**
+ * List Command
+ *
+ * Shows all indexed repositories from the global registry.
+ */
+export declare const listCommand: () => Promise<void>;

package/dist/cli/list.js

@@ -0,0 +1,33 @@
+/**
+ * List Command
+ *
+ * Shows all indexed repositories from the global registry.
+ */
+import { listRegisteredRepos } from '../storage/repo-manager.js';
+export const listCommand = async () => {
+    const entries = await listRegisteredRepos({ validate: true });
+    if (entries.length === 0) {
+        console.log('No indexed repositories found.');
+        console.log('Run `gitnexus analyze` in a git repo to index it.');
+        return;
+    }
+    console.log(`\n  Indexed Repositories (${entries.length})\n`);
+    for (const entry of entries) {
+        const indexedDate = new Date(entry.indexedAt).toLocaleString();
+        const stats = entry.stats || {};
+        const commitShort = entry.lastCommit?.slice(0, 7) || 'unknown';
+        console.log(`  ${entry.name}`);
+        console.log(`    Path:    ${entry.path}`);
+        if (entry.alias) {
+            console.log(`    Alias:   ${entry.alias} (source: ${entry.sourceName || 'unknown'})`);
+        }
+        console.log(`    Indexed: ${indexedDate}`);
+        console.log(`    Commit:  ${commitShort}`);
+        console.log(`    Stats:   ${stats.files ?? 0} files, ${stats.nodes ?? 0} symbols, ${stats.edges ?? 0} edges`);
+        if (stats.communities)
+            console.log(`    Clusters:   ${stats.communities}`);
+        if (stats.processes)
+            console.log(`    Processes:  ${stats.processes}`);
+        console.log('');
+    }
+};

package/dist/cli/mcp.d.ts

@@ -0,0 +1,8 @@
+/**
+ * MCP Command
+ *
+ * Starts the MCP server in standalone mode.
+ * Loads all indexed repos from the global registry.
+ * No longer depends on cwd — works from any directory.
+ */
+export declare const mcpCommand: () => Promise<void>;

package/dist/cli/mcp.js

@@ -0,0 +1,34 @@
+/**
+ * MCP Command
+ *
+ * Starts the MCP server in standalone mode.
+ * Loads all indexed repos from the global registry.
+ * No longer depends on cwd — works from any directory.
+ */
+import { startMCPServer } from '../mcp/server.js';
+import { LocalBackend } from '../mcp/local/local-backend.js';
+export const mcpCommand = async () => {
+    // Prevent unhandled errors from crashing the MCP server process.
+    // KuzuDB lock conflicts and transient errors should degrade gracefully.
+    process.on('uncaughtException', (err) => {
+        console.error(`GitNexus MCP: uncaught exception — ${err.message}`);
+    });
+    process.on('unhandledRejection', (reason) => {
+        const msg = reason instanceof Error ? reason.message : String(reason);
+        console.error(`GitNexus MCP: unhandled rejection — ${msg}`);
+    });
+    // Initialize multi-repo backend from registry.
+    // The server starts even with 0 repos — tools call refreshRepos() lazily,
+    // so repos indexed after the server starts are discovered automatically.
+    const backend = new LocalBackend();
+    await backend.init();
+    const repos = await backend.listRepos();
+    if (repos.length === 0) {
+        console.error('GitNexus: No indexed repos yet. Run `gitnexus analyze` in a git repo — the server will pick it up automatically.');
+    }
+    else {
+        console.error(`GitNexus: MCP server starting with ${repos.length} repo(s): ${repos.map(r => r.name).join(', ')}`);
+    }
+    // Start MCP server (serves all repos, discovers new ones lazily)
+    await startMCPServer(backend);
+};

package/dist/cli/repo-manager-alias.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/repo-manager-alias.test.js

@@ -0,0 +1,40 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { readRegistry, registerRepo } from '../storage/repo-manager.js';
+function makeMeta(repoPath, lastCommit) {
+    return {
+        repoPath,
+        lastCommit,
+        indexedAt: '2026-03-02T00:00:00.000Z',
+        stats: { files: 10, nodes: 20, edges: 30 },
+    };
+}
+test('registerRepo stores alias and rejects collisions on different paths', async () => {
+    const tmpHome = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-home-'));
+    const originalHome = process.env.GITNEXUS_HOME;
+    process.env.GITNEXUS_HOME = tmpHome;
+    try {
+        const repoA = path.join(tmpHome, 'repo-a');
+        const repoB = path.join(tmpHome, 'repo-b');
+        await fs.mkdir(repoA, { recursive: true });
+        await fs.mkdir(repoB, { recursive: true });
+        await registerRepo(repoA, makeMeta(repoA, 'abc1234'), { repoAlias: 'neonspark-v1-subset' });
+        const entries = await readRegistry();
+        assert.equal(entries.length, 1);
+        assert.equal(entries[0].name, 'neonspark-v1-subset');
+        assert.equal(entries[0].alias, 'neonspark-v1-subset');
+        assert.equal(entries[0].sourceName, 'repo-a');
+        await assert.rejects(registerRepo(repoB, makeMeta(repoB, 'def5678'), { repoAlias: 'neonspark-v1-subset' }), /already registered/i);
+    }
+    finally {
+        if (originalHome === undefined) {
+            delete process.env.GITNEXUS_HOME;
+        }
+        else {
+            process.env.GITNEXUS_HOME = originalHome;
+        }
+    }
+});

package/dist/cli/scope-filter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/scope-filter.test.js

@@ -0,0 +1,49 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { parseScopeRules, pathMatchesScopeRules, selectEntriesByScopeRules } from '../core/ingestion/scope-filter.js';
+test('parseScopeRules ignores comments and blank lines', () => {
+    const rules = parseScopeRules(`
+# comment
+Assets/NEON/Code
+
+Packages/com.veewo.*
+  Packages/com.neonspark.*
+`);
+    assert.deepEqual(rules, [
+        'Assets/NEON/Code',
+        'Packages/com.veewo.*',
+        'Packages/com.neonspark.*',
+    ]);
+});
+test('pathMatchesScopeRules supports wildcard and descendant semantics', () => {
+    const rules = ['Assets/NEON/Code', 'Packages/com.veewo.*'];
+    assert.equal(pathMatchesScopeRules('Assets/NEON/Code/Game/A.cs', rules), true);
+    assert.equal(pathMatchesScopeRules('Assets/NEON/Code', rules), true);
+    assert.equal(pathMatchesScopeRules('Packages/com.veewo.stat/Runtime/Stat.cs', rules), true);
+    assert.equal(pathMatchesScopeRules('Packages/com.unity.inputsystem/Runtime/X.cs', rules), false);
+});
+test('selectEntriesByScopeRules reports overlap dedupe and normalized path collisions', () => {
+    const entries = [
+        { path: 'Assets/NEON/Code/Game/A.cs' },
+        { path: 'Packages/com.veewo.stat/Runtime/Stat.cs' },
+        { path: 'Packages\\com.veewo.stat\\Runtime\\Stat.cs' },
+        { path: 'Packages/com.unity.inputsystem/Runtime/X.cs' },
+    ];
+    const result = selectEntriesByScopeRules(entries, [
+        'Assets/NEON/Code',
+        'Assets/NEON/*',
+        'Packages/com.veewo.*',
+    ]);
+    assert.equal(result.selected.length, 3);
+    assert.equal(result.diagnostics.appliedRuleCount, 3);
+    assert.equal(result.diagnostics.overlapFiles, 1);
+    assert.equal(result.diagnostics.dedupedMatchCount, 1);
+    assert.equal(result.diagnostics.normalizedCollisions.length, 1);
+    assert.deepEqual(result.diagnostics.normalizedCollisions[0], {
+        normalizedPath: 'Packages/com.veewo.stat/Runtime/Stat.cs',
+        paths: [
+            'Packages/com.veewo.stat/Runtime/Stat.cs',
+            'Packages\\com.veewo.stat\\Runtime\\Stat.cs',
+        ],
+    });
+});

package/dist/cli/serve.d.ts

@@ -0,0 +1,4 @@
+export declare const serveCommand: (options?: {
+    port?: string;
+    host?: string;
+}) => Promise<void>;

package/dist/cli/serve.js

@@ -0,0 +1,6 @@
+import { createServer } from '../server/api.js';
+export const serveCommand = async (options) => {
+    const port = Number(options?.port ?? 4747);
+    const host = options?.host ?? '127.0.0.1';
+    await createServer(port, host);
+};

package/dist/cli/setup.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Setup Command
+ *
+ * One-time global MCP configuration writer.
+ * Detects installed AI editors and writes the appropriate MCP config
+ * so the GitNexus MCP server is available in all projects.
+ */
+export declare const setupCommand: () => Promise<void>;