@codragraph/cli 2.0.0 → 2.1.1

package/dist/core/ingestion/model/semantic-model.js

@@ -9,7 +9,7 @@
  *
  * ## Dependency direction
  *
- *     codragraph-shared (NodeLabel)             — leaf
+ *     @codragraph/shared (NodeLabel)            — leaf
  *          ↑
  *     symbol-table.ts                         — pure file/callable index
  *          ↑

package/dist/core/ingestion/model/symbol-table.d.ts

@@ -17,7 +17,7 @@
  *
  * Dependency direction (strictly enforced):
  *
- *     codragraph-shared (NodeLabel)       — leaf type
+ *     @codragraph/shared (NodeLabel)      — leaf type
  *          ↑
  *     symbol-table.ts                   — THIS FILE (pure storage)
  *          ↑

package/dist/core/ingestion/model/symbol-table.js

@@ -17,7 +17,7 @@
  *
  * Dependency direction (strictly enforced):
  *
- *     codragraph-shared (NodeLabel)       — leaf type
+ *     @codragraph/shared (NodeLabel)      — leaf type
  *          ↑
  *     symbol-table.ts                   — THIS FILE (pure storage)
  *          ↑

package/dist/core/ingestion/pipeline-phases/feature-clusters.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Phase: featureClusters
+ *
+ * Creates human-facing FeatureCluster nodes above algorithmic Community nodes.
+ * This is the layer agents query for product/domain areas such as Settings,
+ * AI, Auth, MCP, or Ingestion before drilling into exact symbols.
+ *
+ * @deps    processes, structure
+ * @reads   graph (all nodes and relationships)
+ * @writes  graph (FeatureCluster nodes, FEATURE_MEMBER_OF, FEATURE_DEPENDS_ON)
+ */
+import type { PipelinePhase } from './types.js';
+import { type FeatureClusterDetectionResult } from '../feature-cluster-processor.js';
+export interface FeatureClustersOutput {
+    featureClusterResult: FeatureClusterDetectionResult;
+}
+export declare const featureClustersPhase: PipelinePhase<FeatureClustersOutput>;

package/dist/core/ingestion/pipeline-phases/feature-clusters.js

