@codragraph/cli 2.0.0 → 2.1.0

package/dist/core/search/hybrid-search.js

@@ -7,7 +7,7 @@
  * This is the same approach used by Elasticsearch, Pinecone, and other
  * production search systems.
  */
-import { searchFTSFromLbug } from './bm25-index.js';
+import { searchFTSFromCgdb } from './bm25-index.js';
 /**
  * RRF constant - standard value used in the literature
  * Higher values give more weight to lower-ranked results
@@ -112,7 +112,7 @@ export const formatHybridResults = (results) => {
  */
 export const hybridSearch = async (query, limit, executeQuery, semanticSearch) => {
     // Use LadybugDB FTS for always-fresh BM25 results
-    const bm25Results = await searchFTSFromLbug(query, limit);
+    const bm25Results = await searchFTSFromCgdb(query, limit);
     const semanticResults = await semanticSearch(executeQuery, query, limit);
     return mergeWithRRF(bm25Results, semanticResults, limit);
 };

package/dist/core/wiki/generator.d.ts

@@ -41,14 +41,14 @@ export declare class WikiGenerator {
     private repoPath;
     private storagePath;
     private wikiDir;
-    private lbugPath;
+    private cgdbPath;
     private llmConfig;
     private maxTokensPerModule;
     private concurrency;
     private options;
     private onProgress;
     private failedModules;
-    constructor(repoPath: string, storagePath: string, lbugPath: string, llmConfig: LLMConfig, options?: WikiOptions, onProgress?: ProgressCallback);
+    constructor(repoPath: string, storagePath: string, cgdbPath: string, llmConfig: LLMConfig, options?: WikiOptions, onProgress?: ProgressCallback);
     private lastPercent;
     /**
      * Create streaming options that report LLM progress to the progress bar.

package/dist/core/wiki/generator.js

@@ -26,18 +26,18 @@ export class WikiGenerator {
     repoPath;
     storagePath;
     wikiDir;
-    lbugPath;
+    cgdbPath;
     llmConfig;
     maxTokensPerModule;
     concurrency;
     options;
     onProgress;
     failedModules = [];
-    constructor(repoPath, storagePath, lbugPath, llmConfig, options = {}, onProgress) {
+    constructor(repoPath, storagePath, cgdbPath, llmConfig, options = {}, onProgress) {
         this.repoPath = repoPath;
         this.storagePath = storagePath;
         this.wikiDir = path.join(storagePath, WIKI_DIR);
-        this.lbugPath = lbugPath;
+        this.cgdbPath = cgdbPath;
         this.options = options;
         this.llmConfig = llmConfig;
         this.maxTokensPerModule = options.maxTokensPerModule ?? DEFAULT_MAX_TOKENS_PER_MODULE;
@@ -134,7 +134,7 @@ export class WikiGenerator {
         }
         // Init graph
         this.onProgress('init', 2, 'Connecting to knowledge graph...');
-        await initWikiDb(this.lbugPath);
+        await initWikiDb(this.cgdbPath);
         let result;
         try {
             if (!forceMode && existingMeta && existingMeta.fromCommit) {

package/dist/core/wiki/graph-queries.d.ts

@@ -2,7 +2,7 @@
  * Graph Queries for Wiki Generation
  *
  * Encapsulated Cypher queries against the CodraGraph knowledge graph.
- * Uses the MCP-style pooled lbug-adapter for connection management.
+ * Uses the MCP-style pooled cgdb-adapter for connection management.
  */
 /**
  * Touch the wiki DB connection to prevent idle timeout during long LLM calls.
@@ -36,7 +36,7 @@ export interface ProcessInfo {
 /**
  * Initialize the LadybugDB connection for wiki generation.
  */
-export declare function initWikiDb(lbugPath: string): Promise<void>;
+export declare function initWikiDb(cgdbPath: string): Promise<void>;
 /**
  * Close the LadybugDB connection.
  */

package/dist/core/wiki/graph-queries.js

@@ -2,9 +2,9 @@
  * Graph Queries for Wiki Generation
  *
  * Encapsulated Cypher queries against the CodraGraph knowledge graph.
- * Uses the MCP-style pooled lbug-adapter for connection management.
+ * Uses the MCP-style pooled cgdb-adapter for connection management.
  */
-import { initLbug, executeQuery, closeLbug, touchRepo } from '../lbug/pool-adapter.js';
+import { initCgdb, executeQuery, closeCgdb, touchRepo } from '../cgdb/pool-adapter.js';
 const REPO_ID = '__wiki__';
 /**
  * Touch the wiki DB connection to prevent idle timeout during long LLM calls.
@@ -15,14 +15,14 @@ export function touchWikiDb() {
 /**
  * Initialize the LadybugDB connection for wiki generation.
  */
-export async function initWikiDb(lbugPath) {
-    await initLbug(REPO_ID, lbugPath);
+export async function initWikiDb(cgdbPath) {
+    await initCgdb(REPO_ID, cgdbPath);
 }
 /**
  * Close the LadybugDB connection.
  */
 export async function closeWikiDb() {
-    await closeLbug(REPO_ID);
+    await closeCgdb(REPO_ID);
 }
 /**
  * Get all source files with their exported symbol names and types.

package/dist/mcp/core/cgdb-adapter.d.ts

@@ -0,0 +1,5 @@
+/**
+ * LadybugDB connection pool — re-exported from core.
+ * Prefer importing from `../../core/cgdb/pool-adapter.js` in new code.
+ */
+export * from '../../core/cgdb/pool-adapter.js';

package/dist/mcp/core/cgdb-adapter.js

@@ -0,0 +1,5 @@
+/**
+ * LadybugDB connection pool — re-exported from core.
+ * Prefer importing from `../../core/cgdb/pool-adapter.js` in new code.
+ */
+export * from '../../core/cgdb/pool-adapter.js';

package/dist/mcp/core/embedder.js

@@ -6,7 +6,7 @@
  */
 import { pipeline, env } from '@huggingface/transformers';
 import { isHttpMode, getHttpDimensions, httpEmbedQuery, } from '../../core/embeddings/http-client.js';
-import { silenceStdout, restoreStdout, realStderrWrite } from '../../core/lbug/pool-adapter.js';
+import { silenceStdout, restoreStdout, realStderrWrite } from '../../core/cgdb/pool-adapter.js';
 // Model config
 const MODEL_ID = 'Snowflake/snowflake-arctic-embed-xs';
 // Module-level state for singleton pattern

package/dist/mcp/local/local-backend.d.ts

@@ -5,7 +5,7 @@
  * Supports multiple indexed repositories via a global registry.
  * LadybugDB connections are opened lazily per repo on first query.
  */
-import { isWriteQuery } from '../../core/lbug/pool-adapter.js';
+import { isWriteQuery } from '../../core/cgdb/pool-adapter.js';
 export { isWriteQuery };
 import { type RegistryEntry } from '../../storage/repo-manager.js';
 import { GroupService } from '../../core/group/service.js';
@@ -53,7 +53,7 @@ interface RepoHandle {
     name: string;
     repoPath: string;
     storagePath: string;
-    lbugPath: string;
+    cgdbPath: string;
     indexedAt: string;
     lastCommit: string;
     remoteUrl?: string;

package/dist/mcp/local/local-backend.js

@@ -7,7 +7,7 @@
  */
 import fs from 'fs/promises';
 import path from 'path';
-import { initLbug, executeQuery, executeParameterized, closeLbug, isLbugReady, isWriteQuery, } from '../../core/lbug/pool-adapter.js';
+import { initCgdb, executeQuery, executeParameterized, closeCgdb, isCgdbReady, isWriteQuery, } from '../../core/cgdb/pool-adapter.js';
 export { isWriteQuery };
 // Embedding imports are lazy (dynamic import) to avoid loading onnxruntime-node
 // at MCP server startup — crashes on unsupported Node ABI versions (#89)
@@ -18,8 +18,8 @@ import { listRegisteredRepos, cleanupOldKuzuFiles, } from '../../storage/repo-ma
 import { GroupService } from '../../core/group/service.js';
 import { resolveAtGroupMemberRepoPath } from '../../core/group/resolve-at-member.js';
 import { collectBestChunks } from '../../core/embeddings/types.js';
-import { EMBEDDING_TABLE_NAME, EMBEDDING_INDEX_NAME } from '../../core/lbug/schema.js';
-import { decodeContentField } from '../../core/lbug/content-read.js';
+import { EMBEDDING_TABLE_NAME, EMBEDDING_INDEX_NAME } from '../../core/cgdb/schema.js';
+import { decodeContentField } from '../../core/cgdb/content-read.js';
 import { PhaseTimer } from '../../core/search/phase-timer.js';
 import { checkStaleness, checkCwdMatch } from '../../core/git-staleness.js';
 // AI context generation is CLI-only (codragraph analyze)
@@ -189,7 +189,7 @@ export class LocalBackend {
     }
     /** Close all pooled LadybugDB connections (CLI one-shot; optional for long-lived MCP). */
     async dispose() {
-        await closeLbug();
+        await closeCgdb();
     }
     // ─── Initialization ──────────────────────────────────────────────
     /**
@@ -212,9 +212,9 @@ export class LocalBackend {
             const id = this.repoId(entry.name, entry.path);
             freshIds.add(id);
             const storagePath = entry.storagePath;
-            const lbugPath = path.join(storagePath, 'lbug');
+            const cgdbPath = path.join(storagePath, 'cgdb');
             // Clean up any leftover KuzuDB files from before the LadybugDB migration.
-            // If kuzu exists but lbug doesn't, warn so the user knows to re-analyze.
+            // If kuzu exists but cgdb doesn't, warn so the user knows to re-analyze.
             const kuzu = await cleanupOldKuzuFiles(storagePath);
             if (kuzu.found && kuzu.needsReindex) {
                 console.error(`CodraGraph: "${entry.name}" has a stale KuzuDB index. Run: codragraph analyze ${entry.path}`);
@@ -224,7 +224,7 @@ export class LocalBackend {
                 name: entry.name,
                 repoPath: entry.path,
                 storagePath,
-                lbugPath,
+                cgdbPath,
                 indexedAt: entry.indexedAt,
                 lastCommit: entry.lastCommit,
                 remoteUrl: entry.remoteUrl,
@@ -364,7 +364,7 @@ export class LocalBackend {
         // Check if the index was rebuilt since we opened the connection (#297).
         // Throttle staleness checks to at most once per 5 seconds per repo to
         // avoid an fs.readFile round-trip on every tool invocation.
-        if (this.initializedRepos.has(repoId) && isLbugReady(repoId)) {
+        if (this.initializedRepos.has(repoId) && isCgdbReady(repoId)) {
             const now = Date.now();
             const lastCheck = this.lastStalenessCheck.get(repoId) ?? 0;
             if (now - lastCheck < 5000)
@@ -380,10 +380,10 @@ export class LocalBackend {
                     // callers both detect staleness and double-close the pool.
                     const reinit = (async () => {
                         try {
-                            await closeLbug(repoId);
+                            await closeCgdb(repoId);
                             this.initializedRepos.delete(repoId);
                             handle.indexedAt = meta.indexedAt;
-                            await initLbug(repoId, handle.lbugPath);
+                            await initCgdb(repoId, handle.cgdbPath);
                             this.initializedRepos.add(repoId);
                         }
                         finally {
@@ -402,7 +402,7 @@ export class LocalBackend {
             }
         }
         try {
-            await initLbug(repoId, handle.lbugPath);
+            await initCgdb(repoId, handle.cgdbPath);
             this.initializedRepos.add(repoId);
         }
         catch (err) {
@@ -948,10 +948,10 @@ export class LocalBackend {
      * BM25 keyword search helper - uses LadybugDB FTS for always-fresh results
      */
     async bm25Search(repo, query, limit) {
-        const { searchFTSFromLbug } = await import('../../core/search/bm25-index.js');
+        const { searchFTSFromCgdb } = await import('../../core/search/bm25-index.js');
         let bm25Results;
         try {
-            bm25Results = await searchFTSFromLbug(query, limit, repo.id);
+            bm25Results = await searchFTSFromCgdb(query, limit, repo.id);
         }
         catch (err) {
             console.error('CodraGraph: BM25/FTS search failed (FTS indexes may not exist) -', err.message);
@@ -1088,7 +1088,7 @@ export class LocalBackend {
     }
     async cypher(repo, params) {
         await this.ensureInitialized(repo.id);
-        if (!isLbugReady(repo.id)) {
+        if (!isCgdbReady(repo.id)) {
             return { error: 'LadybugDB not ready. Index may be corrupted.' };
         }
         // Block write operations (defense-in-depth — DB is already read-only)
@@ -3222,7 +3222,7 @@ export class LocalBackend {
         };
     }
     async disconnect() {
-        await closeLbug(); // close all connections
+        await closeCgdb(); // close all connections
         // Note: we intentionally do NOT call disposeEmbedder() here.
         // ONNX Runtime's native cleanup segfaults on macOS and some Linux configs,
         // and importing the embedder module on Node v24+ crashes if onnxruntime

package/dist/mcp/server.js

@@ -15,7 +15,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { CompatibleStdioServerTransport } from './compatible-stdio-transport.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListResourceTemplatesRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { CODRAGRAPH_TOOLS } from './tools.js';
-import { realStdoutWrite } from './core/lbug-adapter.js';
+import { realStdoutWrite } from './core/cgdb-adapter.js';
 import { getResourceDefinitions, getResourceTemplates, readResource } from './resources.js';
 /**
  * Next-step hints appended to tool responses.
@@ -208,7 +208,7 @@ export function createMCPServer(backend) {
                     { name: 'repo', description: 'Repository (omit if only one indexed)', required: false },
                     {
                         name: 'symbolId',
-                        description: 'Stable symbol id (PK in the lbug node table)',
+                        description: 'Stable symbol id (PK in the cgdb node table)',
                         required: true,
                     },
                     {
@@ -484,7 +484,7 @@ Follow these steps:
 export async function startMCPServer(backend) {
     const server = createMCPServer(backend);
     // Use the shared stdout reference captured at module-load time by the
-    // lbug-adapter.  Avoids divergence if anything patches stdout between
+    // cgdb-adapter.  Avoids divergence if anything patches stdout between
     // module load and server start.
     const _safeStdout = new Proxy(process.stdout, {
         get(target, prop, receiver) {

package/dist/mcp/tools.js

@@ -806,7 +806,7 @@ Pair with codragraph_context first to get the symbol's stable id (e.g. \`fn:src/
             type: 'object',
             properties: {
                 repo: { type: 'string', description: 'Indexed repo (omit if only one).' },
-                symbolId: { type: 'string', description: 'Stable symbol id (PK in the lbug node table).' },
+                symbolId: { type: 'string', description: 'Stable symbol id (PK in the cgdb node table).' },
                 table: {
                     type: 'string',
                     description: 'Optional table hint to narrow the search (Function, Class, Method, Interface, …).',

package/dist/server/analyze-worker.js

@@ -11,7 +11,7 @@
  *   Child -> Parent: { type: 'error', message: string }
  */
 import { runFullAnalysis } from '../core/run-analyze.js';
-import { closeLbug } from '../core/lbug/lbug-adapter.js';
+import { closeCgdb } from '../core/cgdb/cgdb-adapter.js';
 function send(msg) {
     process.send?.(msg);
 }
@@ -28,7 +28,7 @@ process.on('unhandledRejection', (reason) => {
 process.on('SIGTERM', async () => {
     send({ type: 'error', message: 'Analysis cancelled (worker received SIGTERM)' });
     try {
-        await closeLbug();
+        await closeCgdb();
     }
     catch { }
     process.exit(0);

package/dist/server/api.js

@@ -13,11 +13,11 @@ import path from 'path';
 import fs from 'fs/promises';
 import { createRequire } from 'node:module';
 import { loadMeta, listRegisteredRepos, getStoragePath } from '../storage/repo-manager.js';
-import { executeQuery, executePrepared, executeWithReusedStatement, streamQuery, closeLbug, withLbugDb, } from '../core/lbug/lbug-adapter.js';
-import { isWriteQuery } from '../core/lbug/pool-adapter.js';
-import { decodeContentField } from '../core/lbug/content-read.js';
+import { executeQuery, executePrepared, executeWithReusedStatement, streamQuery, closeCgdb, withCgdbDb, } from '../core/cgdb/cgdb-adapter.js';
+import { isWriteQuery } from '../core/cgdb/pool-adapter.js';
+import { decodeContentField } from '../core/cgdb/content-read.js';
 import { NODE_TABLES } from '../_shared/index.js';
-import { searchFTSFromLbug } from '../core/search/bm25-index.js';
+import { searchFTSFromCgdb } 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)
@@ -388,7 +388,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
     const cleanupMcp = mountMCPEndpoints(app, backend);
     const jobManager = new JobManager();
     // Shared repo lock — prevents concurrent analyze + embed on the same repo path,
-    // which would corrupt LadybugDB (analyze calls closeLbug + initLbug while embed has queries in flight).
+    // which would corrupt LadybugDB (analyze calls closeCgdb + initCgdb while embed has queries in flight).
     const activeRepoPaths = new Set();
     const acquireRepoLock = (repoPath) => {
         if (activeRepoPaths.has(repoPath)) {
@@ -571,7 +571,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
             try {
                 // Close any open LadybugDB handle before deleting files
                 try {
-                    await closeLbug();
+                    await closeCgdb();
                 }
                 catch { }
                 // 1. Delete the .codragraph index/storage directory
@@ -895,21 +895,21 @@ export const createServer = async (port, host = '127.0.0.1') => {
                 res.status(404).json({ error: 'Repository not found' });
                 return;
             }
-            const lbugPath = path.join(entry.storagePath, 'lbug');
+            const cgdbPath = path.join(entry.storagePath, 'cgdb');
             const includeContent = req.query.includeContent === 'true';
             const stream = req.query.stream === 'true';
-            // Guard: when a repo has no materialized lbug schema (fixture-
-            // seeded CAS-only repos), or the lbug WAL is corrupt/stale from
+            // Guard: when a repo has no materialized cgdb schema (fixture-
+            // seeded CAS-only repos), or the cgdb WAL is corrupt/stale from
             // a prior failed analyze, LadybugDB native will abort with
             // UNREACHABLE_CODE or an ANY-vector exception. Detect both
             // shapes — missing file (cheap fs.access) AND empty/4096-byte
             // schema-only file (fs.stat) — and return an empty graph so
             // the dashboard doesn't blow up. The Graph tab keeps working
-            // for repos that actually have a real lbug.
-            const isLbugMaterialized = await (async () => {
+            // for repos that actually have a real cgdb.
+            const isCgdbMaterialized = await (async () => {
                 try {
-                    const stat = await fs.stat(lbugPath);
-                    // Schema-only lbug is exactly 4096 bytes (one page, no real
+                    const stat = await fs.stat(cgdbPath);
+                    // Schema-only cgdb is exactly 4096 bytes (one page, no real
                     // data). Real graphs are larger.
                     return stat.isFile() && stat.size > 4096;
                 }
@@ -917,14 +917,14 @@ export const createServer = async (port, host = '127.0.0.1') => {
                     return false;
                 }
             })();
-            if (!isLbugMaterialized) {
+            if (!isCgdbMaterialized) {
                 if (stream) {
                     res.setHeader('Content-Type', 'application/x-ndjson; charset=utf-8');
                     res.flushHeaders();
                     res.write(JSON.stringify({
                         type: 'meta',
                         repoName: entry.name,
-                        note: 'no lbug file — graph not yet materialized',
+                        note: 'no cgdb file — graph not yet materialized',
                         nodeCount: 0,
                         relationshipCount: 0,
                     }) + '\n');
@@ -937,7 +937,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
                     nodes: [],
                     relationships: [],
                     stats: { nodes: 0, edges: 0 },
-                    note: 'no lbug file — graph not yet materialized',
+                    note: 'no cgdb file — graph not yet materialized',
                 });
                 return;
             }
@@ -959,7 +959,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
                 res.once('finish', markFinished);
                 res.once('close', abortStreaming);
                 try {
-                    await withLbugDb(lbugPath, async () => streamGraphNdjson(res, includeContent, abortController.signal));
+                    await withCgdbDb(cgdbPath, async () => streamGraphNdjson(res, includeContent, abortController.signal));
                     if (!abortController.signal.aborted && !res.writableEnded) {
                         res.end();
                     }
@@ -971,7 +971,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
                 }
                 return;
             }
-            const graph = await withLbugDb(lbugPath, async () => buildGraph(includeContent));
+            const graph = await withCgdbDb(cgdbPath, async () => buildGraph(includeContent));
             res.json(graph);
         }
         catch (err) {
@@ -1009,8 +1009,8 @@ export const createServer = async (port, host = '127.0.0.1') => {
                 res.status(404).json({ error: 'Repository not found' });
                 return;
             }
-            const lbugPath = path.join(entry.storagePath, 'lbug');
-            const result = await withLbugDb(lbugPath, () => executeQuery(cypher));
+            const cgdbPath = path.join(entry.storagePath, 'cgdb');
+            const result = await withCgdbDb(cgdbPath, () => executeQuery(cypher));
             res.json({ result });
         }
         catch (err) {
@@ -1030,14 +1030,14 @@ export const createServer = async (port, host = '127.0.0.1') => {
                 res.status(404).json({ error: 'Repository not found' });
                 return;
             }
-            const lbugPath = path.join(entry.storagePath, 'lbug');
+            const cgdbPath = path.join(entry.storagePath, 'cgdb');
             const parsedLimit = Number(req.body.limit ?? 10);
             const limit = Number.isFinite(parsedLimit)
                 ? Math.max(1, Math.min(100, Math.trunc(parsedLimit)))
                 : 10;
             const mode = req.body.mode ?? 'hybrid';
             const enrich = req.body.enrich !== false; // default true
-            const results = await withLbugDb(lbugPath, async () => {
+            const results = await withCgdbDb(cgdbPath, async () => {
                 let searchResults;
                 if (mode === 'semantic') {
                     const { isEmbedderReady } = await import('../core/embeddings/embedder.js');
@@ -1055,7 +1055,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
                     }));
                 }
                 else if (mode === 'bm25') {
-                    searchResults = await searchFTSFromLbug(query, limit);
+                    searchResults = await searchFTSFromCgdb(query, limit);
                     searchResults = searchResults.map((r, i) => ({
                         ...r,
                         rank: i + 1,
@@ -1070,7 +1070,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
                         searchResults = await hybridSearch(query, limit, executeQuery, semSearch);
                     }
                     else {
-                        searchResults = await searchFTSFromLbug(query, limit);
+                        searchResults = await searchFTSFromCgdb(query, limit);
                     }
                 }
                 if (!enrich)
@@ -1230,8 +1230,8 @@ export const createServer = async (port, host = '127.0.0.1') => {
             const results = [];
             const repoRoot = path.resolve(entry.path);
             // Get file paths from the graph (lightweight — no content loaded)
-            const lbugPath = path.join(entry.storagePath, 'lbug');
-            const fileRows = await withLbugDb(lbugPath, () => executeQuery(`MATCH (n:File) WHERE n.content IS NOT NULL RETURN n.filePath AS filePath`));
+            const cgdbPath = path.join(entry.storagePath, 'cgdb');
+            const fileRows = await withCgdbDb(cgdbPath, () => executeQuery(`MATCH (n:File) WHERE n.content IS NOT NULL RETURN n.filePath AS filePath`));
             // Search files on disk one at a time (constant memory)
             for (const row of fileRows) {
                 if (results.length >= limit)
@@ -1602,12 +1602,12 @@ export const createServer = async (port, host = '127.0.0.1') => {
             // Run embedding pipeline asynchronously
             (async () => {
                 try {
-                    const lbugPath = path.join(entry.storagePath, 'lbug');
-                    await withLbugDb(lbugPath, async () => {
+                    const cgdbPath = path.join(entry.storagePath, 'cgdb');
+                    await withCgdbDb(cgdbPath, async () => {
                         const { runEmbeddingPipeline } = await import('../core/embeddings/embedding-pipeline.js');
                         // Fetch existing content hashes for incremental embedding.
-                        // Delegated to lbug-adapter which owns the DB query logic and legacy-fallback handling.
-                        const { fetchExistingEmbeddingHashes } = await import('../core/lbug/lbug-adapter.js');
+                        // Delegated to cgdb-adapter which owns the DB query logic and legacy-fallback handling.
+                        const { fetchExistingEmbeddingHashes } = await import('../core/cgdb/cgdb-adapter.js');
                         const existingEmbeddings = await fetchExistingEmbeddingHashes(executeQuery);
                         if (existingEmbeddings && existingEmbeddings.size > 0) {
                             console.log(`[embed] ${existingEmbeddings.size} nodes already embedded — incremental run with content-hash comparison`);
@@ -1718,7 +1718,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
             jobManager.dispose();
             embedJobManager.dispose();
             await cleanupMcp();
-            await closeLbug();
+            await closeCgdb();
             await backend.disconnect();
             process.exit(0);
         };

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

@@ -37,7 +37,7 @@
  */
 export declare const canonicalizePath: (p: string) => string;
 /**
- * On-disk schema version for `.codragraph/lbug` and `.codragraph/meta.json`.
+ * On-disk schema version for `.codragraph/cgdb` and `.codragraph/meta.json`.
  *
  *   1  — pre-RFC-0001-Phase-2 layout. Node tables have `content STRING`
  *        but no `contentEncoding` column. Implicit/missing on existing
@@ -110,7 +110,7 @@ export interface RepoMeta {
 export interface IndexedRepo {
     repoPath: string;
     storagePath: string;
-    lbugPath: string;
+    cgdbPath: string;
     metaPath: string;
     meta: RepoMeta;
 }
@@ -140,7 +140,7 @@ export declare const getStoragePath: (repoPath: string) => string;
  */
 export declare const getStoragePaths: (repoPath: string) => {
     storagePath: string;
-    lbugPath: string;
+    cgdbPath: string;
     metaPath: string;
 };
 /**
@@ -153,7 +153,7 @@ export declare const hasKuzuIndex: (storagePath: string) => Promise<boolean>;
  *
  * Returns:
  *   found        — true if .codragraph/kuzu existed and was deleted
- *   needsReindex — true if kuzu existed but lbug does not (re-analyze required)
+ *   needsReindex — true if kuzu existed but cgdb does not (re-analyze required)
  *
  * Callers own the user-facing messaging; this function only deletes files.
  */

package/dist/storage/repo-manager.js

@@ -50,7 +50,7 @@ export const canonicalizePath = (p) => {
     }
 };
 /**
- * On-disk schema version for `.codragraph/lbug` and `.codragraph/meta.json`.
+ * On-disk schema version for `.codragraph/cgdb` and `.codragraph/meta.json`.
  *
  *   1  — pre-RFC-0001-Phase-2 layout. Node tables have `content STRING`
  *        but no `contentEncoding` column. Implicit/missing on existing
@@ -83,7 +83,7 @@ export const getStoragePaths = (repoPath) => {
     const storagePath = getStoragePath(repoPath);
     return {
         storagePath,
-        lbugPath: path.join(storagePath, 'lbug'),
+        cgdbPath: path.join(storagePath, 'cgdb'),
         metaPath: path.join(storagePath, 'meta.json'),
     };
 };
@@ -105,16 +105,16 @@ export const hasKuzuIndex = async (storagePath) => {
  *
  * Returns:
  *   found        — true if .codragraph/kuzu existed and was deleted
- *   needsReindex — true if kuzu existed but lbug does not (re-analyze required)
+ *   needsReindex — true if kuzu existed but cgdb does not (re-analyze required)
  *
  * Callers own the user-facing messaging; this function only deletes files.
  */
 export const cleanupOldKuzuFiles = async (storagePath) => {
     const oldPath = path.join(storagePath, 'kuzu');
-    const newPath = path.join(storagePath, 'lbug');
+    const newPath = path.join(storagePath, 'cgdb');
     try {
         await fs.stat(oldPath);
-        // Old kuzu file/dir exists — determine if lbug is already present
+        // Old kuzu file/dir exists — determine if cgdb is already present
         let needsReindex = false;
         try {
             await fs.stat(newPath);

package/hooks/claude/codragraph-hook.cjs

@@ -236,8 +236,8 @@ function handlePostToolUse(input) {
 
   const cwd = input.cwd || process.cwd();
   if (!path.isAbsolute(cwd)) return;
-  const gitNexusDir = findCodraGraphDir(cwd);
-  if (!gitNexusDir) return;
+  const codragraphDir = findCodraGraphDir(cwd);
+  if (!codragraphDir) return;
 
   // Compare HEAD against last indexed commit — skip if unchanged
   let currentHead = '';
@@ -258,7 +258,7 @@ function handlePostToolUse(input) {
   let lastCommit = '';
   let hadEmbeddings = false;
   try {
-    const meta = JSON.parse(fs.readFileSync(path.join(gitNexusDir, 'meta.json'), 'utf-8'));
+    const meta = JSON.parse(fs.readFileSync(path.join(codragraphDir, 'meta.json'), 'utf-8'));
     lastCommit = meta.lastCommit || '';
     hadEmbeddings = meta.stats && meta.stats.embeddings > 0;
   } catch {
@@ -282,7 +282,7 @@ function handlePostToolUse(input) {
     // reindex is in flight. The spawned analyze removes it on exit (success or
     // failure) via CODRAGRAPH_REINDEX_LOCK_PATH; the 10-min mtime fallback
     // catches the rare crash that bypasses analyze's exit handler.
-    const coalescePath = path.join(gitNexusDir, '.reindex.coalesce');
+    const coalescePath = path.join(codragraphDir, '.reindex.coalesce');
     const crashSafetyTtlMs = 10 * 60 * 1000;
     let inFlight = false;
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codragraph/cli",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": {
     "name": "Anit Chaudhary",
@@ -56,7 +56,7 @@
     "prepack": "node scripts/build.js"
   },
   "dependencies": {
-    "@codragraph/graphstore": "^1.0.0",
+    "@codragraph/graphstore": "^2.1.0",
     "@huggingface/transformers": "^4.1.0",
     "@ladybugdb/core": "^0.16.0",
     "@modelcontextprotocol/sdk": "^1.0.0",
@@ -99,7 +99,7 @@
     "tree-sitter-swift": "^0.6.0"
   },
   "devDependencies": {
-    "@codragraph/shared": "file:../codragraph-shared",
+    "@codragraph/shared": "file:../shared",
     "@types/cli-progress": "^3.11.6",
     "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",