gitnexus 1.2.7 → 1.2.9

package/README.md

@@ -39,6 +39,12 @@ To configure MCP for your editor, run `npx gitnexus setup` once — or set it up
 
 > **Claude Code** gets the deepest integration: MCP tools + agent skills + PreToolUse hooks that automatically enrich grep/glob/bash calls with knowledge graph context.
 
+### Community Integrations
+
+| Agent | Install | Source |
+|-------|---------|--------|
+| [pi](https://pi.dev) | `pi install npm:pi-gitnexus` | [pi-gitnexus](https://github.com/tintinweb/pi-gitnexus) |
+
 ## MCP Setup (manual)
 
 If you prefer to configure manually instead of using `gitnexus setup`:
@@ -135,7 +141,7 @@ gitnexus analyze [path]           # Index a repository (or update stale index)
 gitnexus analyze --force          # Force full re-index
 gitnexus analyze --skip-embeddings  # Skip embedding generation (faster)
 gitnexus mcp                     # Start MCP server (stdio) — serves all indexed repos
-gitnexus serve                   # Start HTTP server for web UI
+gitnexus serve                   # Start local HTTP server (multi-repo) for web UI
 gitnexus list                    # List all indexed repositories
 gitnexus status                  # Show index status for current repo
 gitnexus clean                   # Delete index for current repo
@@ -179,6 +185,8 @@ Installed automatically by both `gitnexus analyze` (per-repo) and `gitnexus setu
 
 GitNexus also has a browser-based UI at [gitnexus.vercel.app](https://gitnexus.vercel.app) — 100% client-side, your code never leaves the browser.
 
+**Local Backend Mode:** Run `gitnexus serve` and open the web UI locally — it auto-detects the server and shows all your indexed repos, with full AI chat support. No need to re-upload or re-index. The agent's tools (Cypher queries, search, code navigation) route through the backend HTTP API automatically.
+
 ## License
 
 [PolyForm Noncommercial 1.0.0](https://polyformproject.org/licenses/noncommercial/1.0.0/)

package/dist/cli/analyze.d.ts

@@ -5,6 +5,6 @@
  */
 export interface AnalyzeOptions {
     force?: boolean;
-    skipEmbeddings?: boolean;
+    embeddings?: boolean;
 }
 export declare const analyzeCommand: (inputPath?: string, options?: AnalyzeOptions) => Promise<void>;

package/dist/cli/analyze.js

@@ -8,7 +8,7 @@ import cliProgress from 'cli-progress';
 import { runPipelineFromRepo } from '../core/ingestion/pipeline.js';
 import { initKuzu, loadGraphToKuzu, getKuzuStats, executeQuery, executeWithReusedStatement, closeKuzu, createFTSIndex, loadCachedEmbeddings } from '../core/kuzu/kuzu-adapter.js';
 import { runEmbeddingPipeline } from '../core/embeddings/embedding-pipeline.js';
-import { disposeEmbedder } from '../core/embeddings/embedder.js';
+// disposeEmbedder intentionally not called — ONNX Runtime segfaults on cleanup (see #38)
 import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, getGlobalRegistryPath } from '../storage/repo-manager.js';
 import { getCurrentCommit, isGitRepo, getGitRoot } from '../storage/git.js';
 import { generateAIContextFiles } from './ai-context.js';
@@ -70,11 +70,29 @@ export const analyzeCommand = async (inputPath, options) => {
         stopOnComplete: false,
     }, cliProgress.Presets.shades_grey);
     bar.start(100, 0, { phase: 'Initializing...' });
+    // Route all console output through bar.log() so the bar doesn't stamp itself
+    // multiple times when other code writes to stdout/stderr mid-render.
+    const origLog = console.log.bind(console);
+    const origWarn = console.warn.bind(console);
+    const origError = console.error.bind(console);
+    const barLog = (...args) => origLog(args.map(a => (typeof a === 'string' ? a : String(a))).join(' '));
+    console.log = barLog;
+    console.warn = barLog;
+    console.error = barLog;
+    // Show elapsed seconds for phases that run longer than 3s
+    let lastPhaseLabel = 'Initializing...';
+    let phaseStart = Date.now();
+    const elapsedTimer = setInterval(() => {
+        const elapsed = Math.round((Date.now() - phaseStart) / 1000);
+        if (elapsed >= 3) {
+            bar.update({ phase: `${lastPhaseLabel} (${elapsed}s)` });
+        }
+    }, 1000);
     const t0Global = Date.now();
     // ── Cache embeddings from existing index before rebuild ────────────
     let cachedEmbeddingNodeIds = new Set();
     let cachedEmbeddings = [];
-    if (existingMeta && !options?.force) {
+    if (options?.embeddings && existingMeta && !options?.force) {
         try {
             bar.update(0, { phase: 'Caching embeddings...' });
             await initKuzu(kuzuPath);
@@ -94,10 +112,16 @@ export const analyzeCommand = async (inputPath, options) => {
     const pipelineResult = await runPipelineFromRepo(repoPath, (progress) => {
         const phaseLabel = PHASE_LABELS[progress.phase] || progress.phase;
         const scaled = Math.round(progress.percent * 0.6);
+        if (phaseLabel !== lastPhaseLabel) {
+            lastPhaseLabel = phaseLabel;
+            phaseStart = Date.now();
+        }
         bar.update(scaled, { phase: phaseLabel });
     });
     // ── Phase 2: KuzuDB (60–85%) ──────────────────────────────────────
-    bar.update(60, { phase: 'Loading into KuzuDB...' });
+    lastPhaseLabel = 'Loading into KuzuDB...';
+    phaseStart = Date.now();
+    bar.update(60, { phase: lastPhaseLabel });
     await closeKuzu();
     const kuzuFiles = [kuzuPath, `${kuzuPath}.wal`, `${kuzuPath}.lock`];
     for (const f of kuzuFiles) {
@@ -117,7 +141,9 @@ export const analyzeCommand = async (inputPath, options) => {
     const kuzuTime = ((Date.now() - t0Kuzu) / 1000).toFixed(1);
     const kuzuWarnings = kuzuResult.warnings;
     // ── Phase 3: FTS (85–90%) ─────────────────────────────────────────
-    bar.update(85, { phase: 'Creating search indexes...' });
+    lastPhaseLabel = 'Creating search indexes...';
+    phaseStart = Date.now();
+    bar.update(85, { phase: lastPhaseLabel });
     const t0Fts = Date.now();
     try {
         await createFTSIndex('File', 'file_fts', ['name', 'content']);
@@ -146,22 +172,28 @@ export const analyzeCommand = async (inputPath, options) => {
     // ── Phase 4: Embeddings (90–98%) ──────────────────────────────────
     const stats = await getKuzuStats();
     let embeddingTime = '0.0';
-    let embeddingSkipped = false;
-    let embeddingSkipReason = '';
-    if (options?.skipEmbeddings) {
-        embeddingSkipped = true;
-        embeddingSkipReason = 'skipped (--skip-embeddings)';
-    }
-    else if (stats.nodes > EMBEDDING_NODE_LIMIT) {
-        embeddingSkipped = true;
-        embeddingSkipReason = `skipped (${stats.nodes.toLocaleString()} nodes > ${EMBEDDING_NODE_LIMIT.toLocaleString()} limit)`;
+    let embeddingSkipped = true;
+    let embeddingSkipReason = 'off (use --embeddings to enable)';
+    if (options?.embeddings) {
+        if (stats.nodes > EMBEDDING_NODE_LIMIT) {
+            embeddingSkipReason = `skipped (${stats.nodes.toLocaleString()} nodes > ${EMBEDDING_NODE_LIMIT.toLocaleString()} limit)`;
+        }
+        else {
+            embeddingSkipped = false;
+        }
     }
     if (!embeddingSkipped) {
-        bar.update(90, { phase: 'Loading embedding model...' });
+        lastPhaseLabel = 'Loading embedding model...';
+        phaseStart = Date.now();
+        bar.update(90, { phase: lastPhaseLabel });
         const t0Emb = Date.now();
         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 || '?'}`;
+            if (label !== lastPhaseLabel) {
+                lastPhaseLabel = label;
+                phaseStart = Date.now();
+            }
             bar.update(scaled, { phase: label });
         }, {}, cachedEmbeddingNodeIds.size > 0 ? cachedEmbeddingNodeIds : undefined);
         embeddingTime = ((Date.now() - t0Emb) / 1000).toFixed(1);
