@codragraph/cli 2.0.0 → 2.1.0

package/README.md

@@ -325,7 +325,7 @@ are too big.
 
 ### Index size — opt-in per-row compression
 
-For repos where `.codragraph/lbug` itself has grown large:
+For repos where `.codragraph/cgdb` itself has grown large:
 
 ```bash
 codragraph analyze --compress brotli   # Node ≥ 18, brotli quality 6
@@ -334,7 +334,7 @@ codragraph analyze --compress none     # explicit default
 ```
 
 `--compress` routes every node-row content field through the matching
-encoder before it's written to the CSV / lbug; readers decode
+encoder before it's written to the CSV / cgdb; readers decode
 transparently via the per-row `contentEncoding` tag. With the flag
 unset, the on-disk layout is byte-identical to pre-1.8 indexes. Pre-1.8
 indexes auto-trigger a full re-analyze the first time a 1.8+ CLI runs

package/dist/_shared/cgdb/schema-constants.d.ts

@@ -0,0 +1,16 @@
+/**
+ * LadybugDB schema constants — single source of truth.
+ *
+ * NODE_TABLES and REL_TYPES define what the knowledge graph can contain.
+ * Both CLI and web must agree on these for data compatibility.
+ *
+ * Full DDL schemas remain in each package's own schema.ts because
+ * the CLI uses native LadybugDB and the web uses WASM.
+ */
+export declare const NODE_TABLES: readonly ["File", "Folder", "Function", "Class", "Interface", "Method", "CodeElement", "Community", "Process", "Section", "Struct", "Enum", "Macro", "Typedef", "Union", "Namespace", "Trait", "Impl", "TypeAlias", "Const", "Static", "Variable", "Property", "Record", "Delegate", "Annotation", "Constructor", "Template", "Module", "Route", "Tool"];
+export type NodeTableName = (typeof NODE_TABLES)[number];
+export declare const REL_TABLE_NAME = "CodeRelation";
+export declare const REL_TYPES: readonly ["CONTAINS", "DEFINES", "IMPORTS", "CALLS", "EXTENDS", "IMPLEMENTS", "HAS_METHOD", "HAS_PROPERTY", "ACCESSES", "METHOD_OVERRIDES", "OVERRIDES", "METHOD_IMPLEMENTS", "MEMBER_OF", "STEP_IN_PROCESS", "HANDLES_ROUTE", "FETCHES", "HANDLES_TOOL", "ENTRY_POINT_OF", "WRAPS", "QUERIES"];
+export type RelType = (typeof REL_TYPES)[number];
+export declare const EMBEDDING_TABLE_NAME = "CodeEmbedding";
+//# sourceMappingURL=schema-constants.d.ts.map

package/dist/_shared/cgdb/schema-constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-constants.d.ts","sourceRoot":"","sources":["../../src/cgdb/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,WAAW,0VAgCd,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAM,cAAc,iBAAiB,CAAC;AAE7C,eAAO,MAAM,SAAS,iSAqBZ,CAAC;AAEX,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD,eAAO,MAAM,oBAAoB,kBAAkB,CAAC"}

package/dist/_shared/cgdb/schema-constants.js

@@ -0,0 +1,67 @@
+/**
+ * LadybugDB schema constants — single source of truth.
+ *
+ * NODE_TABLES and REL_TYPES define what the knowledge graph can contain.
+ * Both CLI and web must agree on these for data compatibility.
+ *
+ * Full DDL schemas remain in each package's own schema.ts because
+ * the CLI uses native LadybugDB and the web uses WASM.
+ */
+export const NODE_TABLES = [
+    'File',
+    'Folder',
+    'Function',
+    'Class',
+    'Interface',
+    'Method',
+    'CodeElement',
+    'Community',
+    'Process',
+    'Section',
+    'Struct',
+    'Enum',
+    'Macro',
+    'Typedef',
+    'Union',
+    'Namespace',
+    'Trait',
+    'Impl',
+    'TypeAlias',
+    'Const',
+    'Static',
+    'Variable',
+    'Property',
+    'Record',
+    'Delegate',
+    'Annotation',
+    'Constructor',
+    'Template',
+    'Module',
+    'Route',
+    'Tool',
+];
+export const REL_TABLE_NAME = 'CodeRelation';
+export const REL_TYPES = [
+    'CONTAINS',
+    'DEFINES',
+    'IMPORTS',
+    'CALLS',
+    'EXTENDS',
+    'IMPLEMENTS',
+    'HAS_METHOD',
+    'HAS_PROPERTY',
+    'ACCESSES',
+    'METHOD_OVERRIDES',
+    'OVERRIDES', // Legacy compat alias — kept until all stored indexes are migrated
+    'METHOD_IMPLEMENTS',
+    'MEMBER_OF',
+    'STEP_IN_PROCESS',
+    'HANDLES_ROUTE',
+    'FETCHES',
+    'HANDLES_TOOL',
+    'ENTRY_POINT_OF',
+    'WRAPS',
+    'QUERIES',
+];
+export const EMBEDDING_TABLE_NAME = 'CodeEmbedding';
+//# sourceMappingURL=schema-constants.js.map