@@ -0,0 +1,88 @@
+/**
+ * Phase: featureClusters
+ *
+ * Creates human-facing FeatureCluster nodes above algorithmic Community nodes.
+ * This is the layer agents query for product/domain areas such as Settings,
+ * AI, Auth, MCP, or Ingestion before drilling into exact symbols.
+ *
+ * @deps    processes, structure
+ * @reads   graph (all nodes and relationships)
+ * @writes  graph (FeatureCluster nodes, FEATURE_MEMBER_OF, FEATURE_DEPENDS_ON)
+ */
+import { getPhaseOutput } from './types.js';
+import { processFeatureClusters, } from '../feature-cluster-processor.js';
+import { generateId } from '../../../lib/utils.js';
+import { isDev } from '../utils/env.js';
+export const featureClustersPhase = {
+    name: 'featureClusters',
+    deps: ['processes', 'structure'],
+    async execute(ctx, deps) {
+        const { totalFiles } = getPhaseOutput(deps, 'structure');
+        ctx.onProgress({
+            phase: 'feature_clusters',
+            percent: 99,
+            message: 'Building feature clusters...',
+            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: ctx.graph.nodeCount },
+        });
+        const featureClusterResult = await processFeatureClusters(ctx.graph, (message, progress) => {
+            ctx.onProgress({
+                phase: 'feature_clusters',
+                percent: Math.round(99 + progress * 0.009),
+                message,
+                stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: ctx.graph.nodeCount },
+            });
+        }, {
+            repo: ctx.options?.featureClusterRepo,
+            lastIndexedCommit: ctx.options?.lastIndexedCommit,
+        });
+        if (isDev) {
+            console.log(`Feature clustering: ${featureClusterResult.stats.totalClusters} clusters, ${featureClusterResult.stats.totalMemberships} memberships`);
+        }
+        featureClusterResult.clusters.forEach((cluster) => {
+            ctx.graph.addNode({
+                id: cluster.id,
+                label: 'FeatureCluster',
+                properties: {
+                    name: cluster.name,
+                    filePath: '',
+                    slug: cluster.slug,
+                    featureKind: cluster.featureKind,
+                    summary: cluster.summary,
+                    description: cluster.description,
+                    repo: cluster.repo,
+                    service: cluster.service,
+                    signals: cluster.signals,
+                    memberCount: cluster.memberCount,
+                    entryPointIds: cluster.entryPointIds,
+                    routes: cluster.routes,
+                    tools: cluster.tools,
+                    testCoverageHints: cluster.testCoverageHints,
+                    lastIndexedCommit: cluster.lastIndexedCommit,
+                    confidence: cluster.confidence,
+                    source: 'heuristic',
+                },
+            });
+        });
+        featureClusterResult.memberships.forEach((membership) => {
+            ctx.graph.addRelationship({
+                id: generateId('FEATURE_MEMBER_OF', `${membership.nodeId}->${membership.clusterId}`),
+                sourceId: membership.nodeId,
+                targetId: membership.clusterId,
+                type: 'FEATURE_MEMBER_OF',
+                confidence: membership.confidence,
+                reason: membership.signals.join('|'),
+            });
+        });
+        featureClusterResult.dependencies.forEach((dependency) => {
+            ctx.graph.addRelationship({
+                id: generateId('FEATURE_DEPENDS_ON', `${dependency.sourceClusterId}->${dependency.targetClusterId}`),
+                sourceId: dependency.sourceClusterId,
+                targetId: dependency.targetClusterId,
+                type: 'FEATURE_DEPENDS_ON',
+                confidence: dependency.confidence,
+                reason: `member-dependency|edges:${dependency.edgeCount}|types:${dependency.relationshipTypes.join(',')}`,
+            });
+        });
+        return { featureClusterResult };
+    },
+};

package/dist/core/ingestion/pipeline-phases/index.d.ts

@@ -17,6 +17,7 @@ export { scopeResolutionPhase, type ScopeResolutionOutput, } from '../scope-reso
 export { mroPhase, type MROOutput } from './mro.js';
 export { communitiesPhase, type CommunitiesOutput } from './communities.js';
 export { processesPhase, type ProcessesOutput } from './processes.js';
+export { featureClustersPhase, type FeatureClustersOutput } from './feature-clusters.js';
 export { runPipeline } from './runner.js';
 export type { PipelinePhase, PipelineContext, PhaseResult } from './types.js';
 export { getPhaseOutput } from './types.js';

package/dist/core/ingestion/pipeline-phases/index.js

@@ -18,6 +18,7 @@ export { scopeResolutionPhase, } from '../scope-resolution/pipeline/phase.js';
 export { mroPhase } from './mro.js';
 export { communitiesPhase } from './communities.js';
 export { processesPhase } from './processes.js';
+export { featureClustersPhase } from './feature-clusters.js';
 // ── Infrastructure ─────────────────────────────────────────────────────────
 export { runPipeline } from './runner.js';
 export { getPhaseOutput } from './types.js';

package/dist/core/ingestion/pipeline.d.ts

