gitnexus 1.4.1 → 1.4.6

package/dist/mcp/resources.js

@@ -256,48 +256,48 @@ async function getProcessesResource(backend, repoName) {
  * Schema resource — graph structure for Cypher queries
  */
 function getSchemaResource() {
-    return `# GitNexus Graph Schema
-
-nodes:
-  - File: Source code files
-  - Folder: Directory containers
-  - Function: Functions and arrow functions
-  - Class: Class definitions
-  - Interface: Interface/type definitions
-  - Method: Class methods
-  - CodeElement: Catch-all for other code elements
-  - Community: Auto-detected functional area (Leiden algorithm)
-  - Process: Execution flow trace
-
-additional_node_types: "Multi-language: Struct, Enum, Macro, Typedef, Union, Namespace, Trait, Impl, TypeAlias, Const, Static, Property, Record, Delegate, Annotation, Constructor, Template, Module (use backticks in queries: \`Struct\`, \`Enum\`, etc.)"
-
-relationships:
-  - CONTAINS: File/Folder contains child
-  - DEFINES: File defines a symbol
-  - CALLS: Function/method invocation
-  - IMPORTS: Module imports
-  - EXTENDS: Class inheritance
-  - IMPLEMENTS: Interface implementation
-  - MEMBER_OF: Symbol belongs to community
-  - STEP_IN_PROCESS: Symbol is step N in process
-
-relationship_table: "All relationships use a single CodeRelation table with a 'type' property. Properties: type (STRING), confidence (DOUBLE), reason (STRING), step (INT32)"
-
-example_queries:
-  find_callers: |
-    MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "myFunc"})
-    RETURN caller.name, caller.filePath
-  
-  find_community_members: |
-    MATCH (s)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
-    WHERE c.heuristicLabel = "Auth"
-    RETURN s.name, labels(s)[0] AS type
-  
-  trace_process: |
-    MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
-    WHERE p.heuristicLabel = "LoginFlow"
-    RETURN s.name, r.step
-    ORDER BY r.step
+    return `# GitNexus Graph Schema
+
+nodes:
+  - File: Source code files
+  - Folder: Directory containers
+  - Function: Functions and arrow functions
+  - Class: Class definitions
+  - Interface: Interface/type definitions
+  - Method: Class methods
+  - CodeElement: Catch-all for other code elements
+  - Community: Auto-detected functional area (Leiden algorithm)
+  - Process: Execution flow trace
+
+additional_node_types: "Multi-language: Struct, Enum, Macro, Typedef, Union, Namespace, Trait, Impl, TypeAlias, Const, Static, Property, Record, Delegate, Annotation, Constructor, Template, Module (use backticks in queries: \`Struct\`, \`Enum\`, etc.)"
+
+relationships:
+  - CONTAINS: File/Folder contains child
+  - DEFINES: File defines a symbol
+  - CALLS: Function/method invocation
+  - IMPORTS: Module imports
+  - EXTENDS: Class inheritance
+  - IMPLEMENTS: Interface implementation
+  - MEMBER_OF: Symbol belongs to community
+  - STEP_IN_PROCESS: Symbol is step N in process
+
+relationship_table: "All relationships use a single CodeRelation table with a 'type' property. Properties: type (STRING), confidence (DOUBLE), reason (STRING), step (INT32)"
+
+example_queries:
+  find_callers: |
+    MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "myFunc"})
+    RETURN caller.name, caller.filePath
+  
+  find_community_members: |
+    MATCH (s)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
+    WHERE c.heuristicLabel = "Auth"
+    RETURN s.name, labels(s)[0] AS type
+  
+  trace_process: |
+    MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
+    WHERE p.heuristicLabel = "LoginFlow"
+    RETURN s.name, r.step
+    ORDER BY r.step
 `;
 }
 /**

package/dist/mcp/server.js

@@ -12,7 +12,7 @@
  */
 import { createRequire } from 'module';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CompatibleStdioServerTransport } from './compatible-stdio-transport.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListResourceTemplatesRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { GITNEXUS_TOOLS } from './tools.js';
 import { getResourceDefinitions, getResourceTemplates, readResource } from './resources.js';
@@ -192,15 +192,14 @@ export function createMCPServer(backend) {
                         role: 'user',
                         content: {
                             type: 'text',
-                            text: `Analyze the impact of my current code changes before committing.
-
-Follow these steps:
-1. First, run \`git diff ${scope === 'staged' ? '--staged' : scope === 'compare' && baseRef ? baseRef : 'HEAD'} --name-only\` locally to get the list of changed files
-2. Run \`detect_changes({ changed_files: [<files from step 1>]${baseRef ? `, base_ref: "${baseRef}"` : ''} })\` to map changed files to symbols and find affected processes
-3. For each changed symbol in critical processes, run \`context({name: "<symbol>"})\` to see its full reference graph
-4. For any high-risk items (many callers or cross-process), run \`impact({target: "<symbol>", direction: "upstream"})\` for blast radius
-5. Summarize: changes, affected processes, risk level, and recommended actions
-
+                            text: `Analyze the impact of my current code changes before committing.
+
+Follow these steps:
+1. Run \`detect_changes(${JSON.stringify({ scope, ...(baseRef ? { base_ref: baseRef } : {}) })})\` to find what changed and affected processes
+2. For each changed symbol in critical processes, run \`context({name: "<symbol>"})\` to see its full reference graph
+3. For any high-risk items (many callers or cross-process), run \`impact({target: "<symbol>", direction: "upstream"})\` for blast radius
+4. Summarize: changes, affected processes, risk level, and recommended actions
+
 Present the analysis as a clear risk report.`,
                         },
                     },
