@codragraph/cli 1.6.4 → 2.1.0

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

@@ -8,6 +8,7 @@
  * IMPORTANT: This module must NEVER call process.exit(). The caller (CLI
  * wrapper or server worker) is responsible for process lifecycle.
  */
+import type { ContentEncoding } from '@codragraph/graphstore';
 export interface AnalyzeCallbacks {
     onProgress: (phase: string, percent: number, message: string) => void;
     onLog?: (message: string) => void;
@@ -41,6 +42,18 @@ export interface AnalyzeOptions {
      * of a pipeline re-index.
      */
     allowDuplicateName?: boolean;
+    /**
+     * RFC 0001 Phase 2 — opt into per-row content compression. `'none'`
+     * (or undefined) writes plain text and the schema-default tag, exactly
+     * as pre-Phase-2 indexes do. `'brotli'` and `'zstd'` route every
+     * content field through `encodeContent` before it hits the CSV; the
+     * read path decodes via the per-row `contentEncoding` tag.
+     *
+     * Choosing `'zstd'` requires Node ≥ 22.15 on the indexer (the runtime
+     * that wrote the rows). Readers on older Node will get a clear
+     * forward-compat error rather than silently bad content.
+     */
+    compress?: ContentEncoding;
 }
 export interface AnalyzeResult {
     repoName: string;

package/dist/core/run-analyze.js

@@ -10,14 +10,16 @@
  */
 import path from 'path';
 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 { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, cleanupOldKuzuFiles, } from '../storage/repo-manager.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 = {
@@ -30,7 +32,7 @@ export const PHASE_LABELS = {
     communities: 'Detecting communities',
     processes: 'Detecting processes',
     complete: 'Pipeline complete',
-    lbug: 'Loading into LadybugDB',
+    cgdb: 'Loading into LadybugDB',
     fts: 'Creating search indexes',
     embeddings: 'Generating embeddings',
     done: 'Done',
@@ -51,8 +53,71 @@ export const PHASE_LABELS = {
  */
 export async function runFullAnalysis(repoPath, options, callbacks) {
     const log = (msg) => callbacks.onLog?.(msg);
-    const progress = (phase, percent, message) => callbacks.onProgress(phase, percent, message);
-    const { storagePath, lbugPath } = getStoragePaths(repoPath);
+    // RFC 0002 Phase 1 — optional heap-profile instrumentation. Set
+    // CODRAGRAPH_HEAP_PROFILE=1 (or run `codragraph profile-heap`) to write a
+    // v8 heap snapshot at every phase boundary, plus a `profile-summary.jsonl`
+    // log of `process.memoryUsage()` at the same boundaries. Snapshots land in
+    // `<repo>/.codragraph/heap-profiles/`. Open snapshots in Chrome DevTools
+    // (Memory → Load) to find which constructors dominate retained set; the
+    // JSONL is the cheap RSS / heapUsed timeline. Off by default — snapshot
+    // writes pause the event loop ~2-5s and consume ~100-500MB of disk each.
+    const heapProfileEnabled = process.env.CODRAGRAPH_HEAP_PROFILE === '1';
+    let heapProfileDir = '';
+    let heapProfileSummaryPath = '';
+    let lastProfilePhase = '';
+    if (heapProfileEnabled) {
+        heapProfileDir = path.join(repoPath, '.codragraph', 'heap-profiles');
+        heapProfileSummaryPath = path.join(heapProfileDir, 'profile-summary.jsonl');
+        try {
+            fsSync.mkdirSync(heapProfileDir, { recursive: true });
+            // Truncate any prior summary so a single run produces a clean log.
+            // We append crash-safely on each phase boundary below.
+            fsSync.writeFileSync(heapProfileSummaryPath, '');
+        }
+        catch {
+            /* permission issue — best-effort */
+        }
+    }
+    const progress = (phase, percent, message) => {
+        callbacks.onProgress(phase, percent, message);
+        // Only snapshot on phase transitions, not every tick. Phase strings come
+        // from runPipelineFromRepo / loadGraphToCgdb and are stable.
+        if (heapProfileEnabled && phase && phase !== lastProfilePhase) {
+            lastProfilePhase = phase;
+            const ts = Date.now();
+            const safe = phase.replace(/[^a-zA-Z0-9]+/g, '_').slice(0, 60);
+            const file = path.join(heapProfileDir, `${ts}-${safe}.heapsnapshot`);
+            // Capture the cheap memoryUsage timeline FIRST — even if writeHeapSnapshot
+            // crashes (out of disk, permissions), we still have the RSS curve which
+            // is the more useful artifact for the heap-pressure RFC.
+            try {
+                const mu = process.memoryUsage();
+                const entry = JSON.stringify({
+                    ts,
+                    phase,
+                    percent,
+                    rss: mu.rss,
+                    heapUsed: mu.heapUsed,
+                    heapTotal: mu.heapTotal,
+                    external: mu.external,
+                    arrayBuffers: mu.arrayBuffers,
+                    snapshotFile: path.basename(file),
+                });
+                fsSync.appendFileSync(heapProfileSummaryPath, entry + '\n');
+            }
+            catch (err) {
+                log(`heap-profile: summary append failed (${err.message})`);
+            }
+            try {
+                v8.writeHeapSnapshot(file);
+                log(`heap-profile: wrote ${file}`);
+            }
+            catch (err) {
+                log(`heap-profile: write failed (${err.message})`);
+            }
+        }
+    };
+    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) {
@@ -62,7 +127,17 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
     const currentCommit = repoHasGit ? getCurrentCommit(repoPath) : '';
     const existingMeta = await loadMeta(storagePath);
     // ── Early-return: already up to date ──────────────────────────────
-    if (existingMeta && !options.force && existingMeta.lastCommit === currentCommit) {
+    // 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.
+    const schemaUpToDate = !!existingMeta && (existingMeta.schemaVersion ?? 0) >= INDEX_SCHEMA_VERSION;
+    if (existingMeta &&
+        schemaUpToDate &&
+        !options.force &&
+        existingMeta.lastCommit === currentCommit) {
         // Non-git folders have currentCommit = '' — always rebuild since we can't detect changes
         if (currentCommit !== '') {
             return {
@@ -73,21 +148,26 @@ 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). ` +
+            `Re-analyzing.`);
+    }
     // ── Cache embeddings from existing index before rebuild ────────────
     let cachedEmbeddingNodeIds = new Set();
     let cachedEmbeddings = [];
     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 */
@@ -101,10 +181,10 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
         progress(p.phase, scaled, phaseLabel);
     });
     // ── 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 });
         }
@@ -112,17 +192,22 @@ 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
+        // a true passthrough, so the on-disk layout is byte-identical to
+        // pre-Phase-2 indexes when no compression flag is passed.
+        { compress: options.compress });
         // ── Phase 2.5: Versioned-graph snapshot (best-effort) ────────────
         // Phase 4 hook: snapshot the freshly-loaded graph into the
         // content-addressed `.codragraph/graphstore/`. Failures here do NOT
@@ -159,7 +244,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`);
@@ -182,7 +267,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) {
@@ -230,6 +315,8 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
             repoPath,
             lastCommit: currentCommit,
             indexedAt: new Date().toISOString(),
+            schemaVersion: INDEX_SCHEMA_VERSION,
+            compress: options.compress ?? 'none',
             // Captured here (not at registration) so it travels with the
             // on-disk meta.json — sibling-clone fingerprinting works for
             // out-of-tree consumers (group-status, future tooling) without
@@ -293,7 +380,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,
@@ -305,7 +392,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,24 +5,63 @@
  * 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 schema served by `searchFTSFromLbug`. Centralised so that both the
- * CLI/pipeline path and the MCP pool path use identical (table, index,
- * properties) tuples and the lazy-create logic stays in one place.
+ * 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`
+ * — for repos that were analysed with `--compress brotli|zstd`, the
+ * `content` column holds base64-of-encoded-bytes and would tokenise to
+ * useless tokens. Those repos get name-only FTS so search at least
+ * matches function/class names instead of returning random hits on
+ * base64 alphabet. Plain (compress='none' / unset) repos get the full
+ * `name + content` index for body-text matches. RFC 0001 Phase 2.5.
  */
-const FTS_INDEXES = [
-    { table: 'File', indexName: 'file_fts', properties: ['name', 'content'] },
-    { table: 'Function', indexName: 'function_fts', properties: ['name', 'content'] },
-    { table: 'Class', indexName: 'class_fts', properties: ['name', 'content'] },
-    { table: 'Method', indexName: 'method_fts', properties: ['name', 'content'] },
-    { table: 'Interface', indexName: 'interface_fts', properties: ['name', 'content'] },
+const FTS_TABLES = [
+    { table: 'File', indexName: 'file_fts' },
+    { table: 'Function', indexName: 'function_fts' },
+    { table: 'Class', indexName: 'class_fts' },
+    { table: 'Method', indexName: 'method_fts' },
+    { table: 'Interface', indexName: 'interface_fts' },
 ];
+const ftsPropertiesFor = (compress) => !compress || compress === 'none' ? ['name', 'content'] : ['name'];
+/**
+ * Look up `meta.compress` for a repo. The MCP path passes `repoId`
+ * (registry-derived); the CLI path passes nothing and we walk up from
+ * cwd. Returns `'none'` whenever the lookup fails so the safe default
+ * (full FTS index) is used — the failure mode is reduced search
+ * quality, never wrong results.
+ */
+async function getCompressMode(repoId) {
+    try {
+        const repoMod = await import('../../storage/repo-manager.js');
+        if (repoId) {
+            // MCP path: registry name is the source of truth. The MCP
+            // backend's `repoId` is `entry.name.toLowerCase()` (or `${name}-${hash}`
+            // on collision); match conservatively against both forms.
+            const entries = await repoMod.listRegisteredRepos();
+            for (const entry of entries) {
+                const base = entry.name.toLowerCase();
+                if (base === repoId || repoId.startsWith(`${base}-`)) {
+                    const meta = await repoMod.loadMeta(entry.storagePath);
+                    return meta?.compress ?? 'none';
+                }
+            }
+            return 'none';
+        }
+        const repo = await repoMod.findRepo(process.cwd());
+        return repo?.meta?.compress ?? 'none';
+    }
+    catch {
+        return 'none';
+    }
+}
 const FALLBACK_SCAN_LIMIT = 50_000;
 const BOOLEAN_QUERY_TOKENS = new Set(['and', 'or', 'not']);
 const FALLBACK_FIELD_WEIGHTS = {
@@ -33,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
@@ -41,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.
  *
@@ -184,9 +223,13 @@ async function queryFallbackViaExecutor(executor, tableName, properties, query,
         return [];
     }
 }
-async function fallbackSearchAllTables(executor, query, limit) {
+async function fallbackSearchAllTables(executor, query, limit, 
+// Same compress-aware property selection as the FTS path. Default keeps
+// pre-Phase-2 behaviour (`['name', 'content']`) for callers that don't
+// pass a value.
+properties = ['name', 'content']) {
     const results = [];
-    for (const { table, properties } of FTS_INDEXES) {
+    for (const { table } of FTS_TABLES) {
         results.push(await queryFallbackViaExecutor(executor, table, properties, query, limit));
     }
     return results;
@@ -202,7 +245,7 @@ async function fallbackSearchAllTables(executor, query, limit) {
  * @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;
@@ -210,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
@@ -220,7 +263,12 @@ export const searchFTSFromLbug = async (query, limit = 20, repoId) => {
         const executor = (cypher) => executeQuery(repoId, cypher);
         // Lazy-create FTS indexes on first query for this repo (analyze no longer
         // creates them up-front, so we ensure them here). Cached per-process.
-        for (const { table, indexName, properties } of FTS_INDEXES) {
+        // RFC 0001 Phase 2.5: drop `content` from FTS properties for repos
+        // analysed with --compress brotli|zstd — the column holds encoded
+        // bytes and would tokenise to garbage.
+        const compress = await getCompressMode(repoId);
+        const properties = ftsPropertiesFor(compress);
+        for (const { table, indexName } of FTS_TABLES) {
             await ensureFTSIndexViaExecutor(executor, repoId, table, indexName, properties);
         }
         fileResults = await queryFTSViaExecutor(executor, 'File', 'file_fts', query, limit);
@@ -235,13 +283,17 @@ export const searchFTSFromLbug = async (query, limit = 20, repoId) => {
             interfaceResults.length ===
             0) {
             [fileResults, functionResults, classResults, methodResults, interfaceResults] =
-                await fallbackSearchAllTables(executor, query, limit);
+                await fallbackSearchAllTables(executor, query, limit, properties);
         }
     }
     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).
-        for (const { table, indexName, properties } of FTS_INDEXES) {
+        // 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.
+        const compress = await getCompressMode();
+        const properties = ftsPropertiesFor(compress);
+        for (const { table, indexName } of FTS_TABLES) {
             await ensureFTSIndex(table, indexName, [...properties]).catch(() => { });
         }
         fileResults = await queryFTS('File', 'file_fts', query, limit, false).catch(() => []);
@@ -256,7 +308,7 @@ export const searchFTSFromLbug = async (query, limit = 20, repoId) => {
             interfaceResults.length ===
             0) {
             [fileResults, functionResults, classResults, methodResults, interfaceResults] =
-                await fallbackSearchAllTables(executeCoreQuery, query, limit);
+                await fallbackSearchAllTables(executeCoreQuery, query, limit, properties);
         }
     }
     // Collect all node scores per filePath to track which nodes actually matched

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;