@veewo/gitnexus 1.3.11-rc.1 → 1.4.6-rc

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**, **Codex**, **Windsurf**, **Cline**, **OpenCode**, and any MCP-compatible tool.
+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/)
@@ -19,31 +19,14 @@ AI coding tools don't understand your codebase structure. They edit a function w
 
 ```bash
 # Index your repo (run from repo root)
-npx gitnexus analyze
+npx -y @veewo/gitnexus@latest analyze
 ```
 
-That's it. This indexes the codebase, updates `AGENTS.md` / `CLAUDE.md` context files, and (when using project scope) installs repo-local agent skills.
+That's it. This indexes the codebase, installs agent skills, registers Claude Code hooks, and creates `AGENTS.md` / `CLAUDE.md` context files — all in one command.
 
-To configure MCP + skills, run `npx gitnexus setup --agent <claude|opencode|codex>` once (default global mode), or add `--scope project` for project-local mode.
+To configure MCP for your editor, run `npx -y @veewo/gitnexus@latest setup` once — or set it up manually below.
 
-`gitnexus setup` requires an agent selection:
-- `--agent claude`: configure Claude MCP only
-- `--agent opencode`: configure OpenCode MCP only
-- `--agent codex`: configure Codex MCP only
-
-It also supports two scopes:
-- `global` (default): writes MCP to the selected agent's global config + installs global skills
-- `project`: writes MCP to the selected agent's project-local config + installs repo-local skills
-
-## Team Deployment and Distribution
-
-For small-team rollout (single stable channel only), follow:
-- [CLI Deployment and Distribution](../docs/cli-release-distribution.md)
-
-Key links:
-- [npm publish workflow](../.github/workflows/publish.yml)
-- [CLI package config](./package.json)
-- [Agent install + acceptance runbook](../INSTALL-GUIDE.md)
+`gitnexus setup` auto-detects your editors and writes the correct global MCP config. You only need to run it once.
 
 ### Editor Support
 
@@ -51,7 +34,6 @@ Key links:
 |--------|-----|--------|---------------------|---------|
 | **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 |
 
@@ -90,25 +72,19 @@ Add to `~/.cursor/mcp.json` (global — works for all projects):
 
 ### OpenCode
 
-Add to `~/.config/opencode/opencode.json`:
+Add to `~/.config/opencode/config.json`:
 
 ```json
 {
   "mcp": {
     "gitnexus": {
-      "type": "local",
-      "command": ["npx", "-y", "@veewo/gitnexus@latest", "mcp"]
+      "command": "npx",
+      "args": ["-y", "@veewo/gitnexus@latest", "mcp"]
     }
   }
 }
 ```
 
-### Codex
-
-```bash
-codex mcp add gitnexus -- npx -y @veewo/gitnexus@latest mcp
-```
-
 ## How It Works
 
 GitNexus builds a complete knowledge graph of your codebase through a multi-phase indexing pipeline:
@@ -120,7 +96,7 @@ GitNexus builds a complete knowledge graph of your codebase through a multi-phas
 5. **Processes** — Traces execution flows from entry points through call chains
 6. **Search** — Builds hybrid search indexes for fast retrieval
 
-The result is a **KuzuDB graph database** stored locally in `.gitnexus/` with full-text search and semantic embeddings.
+The result is a **LadybugDB graph database** stored locally in `.gitnexus/` with full-text search and semantic embeddings.
 
 ## MCP Tools
 