@@ -21,6 +21,10 @@ export interface PipelineOptions {
     skipGraphPhases?: boolean;
     /** Force sequential parsing (no worker pool). Useful for testing the sequential path. */
     skipWorkers?: boolean;
+    /** Repo label written onto FeatureCluster metadata. */
+    featureClusterRepo?: string;
+    /** Indexed source commit written onto FeatureCluster metadata. */
+    lastIndexedCommit?: string;
     /**
      * @internal Test-only override for worker-pool gating thresholds.
      * When unset, production defaults apply (15 files OR 512 KB total bytes).

package/dist/core/ingestion/pipeline.js

@@ -15,15 +15,16 @@
  * See ARCHITECTURE.md for the full phase dependency diagram.
  */
 import { createKnowledgeGraph } from '../graph/graph.js';
-import { runPipeline, getPhaseOutput, scanPhase, structurePhase, markdownPhase, cobolPhase, parsePhase, routesPhase, toolsPhase, ormPhase, crossFilePhase, scopeResolutionPhase, mroPhase, communitiesPhase, processesPhase, } from './pipeline-phases/index.js';
+import { runPipeline, getPhaseOutput, scanPhase, structurePhase, markdownPhase, cobolPhase, parsePhase, routesPhase, toolsPhase, ormPhase, crossFilePhase, scopeResolutionPhase, mroPhase, communitiesPhase, processesPhase, featureClustersPhase, } from './pipeline-phases/index.js';
 // ── Phase registry ─────────────────────────────────────────────────────────
 /**
  * All pipeline phases with their dependency relationships.
  *
  * Phase dependency graph:
  *
- *   scan → structure → [markdown, cobol] → parse → [routes, tools, orm]
- *     → crossFile → mro → communities → processes
+ *   scan -> structure -> [markdown, cobol] -> parse -> [routes, tools, orm]
+ *     -> crossFile -> scopeResolution -> mro -> communities -> processes
+ *     -> featureClusters
  *
  * To add a new phase: create a file in pipeline-phases/, export the phase
  * object, and add it to the appropriate position in this array.
@@ -42,7 +43,7 @@ function buildPhaseList(options) {
         scopeResolutionPhase,
     ];
     if (!options?.skipGraphPhases) {
-        phases.push(mroPhase, communitiesPhase, processesPhase);
+        phases.push(mroPhase, communitiesPhase, processesPhase, featureClustersPhase);
     }
     return phases;
 }
@@ -62,15 +63,17 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
     const { totalFiles, usedWorkerPool } = getPhaseOutput(results, 'parse');
     let communityResult;
     let processResult;
+    let featureClusterResult;
     if (!options?.skipGraphPhases) {
         communityResult = getPhaseOutput(results, 'communities').communityResult;
         processResult = getPhaseOutput(results, 'processes').processResult;
+        featureClusterResult = getPhaseOutput(results, 'featureClusters').featureClusterResult;
     }
     onProgress({
         phase: 'complete',
         percent: 100,
         message: communityResult && processResult
-            ? `Graph complete! ${communityResult.stats.totalCommunities} communities, ${processResult.stats.totalProcesses} processes detected.`
+            ? `Graph complete! ${communityResult.stats.totalCommunities} communities, ${processResult.stats.totalProcesses} processes, ${featureClusterResult?.stats.totalClusters ?? 0} feature clusters detected.`
             : 'Graph complete! (graph phases skipped)',
         stats: {
             filesProcessed: totalFiles,
@@ -84,6 +87,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         totalFileCount: totalFiles,
         communityResult,
         processResult,
+        featureClusterResult,
         usedWorkerPool,
     };
 };

package/dist/core/run-analyze.d.ts

@@ -63,6 +63,7 @@ export interface AnalyzeResult {
         nodes?: number;
         edges?: number;
         communities?: number;
+        featureClusters?: number;
         processes?: number;
         embeddings?: number;
     };

package/dist/core/run-analyze.js

@@ -13,13 +13,13 @@ import fs from 'fs/promises';
 import * as fsSync from 'node:fs';
 import * as v8 from 'node:v8';
 import { runPipelineFromRepo } from './ingestion/pipeline.js';
-import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, loadCachedEmbeddings, } from './lbug/lbug-adapter.js';
+import { initCgdb, loadGraphToCgdb, getCgdbStats, executeQuery, executeWithReusedStatement, closeCgdb, loadCachedEmbeddings, } from './cgdb/cgdb-adapter.js';
 import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, cleanupOldKuzuFiles, INDEX_SCHEMA_VERSION, } from '../storage/repo-manager.js';
 import { getCurrentCommit, getRemoteUrl, hasGitDir, getInferredRepoName } from '../storage/git.js';
 import { recordAnalysisSnapshot } from './graphstore/index.js';
 import { generateAIContextFiles } from '../cli/ai-context.js';
-import { EMBEDDING_TABLE_NAME } from './lbug/schema.js';
-import { STALE_HASH_SENTINEL } from './lbug/schema.js';
+import { EMBEDDING_TABLE_NAME } from './cgdb/schema.js';
+import { STALE_HASH_SENTINEL } from './cgdb/schema.js';
 /** Threshold: auto-skip embeddings for repos with more nodes than this */
 const EMBEDDING_NODE_LIMIT = 50_000;
 export const PHASE_LABELS = {
@@ -31,8 +31,9 @@ export const PHASE_LABELS = {
     heritage: 'Extracting inheritance',
     communities: 'Detecting communities',
     processes: 'Detecting processes',
+    feature_clusters: 'Building feature clusters',
     complete: 'Pipeline complete',
-    lbug: 'Loading into LadybugDB',
+    cgdb: 'Loading into LadybugDB',
     fts: 'Creating search indexes',
     embeddings: 'Generating embeddings',
     done: 'Done',
@@ -81,7 +82,7 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
     const progress = (phase, percent, message) => {
         callbacks.onProgress(phase, percent, message);
         // Only snapshot on phase transitions, not every tick. Phase strings come
-        // from runPipelineFromRepo / loadGraphToLbug and are stable.
+        // from runPipelineFromRepo / loadGraphToCgdb and are stable.
         if (heapProfileEnabled && phase && phase !== lastProfilePhase) {
             lastProfilePhase = phase;
             const ts = Date.now();
@@ -117,7 +118,7 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
             }
         }
     };
-    const { storagePath, lbugPath } = getStoragePaths(repoPath);
+    const { storagePath, cgdbPath } = getStoragePaths(repoPath);
     // Clean up stale KuzuDB files from before the LadybugDB migration.
     const kuzuResult = await cleanupOldKuzuFiles(storagePath);
     if (kuzuResult.found && kuzuResult.needsReindex) {
@@ -129,10 +130,10 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
     // ── Early-return: already up to date ──────────────────────────────
     // Schema-version mismatch forces a full re-analyze regardless of commit
     // equality: existing 1.7.x indexes have no `schemaVersion` field at all,
-    // and 1.8+ readers expect every node table to carry a `contentEncoding`
-    // column (RFC 0001 Phase 2). LadybugDB ALTER on existing tables is not
-    // validated end-to-end yet, so the supported migration path is
-    // re-analyze → fresh CREATE NODE TABLE.
+    // and current readers expect contentEncoding plus rich FeatureCluster
+    // context-pack columns. LadybugDB ALTER on existing tables is not validated
+    // end-to-end yet, so the supported migration path is re-analyze via a fresh
+    // CREATE NODE TABLE.
     const schemaUpToDate = !!existingMeta && (existingMeta.schemaVersion ?? 0) >= INDEX_SCHEMA_VERSION;
     if (existingMeta &&
         schemaUpToDate &&
@@ -150,7 +151,7 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
     }
     if (existingMeta && !schemaUpToDate) {
         log(`Index schema version ${existingMeta.schemaVersion ?? '<missing>'} is older than ` +
-            `${INDEX_SCHEMA_VERSION} (RFC 0001 Phase 2 — adds contentEncoding column). ` +
+            `${INDEX_SCHEMA_VERSION} (FeatureCluster context-pack schema). ` +
             `Re-analyzing.`);
     }
     // ── Cache embeddings from existing index before rebuild ────────────
@@ -159,15 +160,15 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
     if (options.embeddings && existingMeta && !options.force) {
         try {
             progress('embeddings', 0, 'Caching embeddings...');
-            await initLbug(lbugPath);
+            await initCgdb(cgdbPath);
             const cached = await loadCachedEmbeddings();
             cachedEmbeddingNodeIds = cached.embeddingNodeIds;
             cachedEmbeddings = cached.embeddings;
-            await closeLbug();
+            await closeCgdb();
         }
         catch {
             try {
-                await closeLbug();
+                await closeCgdb();
             }
             catch {
                 /* swallow */
@@ -175,16 +176,20 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
         }
     }
     // ── Phase 1: Full Pipeline (0–60%) ────────────────────────────────
+    const repoNameForFeatureClusters = options.registryName ?? getInferredRepoName(repoPath) ?? path.basename(repoPath);
     const pipelineResult = await runPipelineFromRepo(repoPath, (p) => {
         const phaseLabel = PHASE_LABELS[p.phase] || p.phase;
         const scaled = Math.round(p.percent * 0.6);
         progress(p.phase, scaled, phaseLabel);
+    }, {
+        featureClusterRepo: repoNameForFeatureClusters,
+        lastIndexedCommit: currentCommit || undefined,
     });
     // ── Phase 2: LadybugDB (60–85%) ──────────────────────────────────
-    progress('lbug', 60, 'Loading into LadybugDB...');
-    await closeLbug();
-    const lbugFiles = [lbugPath, `${lbugPath}.wal`, `${lbugPath}.lock`];
-    for (const f of lbugFiles) {
+    progress('cgdb', 60, 'Loading into LadybugDB...');
+    await closeCgdb();
+    const cgdbFiles = [cgdbPath, `${cgdbPath}.wal`, `${cgdbPath}.lock`];
+    for (const f of cgdbFiles) {
         try {
             await fs.rm(f, { recursive: true, force: true });
         }
@@ -192,16 +197,16 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
             /* swallow */
         }
     }
-    await initLbug(lbugPath);
+    await initCgdb(cgdbPath);
     try {
-        // All work after initLbug is wrapped in try/finally to ensure closeLbug()
+        // All work after initCgdb is wrapped in try/finally to ensure closeCgdb()
         // is called even if an error occurs — the module-level singleton DB handle
         // must be released to avoid blocking subsequent invocations.
-        let lbugMsgCount = 0;
-        await loadGraphToLbug(pipelineResult.graph, pipelineResult.repoPath, storagePath, (msg) => {
-            lbugMsgCount++;
-            const pct = Math.min(84, 60 + Math.round((lbugMsgCount / (lbugMsgCount + 10)) * 24));
-            progress('lbug', pct, msg);
+        let cgdbMsgCount = 0;
+        await loadGraphToCgdb(pipelineResult.graph, pipelineResult.repoPath, storagePath, (msg) => {
+            cgdbMsgCount++;
+            const pct = Math.min(84, 60 + Math.round((cgdbMsgCount / (cgdbMsgCount + 10)) * 24));
+            progress('cgdb', pct, msg);
         }, 
         // RFC 0001 Phase 2: when --compress is set, every content row goes
         // through encodeContent before hitting the CSV. Default 'none' is
@@ -244,7 +249,7 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
         // ── Phase 3.5: Re-insert cached embeddings ────────────────────────
         if (cachedEmbeddings.length > 0) {
             const cachedDims = cachedEmbeddings[0].embedding.length;
-            const { EMBEDDING_DIMS } = await import('./lbug/schema.js');
+            const { EMBEDDING_DIMS } = await import('./cgdb/schema.js');
             if (cachedDims !== EMBEDDING_DIMS) {
                 // Dimensions changed (e.g. switched embedding model) — discard cache and re-embed all
                 log(`Embedding dimensions changed (${cachedDims}d -> ${EMBEDDING_DIMS}d), discarding cache`);
@@ -267,7 +272,7 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
             }
         }
         // ── Phase 4: Embeddings (90–98%) ──────────────────────────────────
-        const stats = await getLbugStats();
+        const stats = await getCgdbStats();
         let embeddingSkipped = true;
         if (options.embeddings) {
             if (stats.nodes <= EMBEDDING_NODE_LIMIT) {
@@ -334,6 +339,7 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
                 nodes: stats.nodes,
                 edges: stats.edges,
                 communities: pipelineResult.communityResult?.stats.totalCommunities,
+                featureClusters: pipelineResult.featureClusterResult?.stats.totalClusters,
                 processes: pipelineResult.processResult?.stats.totalProcesses,
                 embeddings: embeddingCount,
             },
@@ -372,7 +378,7 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
                 nodes: stats.nodes,
                 edges: stats.edges,
                 communities: pipelineResult.communityResult?.stats.totalCommunities,
-                clusters: aggregatedClusterCount,
+                clusters: pipelineResult.featureClusterResult?.stats.totalClusters ?? aggregatedClusterCount,
                 processes: pipelineResult.processResult?.stats.totalProcesses,
             }, undefined, { skipAgentsMd: options.skipAgentsMd, noStats: options.noStats });
         }
@@ -380,7 +386,7 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
             // Best-effort — don't fail the entire analysis for context file issues
         }
         // ── Close LadybugDB ──────────────────────────────────────────────
-        await closeLbug();
+        await closeCgdb();
         progress('done', 100, 'Done');
         return {
             repoName: projectName,
@@ -392,7 +398,7 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
     catch (err) {
         // Ensure LadybugDB is closed even on error
         try {
-            await closeLbug();
+            await closeCgdb();
         }
         catch {
             /* swallow */

package/dist/core/search/bm25-index.d.ts

@@ -5,7 +5,7 @@
  * Always reads from the database (no cached state to drift).
  *
  * FTS indexes are created lazily on first query (via `ensureFTSIndex`) — see
- * `lbug-adapter.ts` for the rationale. This keeps `analyze` fast (the
+ * `cgdb-adapter.ts` for the rationale. This keeps `analyze` fast (the
  * ~440 ms × 5 LadybugDB CREATE_FTS_INDEX cost dominates pipeline time on
  * small repos / CI runners) at the cost of paying that overhead on the
  * first `query`/`context` call in a session.
@@ -20,7 +20,7 @@ export interface BM25SearchResult {
  * Drop all ensured-FTS cache entries for a given repoId.
  *
  * Called from the pool-close listener so that a pool teardown / recreation
- * forces the next `searchFTSFromLbug` call to re-issue `CREATE_FTS_INDEX`
+ * forces the next `searchFTSFromCgdb` call to re-issue `CREATE_FTS_INDEX`
  * against the fresh connection rather than trust stale ensure-state from a
  * previous pool lifetime.
  *
@@ -38,4 +38,4 @@ export declare function invalidateEnsuredFTSForRepo(repoId: string): void;
  * @param repoId - If provided, queries will be routed via the MCP connection pool
  * @returns Ranked search results from FTS indexes
  */
-export declare const searchFTSFromLbug: (query: string, limit?: number, repoId?: string) => Promise<BM25SearchResult[]>;
+export declare const searchFTSFromCgdb: (query: string, limit?: number, repoId?: string) => Promise<BM25SearchResult[]>;

package/dist/core/search/bm25-index.js

@@ -5,14 +5,14 @@
  * Always reads from the database (no cached state to drift).
  *
  * FTS indexes are created lazily on first query (via `ensureFTSIndex`) — see
- * `lbug-adapter.ts` for the rationale. This keeps `analyze` fast (the
+ * `cgdb-adapter.ts` for the rationale. This keeps `analyze` fast (the
  * ~440 ms × 5 LadybugDB CREATE_FTS_INDEX cost dominates pipeline time on
  * small repos / CI runners) at the cost of paying that overhead on the
  * first `query`/`context` call in a session.
  */
-import { queryFTS, ensureFTSIndex, executeQuery as executeCoreQuery, } from '../lbug/lbug-adapter.js';
+import { queryFTS, ensureFTSIndex, executeQuery as executeCoreQuery, } from '../cgdb/cgdb-adapter.js';
 /**
- * FTS table set served by `searchFTSFromLbug`. Centralised so that both
+ * FTS table set served by `searchFTSFromCgdb`. Centralised so that both
  * the CLI/pipeline path and the MCP pool path stay in lockstep.
  *
  * The properties list is computed at FTS-create time via `ftsPropertiesFor`
@@ -72,7 +72,7 @@ const FALLBACK_FIELD_WEIGHTS = {
 /**
  * Per-process cache for the MCP pool path: tracks which `(repoId, table)`
  * pairs have been ensured. The CLI/pipeline path gets its own cache inside
- * `lbug-adapter.ts` keyed by table/index, scoped to the singleton connection.
+ * `cgdb-adapter.ts` keyed by table/index, scoped to the singleton connection.
  *
  * IMPORTANT: an entry is added ONLY when the index was confirmed to exist
  * (CREATE_FTS_INDEX succeeded, or failed with `'already exists'`). Other
@@ -80,14 +80,14 @@ const FALLBACK_FIELD_WEIGHTS = {
  * unset so the next query retries instead of silently caching the failure.
  *
  * Entries for a given repoId are invalidated when its pool is closed —
- * see the `addPoolCloseListener` registration in `searchFTSFromLbug`.
+ * see the `addPoolCloseListener` registration in `searchFTSFromCgdb`.
  */
 const ensuredPoolFTS = new Set();
 /**
  * Drop all ensured-FTS cache entries for a given repoId.
  *
  * Called from the pool-close listener so that a pool teardown / recreation
- * forces the next `searchFTSFromLbug` call to re-issue `CREATE_FTS_INDEX`
+ * forces the next `searchFTSFromCgdb` call to re-issue `CREATE_FTS_INDEX`
  * against the fresh connection rather than trust stale ensure-state from a
  * previous pool lifetime.
  *
@@ -245,7 +245,7 @@ properties = ['name', 'content']) {
  * @param repoId - If provided, queries will be routed via the MCP connection pool
  * @returns Ranked search results from FTS indexes
  */
-export const searchFTSFromLbug = async (query, limit = 20, repoId) => {
+export const searchFTSFromCgdb = async (query, limit = 20, repoId) => {
     if (!query.trim() || limit <= 0)
         return [];
     let fileResults, functionResults, classResults, methodResults, interfaceResults;
@@ -253,7 +253,7 @@ export const searchFTSFromLbug = async (query, limit = 20, repoId) => {
         // Use MCP connection pool via dynamic import
         // IMPORTANT: FTS queries run sequentially to avoid connection contention.
         // The MCP pool supports multiple connections, but FTS is best run serially.
-        const poolMod = await import('../lbug/pool-adapter.js');
+        const poolMod = await import('../cgdb/pool-adapter.js');
         const { executeQuery, addPoolCloseListener } = poolMod;
         // Register the pool-close listener lazily on first use so a teardown of
         // the pool entry (LRU eviction, idle timeout, explicit close) drops the
@@ -287,7 +287,7 @@ export const searchFTSFromLbug = async (query, limit = 20, repoId) => {
         }
     }
     else {
-        // Use core lbug adapter (CLI / pipeline context) — also sequential for safety.
+        // Use core cgdb adapter (CLI / pipeline context) — also sequential for safety.
         // Lazy-create FTS indexes on first query (analyze no longer does it).
         // RFC 0001 Phase 2.5 — same `compress`-aware property selection as the MCP
         // path; the CLI walks up from cwd to find the repo's meta.json.

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';