package/dist/_shared/cgdb/schema-constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-constants.js","sourceRoot":"","sources":["../../src/cgdb/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,MAAM;IACN,QAAQ;IACR,UAAU;IACV,OAAO;IACP,WAAW;IACX,QAAQ;IACR,aAAa;IACb,WAAW;IACX,SAAS;IACT,SAAS;IACT,QAAQ;IACR,MAAM;IACN,OAAO;IACP,SAAS;IACT,OAAO;IACP,WAAW;IACX,OAAO;IACP,MAAM;IACN,WAAW;IACX,OAAO;IACP,QAAQ;IACR,UAAU;IACV,UAAU;IACV,QAAQ;IACR,UAAU;IACV,YAAY;IACZ,aAAa;IACb,UAAU;IACV,QAAQ;IACR,OAAO;IACP,MAAM;CACE,CAAC;AAIX,MAAM,CAAC,MAAM,cAAc,GAAG,cAAc,CAAC;AAE7C,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,UAAU;IACV,SAAS;IACT,SAAS;IACT,OAAO;IACP,SAAS;IACT,YAAY;IACZ,YAAY;IACZ,cAAc;IACd,UAAU;IACV,kBAAkB;IAClB,WAAW,EAAE,mEAAmE;IAChF,mBAAmB;IACnB,WAAW;IACX,iBAAiB;IACjB,eAAe;IACf,SAAS;IACT,cAAc;IACd,gBAAgB;IAChB,OAAO;IACP,SAAS;CACD,CAAC;AAIX,MAAM,CAAC,MAAM,oBAAoB,GAAG,eAAe,CAAC"}

package/dist/_shared/index.d.ts

@@ -1,6 +1,6 @@
 export type { NodeLabel, NodeProperties, RelationshipType, GraphNode, GraphRelationship, } from './graph/types.js';
-export { NODE_TABLES, REL_TABLE_NAME, REL_TYPES, EMBEDDING_TABLE_NAME, } from './lbug/schema-constants.js';
-export type { NodeTableName, RelType } from './lbug/schema-constants.js';
+export { NODE_TABLES, REL_TABLE_NAME, REL_TYPES, EMBEDDING_TABLE_NAME, } from './cgdb/schema-constants.js';
+export type { NodeTableName, RelType } from './cgdb/schema-constants.js';
 export { SupportedLanguages } from './languages.js';
 export { getLanguageFromFilename, getSyntaxLanguageFromFilename } from './language-detection.js';
 export type { MroStrategy } from './mro-strategy.js';

package/dist/_shared/index.js

@@ -1,5 +1,5 @@
 // Schema constants
-export { NODE_TABLES, REL_TABLE_NAME, REL_TYPES, EMBEDDING_TABLE_NAME, } from './lbug/schema-constants.js';
+export { NODE_TABLES, REL_TABLE_NAME, REL_TYPES, EMBEDDING_TABLE_NAME, } from './cgdb/schema-constants.js';
 // Language support
 export { SupportedLanguages } from './languages.js';
 export { getLanguageFromFilename, getSyntaxLanguageFromFilename } from './language-detection.js';

package/dist/cli/analyze.js

@@ -12,7 +12,7 @@ import { execFileSync } from 'child_process';
 import v8 from 'v8';
 import cliProgress from 'cli-progress';
 import * as fsSync from 'node:fs';
