@code-rag/cli 0.1.5 → 0.1.7

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@code-rag/cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "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.5",
-    "@code-rag/core": "0.1.5",
-    "@code-rag/mcp-server": "0.1.5"
+    "@code-rag/api-server": "0.1.7",
+    "@code-rag/core": "0.1.7",
+    "@code-rag/mcp-server": "0.1.7"
   },
   "devDependencies": {
     "@types/node": "^22.13.4",