@veewo/gitnexus 1.3.11 → 1.4.7-rc

package/dist/mcp/local/unity-parity-seed-loader.d.ts

@@ -1,2 +1,7 @@
 import type { UnityParitySeed } from '../../core/ingestion/unity-parity-seed.js';
-export declare function loadUnityParitySeed(storagePath: string): Promise<UnityParitySeed | null>;
+interface LoadUnityParitySeedOptions {
+    indexedCommit?: string;
+}
+export declare function loadUnityParitySeed(storagePath: string, options?: LoadUnityParitySeedOptions): Promise<UnityParitySeed | null>;
+export declare function __resetUnityParitySeedLoaderCacheForTest(): void;
+export {};

package/dist/mcp/local/unity-parity-seed-loader.js

@@ -1,18 +1,46 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 const SEED_FILENAME = 'unity-parity-seed.json';
-export async function loadUnityParitySeed(storagePath) {
+const DEFAULT_IDLE_MS = 30_000;
+const DEFAULT_MAX_ENTRIES = 2;
+const seedCache = new Map();
+const inFlightLoads = new Map();
+export async function loadUnityParitySeed(storagePath, options) {
     const seedPath = path.join(storagePath, SEED_FILENAME);
-    let raw = '';
-    try {
-        raw = await fs.readFile(seedPath, 'utf-8');
+    const cacheKey = await buildSeedCacheKey(seedPath, storagePath, options?.indexedCommit);
+    if (!cacheKey) {
+        return null;
     }
-    catch (error) {
-        if (error.code === 'ENOENT') {
-            return null;
-        }
-        throw error;
+    const cached = seedCache.get(cacheKey);
+    if (cached) {
+        touchCacheEntry(cacheKey, cached);
+        return cached.value;
+    }
+    const pending = inFlightLoads.get(cacheKey);
+    if (pending) {
+        return pending;
     }
+    const loadPromise = (async () => {
+        let raw = '';
+        try {
+            raw = await fs.readFile(seedPath, 'utf-8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+        const parsed = parseSeed(raw);
+        setCacheEntry(cacheKey, parsed);
+        return parsed;
+    })().finally(() => {
+        inFlightLoads.delete(cacheKey);
+    });
+    inFlightLoads.set(cacheKey, loadPromise);
+    return loadPromise;
+}
+function parseSeed(raw) {
     try {
         const parsed = JSON.parse(raw);
         if (!parsed
@@ -28,3 +56,85 @@ export async function loadUnityParitySeed(storagePath) {
         return null;
     }
 }
+async function buildSeedCacheKey(seedPath, storagePath, indexedCommit) {
+    try {
+        const stat = await fs.stat(seedPath);
+        const commitKey = String(indexedCommit || '').trim() || 'no-commit';
+        return `${storagePath}::${commitKey}::${Math.trunc(stat.mtimeMs)}`;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+function setCacheEntry(cacheKey, value) {
+    const now = Date.now();
+    const existing = seedCache.get(cacheKey);
+    if (existing?.idleTimer) {
+        clearTimeout(existing.idleTimer);
+    }
+    const entry = {
+        value,
+        lastAccessMs: now,
+    };
+    seedCache.set(cacheKey, entry);
+    scheduleEviction(cacheKey, entry);
+    pruneOldestEntries(resolveMaxEntries());
+}
+function touchCacheEntry(cacheKey, entry) {
+    entry.lastAccessMs = Date.now();
+    if (entry.idleTimer) {
+        clearTimeout(entry.idleTimer);
+    }
+    scheduleEviction(cacheKey, entry);
+}
+function scheduleEviction(cacheKey, entry) {
+    const idleMs = resolveIdleMs();
+    entry.idleTimer = setTimeout(() => {
+        const current = seedCache.get(cacheKey);
+        if (!current || current !== entry) {
+            return;
+        }
+        seedCache.delete(cacheKey);
+    }, idleMs);
+    entry.idleTimer.unref?.();
+}
+function pruneOldestEntries(maxEntries) {
+    if (seedCache.size <= maxEntries) {
+        return;
+    }
+    const rows = [...seedCache.entries()].sort((left, right) => left[1].lastAccessMs - right[1].lastAccessMs);
+    const removeCount = rows.length - maxEntries;
+    for (let index = 0; index < removeCount; index += 1) {
+        const [key, entry] = rows[index];
+        if (entry.idleTimer) {
+            clearTimeout(entry.idleTimer);
+        }
+        seedCache.delete(key);
+    }
+}
+function resolveIdleMs() {
+    const parsed = Number.parseInt(String(process.env.GITNEXUS_UNITY_PARITY_SEED_CACHE_IDLE_MS || '').trim(), 10);
+    if (Number.isFinite(parsed) && parsed > 0) {
+        return parsed;
+    }
+    return DEFAULT_IDLE_MS;
+}
+function resolveMaxEntries() {
+    const parsed = Number.parseInt(String(process.env.GITNEXUS_UNITY_PARITY_SEED_CACHE_MAX_ENTRIES || '').trim(), 10);
+    if (Number.isFinite(parsed) && parsed > 0) {
+        return parsed;
+    }
+    return DEFAULT_MAX_ENTRIES;
+}
+export function __resetUnityParitySeedLoaderCacheForTest() {
+    for (const entry of seedCache.values()) {
+        if (entry.idleTimer) {
+            clearTimeout(entry.idleTimer);
+        }
+    }
+    seedCache.clear();
+    inFlightLoads.clear();
+}

package/dist/mcp/local/unity-parity-seed-loader.test.js

@@ -3,23 +3,111 @@ import assert from 'node:assert/strict';
 import os from 'node:os';
 import path from 'node:path';
 import fs from 'node:fs/promises';
-import { loadUnityParitySeed } from './unity-parity-seed-loader.js';
+import { __resetUnityParitySeedLoaderCacheForTest, loadUnityParitySeed } from './unity-parity-seed-loader.js';
+const baseSeed = {
+    version: 1,
+    symbolToScriptPath: { DoorObj: 'Assets/Code/DoorObj.cs' },
+    scriptPathToGuid: { 'Assets/Code/DoorObj.cs': 'abc123abc123abc123abc123abc123ab' },
+    guidToResourcePaths: { abc123abc123abc123abc123abc123ab: ['Assets/Prefabs/Door.prefab'] },
+};
+async function writeSeed(storagePath, symbol = 'DoorObj') {
+    await fs.writeFile(path.join(storagePath, 'unity-parity-seed.json'), JSON.stringify({
+        ...baseSeed,
+        symbolToScriptPath: { [symbol]: `Assets/Code/${symbol}.cs` },
+        scriptPathToGuid: { [`Assets/Code/${symbol}.cs`]: 'abc123abc123abc123abc123abc123ab' },
+    }), 'utf-8');
+}
 test('loadUnityParitySeed returns null on missing file and parsed object on valid file', async () => {
     const storagePath = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-seed-loader-'));
     try {
         const missing = await loadUnityParitySeed(storagePath);
         assert.equal(missing, null);
-        await fs.writeFile(path.join(storagePath, 'unity-parity-seed.json'), JSON.stringify({
-            version: 1,
-            symbolToScriptPath: { DoorObj: 'Assets/Code/DoorObj.cs' },
-            scriptPathToGuid: { 'Assets/Code/DoorObj.cs': 'abc123abc123abc123abc123abc123ab' },
-            guidToResourcePaths: { abc123abc123abc123abc123abc123ab: ['Assets/Prefabs/Door.prefab'] },
-        }), 'utf-8');
+        await writeSeed(storagePath, 'DoorObj');
         const loaded = await loadUnityParitySeed(storagePath);
         assert.equal(loaded?.version, 1);
         assert.equal(loaded?.symbolToScriptPath.DoorObj, 'Assets/Code/DoorObj.cs');
     }
     finally {
+        __resetUnityParitySeedLoaderCacheForTest();
+        await fs.rm(storagePath, { recursive: true, force: true });
+    }
+});
+test('loadUnityParitySeed deduplicates concurrent requests for same storage key', async (t) => {
+    const storagePath = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-seed-loader-'));
+    try {
+        await writeSeed(storagePath, 'ConcurrentSymbol');
+        const readFileOriginal = fs.readFile.bind(fs);
+        let readFileCalls = 0;
+        t.mock.method(fs, 'readFile', async (...args) => {
+            readFileCalls += 1;
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            return readFileOriginal(...args);
+        });
+        const results = await Promise.all(Array.from({ length: 10 }, () => loadUnityParitySeed(storagePath)));
+        assert.equal(results.every((row) => row?.symbolToScriptPath.ConcurrentSymbol), true);
+        assert.equal(readFileCalls, 1);
+    }
+    finally {
+        __resetUnityParitySeedLoaderCacheForTest();
+        await fs.rm(storagePath, { recursive: true, force: true });
+    }
+});
+test('loadUnityParitySeed evicts idle cache entry after ttl', async (t) => {
+    const storagePath = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-seed-loader-'));
+    const idleEnvKey = 'GITNEXUS_UNITY_PARITY_SEED_CACHE_IDLE_MS';
+    const previousIdle = process.env[idleEnvKey];
+    process.env[idleEnvKey] = '15';
+    try {
+        await writeSeed(storagePath, 'IdleSymbol');
+        const readFileOriginal = fs.readFile.bind(fs);
+        let readFileCalls = 0;
+        t.mock.method(fs, 'readFile', async (...args) => {
+            readFileCalls += 1;
+            return readFileOriginal(...args);
+        });
+        await loadUnityParitySeed(storagePath);
+        await loadUnityParitySeed(storagePath);
+        assert.equal(readFileCalls, 1);
+        await new Promise((resolve) => setTimeout(resolve, 30));
+        await loadUnityParitySeed(storagePath);
+        assert.equal(readFileCalls, 2);
+    }
+    finally {
+        __resetUnityParitySeedLoaderCacheForTest();
+        if (previousIdle === undefined) {
+            delete process.env[idleEnvKey];
+        }
+        else {
+            process.env[idleEnvKey] = previousIdle;
+        }
+        await fs.rm(storagePath, { recursive: true, force: true });
+    }
+});
+test('loadUnityParitySeed invalidates cache when seed mtime changes', async (t) => {
+    const storagePath = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-seed-loader-'));
+    const seedPath = path.join(storagePath, 'unity-parity-seed.json');
+    try {
+        await writeSeed(storagePath, 'VersionA');
+        const readFileOriginal = fs.readFile.bind(fs);
+        let readFileCalls = 0;
+        t.mock.method(fs, 'readFile', async (...args) => {
+            readFileCalls += 1;
+            return readFileOriginal(...args);
+        });
+        const first = await loadUnityParitySeed(storagePath);
+        const second = await loadUnityParitySeed(storagePath);
+        assert.equal(first?.symbolToScriptPath.VersionA, 'Assets/Code/VersionA.cs');
+        assert.equal(second?.symbolToScriptPath.VersionA, 'Assets/Code/VersionA.cs');
+        assert.equal(readFileCalls, 1);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        await writeSeed(storagePath, 'VersionB');
+        await fs.utimes(seedPath, new Date(), new Date());
+        const third = await loadUnityParitySeed(storagePath);
+        assert.equal(third?.symbolToScriptPath.VersionB, 'Assets/Code/VersionB.cs');
+        assert.equal(readFileCalls, 2);
+    }
+    finally {
+        __resetUnityParitySeedLoaderCacheForTest();
         await fs.rm(storagePath, { recursive: true, force: true });
     }
 });

package/dist/mcp/resources.js

@@ -186,7 +186,7 @@ async function getContextResource(backend, repoName) {
     lines.push('  - cypher: Raw graph queries');
     lines.push('  - list_repos: Discover all indexed repositories');
     lines.push('');
-    lines.push('re_index: If data is stale, ask user whether to run `npx -y gitnexus analyze` (reuses previous analyze scope/options unless `--no-reuse-options` is passed). If user declines, clearly state retrieval may not reflect current code. For build/analyze/test commands, use 10-30 minute timeout; on failure/timeout, report exact tool output and do not auto-retry or silently switch to glob/grep fallback.');
+    lines.push('re_index: If data is stale, ask user whether to run `npx -y @veewo/gitnexus@latest analyze` (reuses previous analyze scope/options unless `--no-reuse-options` is passed). If user declines, clearly state retrieval may not reflect current code. For build/analyze/test commands, use 10-30 minute timeout; on failure/timeout, report exact tool output and do not auto-retry or silently switch to glob/grep fallback.');
     lines.push('');
     lines.push('resources_available:');
     lines.push('  - gitnexus://repos: All indexed repositories');
@@ -372,7 +372,7 @@ async function getProcessDetailResource(name, backend, repoName) {
 async function getSetupResource(backend) {
     const repos = await backend.listRepos();
     if (repos.length === 0) {
-        return '# GitNexus\n\nNo repositories indexed. Run: `npx gitnexus analyze` in a repository.';
+        return '# GitNexus\n\nNo repositories indexed. Run: `npx -y @veewo/gitnexus@latest analyze` in a repository.';
     }
     const sections = [];
     for (const repo of repos) {

package/dist/mcp/server.js

@@ -10,8 +10,9 @@
  * Tools: list_repos, query, cypher, context, impact, detect_changes, rename
  * Resources: repos, repo/{name}/context, repo/{name}/clusters, ...
  */
+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';
@@ -59,9 +60,11 @@ function getNextStepHint(toolName, args) {
  * Transport-agnostic — caller connects the desired transport.
  */
 export function createMCPServer(backend) {
+    const require = createRequire(import.meta.url);
+    const pkgVersion = require('../../package.json').version;
     const server = new Server({
         name: 'gitnexus',
-        version: '1.1.9',
+        version: pkgVersion,
     }, {
         capabilities: {
             tools: {},
@@ -235,17 +238,29 @@ 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);
-    // Handle graceful shutdown
-    process.on('SIGINT', async () => {
-        await backend.disconnect();
-        await server.close();
-        process.exit(0);
-    });
-    process.on('SIGTERM', async () => {
-        await backend.disconnect();
-        await server.close();
+    // Graceful shutdown helper
+    let shuttingDown = false;
+    const shutdown = async () => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        try {
+            await backend.disconnect();
+        }
+        catch { }
+        try {
+            await server.close();
+        }
+        catch { }
         process.exit(0);
-    });
+    };
+    // Handle graceful shutdown
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    // Handle stdio errors — stdin close means the parent process is gone
+    process.stdin.on('end', shutdown);
+    process.stdin.on('error', () => shutdown());
+    process.stdout.on('error', () => shutdown());
 }

package/dist/mcp/staleness.js

@@ -4,14 +4,14 @@
  * Checks if the GitNexus index is behind the current git HEAD.
  * Returns a hint for the LLM to call analyze if stale.
  */
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 /**
  * Check how many commits the index is behind HEAD
  */
 export function checkStaleness(repoPath, lastCommit) {
     try {
         // Get count of commits between lastCommit and HEAD
-        const result = execSync(`git rev-list --count ${lastCommit}..HEAD`, { cwd: repoPath, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        const result = execFileSync('git', ['rev-list', '--count', `${lastCommit}..HEAD`], { cwd: repoPath, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
         const commitsBehind = parseInt(result, 10) || 0;
         if (commitsBehind > 0) {
             return {

package/dist/mcp/tools.js

@@ -78,7 +78,7 @@ 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 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:
@@ -91,6 +91,15 @@ EXAMPLES:
 • 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:
@@ -208,7 +217,7 @@ Depth groups:
 - d=2: LIKELY AFFECTED (indirect)
 - d=3: MAY NEED TESTING (transitive)
 
-EdgeType: CALLS, IMPORTS, EXTENDS, IMPLEMENTS
+EdgeType: CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, OVERRIDES
 Confidence: 1.0 = certain, <0.8 = fuzzy match`,
         inputSchema: {
             type: 'object',
@@ -218,7 +227,7 @@ Confidence: 1.0 = certain, <0.8 = fuzzy match`,
                 file_path: { type: 'string', description: 'Optional file path filter to disambiguate target name' },
                 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.3)' },
                 repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },

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/git.js

@@ -1,4 +1,5 @@
 import { execSync } from 'child_process';
+import path from 'path';
 // Git utilities for repository detection, commit tracking, and diff analysis
 export const isGitRepo = (repoPath) => {
     try {
@@ -22,9 +23,11 @@ export const getCurrentCommit = (repoPath) => {
  */
 export const getGitRoot = (fromPath) => {
     try {
-        return execSync('git rev-parse --show-toplevel', { cwd: fromPath })
+        const raw = execSync('git rev-parse --show-toplevel', { cwd: fromPath })
             .toString()
             .trim();
+        // On Windows, git returns /d/Projects/Foo — path.resolve normalizes to D:\Projects\Foo
+        return path.resolve(raw);
     }
     catch {
         return null;

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

@@ -27,7 +27,7 @@ export interface RepoMeta {
 export interface IndexedRepo {
     repoPath: string;
     storagePath: string;
-    kuzuPath: string;
+    lbugPath: string;
     metaPath: string;
     meta: RepoMeta;
 }
@@ -56,9 +56,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
  */