-import { closeLbug } from '../core/lbug/lbug-adapter.js';
+import { closeCgdb } from '../core/cgdb/cgdb-adapter.js';
 import { getStoragePaths, getGlobalRegistryPath, RegistryNameCollisionError, } from '../storage/repo-manager.js';
 import { getGitRoot, hasGitDir } from '../storage/git.js';
 import { runFullAnalysis } from '../core/run-analyze.js';
@@ -79,7 +79,7 @@ export const analyzeCommand = async (inputPath, options) => {
         // gracefully falls back to name-only matches instead of tokenising
         // base64 garbage. Surface the trade-off so users know what they're
         // opting into.
-        console.warn(`  Note: --compress ${options.compress} reduces .codragraph/lbug size.\n` +
+        console.warn(`  Note: --compress ${options.compress} reduces .codragraph/cgdb size.\n` +
             `  BM25 search will index symbol names only (function bodies are not tokenised\n` +
             `  when compressed); embeddings, graph queries, and \`context\` / \`impact\` are\n` +
             `  unaffected. Run with --compress none if you rely on full-text search inside\n` +
@@ -182,7 +182,7 @@ export const analyzeCommand = async (inputPath, options) => {
         aborted = true;
         bar.stop();
         console.log('\n  Interrupted — cleaning up...');
-        closeLbug()
+        closeCgdb()
             .catch(() => { })
             .finally(() => process.exit(130));
     };

package/dist/cli/graphstore.js

@@ -12,7 +12,7 @@ import fs from 'node:fs/promises';
 import { FsCAS, createBranch, createCommit, DEFAULT_BRANCH, deleteBranch, diffSemantic, diffSnapshots, gc as runGc, getJson, listBranches, materializeSnapshot, parseObjectId, readCommit, readHead, resolveHeadCommit, setHead, threeWayMerge, walkCommits, writeHeadBranch, writeHeadDetached, } from '@codragraph/graphstore';
 import { findRepo, loadMeta, saveMeta } from '../storage/repo-manager.js';
 import { GRAPHSTORE_SUBDIR } from '../core/graphstore/index.js';
-import { initLbug, closeLbug } from '../core/lbug/lbug-adapter.js';
+import { initCgdb, closeCgdb } from '../core/cgdb/cgdb-adapter.js';
 import { recordAnalysisSnapshot } from '../core/graphstore/index.js';
 import { getCurrentCommit, hasGitDir } from '../storage/git.js';
 const resolveGraphstore = async (cwd) => {
@@ -164,7 +164,7 @@ export const commitCommand = async (opts = {}) => {
     const repo = await findRepo(process.cwd());
     if (!repo)
         throw new Error('No CodraGraph index found');
-    await initLbug(repo.lbugPath);
+    await initCgdb(repo.cgdbPath);
     try {
         const result = await recordAnalysisSnapshot({
             storagePath: repo.storagePath,
@@ -191,7 +191,7 @@ export const commitCommand = async (opts = {}) => {
         }
     }
     finally {
-        await closeLbug();
+        await closeCgdb();
     }
     // Avoid unused warnings while keeping the import live for future callers.
     void ctx;
@@ -221,10 +221,10 @@ export const branchCreateCommand = async (name, opts = {}) => {
 // ──────────────────────────────────────────────────────────────────────
 //
 // Two modes:
-//   - default       : just move HEAD (no lbug rewrite). Cheap; good for
+//   - default       : just move HEAD (no cgdb rewrite). Cheap; good for
 //                     log/diff inspection from a different vantage point.
 //   - --materialize : also rebuild the live LadybugDB from the target
-//                     snapshot. Destructive of the current lbug state —
+//                     snapshot. Destructive of the current cgdb state —
 //                     run `commit` first if you have unsaved changes.
 export const checkoutCommand = async (target, opts = {}) => {
     const ctx = await resolveGraphstore(process.cwd());
@@ -247,9 +247,9 @@ export const checkoutCommand = async (target, opts = {}) => {
             throw new Error('No CodraGraph index found');
         const commit = await readCommit(ctx.cas, commitId);
         process.stdout.write(`materializing snapshot ${commit.snapshot.slice(7, 7 + 12)}...\n`);
-        // Wipe and reinit lbug.
-        await closeLbug();
-        for (const f of [repo.lbugPath, `${repo.lbugPath}.wal`, `${repo.lbugPath}.lock`]) {
+        // Wipe and reinit cgdb.
+        await closeCgdb();
+        for (const f of [repo.cgdbPath, `${repo.cgdbPath}.wal`, `${repo.cgdbPath}.lock`]) {
             try {
                 await fs.rm(f, { recursive: true, force: true });
             }
@@ -257,9 +257,9 @@ export const checkoutCommand = async (target, opts = {}) => {
                 /* swallow */
             }
         }
-        await initLbug(repo.lbugPath);
+        await initCgdb(repo.cgdbPath);
         try {
-            const sink = await createLbugRowSinkForCheckout(repo.lbugPath);
+            const sink = await createCgdbRowSinkForCheckout(repo.cgdbPath);
             const result = await materializeSnapshot({
                 cas: ctx.cas,
                 snapshotId: commit.snapshot,
@@ -269,14 +269,14 @@ export const checkoutCommand = async (target, opts = {}) => {
                 `${result.stats.edgeRowCount} edges\n`);
         }
         finally {
-            await closeLbug();
+            await closeCgdb();
         }
     }
 };
 // ──────────────────────────────────────────────────────────────────────
 // codragraph materialize <target> --into <path>
 // ──────────────────────────────────────────────────────────────────────
-// Read-only inspection: rebuild a snapshot into a fresh sibling lbug
+// Read-only inspection: rebuild a snapshot into a fresh sibling cgdb
 // without touching the live one. Useful for "let me query the graph as
 // it was at commit X" without disturbing current work.
 export const materializeCommand = async (target, opts) => {
@@ -295,9 +295,9 @@ export const materializeCommand = async (target, opts) => {
     catch {
         /* doesn't exist, good */
     }
-    await initLbug(into);
+    await initCgdb(into);
     try {
-        const sink = await createLbugRowSinkForCheckout(into);
+        const sink = await createCgdbRowSinkForCheckout(into);
         const result = await materializeSnapshot({
             cas: ctx.cas,
             snapshotId: commit.snapshot,
@@ -310,7 +310,7 @@ export const materializeCommand = async (target, opts) => {
             `edges:  ${result.stats.edgeRowCount}\n`);
     }
     finally {
-        await closeLbug();
+        await closeCgdb();
     }
 };
 // ──────────────────────────────────────────────────────────────────────
@@ -386,7 +386,7 @@ const locateSymbolHash = (manifest, symbolId, tableHint) => {
     return null;
 };
 // ──────────────────────────────────────────────────────────────────────
-// LbugRowSink — used by checkout --materialize and `materialize` command.
+// CgdbRowSink — used by checkout --materialize and `materialize` command.
 // ──────────────────────────────────────────────────────────────────────
 //
 // Bulk-loads rows back into a fresh LadybugDB instance. Phase 4 keeps it
@@ -394,9 +394,9 @@ const locateSymbolHash = (manifest, symbolId, tableHint) => {
 // `executeWithReusedStatement` helper. For typical repos (≤100k rows)
 // this finishes in seconds; CSV-based bulk loading is a Phase 4.5
 // optimization once we measure where the bottleneck actually is.
-const createLbugRowSinkForCheckout = async (lbugPath) => {
-    const { executeQuery } = await import('../core/lbug/lbug-adapter.js');
-    const { SCHEMA_QUERIES } = await import('../core/lbug/schema.js');
+const createCgdbRowSinkForCheckout = async (cgdbPath) => {
+    const { executeQuery } = await import('../core/cgdb/cgdb-adapter.js');
+    const { SCHEMA_QUERIES } = await import('../core/cgdb/schema.js');
     // Recreate the schema; the path was just wiped, so this is a clean install.
     for (const ddl of SCHEMA_QUERIES) {
         try {
@@ -424,7 +424,7 @@ const createLbugRowSinkForCheckout = async (lbugPath) => {
         endEdges: async () => { },
         finalize: async () => { },
     };
-    void lbugPath;
+    void cgdbPath;
     return sink;
 };
 const insertNode = async (executeQuery, table, row) => {
@@ -468,7 +468,7 @@ const cypherLiteral = (v) => {
         return JSON.stringify(v);
     if (typeof v === 'number' || typeof v === 'boolean')
         return String(v);
-    // Fall back to JSON for arrays / nested objects; the underlying lbug
+    // Fall back to JSON for arrays / nested objects; the underlying cgdb
     // schema is mostly scalar so this is rare.
     return JSON.stringify(v);
 };

package/dist/cli/index-repo.js

@@ -49,7 +49,7 @@ export const indexCommand = async (inputPathParts, options) => {
         process.exitCode = 1;
         return;
     }
-    const { storagePath, lbugPath } = getStoragePaths(repoPath);
+    const { storagePath, cgdbPath } = getStoragePaths(repoPath);
     // ── Verify .codragraph/ exists ──────────────────────────────────────
     try {
         await fs.access(storagePath);
@@ -60,9 +60,9 @@ export const indexCommand = async (inputPathParts, options) => {
         process.exitCode = 1;
         return;
     }
-    // ── Verify lbug database exists ───────────────────────────────────
+    // ── Verify cgdb database exists ───────────────────────────────────
     try {
-        await fs.access(lbugPath);
+        await fs.access(cgdbPath);
     }
     catch {
         console.log(`  .codragraph/ folder exists but contains no LadybugDB index.`);

package/dist/cli/wiki.js

@@ -91,7 +91,7 @@ export const wikiCommand = async (inputPath, options) => {
         return;
     }
     // ── Check for existing index ────────────────────────────────────────
-    const { storagePath, lbugPath } = getStoragePaths(repoPath);
+    const { storagePath, cgdbPath } = getStoragePaths(repoPath);
     const meta = await loadMeta(storagePath);
     if (!meta) {
         console.log('  Error: No CodraGraph index found.');
@@ -333,7 +333,7 @@ export const wikiCommand = async (inputPath, options) => {
         concurrency: options?.concurrency ? parseInt(options.concurrency, 10) : undefined,
         reviewOnly: options?.review,
     };
-    const generator = new WikiGenerator(repoPath, storagePath, lbugPath, llmConfig, wikiOptions, (phase, percent, detail) => {
+    const generator = new WikiGenerator(repoPath, storagePath, cgdbPath, llmConfig, wikiOptions, (phase, percent, detail) => {
         const label = detail || phase;
         if (label !== lastPhase) {
             lastPhase = label;
@@ -406,7 +406,7 @@ export const wikiCommand = async (inputPath, options) => {
                 ...wikiOptions,
                 reviewOnly: false,
             };
-            const continueGenerator = new WikiGenerator(repoPath, storagePath, lbugPath, llmConfig, continueOptions, (phase, percent, detail) => {
+            const continueGenerator = new WikiGenerator(repoPath, storagePath, cgdbPath, llmConfig, continueOptions, (phase, percent, detail) => {
                 const label = detail || phase;
                 if (label !== lastPhase) {
                     lastPhase = label;

package/dist/core/augmentation/engine.js

@@ -56,7 +56,7 @@ async function findRepoForCwd(cwd) {
         return {
             name: bestMatch.name,
             storagePath: bestMatch.storagePath,
-            lbugPath: path.join(bestMatch.storagePath, 'lbug'),
+            cgdbPath: path.join(bestMatch.storagePath, 'cgdb'),
         };
     }
     catch {
@@ -81,16 +81,16 @@ export async function augment(pattern, cwd) {
         const repo = await findRepoForCwd(workDir);
         if (!repo)
             return '';
-        // Lazy-load lbug adapter (skip unnecessary init)
-        const { initLbug, executeQuery, isLbugReady } = await import('../lbug/pool-adapter.js');
-        const { searchFTSFromLbug } = await import('../search/bm25-index.js');
+        // Lazy-load cgdb adapter (skip unnecessary init)
+        const { initCgdb, executeQuery, isCgdbReady } = await import('../cgdb/pool-adapter.js');
+        const { searchFTSFromCgdb } = await import('../search/bm25-index.js');
         const repoId = repo.name.toLowerCase();
         // Init LadybugDB if not already
-        if (!isLbugReady(repoId)) {
-            await initLbug(repoId, repo.lbugPath);
+        if (!isCgdbReady(repoId)) {
+            await initCgdb(repoId, repo.cgdbPath);
         }
         // Step 1: BM25 search (fast, no embeddings)
-        const bm25Results = await searchFTSFromLbug(pattern, 10, repoId);
+        const bm25Results = await searchFTSFromCgdb(pattern, 10, repoId);
         if (bm25Results.length === 0)
             return '';
         // Step 2: Map BM25 file results to symbols

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

@@ -0,0 +1,176 @@
+import cgdb from '@ladybugdb/core';
+import { KnowledgeGraph } from '../graph/types.js';
+import type { CachedEmbedding } from '../embeddings/types.js';
+import type { ContentEncoding } from '@codragraph/graphstore';
+/** Factory for creating WriteStreams — injectable for testing. */
+export type WriteStreamFactory = (filePath: string) => import('fs').WriteStream;
+/** Result of splitting the relationship CSV into per-label-pair files. */
+export interface RelCsvSplitResult {
+    relHeader: string;
+    relsByPairMeta: Map<string, {
+        csvPath: string;
+        rows: number;
+    }>;
+    pairWriteStreams: Map<string, import('fs').WriteStream>;
+    skippedRels: number;
+    totalValidRels: number;
+}
+/**
+ * Split a relationship CSV into per-label-pair files on disk.
+ *
+ * Streams the CSV line-by-line, routing each relationship to a file named
+ * `rel_{fromLabel}_{toLabel}.csv`. Handles backpressure correctly: only one
+ * drain listener per stream at a time, and readline resumes only when ALL
+ * backpressured streams have drained.
+ *
+ * @param csvPath       Path to the combined relationship CSV
+ * @param csvDir        Directory to write per-pair CSV files
+ * @param validTables   Set of valid node table names
+ * @param getNodeLabel  Function to extract the label from a node ID
+ * @param wsFactory     Optional WriteStream factory (defaults to fs.createWriteStream)
+ */
+export declare const splitRelCsvByLabelPair: (csvPath: string, csvDir: string, validTables: Set<string>, getNodeLabel: (id: string) => string, wsFactory?: WriteStreamFactory) => Promise<RelCsvSplitResult>;
+/** Expose the current Database for pool adapter reuse in tests. */
+export declare const getDatabase: () => cgdb.Database | null;
+/**
+ * Return true when the error message indicates that another process holds
+ * an exclusive lock on the LadybugDB file (e.g. `codragraph analyze` or
+ * `codragraph serve` running at the same time).
+ */
+export declare const isDbBusyError: (err: unknown) => boolean;
+export declare const initCgdb: (dbPath: string) => Promise<{
+    db: cgdb.Database;
+    conn: cgdb.Connection;
+}>;
+/**
+ * Execute multiple queries against one repo DB atomically.
+ * While the callback runs, no other request can switch the active DB.
+ *
+ * Automatically retries up to DB_LOCK_RETRY_ATTEMPTS times when the
+ * database is busy (e.g. `codragraph analyze` holds the write lock).
+ * Each retry waits DB_LOCK_RETRY_DELAY_MS * attempt milliseconds.
+ */
+export declare const withCgdbDb: <T>(dbPath: string, operation: () => Promise<T>) => Promise<T>;
+export type CgdbProgressCallback = (message: string) => void;
+export declare const loadGraphToCgdb: (graph: KnowledgeGraph, repoPath: string, storagePath: string, onProgress?: CgdbProgressCallback, options?: {
+    compress?: ContentEncoding;
+}) => Promise<{
+    success: boolean;
+    insertedRels: number;
+    skippedRels: number;
+    warnings: string[];
+}>;
+/**
+ * Insert a single node to LadybugDB
+ * @param label - Node type (File, Function, Class, etc.)
+ * @param properties - Node properties
+ * @param dbPath - Path to LadybugDB database (optional if already initialized)
+ */
+export declare const insertNodeToCgdb: (label: string, properties: Record<string, any>, dbPath?: string) => Promise<boolean>;
+/**
+ * Batch insert multiple nodes to LadybugDB using a single connection
+ * @param nodes - Array of {label, properties} to insert
+ * @param dbPath - Path to LadybugDB database
+ * @returns Object with success count and error count
+ */
+export declare const batchInsertNodesToCgdb: (nodes: Array<{
+    label: string;
+    properties: Record<string, any>;
+}>, dbPath: string) => Promise<{
+    inserted: number;
+    failed: number;
+}>;
+export declare const executeQuery: (cypher: string) => Promise<any[]>;
+export declare const streamQuery: (cypher: string, onRow: (row: any) => void | Promise<void>) => Promise<number>;
+/**
+ * Execute a single parameterized query (prepare/execute pattern).
+ * Prevents Cypher injection by binding values as parameters.
+ */
+export declare const executePrepared: (cypher: string, params: Record<string, any>) => Promise<any[]>;
+export declare const executeWithReusedStatement: (cypher: string, paramsList: Array<Record<string, any>>) => Promise<void>;
+export declare const getCgdbStats: () => Promise<{
+    nodes: number;
+    edges: number;
+}>;
+/**
+ * Load cached embeddings from LadybugDB before a rebuild.
+ * Returns all embedding vectors so they can be re-inserted after the graph is reloaded,
+ * avoiding expensive re-embedding of unchanged nodes.
+ *
+ * Detects old schema (no chunkIndex column) and returns empty cache to trigger rebuild.
+ */
+export declare const loadCachedEmbeddings: () => Promise<{
+    embeddingNodeIds: Set<string>;
+    embeddings: CachedEmbedding[];
+}>;
+/**
+ * Fetch existing embedding hashes from CodeEmbedding table for incremental embedding.
+ * Returns a Map<nodeId, contentHash> suitable for passing to `runEmbeddingPipeline`.
+ * Handles legacy DBs without the `contentHash` column (all rows treated as stale with empty hash).
+ * Returns undefined if the CodeEmbedding table does not exist.
+ *
+ * @param execQuery - Cypher query executor (typically pool-adapter's `executeQuery`)
+ */
+export declare const fetchExistingEmbeddingHashes: (execQuery: (cypher: string) => Promise<any[]>) => Promise<Map<string, string> | undefined>;
+export declare const closeCgdb: () => Promise<void>;
+export declare const isCgdbReady: () => boolean;
+/**
+ * Delete all nodes (and their relationships) for a specific file from LadybugDB
+ * @param filePath - The file path to delete nodes for
+ * @param dbPath - Optional path to LadybugDB for per-query connection
+ * @returns Object with counts of deleted nodes
+ */
+export declare const deleteNodesForFile: (filePath: string, dbPath?: string) => Promise<{
+    deletedNodes: number;
+}>;
+export declare const getEmbeddingTableName: () => string;
+/**
+ * Load the FTS extension (required before using FTS functions).
+ * Safe to call multiple times — tracks loaded state via module-level ftsLoaded.
+ */
+export declare const loadFTSExtension: () => Promise<void>;
+/**
+ * Load the VECTOR extension (required before using QUERY_VECTOR_INDEX).
+ * Safe to call multiple times -- tracks loaded state via module-level vectorExtensionLoaded.
+ */
+export declare const loadVectorExtension: () => Promise<void>;
+/**
+ * Create a full-text search index on a table
+ * @param tableName - The node table name (e.g., 'File', 'CodeSymbol')
+ * @param indexName - Name for the FTS index
+ * @param properties - List of properties to index (e.g., ['name', 'code'])
+ * @param stemmer - Stemming algorithm (default: 'porter')
+ */
+export declare const createFTSIndex: (tableName: string, indexName: string, properties: string[], stemmer?: string) => Promise<void>;
+/**
+ * Lazy-create an FTS index, caching the fact in-process.
+ *
+ * Used by `queryFTS` so that `analyze` doesn't pay the ~440 ms × 5 fixed
+ * LadybugDB cost up-front (it dominates analyze on small repos). Instead,
+ * the cost is moved to the first `query`/`context` call in a session,
+ * where it's amortised across many lookups.
+ *
+ * Safe to call repeatedly — the in-process Set guarantees only the first
+ * call hits LadybugDB. `closeCgdb` clears the cache so re-init starts fresh.
+ */
+export declare const ensureFTSIndex: (tableName: string, indexName: string, properties: string[], stemmer?: string) => Promise<void>;
+/**
+ * Query a full-text search index
+ * @param tableName - The node table name
+ * @param indexName - FTS index name
+ * @param query - Search query string
+ * @param limit - Maximum results
+ * @param conjunctive - If true, all terms must match (AND); if false, any term matches (OR)
+ * @returns Array of { node properties, score }
+ */
+export declare const queryFTS: (tableName: string, indexName: string, query: string, limit?: number, conjunctive?: boolean) => Promise<Array<{
+    nodeId: string;
+    name: string;
+    filePath: string;
+    score: number;
+    [key: string]: any;
+}>>;
+/**
+ * Drop an FTS index
+ */
+export declare const dropFTSIndex: (tableName: string, indexName: string) => Promise<void>;