@@ -203,8 +235,14 @@ export const analyzeCommand = async (inputPath, options) => {
         processes: pipelineResult.processResult?.stats.totalProcesses,
     });
     await closeKuzu();
-    await disposeEmbedder();
+    // Note: we intentionally do NOT call disposeEmbedder() here.
+    // ONNX Runtime's native cleanup segfaults on macOS and some Linux configs.
+    // Since the process exits immediately after, Node.js reclaims everything.
     const totalTime = ((Date.now() - t0Global) / 1000).toFixed(1);
+    clearInterval(elapsedTimer);
+    console.log = origLog;
+    console.warn = origWarn;
+    console.error = origError;
     bar.update(100, { phase: 'Done' });
     bar.stop();
     // ── Summary ───────────────────────────────────────────────────────
@@ -233,4 +271,10 @@ export const analyzeCommand = async (inputPath, options) => {
         console.log('\n  Tip: Run `gitnexus setup` to configure MCP for your editor.');
     }
     console.log('');
+    // ONNX Runtime registers native atexit hooks that segfault during process
+    // shutdown on macOS (#38) and some Linux configs (#40). Force-exit to
+    // bypass them when embeddings were loaded.
+    if (!embeddingSkipped) {
+        process.exit(0);
+    }
 };

package/dist/cli/index.js