@@ -215,14 +214,14 @@ Present the analysis as a clear risk report.`,
                         role: 'user',
                         content: {
                             type: 'text',
-                            text: `Generate architecture documentation for this codebase using the knowledge graph.
-
-Follow these steps:
-1. READ \`gitnexus://repo/${repo || '{name}'}/context\` for codebase stats
-2. READ \`gitnexus://repo/${repo || '{name}'}/clusters\` to see all functional areas
-3. READ \`gitnexus://repo/${repo || '{name}'}/processes\` to see all execution flows
-4. For the top 5 most important processes, READ \`gitnexus://repo/${repo || '{name}'}/process/{name}\` for step-by-step traces
-5. Generate a mermaid architecture diagram showing the major areas and their connections
+                            text: `Generate architecture documentation for this codebase using the knowledge graph.
+
+Follow these steps:
+1. READ \`gitnexus://repo/${repo || '{name}'}/context\` for codebase stats
+2. READ \`gitnexus://repo/${repo || '{name}'}/clusters\` to see all functional areas
+3. READ \`gitnexus://repo/${repo || '{name}'}/processes\` to see all execution flows
+4. For the top 5 most important processes, READ \`gitnexus://repo/${repo || '{name}'}/process/{name}\` for step-by-step traces
+5. Generate a mermaid architecture diagram showing the major areas and their connections
 6. Write an ARCHITECTURE.md file with: overview, functional areas, key execution flows, and the mermaid diagram`,
                         },
                     },