@@ -160,14 +136,11 @@ Your AI agent gets these tools automatically:
 ## CLI Commands
 
 ```bash
-gitnexus setup --agent claude                     # Global setup for Claude
-gitnexus setup --agent codex                      # Global setup for Codex
-gitnexus setup --scope project --agent opencode   # Project-local setup for OpenCode
-gitnexus analyze [path]           # Index a repository (or update stale index)
-gitnexus analyze --force          # Force full re-index
-gitnexus analyze --embeddings     # Enable semantic embeddings (off by default)
-gitnexus analyze --scope-prefix Assets/NEON/Code --scope-prefix Packages/com.veewo.*  # Scoped multi-directory indexing
-gitnexus analyze --scope-manifest .gitnexus/sync-manifest.txt --repo-alias neonspark-v1-subset  # Scoped indexing + stable repo alias
+gitnexus setup                    # Configure MCP for your editors (one-time)
+npx -y @veewo/gitnexus@latest analyze [path]           # Index a repository (or update stale index)
+npx -y @veewo/gitnexus@latest analyze --force          # Force full re-index
+npx -y @veewo/gitnexus@latest analyze --embeddings     # Enable embedding generation (slower, better search)
+npx -y @veewo/gitnexus@latest 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 list                    # List all indexed repositories
@@ -176,45 +149,35 @@ gitnexus clean                   # Delete index for current repo
 gitnexus clean --all --force     # Delete all indexes
 gitnexus wiki [path]             # Generate LLM-powered docs from knowledge graph
 gitnexus wiki --model <model>    # Wiki with custom LLM model (default: gpt-4o-mini)
-gitnexus unity-bindings <symbol> --target-path <path> [--json]  # Experimental Unity C# <-> prefab/scene/asset cross-reference
-gitnexus context <symbol> --unity-resources on                   # Include graph-native Unity resource data (opt-in)
-gitnexus query <symbol> --unity-resources on                     # Enrich query symbol hits with Unity resource data (opt-in)
-gitnexus benchmark-unity ../benchmarks/unity-baseline/v1 --profile quick --target-path ../benchmarks/fixtures/unity-mini
-gitnexus benchmark-unity ../benchmarks/unity-baseline/v1 --profile full --target-path ../benchmarks/fixtures/unity-mini
-```
-
-For scoped indexing, `analyze` logs scope overlap dedupe counts and any normalized path collisions to help diagnose multi-directory merge safety.
-
-Unity resource retrieval is opt-in on `query/context` via `unity_resources: off|on|auto` (default: `off`). Use `--unity-resources on` when you need `resourceBindings`, `serializedFields`, `resolvedReferences`, and `unityDiagnostics` in output.
-
-## Unity Benchmark
-
-Run reproducible Unity/C# accuracy and regression checks:
-
-```bash
-gitnexus benchmark-unity ../benchmarks/unity-baseline/v1 --profile quick --target-path ../benchmarks/fixtures/unity-mini
-gitnexus benchmark-unity ../benchmarks/unity-baseline/v1 --profile full --target-path ../benchmarks/fixtures/unity-mini
 ```
 
-Reports are written to `.gitnexus/benchmark/benchmark-report.json` and `.gitnexus/benchmark/benchmark-summary.md`.
+## Multi-Repo Support
 
-Hard gates:
+GitNexus supports indexing multiple repositories. Each `npx -y @veewo/gitnexus@latest analyze` registers the repo in a global registry (`~/.gitnexus/registry.json`). The MCP server serves all indexed repos automatically.
 
-| Metric | Threshold |
-|--------|-----------|
-| Query precision | `>= 0.90` |
-| Query recall | `>= 0.85` |
-| Context/impact F1 | `>= 0.80` |
-| Smoke pass rate | `= 1.00` |
-| Analyze time regression | `<= +15%` |
+## Supported Languages
 
-## Multi-Repo Support
+TypeScript, JavaScript, Python, Java, C, C++, C#, Go, Rust, PHP, Kotlin, Swift, Ruby
 
-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.
+### Language Feature Matrix
 
-## Supported Languages
+| Language | Imports | Named Bindings | Exports | Heritage | Type Annotations | Constructor Inference | Config | Frameworks | Entry Points |
+|----------|---------|----------------|---------|----------|-----------------|---------------------|--------|------------|-------------|
+| TypeScript | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+| JavaScript | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ | ✓ |
+| Python | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+| Java | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
+| Kotlin | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
+| C# | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+| Go | ✓ | — | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+| Rust | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
+| PHP | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ | ✓ | ✓ |
+| Ruby | ✓ | — | ✓ | ✓ | — | ✓ | — | ✓ | ✓ |
+| Swift | — | — | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
+| C | — | — | ✓ | — | ✓ | ✓ | — | ✓ | ✓ |
+| C++ | — | — | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
 
