@code-rag/cli 0.1.6 → 0.1.8

package/dist/commands/benchmark-cmd.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CLI command: coderag benchmark
+ *
+ * Auto-generates a benchmark dataset from an indexed project and evaluates
+ * CodeRAG search quality against it. Prints a summary table and optionally
+ * saves a detailed JSON report.
+ */
+import { Command } from 'commander';
+import type { BenchmarkReport } from '@code-rag/core';
+/**
+ * Format a BenchmarkReport as a colored terminal summary.
+ */
+export declare function formatColoredSummary(report: BenchmarkReport): string;
+export declare function registerBenchmarkCommand(program: Command): void;

package/dist/commands/benchmark-cmd.js

@@ -0,0 +1,198 @@
+/**
+ * CLI command: coderag benchmark
+ *
+ * Auto-generates a benchmark dataset from an indexed project and evaluates
+ * CodeRAG search quality against it. Prints a summary table and optionally
+ * saves a detailed JSON report.
+ */
+import chalk from 'chalk';
+import { writeFile, readFile } from 'node:fs/promises';
+import { resolve, join } from 'node:path';
+import { createRuntime, parseIndexRows, buildCallerMap, buildTestMap, generateQueries, runBenchmark, } from '@code-rag/core';
+/**
+ * Format a BenchmarkReport as a colored terminal summary.
+ */
+export function formatColoredSummary(report) {
+    const lines = [];
+    const a = report.aggregate;
+    lines.push(chalk.bold('Benchmark Results'));
+    lines.push(chalk.dim('================='));
+    lines.push(`Queries:    ${chalk.cyan(String(report.metadata.totalQueries))}`);
+    lines.push(`Index size: ${chalk.cyan(String(report.metadata.totalChunksInIndex))} chunks`);
+    lines.push(`Duration:   ${chalk.cyan((report.metadata.durationMs / 1000).toFixed(1))}s`);
+    lines.push('');
+    lines.push(chalk.bold('Aggregate Metrics:'));
+    lines.push(`  P@5:       ${colorMetric(a.precisionAt5)}`);
+    lines.push(`  P@10:      ${colorMetric(a.precisionAt10)}`);
+    lines.push(`  Recall@10: ${colorMetric(a.recallAt10)}`);
+    lines.push(`  MRR:       ${colorMetric(a.mrr)}`);
+    lines.push(`  nDCG@10:   ${colorMetric(a.ndcgAt10)}`);
+    if (report.byQueryType.length > 0) {
+        lines.push('');
+        lines.push(chalk.bold('By Query Type:'));
+        lines.push(chalk.dim('  Type                 | Count |  P@5  | P@10  | R@10  |  MRR  | nDCG@10'));
+        lines.push(chalk.dim('  ---------------------|-------|-------|-------|-------|-------|--------'));
+        for (const bt of report.byQueryType) {
+            const m = bt.metrics;
+            const type = bt.queryType.padEnd(20);
+            lines.push(`  ${chalk.cyan(type)} | ${String(m.queryCount).padStart(5)} | ${fmt(m.precisionAt5)} | ${fmt(m.precisionAt10)} | ${fmt(m.recallAt10)} | ${fmt(m.mrr)} | ${fmt(m.ndcgAt10)}`);
+        }
+    }
+    return lines.join('\n');
+}
+function colorMetric(value) {
+    const formatted = value.toFixed(4).padStart(6);
+    if (value >= 0.7)
+        return chalk.green(formatted);
+    if (value >= 0.4)
+        return chalk.yellow(formatted);
+    return chalk.red(formatted);
+}
+function fmt(value) {
+    return value.toFixed(4).padStart(6);
+}
+export function registerBenchmarkCommand(program) {
+    program
+        .command('benchmark')
+        .description('Auto-generate benchmarks from the index and evaluate search quality')
+        .option('--queries <n>', 'Number of benchmark queries to generate', '100')
+        .option('--output <path>', 'Save detailed JSON report to this path')
+        .option('--top-k <n>', 'Number of search results per query', '10')
+        .option('--seed <n>', 'Random seed for reproducible generation', '42')
+        .action(async (options) => {
+        try {
+            const rootDir = process.cwd();
+            const queryCount = parseInt(options.queries, 10);
+            const topK = parseInt(options.topK, 10);
+            const seed = parseInt(options.seed, 10);
+            if (isNaN(queryCount) || queryCount < 1) {
+                // eslint-disable-next-line no-console
+                console.error(chalk.red('Invalid --queries value. Must be a positive integer.'));
+                process.exit(1);
+            }
+            if (isNaN(topK) || topK < 1) {
+                // eslint-disable-next-line no-console
+                console.error(chalk.red('Invalid --top-k value. Must be a positive integer.'));
+                process.exit(1);
+            }
+            if (isNaN(seed)) {
+                // eslint-disable-next-line no-console
+                console.error(chalk.red('Invalid --seed value. Must be an integer.'));
+                process.exit(1);
+            }
+            // --- Initialize runtime ---
+            // eslint-disable-next-line no-console
+            console.log(chalk.dim('Initializing runtime...'));
+            const runtimeResult = await createRuntime({ rootDir, searchOnly: true });
+            if (runtimeResult.isErr()) {
+                // eslint-disable-next-line no-console
+                console.error(chalk.red('Initialization failed.'), runtimeResult.error.message);
+                process.exit(1);
+            }
+            const runtime = runtimeResult.value;
+            // --- Scan index ---
+            // eslint-disable-next-line no-console
+            console.log(chalk.dim('Scanning index...'));
+            const allRowsResult = await runtime.store.getAll();
+            if (allRowsResult.isErr()) {
+                runtime.close();
+                // eslint-disable-next-line no-console
+                console.error(chalk.red('Failed to scan index:'), allRowsResult.error.message);
+                process.exit(1);
+            }
+            const rows = allRowsResult.value;
+            if (rows.length === 0) {
+                runtime.close();
+                // eslint-disable-next-line no-console
+                console.log(chalk.yellow('Index is empty. Run "coderag index" first.'));
+                return;
+            }
+            const scanResult = parseIndexRows(rows);
+            if (scanResult.isErr()) {
+                runtime.close();
+                // eslint-disable-next-line no-console
+                console.error(chalk.red('Failed to parse index:'), scanResult.error.message);
+                process.exit(1);
+            }
+            const scan = scanResult.value;
+            // eslint-disable-next-line no-console
+            console.log(chalk.dim(`Found ${scan.totalChunks} chunks in index.`));
+            // --- Load dependency graph ---
+            let edges = [];
+            const storagePath = resolve(rootDir, runtime.config.storage.path);
+            const graphPath = join(storagePath, 'graph.json');
+            try {
+                const graphData = await readFile(graphPath, 'utf-8');
+                const parsed = JSON.parse(graphData);
+                if (parsed !== null &&
+                    typeof parsed === 'object' &&
+                    'edges' in parsed &&
+                    Array.isArray(parsed['edges'])) {
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Runtime-checked graph JSON structure
+                    edges = parsed.edges;
+                }
+            }
+            catch {
+                // No graph available, proceed with empty edges
+                // eslint-disable-next-line no-console
+                console.log(chalk.dim('No dependency graph found, skipping caller/import queries.'));
+            }
+            // --- Build relationship maps ---
+            const callerMap = buildCallerMap(edges);
+            const testMap = buildTestMap(scan.fileToChunkIds);
+            // --- Generate queries ---
+            // eslint-disable-next-line no-console
+            console.log(chalk.dim(`Generating ${queryCount} benchmark queries...`));
+            const queries = generateQueries(scan, edges, callerMap, testMap, { maxQueries: queryCount }, seed);
+            if (queries.length === 0) {
+                runtime.close();
+                // eslint-disable-next-line no-console
+                console.log(chalk.yellow('Could not generate any benchmark queries from this index.'));
+                return;
+            }
+            // eslint-disable-next-line no-console
+            console.log(chalk.dim(`Generated ${queries.length} queries. Running evaluation...`));
+            // --- Run benchmark ---
+            const searchFn = async (query) => {
+                const result = await runtime.hybridSearch.search(query, { topK });
+                if (result.isErr())
+                    return [];
+                return result.value.map((r) => r.chunkId);
+            };
+            const reportResult = await runBenchmark(queries, searchFn, scan.totalChunks, (completed, total) => {
+                if (completed % 10 === 0 || completed === total) {
+                    // eslint-disable-next-line no-console
+                    process.stdout.write(`\r${chalk.dim(`  Progress: ${completed}/${total}`)}`);
+                }
+            });
+            runtime.close();
+            if (reportResult.isErr()) {
+                // eslint-disable-next-line no-console
+                console.error(chalk.red('\nBenchmark failed:'), reportResult.error.message);
+                process.exit(1);
+            }
+            const report = reportResult.value;
+            // --- Print summary ---
+            // eslint-disable-next-line no-console
+            console.log('\n');
+            // eslint-disable-next-line no-console
+            console.log(formatColoredSummary(report));
+            // --- Save JSON report ---
+            if (options.output) {
+                const outputPath = resolve(options.output);
+                const jsonReport = JSON.stringify(report, null, 2);
+                await writeFile(outputPath, jsonReport, 'utf-8');
+                // eslint-disable-next-line no-console
+                console.log('');
+                // eslint-disable-next-line no-console
+                console.log(chalk.green(`Detailed report saved to: ${outputPath}`));
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            // eslint-disable-next-line no-console
+            console.error(chalk.red('Benchmark failed:'), message);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/index-cmd.d.ts

@@ -1,4 +1,34 @@
 import { Command } from 'commander';
-import { type EmbeddingConfig, type EmbeddingProvider } from '@code-rag/core';
+import { type ParsedFile, type CodeRAGConfig, type EmbeddingConfig, type EmbeddingProvider } from '@code-rag/core';
 export declare function createSimpleEmbeddingProvider(embeddingConfig: EmbeddingConfig): EmbeddingProvider;
+export declare class IndexLogger {
+    private spinner;
+    private logPath;
+    private progressPath;
+    private phase;
+    private counts;
+    private readonly quiet;
+    constructor(storagePath: string, quiet?: boolean);
+    init(): Promise<void>;
+    start(text: string): void;
+    info(text: string): Promise<void>;
+    succeed(text: string): Promise<void>;
+    warn(text: string): Promise<void>;
+    fail(text: string): Promise<void>;
+    setPhase(phase: string, counts?: Record<string, number>): Promise<void>;
+    updateCount(key: string, value: number): Promise<void>;
+    private log;
+    private writeProgress;
+}
 export declare function registerIndexCommand(program: Command): void;
+/**
+ * Rebuild the root-level merged index from existing per-repo stores.
+ * Used when incremental indexing finds no changes but the unified index is missing
+ * (e.g., after upgrading CodeRAG or first run after multi-repo index was created).
+ */
+export declare function rebuildMergedIndex(storagePath: string, repoResults: Array<{
+    repoName: string;
+    repoPath: string;
+    repoStoragePath: string;
+    parsedFiles: ParsedFile[];
+}>, config: CodeRAGConfig, logger: IndexLogger): Promise<void>;

package/dist/commands/index-cmd.js

@@ -33,7 +33,7 @@ export function createSimpleEmbeddingProvider(embeddingConfig) {
 // ---------------------------------------------------------------------------
 // IndexLogger — dual output: ora spinner (interactive) + file log
 // ---------------------------------------------------------------------------
-class IndexLogger {
+export class IndexLogger {
     spinner;
     logPath;
     progressPath;
@@ -968,6 +968,86 @@ export function registerIndexCommand(program) {
         }
     });
 }
+/**
+ * Rebuild the root-level merged index from existing per-repo stores.
+ * Used when incremental indexing finds no changes but the unified index is missing
+ * (e.g., after upgrading CodeRAG or first run after multi-repo index was created).
+ */
+export async function rebuildMergedIndex(storagePath, repoResults, config, logger) {
+    await logger.info('Rebuilding unified index from per-repo data...');
+    const mergedGraph = new DependencyGraph();
+    let totalMergedChunks = 0;
+    // Open root LanceDB store
+    const rootStore = new LanceDBStore(storagePath, config.embedding.dimensions);
+    await rootStore.connect();
+    for (const rr of repoResults) {
+        const repoGraphPath = join(rr.repoStoragePath, 'graph.json');
+        // Read all rows from per-repo LanceDB and copy to root store
+        const repoStore = new LanceDBStore(rr.repoStoragePath, config.embedding.dimensions);
+        await repoStore.connect();
+        try {
+            const internal = repoStore;
+            const table = internal.table;
+            if (table) {
+                const allRows = await table.query().toArray();
+                if (allRows.length > 0) {
+                    const ids = allRows.map((r) => r.id);
+                    // LanceDB returns Arrow-typed vectors (FixedSizeList with .isValid),
+                    // not plain number[]. Convert to plain arrays for re-ingestion.
+                    const embeddings = allRows.map((r) => Array.from(r.vector));
+                    // Parse the metadata JSON string back to an object so upsert
+                    // preserves all original fields (start_line, end_line, name, repo_name, etc.)
+                    // without double-serialization.
+                    const metadata = allRows.map((r) => {
+                        try {
+                            return JSON.parse(r.metadata);
+                        }
+                        catch {
+                            return {
+                                content: r.content,
+                                nl_summary: r.nl_summary,
+                                chunk_type: r.chunk_type,
+                                file_path: r.file_path,
+                                language: r.language,
+                            };
+                        }
+                    });
+                    const upsertResult = await rootStore.upsert(ids, embeddings, metadata);
+                    if (upsertResult.isOk()) {
+                        totalMergedChunks += allRows.length;
+                    }
+                    else {
+                        await logger.warn(`[${rr.repoName}] LanceDB upsert failed: ${upsertResult.error.message}`);
+                    }
+                }
+            }
+        }
+        catch (mergeErr) {
+            const mergeMsg = mergeErr instanceof Error ? mergeErr.message : String(mergeErr);
+            await logger.warn(`[${rr.repoName}] Failed to read LanceDB for merge: ${mergeMsg}`);
+        }
+        repoStore.close();
+        // Merge graph
+        try {
+            const graphData = await readFile(repoGraphPath, 'utf-8');
+            const repoGraph = DependencyGraph.fromJSON(JSON.parse(graphData));
+            for (const node of repoGraph.getAllNodes())
+                mergedGraph.addNode(node);
+            for (const edge of repoGraph.getAllEdges())
+                mergedGraph.addEdge(edge);
+        }
+        catch {
+            // No graph for this repo — skip
+        }
+    }
+    // Build merged BM25 from the root LanceDB (which now has all chunks)
+    const mergedBm25 = await rebuildBm25FromStore(rootStore, logger, '');
+    await writeFile(join(storagePath, 'bm25-index.json'), mergedBm25.serialize(), 'utf-8');
+    rootStore.close();
+    // Write merged graph
+    await writeFile(join(storagePath, 'graph.json'), JSON.stringify(mergedGraph.toJSON()), 'utf-8');
+    await logger.succeed(`Unified index rebuilt: ${totalMergedChunks} chunks from ${repoResults.length} repos`);
+}
 /**
  * Multi-repo indexing: iterate configured repos, index each with separate
  * progress reporting and per-repo storage directories.
@@ -1113,9 +1193,25 @@ async function indexMultiRepo(config, storagePath, options, logger, startTime, e
             }
             await writeFile(rr.indexStatePath, JSON.stringify(rr.indexState.toJSON(), null, 2), 'utf-8');
         }
+        // Check if root merged index is missing or empty — rebuild from per-repo stores
+        const rootBm25Path = join(storagePath, 'bm25-index.json');
+        let needsRebuild = !existsSync(rootBm25Path);
+        if (!needsRebuild) {
+            try {
+                const bm25Data = await readFile(rootBm25Path, 'utf-8');
+                const parsed = JSON.parse(bm25Data);
+                needsRebuild = !parsed.documentCount || parsed.documentCount === 0;
+            }
+            catch {
+                needsRebuild = true;
+            }
+        }
+        if (needsRebuild) {
+            await rebuildMergedIndex(storagePath, repoResults, config, logger);
+        }
         const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
         // eslint-disable-next-line no-console
-        console.log(chalk.yellow('No chunks produced. Nothing to embed.'));
+        console.log(chalk.yellow('No new chunks. Index is up to date.'));
         // eslint-disable-next-line no-console
         console.log(`  Time elapsed: ${chalk.cyan(elapsed + 's')}`);
         return;
@@ -1198,6 +1294,12 @@ async function indexMultiRepo(config, storagePath, options, logger, startTime, e
     // ── Phase 3: Embed & Store per repo ─────────────────────────────────
     await logger.setPhase('embed');
     const resolvedEmbeddingProvider = embeddingProvider ?? createSimpleEmbeddingProvider(config.embedding);
+    // Accumulators for merged root-level index
+    const mergedIds = [];
+    const mergedEmbeddings = [];
+    const mergedMetadata = [];
+    const mergedBm25Chunks = [];
+    const mergedGraph = new DependencyGraph();
     for (const rr of repoResults) {
         if (rr.chunks.length === 0)
             continue;
@@ -1215,7 +1317,7 @@ async function indexMultiRepo(config, storagePath, options, logger, startTime, e
             continue;
         }
         const embeddings = embedResult.value;
-        // Store in LanceDB
+        // Store in per-repo LanceDB
         await logger.info(`[${rr.repoName}] Storing in LanceDB...`);
         const store = new LanceDBStore(rr.repoStoragePath, config.embedding.dimensions);
         await store.connect();
@@ -1238,7 +1340,12 @@ async function indexMultiRepo(config, storagePath, options, logger, startTime, e
             await logger.fail(`[${rr.repoName}] Store failed: ${upsertResult.error.message}`);
             continue;
         }
-        // BM25 index
+        // Accumulate for merged root index
+        mergedIds.push(...ids);
+        mergedEmbeddings.push(...embeddings);
+        mergedMetadata.push(...metadata);
+        mergedBm25Chunks.push(...enrichedChunks);
+        // Per-repo BM25 index
         const bm25Path = join(rr.repoStoragePath, 'bm25-index.json');
         let bm25;
         if (options.full) {
@@ -1269,12 +1376,17 @@ async function indexMultiRepo(config, storagePath, options, logger, startTime, e
         }
         bm25.addChunks(enrichedChunks);
         await writeFile(bm25Path, bm25.serialize(), 'utf-8');
-        // Dependency graph
+        // Per-repo dependency graph
         const graphBuilder = new GraphBuilder(rr.repoPath);
         const graphResult = graphBuilder.buildFromFiles(rr.parsedFiles);
         if (graphResult.isOk()) {
             const graphPath = join(rr.repoStoragePath, 'graph.json');
             const newGraph = graphResult.value;
+            // Accumulate for merged graph
+            for (const node of newGraph.getAllNodes())
+                mergedGraph.addNode(node);
+            for (const edge of newGraph.getAllEdges())
+                mergedGraph.addEdge(edge);
             if (options.full) {
                 await writeFile(graphPath, JSON.stringify(newGraph.toJSON()), 'utf-8');
             }
@@ -1320,6 +1432,26 @@ async function indexMultiRepo(config, storagePath, options, logger, startTime, e
         store.close();
         await logger.succeed(`[${rr.repoName}] ${enrichedChunks.length} chunks indexed`);
     }
+    // ── Phase 4: Merge all repos into root-level unified index ─────────
+    // This ensures search/MCP/viewer/benchmark can query all repos at once
+    if (mergedIds.length > 0) {
+        await logger.info('Merging all repos into unified index...');
+        // Merged LanceDB at root storagePath
+        const rootStore = new LanceDBStore(storagePath, config.embedding.dimensions);
+        await rootStore.connect();
+        const mergeResult = await rootStore.upsert(mergedIds, mergedEmbeddings, mergedMetadata);
+        if (mergeResult.isErr()) {
+            await logger.fail(`Merged store failed: ${mergeResult.error.message}`);
+        }
+        rootStore.close();
+        // Merged BM25 index at root
+        const rootBm25 = new BM25Index();
+        rootBm25.addChunks(mergedBm25Chunks);
+        await writeFile(join(storagePath, 'bm25-index.json'), rootBm25.serialize(), 'utf-8');
+        // Merged graph at root
+        await writeFile(join(storagePath, 'graph.json'), JSON.stringify(mergedGraph.toJSON()), 'utf-8');
+        await logger.succeed(`Unified index: ${mergedIds.length} chunks across ${repos.length} repos`);
+    }
     // ── Final summary ───────────────────────────────────────────────────
     const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
     // eslint-disable-next-line no-console

package/dist/commands/init-wizard.d.ts

@@ -93,3 +93,8 @@ export declare function runNonInteractive(rootDir: string, options: {
     languages?: string;
     multi?: boolean;
 }): Promise<void>;
+/**
+ * Ensure .coderag/ is listed in .gitignore so database files are not committed.
+ * Creates .gitignore if it does not exist; appends entry if missing.
+ */
+export declare function ensureGitignore(rootDir: string): Promise<void>;

package/dist/commands/init-wizard.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import { select, input, confirm } from '@inquirer/prompts';
 import { stringify } from 'yaml';
-import { writeFile, mkdir, access, readdir } from 'node:fs/promises';
+import { writeFile, readFile, mkdir, access, readdir } from 'node:fs/promises';
 import { join, basename } from 'node:path';
 import { detectLanguages } from './init.js';
 // --- Constants ---
@@ -419,6 +419,8 @@ export async function runWizard(rootDir) {
     await mkdir(storageDir, { recursive: true });
     // eslint-disable-next-line no-console
     console.log(chalk.green(`  Created ${storageDir}`));
+    // Step 7b: Ensure .coderag/ is in .gitignore
+    await ensureGitignore(rootDir);
     // Step 8: Summary
     // eslint-disable-next-line no-console
     console.log(chalk.bold.green('\n  CodeRAG initialized successfully!\n'));
@@ -501,12 +503,37 @@ export async function runNonInteractive(rootDir, options) {
     await mkdir(storageDir, { recursive: true });
     // eslint-disable-next-line no-console
     console.log(chalk.green('Created'), storageDir);
+    // Ensure .coderag/ is in .gitignore
+    await ensureGitignore(rootDir);
     // Done
     // eslint-disable-next-line no-console
     console.log(chalk.green('\nCodeRAG initialized successfully!'));
     // eslint-disable-next-line no-console
     console.log(chalk.dim('Run "coderag index" to index your codebase.'));
 }
+/**
+ * Ensure .coderag/ is listed in .gitignore so database files are not committed.
+ * Creates .gitignore if it does not exist; appends entry if missing.
+ */
+export async function ensureGitignore(rootDir) {
+    const gitignorePath = join(rootDir, '.gitignore');
+    const entry = '.coderag/';
+    try {
+        const content = await readFile(gitignorePath, 'utf-8');
+        const lines = content.split('\n').map((l) => l.trim());
+        if (lines.includes(entry) || lines.includes('.coderag'))
+            return;
+        const newContent = content.endsWith('\n') ? `${content}${entry}\n` : `${content}\n${entry}\n`;
+        await writeFile(gitignorePath, newContent, 'utf-8');
+        // eslint-disable-next-line no-console
+        console.log(chalk.green(`  Added ${entry} to .gitignore`));
+    }
+    catch {
+        await writeFile(gitignorePath, `${entry}\n`, 'utf-8');
+        // eslint-disable-next-line no-console
+        console.log(chalk.green(`  Created .gitignore with ${entry}`));
+    }
+}
 /**
  * Pull an Ollama model via the API.
  */

package/dist/commands/search.js

@@ -1,7 +1,5 @@
 import chalk from 'chalk';
-import { readFile } from 'node:fs/promises';
-import { join, resolve, sep } from 'node:path';
-import { loadConfig, OllamaEmbeddingProvider, LanceDBStore, BM25Index, HybridSearch, } from '@code-rag/core';
+import { createRuntime, } from '@code-rag/core';
 /**
  * Format a single search result for terminal display.
  */
@@ -39,44 +37,18 @@ export function registerSearchCommand(program) {
                 console.error(chalk.red('Invalid --top-k value. Must be a positive integer.'));
                 process.exit(1);
             }
-            // Load config
-            const configResult = await loadConfig(rootDir);
-            if (configResult.isErr()) {
+            // Initialize runtime (search-only mode: skip graph, reranker, context expander)
+            const runtimeResult = await createRuntime({ rootDir, searchOnly: true });
+            if (runtimeResult.isErr()) {
                 // eslint-disable-next-line no-console
-                console.error(chalk.red('Config not found.'), 'Run "coderag init" first.');
+                console.error(chalk.red('Initialization failed.'), runtimeResult.error.message);
                 process.exit(1);
             }
-            const config = configResult.value;
-            const storagePath = resolve(rootDir, config.storage.path);
-            // Prevent path traversal outside project root
-            if (!storagePath.startsWith(resolve(rootDir) + sep) && storagePath !== resolve(rootDir)) {
-                // eslint-disable-next-line no-console
-                console.error(chalk.red('Storage path escapes project root'));
-                process.exit(1);
-            }
-            // Create services
-            const embeddingProvider = new OllamaEmbeddingProvider({
-                model: config.embedding.model,
-                dimensions: config.embedding.dimensions,
-            });
-            const store = new LanceDBStore(storagePath, config.embedding.dimensions);
-            await store.connect();
-            // Load BM25 index
-            let bm25 = new BM25Index();
-            const bm25Path = join(storagePath, 'bm25-index.json');
-            try {
-                const bm25Data = await readFile(bm25Path, 'utf-8');
-                bm25 = BM25Index.deserialize(bm25Data);
-            }
-            catch {
-                // No BM25 index yet
-            }
-            // Create hybrid search
-            const hybridSearch = new HybridSearch(store, bm25, embeddingProvider, config.search);
+            const runtime = runtimeResult.value;
             // Run search
-            const searchResult = await hybridSearch.search(query, { topK });
+            const searchResult = await runtime.hybridSearch.search(query, { topK });
             if (searchResult.isErr()) {
-                store.close();
+                runtime.close();
                 // eslint-disable-next-line no-console
                 console.error(chalk.red('Search failed:'), searchResult.error.message);
                 process.exit(1);
@@ -95,7 +67,7 @@ export function registerSearchCommand(program) {
                 const fileFilter = options.file.toLowerCase();
                 results = results.filter((r) => (r.chunk?.filePath ?? '').toLowerCase().includes(fileFilter));
             }
-            store.close();
+            runtime.close();
             // Display results
             if (results.length === 0) {
                 // eslint-disable-next-line no-console

package/dist/index.js

@@ -9,6 +9,7 @@ import { registerStatusCommand } from './commands/status.js';
 import { registerViewerCommand } from './commands/viewer.js';
 import { registerWatchCommand } from './commands/watch-cmd.js';
 import { registerHooksCommand } from './commands/hooks-cmd.js';
+import { registerBenchmarkCommand } from './commands/benchmark-cmd.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 const program = new Command();
@@ -24,4 +25,5 @@ registerStatusCommand(program);
 registerViewerCommand(program);
 registerWatchCommand(program);
 registerHooksCommand(program);
+registerBenchmarkCommand(program);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@code-rag/cli",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "CLI tool for CodeRAG — init, index, search, serve, and status commands for codebase context engine",
   "type": "module",
   "license": "MIT",
@@ -48,9 +48,9 @@
     "commander": "^13.1.0",
     "ora": "^8.2.0",
     "yaml": "^2.7.0",
-    "@code-rag/api-server": "0.1.6",
-    "@code-rag/mcp-server": "0.1.6",
-    "@code-rag/core": "0.1.6"
+    "@code-rag/api-server": "0.1.8",
+    "@code-rag/core": "0.1.8",
+    "@code-rag/mcp-server": "0.1.8"
   },
   "devDependencies": {
     "@types/node": "^22.13.4",