@@ -239,7 +238,7 @@ Follow these steps:
 export async function startMCPServer(backend) {
     const server = createMCPServer(backend);
     // Connect to stdio transport
-    const transport = new StdioServerTransport();
+    const transport = new CompatibleStdioServerTransport();
     await server.connect(transport);
     // Graceful shutdown helper
     let shuttingDown = false;

package/dist/mcp/tools.js

@@ -7,19 +7,15 @@
 export const GITNEXUS_TOOLS = [
     {
         name: 'list_repos',
-        description: `List all indexed repositories available to GitNexus.
-
-Returns each repo's name, branch, indexed date, last commit, and stats.
-
-WHEN TO USE: First step when multiple repos are indexed, or to discover available repos.
-AFTER THIS: READ gitnexus://repo/{name}/context for the repo you want to work with.
-
-When multiple repos are indexed, you MUST specify the "repo" parameter
-on other tools (query, context, impact, etc.) to target the correct one.
-
-BRANCH HANDLING: The same repo can be indexed on different branches. Non-default
-branches appear as "owner/repo@branch" in the list. Use that exact name as the
-"repo" parameter in other tools to target the correct branch's graph.`,
+        description: `List all indexed repositories available to GitNexus.
+
+Returns each repo's name, path, indexed date, last commit, and stats.
+
+WHEN TO USE: First step when multiple repos are indexed, or to discover available repos.
+AFTER THIS: READ gitnexus://repo/{name}/context for the repo you want to work with.
+
+When multiple repos are indexed, you MUST specify the "repo" parameter
+on other tools (query, context, impact, etc.) to target the correct one.`,
         inputSchema: {
             type: 'object',
             properties: {},
@@ -28,17 +24,17 @@ branches appear as "owner/repo@branch" in the list. Use that exact name as the
     },
     {
         name: 'query',
-        description: `Query the code knowledge graph for execution flows related to a concept.
-Returns processes (call chains) ranked by relevance, each with its symbols and file locations.
-
-WHEN TO USE: Understanding how code works together. Use this when you need execution flows and relationships, not just file matches. Complements grep/IDE search.
-AFTER THIS: Use context() on a specific symbol for 360-degree view (callers, callees, categorized refs).
-
-Returns results grouped by process (execution flow):
-- processes: ranked execution flows with relevance priority
-- process_symbols: all symbols in those flows with file locations and module (functional area)
-- definitions: standalone types/interfaces not in any process
-
+        description: `Query the code knowledge graph for execution flows related to a concept.
+Returns processes (call chains) ranked by relevance, each with its symbols and file locations.
+
+WHEN TO USE: Understanding how code works together. Use this when you need execution flows and relationships, not just file matches. Complements grep/IDE search.
+AFTER THIS: Use context() on a specific symbol for 360-degree view (callers, callees, categorized refs).
+
+Returns results grouped by process (execution flow):
+- processes: ranked execution flows with relevance priority
+- process_symbols: all symbols in those flows with file locations and module (functional area)
+- definitions: standalone types/interfaces not in any process
+
 Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank Fusion.`,
         inputSchema: {
             type: 'object',
@@ -49,59 +45,68 @@ Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank
                 limit: { type: 'number', description: 'Max processes to return (default: 5)', default: 5 },
                 max_symbols: { type: 'number', description: 'Max symbols per process (default: 10)', default: 10 },
                 include_content: { type: 'boolean', description: 'Include full symbol source code (default: false)', default: false },
-                repo: { type: 'string', description: 'Repository name (e.g. "owner/repo"). For repos indexed on a specific branch, append @branch (e.g. "owner/repo@develop"). Omit if only one repo is indexed. Use list_repos to see available repos.' },
+                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
             },
             required: ['query'],
         },
     },
     {
         name: 'cypher',
-        description: `Execute Cypher query against the code knowledge graph.
-
-WHEN TO USE: Complex structural queries that search/explore can't answer. READ gitnexus://repo/{name}/schema first for the full schema.
-AFTER THIS: Use context() on result symbols for deeper context.
-
-SCHEMA:
-- Nodes: File, Folder, Function, Class, Interface, Method, CodeElement, Community, Process
-- Multi-language nodes (use backticks): \`Struct\`, \`Enum\`, \`Trait\`, \`Impl\`, etc.
-- All edges via single CodeRelation table with 'type' property
-- Edge types: CONTAINS, DEFINES, CALLS, IMPORTS, EXTENDS, IMPLEMENTS, MEMBER_OF, STEP_IN_PROCESS
-- Edge properties: type (STRING), confidence (DOUBLE), reason (STRING), step (INT32)
-
-EXAMPLES:
-• Find callers of a function:
-  MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b:Function {name: "validateUser"}) RETURN a.name, a.filePath
-
-• Find community members:
-  MATCH (f)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community) WHERE c.heuristicLabel = "Auth" RETURN f.name
-
-• Trace a process:
-  MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process) WHERE p.heuristicLabel = "UserLogin" RETURN s.name, r.step ORDER BY r.step
-
-OUTPUT: Returns { markdown, row_count } — results formatted as a Markdown table for easy reading.
-
-TIPS:
-- All relationships use single CodeRelation table — filter with {type: 'CALLS'} etc.
-- Community = auto-detected functional area (Leiden algorithm)
-- Process = execution flow trace from entry point to terminal
+        description: `Execute Cypher query against the code knowledge graph.
+
+WHEN TO USE: Complex structural queries that search/explore can't answer. READ gitnexus://repo/{name}/schema first for the full schema.
+AFTER THIS: Use context() on result symbols for deeper context.
+
+SCHEMA:
+- Nodes: File, Folder, Function, Class, Interface, Method, CodeElement, Community, Process
+- Multi-language nodes (use backticks): \`Struct\`, \`Enum\`, \`Trait\`, \`Impl\`, etc.
+- All edges via single CodeRelation table with 'type' property
+- Edge types: CONTAINS, DEFINES, CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, OVERRIDES, MEMBER_OF, STEP_IN_PROCESS
+- Edge properties: type (STRING), confidence (DOUBLE), reason (STRING), step (INT32)
+
+EXAMPLES:
+• Find callers of a function:
+  MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b:Function {name: "validateUser"}) RETURN a.name, a.filePath
+
+• Find community members:
+  MATCH (f)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community) WHERE c.heuristicLabel = "Auth" RETURN f.name
+
+• Trace a process:
+  MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process) WHERE p.heuristicLabel = "UserLogin" RETURN s.name, r.step ORDER BY r.step
+
+• Find all methods of a class:
+  MATCH (c:Class {name: "UserService"})-[r:CodeRelation {type: 'HAS_METHOD'}]->(m:Method) RETURN m.name, m.parameterCount, m.returnType
+
+• Find method overrides (MRO resolution):
+  MATCH (winner:Method)-[r:CodeRelation {type: 'OVERRIDES'}]->(loser:Method) RETURN winner.name, winner.filePath, loser.filePath, r.reason
+
+• Detect diamond inheritance:
+  MATCH (d:Class)-[:CodeRelation {type: 'EXTENDS'}]->(b1), (d)-[:CodeRelation {type: 'EXTENDS'}]->(b2), (b1)-[:CodeRelation {type: 'EXTENDS'}]->(a), (b2)-[:CodeRelation {type: 'EXTENDS'}]->(a) WHERE b1 <> b2 RETURN d.name, b1.name, b2.name, a.name
+
+OUTPUT: Returns { markdown, row_count } — results formatted as a Markdown table for easy reading.
+
+TIPS:
+- All relationships use single CodeRelation table — filter with {type: 'CALLS'} etc.
+- Community = auto-detected functional area (Leiden algorithm)
+- Process = execution flow trace from entry point to terminal
 - Use heuristicLabel (not label) for human-readable community/process names`,
         inputSchema: {
             type: 'object',
             properties: {
                 query: { type: 'string', description: 'Cypher query to execute' },
-                repo: { type: 'string', description: 'Repository name (e.g. "owner/repo"). For repos indexed on a specific branch, append @branch (e.g. "owner/repo@develop"). Omit if only one repo is indexed. Use list_repos to see available repos.' },
+                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
             },
             required: ['query'],
         },
     },
     {
         name: 'context',
-        description: `360-degree view of a single code symbol.
-Shows categorized incoming/outgoing references (calls, imports, extends, implements), process participation, and file location.
-
-WHEN TO USE: After query() to understand a specific symbol in depth. When you need to know all callers, callees, and what execution flows a symbol participates in.
-AFTER THIS: Use impact() if planning changes, or READ gitnexus://repo/{name}/process/{processName} for full execution trace.
-
+        description: `360-degree view of a single code symbol.
+Shows categorized incoming/outgoing references (calls, imports, extends, implements), process participation, and file location.
+
+WHEN TO USE: After query() to understand a specific symbol in depth. When you need to know all callers, callees, and what execution flows a symbol participates in.
+AFTER THIS: Use impact() if planning changes, or READ gitnexus://repo/{name}/process/{processName} for full execution trace.
+
 Handles disambiguation: if multiple symbols share the same name, returns candidates for you to pick from. Use uid param for zero-ambiguity lookup from prior results.`,
         inputSchema: {
             type: 'object',
@@ -110,46 +115,40 @@ Handles disambiguation: if multiple symbols share the same name, returns candida
                 uid: { type: 'string', description: 'Direct symbol UID from prior tool results (zero-ambiguity lookup)' },
                 file_path: { type: 'string', description: 'File path to disambiguate common names' },
                 include_content: { type: 'boolean', description: 'Include full symbol source code (default: false)', default: false },
-                repo: { type: 'string', description: 'Repository name (e.g. "owner/repo"). For repos indexed on a specific branch, append @branch (e.g. "owner/repo@develop"). Omit if only one repo is indexed. Use list_repos to see available repos.' },
+                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
             },
             required: [],
         },
     },
     {
         name: 'detect_changes',
-        description: `Analyze code changes and find affected execution flows.
-Maps changed files to indexed symbols, then traces which processes are impacted.
-
-WHEN TO USE: Before committing — to understand what your changes affect. Pre-commit review, PR preparation.
-AFTER THIS: Review affected processes. Use context() on high-risk symbols. READ gitnexus://repo/{name}/process/{name} for full traces.
-
-FOR HUB USERS: The Hub server has no local git checkout. You MUST provide the changed_files
-parameter by running git diff locally first and passing the file list. Example:
-  1. Run \`git diff --name-only\` (or \`git diff HEAD --name-only\` for all changes)
-  2. Pass the resulting file paths as the changed_files array
-
+        description: `Analyze uncommitted git changes and find affected execution flows.
+Maps git diff hunks to indexed symbols, then traces which processes are impacted.
+
+WHEN TO USE: Before committing — to understand what your changes affect. Pre-commit review, PR preparation.
+AFTER THIS: Review affected processes. Use context() on high-risk symbols. READ gitnexus://repo/{name}/process/{name} for full traces.
+
 Returns: changed symbols, affected processes, and a risk summary.`,
         inputSchema: {
             type: 'object',
             properties: {
                 scope: { type: 'string', description: 'What to analyze: "unstaged" (default), "staged", "all", or "compare"', enum: ['unstaged', 'staged', 'all', 'compare'], default: 'unstaged' },
                 base_ref: { type: 'string', description: 'Branch/commit for "compare" scope (e.g., "main")' },
-                changed_files: { type: 'array', items: { type: 'string' }, description: 'Pre-computed list of changed file paths (from local git diff). Required for Hub MCP — the server has no git checkout. The local MCP server ignores this and runs git diff itself.' },
-                repo: { type: 'string', description: 'Repository name (e.g. "owner/repo"). For repos indexed on a specific branch, append @branch (e.g. "owner/repo@develop"). Omit if only one repo is indexed. Use list_repos to see available repos.' },
+                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
             },
             required: [],
         },
     },
     {
         name: 'rename',
-        description: `Multi-file coordinated rename using the knowledge graph + text search.
-Finds all references via graph (high confidence) and regex text search (lower confidence). Preview by default.
-
-WHEN TO USE: Renaming a function, class, method, or variable across the codebase. Safer than find-and-replace.
-AFTER THIS: Run detect_changes() to verify no unexpected side effects.
-
-Each edit is tagged with confidence:
-- "graph": found via knowledge graph relationships (high confidence, safe to accept)
+        description: `Multi-file coordinated rename using the knowledge graph + text search.
+Finds all references via graph (high confidence) and regex text search (lower confidence). Preview by default.
+
+WHEN TO USE: Renaming a function, class, method, or variable across the codebase. Safer than find-and-replace.
+AFTER THIS: Run detect_changes() to verify no unexpected side effects.
+
+Each edit is tagged with confidence:
+- "graph": found via knowledge graph relationships (high confidence, safe to accept)
 - "text_search": found via regex text search (lower confidence, review carefully)`,
         inputSchema: {
             type: 'object',
@@ -159,32 +158,32 @@ Each edit is tagged with confidence:
                 new_name: { type: 'string', description: 'The new name for the symbol' },
                 file_path: { type: 'string', description: 'File path to disambiguate common names' },
                 dry_run: { type: 'boolean', description: 'Preview edits without modifying files (default: true)', default: true },
-                repo: { type: 'string', description: 'Repository name (e.g. "owner/repo"). For repos indexed on a specific branch, append @branch (e.g. "owner/repo@develop"). Omit if only one repo is indexed. Use list_repos to see available repos.' },
+                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
             },
             required: ['new_name'],
         },
     },
     {
         name: 'impact',
-        description: `Analyze the blast radius of changing a code symbol.
-Returns affected symbols grouped by depth, plus risk assessment, affected execution flows, and affected modules.
-
-WHEN TO USE: Before making code changes — especially refactoring, renaming, or modifying shared code. Shows what would break.
-AFTER THIS: Review d=1 items (WILL BREAK). Use context() on high-risk symbols.
-
-Output includes:
-- risk: LOW / MEDIUM / HIGH / CRITICAL
-- summary: direct callers, processes affected, modules affected
-- affected_processes: which execution flows break and at which step
-- affected_modules: which functional areas are hit (direct vs indirect)
-- byDepth: all affected symbols grouped by traversal depth
-
-Depth groups:
-- d=1: WILL BREAK (direct callers/importers)
-- d=2: LIKELY AFFECTED (indirect)
-- d=3: MAY NEED TESTING (transitive)
-
-EdgeType: CALLS, IMPORTS, EXTENDS, IMPLEMENTS
+        description: `Analyze the blast radius of changing a code symbol.
+Returns affected symbols grouped by depth, plus risk assessment, affected execution flows, and affected modules.
+
+WHEN TO USE: Before making code changes — especially refactoring, renaming, or modifying shared code. Shows what would break.
+AFTER THIS: Review d=1 items (WILL BREAK). Use context() on high-risk symbols.
+
+Output includes:
+- risk: LOW / MEDIUM / HIGH / CRITICAL
+- summary: direct callers, processes affected, modules affected
+- affected_processes: which execution flows break and at which step
+- affected_modules: which functional areas are hit (direct vs indirect)
+- byDepth: all affected symbols grouped by traversal depth
+
+Depth groups:
+- d=1: WILL BREAK (direct callers/importers)
+- d=2: LIKELY AFFECTED (indirect)
+- d=3: MAY NEED TESTING (transitive)
+
+EdgeType: CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, OVERRIDES
 Confidence: 1.0 = certain, <0.8 = fuzzy match`,
         inputSchema: {
             type: 'object',
@@ -192,10 +191,10 @@ Confidence: 1.0 = certain, <0.8 = fuzzy match`,
                 target: { type: 'string', description: 'Name of function, class, or file to analyze' },
                 direction: { type: 'string', description: 'upstream (what depends on this) or downstream (what this depends on)' },
                 maxDepth: { type: 'number', description: 'Max relationship depth (default: 3)', default: 3 },
-                relationTypes: { type: 'array', items: { type: 'string' }, description: 'Filter: CALLS, IMPORTS, EXTENDS, IMPLEMENTS (default: usage-based)' },
+                relationTypes: { type: 'array', items: { type: 'string' }, description: 'Filter: CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, OVERRIDES (default: usage-based)' },
                 includeTests: { type: 'boolean', description: 'Include test files (default: false)' },
                 minConfidence: { type: 'number', description: 'Minimum confidence 0-1 (default: 0.7)' },
-                repo: { type: 'string', description: 'Repository name (e.g. "owner/repo"). For repos indexed on a specific branch, append @branch (e.g. "owner/repo@develop"). Omit if only one repo is indexed. Use list_repos to see available repos.' },
+                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
             },
             required: ['target', 'direction'],
         },

package/dist/server/api.js

@@ -12,9 +12,9 @@ import cors from 'cors';
 import path from 'path';
 import fs from 'fs/promises';
 import { loadMeta, listRegisteredRepos } from '../storage/repo-manager.js';
-import { executeQuery, closeKuzu, withKuzuDb } from '../core/kuzu/kuzu-adapter.js';
-import { NODE_TABLES } from '../core/kuzu/schema.js';
-import { searchFTSFromKuzu } from '../core/search/bm25-index.js';
+import { executeQuery, closeLbug, withLbugDb } from '../core/lbug/lbug-adapter.js';
+import { NODE_TABLES } from '../core/lbug/schema.js';
+import { searchFTSFromLbug } from '../core/search/bm25-index.js';
 import { hybridSearch } from '../core/search/hybrid-search.js';
 // Embedding imports are lazy (dynamic import) to avoid loading onnxruntime-node
 // at server startup — crashes on unsupported Node ABI versions (#89)
@@ -171,8 +171,8 @@ export const createServer = async (port, host = '127.0.0.1') => {
                 res.status(404).json({ error: 'Repository not found' });
                 return;
             }
-            const kuzuPath = path.join(entry.storagePath, 'kuzu');
-            const graph = await withKuzuDb(kuzuPath, async () => buildGraph());
+            const lbugPath = path.join(entry.storagePath, 'lbug');
+            const graph = await withLbugDb(lbugPath, async () => buildGraph());
             res.json(graph);
         }
         catch (err) {
@@ -192,8 +192,8 @@ export const createServer = async (port, host = '127.0.0.1') => {
                 res.status(404).json({ error: 'Repository not found' });
                 return;
             }
-            const kuzuPath = path.join(entry.storagePath, 'kuzu');
-            const result = await withKuzuDb(kuzuPath, () => executeQuery(cypher));
+            const lbugPath = path.join(entry.storagePath, 'lbug');
+            const result = await withLbugDb(lbugPath, () => executeQuery(cypher));
             res.json({ result });
         }
         catch (err) {
@@ -213,19 +213,19 @@ export const createServer = async (port, host = '127.0.0.1') => {
                 res.status(404).json({ error: 'Repository not found' });
                 return;
             }
-            const kuzuPath = path.join(entry.storagePath, 'kuzu');
+            const lbugPath = path.join(entry.storagePath, 'lbug');
             const parsedLimit = Number(req.body.limit ?? 10);
             const limit = Number.isFinite(parsedLimit)
                 ? Math.max(1, Math.min(100, Math.trunc(parsedLimit)))
                 : 10;
-            const results = await withKuzuDb(kuzuPath, async () => {
+            const results = await withLbugDb(lbugPath, async () => {
                 const { isEmbedderReady } = await import('../core/embeddings/embedder.js');
                 if (isEmbedderReady()) {
                     const { semanticSearch } = await import('../core/embeddings/embedding-pipeline.js');
                     return hybridSearch(query, limit, executeQuery, semanticSearch);
                 }
                 // FTS-only fallback when embeddings aren't loaded
-                return searchFTSFromKuzu(query, limit);
+                return searchFTSFromLbug(query, limit);
             });
             res.json({ results });
         }
@@ -331,11 +331,11 @@ export const createServer = async (port, host = '127.0.0.1') => {
     const server = app.listen(port, host, () => {
         console.log(`GitNexus server running on http://${host}:${port}`);
     });
-    // Graceful shutdown — close Express + KuzuDB cleanly
+    // Graceful shutdown — close Express + LadybugDB cleanly
     const shutdown = async () => {
         server.close();
         await cleanupMcp();
-        await closeKuzu();
+        await closeLbug();
         await backend.disconnect();
         process.exit(0);
     };

package/dist/server/mcp-http.d.ts

@@ -3,7 +3,7 @@
  *
  * Mounts the GitNexus MCP server on Express using StreamableHTTP transport.
  * Each connecting client gets its own stateful session; the LocalBackend
- * is shared across all sessions (thread-safe — lazy KuzuDB per repo).
+ * is shared across all sessions (thread-safe — lazy LadybugDB per repo).
  *
  * Sessions are cleaned up on explicit close or after SESSION_TTL_MS of inactivity
  * (guards against network drops that never trigger onclose).

package/dist/server/mcp-http.js

@@ -3,7 +3,7 @@
  *
  * Mounts the GitNexus MCP server on Express using StreamableHTTP transport.
  * Each connecting client gets its own stateful session; the LocalBackend
- * is shared across all sessions (thread-safe — lazy KuzuDB per repo).
+ * is shared across all sessions (thread-safe — lazy LadybugDB per repo).
  *
  * Sessions are cleaned up on explicit close or after SESSION_TTL_MS of inactivity
  * (guards against network drops that never trigger onclose).

package/dist/storage/repo-manager.d.ts

@@ -21,7 +21,7 @@ export interface RepoMeta {
 export interface IndexedRepo {
     repoPath: string;
     storagePath: string;
-    kuzuPath: string;
+    lbugPath: string;
     metaPath: string;
     meta: RepoMeta;
 }
@@ -45,9 +45,27 @@ export declare const getStoragePath: (repoPath: string) => string;
  */
 export declare const getStoragePaths: (repoPath: string) => {
     storagePath: string;
-    kuzuPath: string;
+    lbugPath: string;
     metaPath: string;
 };
+/**
+ * Check whether a KuzuDB index exists in the given storage path.
+ * Non-destructive — safe to call from status commands.
+ */
+export declare const hasKuzuIndex: (storagePath: string) => Promise<boolean>;
+/**
+ * Clean up stale KuzuDB files after migration to LadybugDB.
+ *
+ * Returns:
+ *   found        — true if .gitnexus/kuzu existed and was deleted
+ *   needsReindex — true if kuzu existed but lbug does not (re-analyze required)
+ *
+ * Callers own the user-facing messaging; this function only deletes files.
+ */
+export declare const cleanupOldKuzuFiles: (storagePath: string) => Promise<{
+    found: boolean;
+    needsReindex: boolean;
+}>;
 /**
  * Load metadata from an indexed repo
  */