-TypeScript, JavaScript, Python, Java, C, C++, C#, Go, Rust
+**Imports** — cross-file import resolution · **Named Bindings** — `import { X as Y }` / re-export tracking · **Exports** — public/exported symbol detection · **Heritage** — class inheritance, interfaces, mixins · **Type Annotations** — explicit type extraction for receiver resolution · **Constructor Inference** — infer receiver type from constructor calls (`self`/`this` resolution included for all languages) · **Config** — language toolchain config parsing (tsconfig, go.mod, etc.) · **Frameworks** — AST-based framework pattern detection · **Entry Points** — entry point scoring heuristics
 
 ## Agent Skills
 
@@ -225,13 +188,7 @@ GitNexus ships with skill files that teach AI agents how to use the tools effect
 - **Impact Analysis** — Analyze blast radius before changes
 - **Refactoring** — Plan safe refactors using dependency mapping
 
-Installation rules:
-
-- `gitnexus setup` controls skill scope:
-  - requires `--agent <claude|opencode|codex>`
-  - default `global`: installs to `~/.agents/skills/gitnexus/`
-  - `--scope project`: installs to `.agents/skills/gitnexus/` in current repo
-- `gitnexus analyze` always updates `AGENTS.md` / `CLAUDE.md`; skill install follows configured setup scope.
+Installed automatically by both `npx -y @veewo/gitnexus@latest analyze` (per-repo) and `gitnexus setup` (global).
 
 ## Requirements
 

package/dist/benchmark/agent-context/tool-runner.js

@@ -1,4 +1,4 @@
-import { closeKuzu } from '../../mcp/core/kuzu-adapter.js';
+import { closeLbug } from '../../mcp/core/lbug-adapter.js';
 import { LocalBackend } from '../../mcp/local/local-backend.js';
 export async function createAgentContextToolRunner() {
     const backend = new LocalBackend();
@@ -12,7 +12,7 @@ export async function createAgentContextToolRunner() {
         impact: (params) => backend.callTool('impact', params),
         cypher: (params) => backend.callTool('cypher', params),
         close: async () => {
-            await closeKuzu();
+            await closeLbug();
         },
     };
 }