@@ -24,7 +24,7 @@ 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)')
+    .option('--embeddings', 'Enable embedding generation for semantic search (off by default)')
     .action(analyzeCommand);
 program
     .command('serve')

package/dist/cli/setup.js

@@ -13,9 +13,16 @@ import { getGlobalDir } from '../storage/repo-manager.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 /**
- * The MCP server entry for all editors
+ * The MCP server entry for all editors.
+ * On Windows, npx must be invoked via cmd /c since it's a .cmd script.
  */
 function getMcpEntry() {
+    if (process.platform === 'win32') {
+        return {
+            command: 'cmd',
+            args: ['/c', 'npx', '-y', 'gitnexus@latest', 'mcp'],
+        };
+    }
     return {
         command: 'npx',
         args: ['-y', 'gitnexus@latest', 'mcp'],

package/dist/cli/view.d.ts

@@ -0,0 +1,13 @@
+/**
+ * View Command
+ *
+ * Generates a self-contained graph.html from the KuzuDB index and
+ * opens it in the default browser.
+ *
+ * Usage: gitnexus view [path] [--no-open]
+ */
+export interface ViewCommandOptions {
+    noOpen?: boolean;
+    output?: string;
+}
+export declare const viewCommand: (inputPath?: string, options?: ViewCommandOptions) => Promise<void>;

package/dist/cli/view.js

@@ -0,0 +1,59 @@
+/**
+ * View Command
+ *
+ * Generates a self-contained graph.html from the KuzuDB index and
+ * opens it in the default browser.
+ *
+ * Usage: gitnexus view [path] [--no-open]
+ */
+import path from 'path';
+import fs from 'fs/promises';
+import { exec } from 'child_process';
+import { findRepo } from '../storage/repo-manager.js';
+import { initKuzu } from '../core/kuzu/kuzu-adapter.js';
+import { buildGraph } from '../server/api.js';
+import { generateHTMLGraphViewer } from '../core/graph/html-graph-viewer.js';
+import { getCurrentCommit } from '../storage/git.js';
+function openInBrowser(filePath) {
+    const url = `file://${filePath}`;
+    let cmd;
+    if (process.platform === 'darwin') {
+        cmd = `open "${url}"`;
+    }
+    else if (process.platform === 'win32') {
+        cmd = `start "" "${url}"`;
+    }
+    else {
+        cmd = `xdg-open "${url}"`;
+    }
+    exec(cmd, (err) => {
+        if (err)
+            console.error('Failed to open browser:', err.message);
+    });
+}
+export const viewCommand = async (inputPath, options) => {
+    console.log('⚠ Experimental: gitnexus view is under active development.\n');
+    const repoPath = inputPath ? path.resolve(inputPath) : process.cwd();
+    const repo = await findRepo(repoPath);
+    if (!repo) {
+        console.error('No index found. Run: gitnexus analyze');
+        process.exit(1);
+    }
+    const currentCommit = getCurrentCommit(repo.repoPath);
+    if (currentCommit !== repo.meta.lastCommit) {
+        console.warn('Index is stale — showing last indexed state. Run: gitnexus analyze\n');
+    }
+    await initKuzu(repo.kuzuPath);
+    const { nodes, relationships } = await buildGraph();
+    const projectName = path.basename(repo.repoPath);
+    const outputPath = options?.output
+        ? path.resolve(options.output)
+        : path.join(repo.storagePath, 'graph.html');
+    const html = generateHTMLGraphViewer(nodes, relationships, projectName);
+    await fs.writeFile(outputPath, html, 'utf-8');
+    console.log(`Graph written to: ${outputPath}`);
+    console.log(`Nodes: ${nodes.length}  Edges: ${relationships.length}`);
+    if (!options?.noOpen) {
+        openInBrowser(outputPath);
+    }
+};

package/dist/core/embeddings/embedder.js

@@ -89,6 +89,7 @@ export const initEmbedder = async (onProgress, config = {}, forceDevice) => {
                         device: device,
                         dtype: 'fp32',
                         progress_callback: progressCallback,
+                        session_options: { logSeverityLevel: 3 },
                     });
                     currentDevice = device;
                     if (isDev) {

package/dist/core/graph/html-graph-viewer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * HTML Graph Viewer Generator
+ *
+ * Produces a self-contained graph.html that renders the knowledge graph
+ * using Sigma.js v2 + graphology (both from CDN).
+ *
+ * Critical: node `content` fields are stripped before embedding to prevent
+ * </script> injection from source code breaking the HTML parser.
+ */
+import { GraphNode, GraphRelationship } from './types.js';
+/**
+ * Generate a self-contained HTML file that renders the knowledge graph.
+ * Strips large/unsafe fields from nodes before embedding.
+ */
+export declare function generateHTMLGraphViewer(nodes: GraphNode[], relationships: GraphRelationship[], projectName: string): string;