package/dist/benchmark/neonspark-candidates.js

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { listRegisteredRepos } from '../storage/repo-manager.js';
-import { closeKuzu, executeQuery, initKuzu } from '../mcp/core/kuzu-adapter.js';
+import { closeLbug, executeQuery, initLbug } from '../mcp/core/lbug-adapter.js';
 const ALLOWED_PREFIXES = ['Assets/NEON/Code/', 'Packages/com.veewo.', 'Packages/com.neonspark.'];
 export function filterNeonsparkPaths(rows) {
     return rows.filter((r) => {
@@ -25,7 +25,7 @@ export async function extractCandidates(repoName, outFile) {
     const repo = repos.find((r) => r.name === repoName);
     if (!repo)
         throw new Error(`repo not indexed: ${repoName}`);
-    await initKuzu(repoName, path.join(repo.storagePath, 'kuzu'));
+    await initLbug(repoName, path.join(repo.storagePath, 'lbug'));
     try {
         const rows = await executeQuery(repoName, `
       MATCH (s:Class)
@@ -67,7 +67,7 @@ export async function extractCandidates(repoName, outFile) {
         return normalized.length;
     }
     finally {
-        await closeKuzu(repoName);
+        await closeLbug(repoName);
     }
 }
 export function parseCandidatesCliArgs(argv) {

package/dist/benchmark/tool-runner.js

@@ -1,4 +1,4 @@
-import { closeKuzu } from '../mcp/core/kuzu-adapter.js';
+import { closeLbug } from '../mcp/core/lbug-adapter.js';
 import { LocalBackend } from '../mcp/local/local-backend.js';
 export async function createToolRunner() {
     const backend = new LocalBackend();
@@ -11,7 +11,7 @@ export async function createToolRunner() {
         context: (params) => backend.callTool('context', params),
         impact: (params) => backend.callTool('impact', params),
         close: async () => {
-            await closeKuzu();
+            await closeLbug();
         },
     };
 }

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

@@ -5,6 +5,7 @@
  * 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';
 type SkillScope = 'project' | 'global';
 interface RepoStats {
     files?: number;
@@ -19,7 +20,7 @@ interface RepoStats {
  */
 export declare function generateAIContextFiles(repoPath: string, _storagePath: string, projectName: string, stats: RepoStats, options?: {
     skillScope?: SkillScope;
-}): Promise<{
+}, generatedSkills?: GeneratedSkillInfo[]): Promise<{
     files: string[];
 }>;
 export {};

package/dist/cli/ai-context.js

@@ -16,17 +16,21 @@ const GITNEXUS_END_MARKER = '<!-- gitnexus:end -->';
 /**
  * Generate the full GitNexus context content.
  *
- * Design principles (learned from real agent behavior):
- * - AGENTS.md is the ROUTER — it tells the agent WHICH skill to read
- * - Skills contain the actual workflows — AGENTS.md does NOT duplicate them
- * - Bold **IMPORTANT** block + "Skills — Read First" heading — agents skip soft suggestions
- * - One-line quick start (read context resource) gives agents an entry point
- * - Tools/Resources sections are labeled "Reference" — agents treat them as lookup, not workflow
+ * Design principles (learned from real agent behavior and industry research):
+ * - Inline critical workflows — skills are skipped 56% of the time (Vercel eval data)
+ * - Use RFC 2119 language (MUST, NEVER, ALWAYS) — models follow imperative rules
+ * - Three-tier boundaries (Always/When/Never) — proven to change model behavior
+ * - Keep under 120 lines — adherence degrades past 150 lines
+ * - Exact tool commands with parameters — vague directives get ignored
+ * - Self-review checklist — forces model to verify its own work
  */
-function generateGitNexusContent(projectName, stats, skillScope) {
+function generateGitNexusContent(projectName, stats, skillScope, generatedSkills) {
     const skillRoot = skillScope === 'global'
         ? '~/.agents/skills/gitnexus'
         : '.agents/skills/gitnexus';
+    const generatedRows = (generatedSkills && generatedSkills.length > 0)
+        ? `\n${generatedSkills.map((s) => `| Work in the ${s.label} area (${s.symbolCount} symbols) | \`.claude/skills/generated/${s.name}/SKILL.md\` |`).join('\n')}`
+        : '';
     return `${GITNEXUS_START_MARKER}
 # GitNexus MCP
 
@@ -38,7 +42,7 @@ This project is indexed by GitNexus as **${projectName}** (${stats.nodes || 0} s
 2. **Match your task to a skill below** and **read that skill file**
 3. **Follow the skill's workflow and checklist**
 
-> If step 1 warns the index is stale, ask user whether to rebuild index via \`npx -y gitnexus analyze\` first (it reuses previous analyze scope/options by default; add \`--no-reuse-options\` to reset). If user declines, explicitly warn that retrieval may not reflect current codebase. For build/analyze/test commands, use a 10-30 minute timeout; on failure/timeout, report exact tool output and do not auto-retry or silently fall back to glob/grep.
+> If step 1 warns the index is stale, ask user whether to rebuild index via \`npx -y @veewo/gitnexus@latest analyze\` first (it reuses previous analyze scope/options by default; add \`--no-reuse-options\` to reset). If user declines, explicitly warn that retrieval may not reflect current codebase. For build/analyze/test commands, use a 10-30 minute timeout; on failure/timeout, report exact tool output and do not auto-retry or silently fall back to glob/grep.
 
 ## Skills
 
@@ -49,7 +53,7 @@ This project is indexed by GitNexus as **${projectName}** (${stats.nodes || 0} s
 | Trace bugs / "Why is X failing?" | \`${skillRoot}/gitnexus-debugging/SKILL.md\` |
 | Rename / extract / split / refactor | \`${skillRoot}/gitnexus-refactoring/SKILL.md\` |
 | Tools, resources, schema reference | \`${skillRoot}/gitnexus-guide/SKILL.md\` |
-| Index, status, clean, wiki CLI commands | \`${skillRoot}/gitnexus-cli/SKILL.md\` |
+| Index, status, clean, wiki CLI commands | \`${skillRoot}/gitnexus-cli/SKILL.md\` |${generatedRows}
 
 ${GITNEXUS_END_MARKER}`;
 }
@@ -81,7 +85,7 @@ async function upsertGitNexusSection(filePath, content) {
     // 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) {
+    if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
         // Replace existing section
         const before = existingContent.substring(0, startIdx);
         const after = existingContent.substring(endIdx + GITNEXUS_END_MARKER.length);
@@ -167,9 +171,9 @@ Use GitNexus tools to accomplish this task.
 /**
  * Generate AI context files after indexing
  */
-export async function generateAIContextFiles(repoPath, _storagePath, projectName, stats, options) {
+export async function generateAIContextFiles(repoPath, _storagePath, projectName, stats, options, generatedSkills) {
     const skillScope = options?.skillScope === 'global' ? 'global' : 'project';
-    const content = generateGitNexusContent(projectName, stats, skillScope);
+    const content = generateGitNexusContent(projectName, stats, skillScope, generatedSkills);
     const createdFiles = [];
     // Create AGENTS.md (standard for Cursor, Windsurf, OpenCode, Codex, Cline, etc.)
     const agentsPath = path.join(repoPath, 'AGENTS.md');

package/dist/cli/analyze.d.ts

@@ -11,5 +11,7 @@ export interface AnalyzeOptions {
     scopeManifest?: string;
     scopePrefix?: string[];
     reuseOptions?: boolean;
+    skills?: boolean;
+    verbose?: boolean;
 }
 export declare const analyzeCommand: (inputPath?: string, options?: AnalyzeOptions) => Promise<void>;

package/dist/cli/analyze.js

@@ -8,20 +8,19 @@ import { execFileSync } from 'child_process';
 import v8 from 'v8';
 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 { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, createFTSIndex, loadCachedEmbeddings } from '../core/lbug/lbug-adapter.js';
 // Embedding imports are lazy (dynamic import) so onnxruntime-node is never
 // loaded when embeddings are not requested. This avoids crashes on Node
 // 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, loadCLIConfig } from '../storage/repo-manager.js';
+import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, getGlobalRegistryPath, loadCLIConfig, cleanupOldKuzuFiles } from '../storage/repo-manager.js';
 import { getCurrentCommit, isGitRepo, getGitRoot } from '../storage/git.js';
 import { generateAIContextFiles } from './ai-context.js';
+import { generateSkillFiles } from './skill-gen.js';
 import fs from 'fs/promises';
-import { registerClaudeHook } from './claude-hooks.js';
 import { resolveEffectiveAnalyzeOptions } from './analyze-options.js';
 import { formatFallbackSummary, formatUnityDiagnosticsSummary } from './analyze-summary.js';
 import { resolveChildProcessExit } from './exit-code.js';
-import { shouldCloseKuzuOnAnalyzeExit } from './analyze-close-policy.js';
 import { toPipelineRuntimeSummary } from './analyze-runtime-summary.js';
 const HEAP_MB = 8192;
 const HEAP_FLAG = `--max-old-space-size=${HEAP_MB}`;
@@ -60,7 +59,7 @@ const PHASE_LABELS = {
     communities: 'Detecting communities',
     processes: 'Detecting processes',
     complete: 'Pipeline complete',
-    kuzu: 'Loading into KuzuDB',
+    lbug: 'Loading into LadybugDB',
     fts: 'Creating search indexes',
     embeddings: 'Generating embeddings',
     done: 'Done',
@@ -68,6 +67,9 @@ const PHASE_LABELS = {
 export const analyzeCommand = async (inputPath, options) => {
     if (ensureHeap())
         return;
+    if (options?.verbose) {
+        process.env.GITNEXUS_VERBOSE = '1';
+    }
     console.log('\n  GitNexus Analyzer\n');
     let repoPath;
     if (inputPath) {
@@ -87,7 +89,13 @@ export const analyzeCommand = async (inputPath, options) => {
         process.exitCode = 1;
         return;
     }
-    const { storagePath, kuzuPath } = getStoragePaths(repoPath);
+    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.
+    const kuzuResult = await cleanupOldKuzuFiles(storagePath);
+    if (kuzuResult.found && kuzuResult.needsReindex) {
+        console.log('  Migrating from KuzuDB to LadybugDB — rebuilding index...\n');
+    }
     const currentCommit = getCurrentCommit(repoPath);
     const existingMeta = await loadMeta(storagePath);
     let includeExtensions = [];
@@ -113,7 +121,7 @@ export const analyzeCommand = async (inputPath, options) => {
         process.exitCode = 1;
         return;
     }
-    if (existingMeta && !options?.force && existingMeta.lastCommit === currentCommit) {
+    if (existingMeta && !options?.force && existingMeta.lastCommit === currentCommit && !options?.skills) {
         const hasScopePrefixInput = Array.isArray(options?.scopePrefix)
             ? options.scopePrefix.length > 0
             : Boolean(options?.scopePrefix);
@@ -136,6 +144,9 @@ export const analyzeCommand = async (inputPath, options) => {
             return;
         }
     }
+    if (process.env.GITNEXUS_NO_GITIGNORE) {
+        console.log('  GITNEXUS_NO_GITIGNORE is set — skipping .gitignore (still reading .gitnexusignore)\n');
+    }
     // Single progress bar for entire pipeline
     const bar = new cliProgress.SingleBar({
         format: '  {bar} {percentage}% | {phase}',
@@ -156,11 +167,7 @@ export const analyzeCommand = async (inputPath, options) => {
         aborted = true;
         bar.stop();
         console.log('\n  Interrupted — cleaning up...');
-        if (!shouldCloseKuzuOnAnalyzeExit()) {
-            process.exit(130);
-            return;
-        }
-        closeKuzu().catch(() => { }).finally(() => process.exit(130));
+        closeLbug().catch(() => { }).finally(() => process.exit(130));
     };
     process.on('SIGINT', sigintHandler);
     // Route all console output through bar.log() so the bar doesn't stamp itself
@@ -206,15 +213,15 @@ export const analyzeCommand = async (inputPath, options) => {
     if (embeddingsEnabled && existingMeta && !options?.force) {
         try {
             updateBar(0, 'Caching embeddings...');
-            await initKuzu(kuzuPath);
+            await initLbug(lbugPath);
             const cached = await loadCachedEmbeddings();
             cachedEmbeddingNodeIds = cached.embeddingNodeIds;
             cachedEmbeddings = cached.embeddings;
-            await closeKuzu();
+            await closeLbug();
         }
         catch {
             try {
-                await closeKuzu();
+                await closeLbug();
             }
             catch { }
         }
@@ -239,28 +246,29 @@ export const analyzeCommand = async (inputPath, options) => {
         process.exitCode = 1;
         return;
     }
-    // ── Phase 2: KuzuDB (60–85%) ──────────────────────────────────────
-    updateBar(60, 'Loading into KuzuDB...');
-    await closeKuzu();
-    const kuzuFiles = [kuzuPath, `${kuzuPath}.wal`, `${kuzuPath}.lock`];
-    for (const f of kuzuFiles) {
+    // ── Phase 2: LadybugDB (60–85%) ──────────────────────────────────────
+    updateBar(60, 'Loading into LadybugDB...');
+    await closeLbug();
+    const lbugFiles = [lbugPath, `${lbugPath}.wal`, `${lbugPath}.lock`];
+    for (const f of lbugFiles) {
         try {
             await fs.rm(f, { recursive: true, force: true });
         }
         catch { }
     }
-    const t0Kuzu = Date.now();
-    await initKuzu(kuzuPath);
-    let kuzuMsgCount = 0;
-    const kuzuResult = await loadGraphToKuzu(pipelineResult.graph, pipelineResult.repoPath, storagePath, (msg) => {
-        kuzuMsgCount++;
-        const progress = Math.min(84, 60 + Math.round((kuzuMsgCount / (kuzuMsgCount + 10)) * 24));
+    const t0Lbug = Date.now();
+    await initLbug(lbugPath);
+    let lbugMsgCount = 0;
+    const lbugResult = await loadGraphToLbug(pipelineResult.graph, pipelineResult.repoPath, storagePath, (msg) => {
+        lbugMsgCount++;
+        const progress = Math.min(84, 60 + Math.round((lbugMsgCount / (lbugMsgCount + 10)) * 24));
         updateBar(progress, msg);
     });
+    const pipelineForSkills = pipelineResult;
     const pipelineRuntime = toPipelineRuntimeSummary(pipelineResult);
     pipelineResult = undefined;
-    const kuzuTime = ((Date.now() - t0Kuzu) / 1000).toFixed(1);
-    const kuzuWarnings = kuzuResult.warnings;
+    const lbugTime = ((Date.now() - t0Lbug) / 1000).toFixed(1);
+    const lbugWarnings = lbugResult.warnings;
     // ── Phase 3: FTS (85–90%) ─────────────────────────────────────────
     updateBar(85, 'Creating search indexes...');
     const t0Fts = Date.now();
@@ -289,7 +297,7 @@ export const analyzeCommand = async (inputPath, options) => {
         }
     }
     // ── Phase 4: Embeddings (90–98%) ──────────────────────────────────
-    const stats = await getKuzuStats();
+    const stats = await getLbugStats();
     let embeddingTime = '0.0';
     let embeddingSkipped = true;
     let embeddingSkipReason = 'off (use --embeddings to enable)';
@@ -314,6 +322,13 @@ export const analyzeCommand = async (inputPath, options) => {
     }
     // ── Phase 5: Finalize (98–100%) ───────────────────────────────────
     updateBar(98, 'Saving metadata...');
+    // Count embeddings in the index (cached + newly generated)
+    let embeddingCount = 0;
+    try {
+        const embResult = await executeQuery(`MATCH (e:CodeEmbedding) RETURN count(e) AS cnt`);
+        embeddingCount = embResult?.[0]?.cnt ?? 0;
+    }
+    catch { /* table may not exist if embeddings never ran */ }
     const meta = {
         repoPath,
         lastCommit: currentCommit,
@@ -330,13 +345,13 @@ export const analyzeCommand = async (inputPath, options) => {
             edges: stats.edges,
             communities: pipelineRuntime.communityResult?.stats.totalCommunities,
             processes: pipelineRuntime.processResult?.stats.totalProcesses,
+            embeddings: embeddingCount,
         },
     };
     await saveMeta(storagePath, meta);
     await persistUnityParitySeed(storagePath, pipelineRuntime.unityResult?.paritySeed);
     const registeredRepo = await registerRepo(repoPath, meta, { repoAlias });
     await addToGitignore(repoPath);
-    const hookResult = await registerClaudeHook();
     const projectName = path.basename(repoPath);
     let aggregatedClusterCount = 0;
     if (pipelineRuntime.communityResult?.communities) {
@@ -347,6 +362,12 @@ export const analyzeCommand = async (inputPath, options) => {
         }
         aggregatedClusterCount = Array.from(groups.values()).filter(count => count >= 5).length;
     }
+    let generatedSkills = [];
+    if (options?.skills && pipelineForSkills.communityResult) {
+        updateBar(99, 'Generating skill files...');
+        const skillResult = await generateSkillFiles(repoPath, projectName, pipelineForSkills);
+        generatedSkills = skillResult.skills;
+    }
     const aiContext = await generateAIContextFiles(repoPath, storagePath, projectName, {
         files: pipelineRuntime.totalFileCount,
         nodes: stats.nodes,
@@ -356,10 +377,8 @@ export const analyzeCommand = async (inputPath, options) => {
         processes: pipelineRuntime.processResult?.stats.totalProcesses,
     }, {
         skillScope: ((await loadCLIConfig()).setupScope === 'global') ? 'global' : 'project',
-    });
-    if (shouldCloseKuzuOnAnalyzeExit()) {
-        await closeKuzu();
-    }
+    }, generatedSkills);
+    await closeLbug();
     // 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.
@@ -399,7 +418,7 @@ export const analyzeCommand = async (inputPath, options) => {
         console.log(`  ${line}`);
     }
     console.log(`  ${stats.nodes.toLocaleString()} nodes | ${stats.edges.toLocaleString()} edges | ${pipelineRuntime.communityResult?.stats.totalCommunities || 0} clusters | ${pipelineRuntime.processResult?.stats.totalProcesses || 0} flows`);
-    console.log(`  KuzuDB ${kuzuTime}s | FTS ${ftsTime}s | Embeddings ${embeddingSkipped ? embeddingSkipReason : embeddingTime + 's'}`);
+    console.log(`  LadybugDB ${lbugTime}s | FTS ${ftsTime}s | Embeddings ${embeddingSkipped ? embeddingSkipReason : embeddingTime + 's'}`);
     if (includeExtensions.length > 0) {
         console.log(`  File filter: ${includeExtensions.join(', ')}`);
     }
@@ -407,16 +426,19 @@ export const analyzeCommand = async (inputPath, options) => {
     if (aiContext.files.length > 0) {
         console.log(`  Context: ${aiContext.files.join(', ')}`);
     }
-    if (hookResult.registered) {
-        console.log(`  Hooks: ${hookResult.message}`);
-    }
-    // Show fallback summary with pair-level preview and explicit outcomes
-    if (kuzuWarnings.length > 0) {
-        const fallbackLines = formatFallbackSummary(kuzuWarnings, kuzuResult.fallbackStats);
+    if (lbugWarnings.length > 0) {
+        const totalFallback = lbugWarnings.reduce((sum, warning) => {
+            const match = warning.match(/\((\d+) edges\)/);
+            return sum + (match ? Number.parseInt(match[1], 10) : 0);
+        }, 0);
+        const fallbackLines = formatFallbackSummary(lbugWarnings, {
+            attempted: totalFallback,
+            succeeded: totalFallback,
+            failed: 0,
+        });
         for (const line of fallbackLines) {
             console.log(`  ${line}`);
         }
-        console.log('  Note: schema pair coverage should be updated when fallback failures are non-zero');
     }
     try {
         await fs.access(getGlobalRegistryPath());
@@ -425,12 +447,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);
-    }
+    // LadybugDB's native module holds open handles that prevent Node from exiting.
+    // ONNX Runtime also registers native atexit hooks that segfault on some
+    // platforms (#38, #40). Force-exit to ensure clean termination.
+    process.exit(0);
 };
 async function persistUnityParitySeed(storagePath, seed) {
     const seedPath = path.join(storagePath, 'unity-parity-seed.json');

package/dist/cli/augment.js

@@ -19,7 +19,7 @@ export async function augmentCommand(pattern) {
         const result = await augment(pattern, process.cwd());
         if (result) {
             // IMPORTANT: Write to stderr, NOT stdout.
-            // KuzuDB's native module captures stdout fd at OS level during init,
+            // LadybugDB's native module captures stdout fd at OS level during init,
             // which makes stdout permanently broken in subprocess contexts.
             // stderr is never captured, so it works reliably everywhere.
             // The hook reads from the subprocess's stderr.

package/dist/cli/eval-server.d.ts

@@ -1,7 +1,7 @@
 /**
  * Eval Server — Lightweight HTTP server for SWE-bench evaluation
  *
- * Keeps KuzuDB warm in memory so tool calls from the agent are near-instant.
+ * Keeps LadybugDB warm in memory so tool calls from the agent are near-instant.
  * Designed to run inside Docker containers during SWE-bench evaluation.
  *
  * KEY DESIGN: Returns LLM-friendly text, not raw JSON.
@@ -27,4 +27,11 @@ export interface EvalServerOptions {
     port?: string;
     idleTimeout?: string;
 }
+export declare function formatQueryResult(result: any): string;
+export declare function formatContextResult(result: any): string;
+export declare function formatImpactResult(result: any): string;
+export declare function formatCypherResult(result: any): string;
+export declare function formatDetectChangesResult(result: any): string;
+export declare function formatListReposResult(result: any): string;
 export declare function evalServerCommand(options?: EvalServerOptions): Promise<void>;
+export declare const MAX_BODY_SIZE: number;