codesearch-mcp 0.0.15-alpha → 0.0.17-alpha

package/CHANGELOG.md

@@ -3,6 +3,59 @@
 All notable changes to this project will be documented in this file.
 Format based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [0.0.17-alpha] - 2026-05-13
+
+### Added
+
+- **`get_callers` MCP tool** — finds all call sites of a function or method by exact name. Uses the `code_call` table populated by `rag-index backfill --calls`. Requires both `symbol` and `project`; optional `callee_file` to disambiguate overloaded names. Returns empty if backfill has not been run.
+
+- **Call graph indexing** — `code_call` table records per-call-site entries `(project, fromFile, fromSymbol, calleeName, calleeFile, calleeSymbol, line, col)`. Populated during normal indexing (`ingestFile`) and via `rag-index backfill --calls` for existing installations. `AstParserService` extracts call expressions using ts-morph `CallExpression` nodes.
+
+- **`analyzeProject` `skipDependencyResolution` option** — `IAstParser.analyzeProject` now accepts `opts?: { skipDependencyResolution?: boolean }`. `AstParserService.createMorphProject` propagates the flag to ts-morph `Project` options. Used by `IndexerService` for large projects to avoid OOM.
+
+- **Configurable AST batch size (`indexing.astBatchSize`)** — `IndexerService` splits large projects into ts-morph batches. Threshold and batch size are now controlled by `indexing.astBatchSize` (default `3000`, configurable via `rag-config set indexing.astBatchSize <N>`). Projects above the threshold use `skipDependencyResolution: true` and print a console warning about potentially incomplete cross-batch dependency edges.
+
+- **`include_graph_context` parameter for `search_codebase`** — appends direct imports and dependents inline with each result (`Imports: X · Y` / `Used by: Z`), eliminating separate `get_dependencies` / `get_dependents` calls for basic context. Single batch SQL query (UNION ALL + VALUES) for all result files — no N+1. Deduplicates via Sets; limits to 50 entries per direction per file.
+
+- **Cross-encoder reranking** — optional second-pass via `POST /api/rerank` (requires Ollama ≥ 0.6). Controlled by `reranker.enabled`, `reranker.model`, `reranker.url` (defaults to `${ollama.host}/api/rerank`), `reranker.overfetch`. When enabled, `search_codebase` overfetches `limit × reranker.overfetch` vector candidates and reranks before returning `limit` results. Falls back gracefully to vector order on error (`warn` log). `rerank?` is an optional method on `IEmbedder` — `OllamaEmbedder` assigns it only when both `reranker.enabled=true` and `reranker.model` is set.
+
+- **`ProjectSelector` unit tests** — full test coverage for project selection workflows including first-run auto-select, `--select` flag, `.ragprojects` / `.ragskip` persistence
+
+- **`rag-config` command** — manage `~/.config/codesearch-mcp/config.json` from the CLI: `rag-config show`, `rag-config get <key>`, `rag-config set <key> <value>`, `rag-config reset <key>`. Supports all config keys with type coercion (string / number / boolean).
+
+### Changed
+
+- **Config migrated from `.env` to `config.json`** — configuration is now stored in `~/.config/codesearch-mcp/config.json` instead of a `.env` file. `rag-setup` writes JSON; `dotenv` dependency removed. Existing `.env` files are no longer read — run `rag-setup` once to migrate.
+
+- **`Config` class replaces module-level singleton** — `src/config.ts` now exports a `Config` class instantiated in `createContainer()`. Reads `config.json` via `readConfigJson()`, Zod-validates, throws `ConfigError` on missing required fields (caught in `app.ts` with a user-friendly message).
+
+- **`LoggerService.fromConfig(cfg, name?)`** replaces `fromEnv()` — takes the `logging` sub-object from `Config` directly instead of reading `LOG_LEVEL` / `LOG_DIR` from `process.env`.
+
+- **`reranker.*` and `search.*` config keys** — `RERANKER_ENABLED` and `RERANKER_OVERFETCH` in `config.search`; `config.ollama` retains only `rerankerModel` and `rerankerUrl`
+- **`fetchLimit` capped at 200** — prevents runaway DB queries when `reranker.overfetch` is high
+- **Reranker index validation** — indices from cross-encoder filtered for bounds before mapping
+- **30s timeout + truncated error body on rerank HTTP call** — `AbortSignal.timeout(30_000)`; error body sliced to 200 chars
+- **Enriched embedding context** — chunks now include `Project`, `Role` (inferred from file path), `Symbols` (overlapping definitions), and `Dependencies` in the embedding prompt. Improves semantic search quality for architectural queries. **Requires full re-index** (`rag-index --reindex`).
+- **`ProjectSelector` refactored** — improved modularity and maintainability; extracted logic into smaller focused methods
+- **`IndexCommand` argument validation** — enhanced error handling and validation across CLI modes
+
+## [0.0.16-alpha] - 2026-05-02
+
+### Added
+
+- **Hybrid incremental indexing (mtime + SHA-256)** — `rag-index` now uses a two-step skip check per file: fast `mtime` comparison first (no file read), then SHA-256 content hash if `mtime` changed. Files with identical content but reset timestamps (after `git clone`, DB transfer, or `touch`) are skipped without re-embedding. `lastModified` is refreshed in a single batch SQL `UPDATE` after each project scan. `--reindex` clears both fields.
+- `contentHash varchar(64)` column added to `code_chunk`; applied automatically via `ALTER TABLE ... ADD COLUMN IF NOT EXISTS` on startup — no manual migration needed.
+
+### Changed
+
+- **Migrated from TypeORM to Drizzle ORM** — schema management and queries rewritten with Drizzle API; TypeORM decorators and metadata removed
+- **Batch AST parsing (`analyzeProject`)** — `IndexerService` now parses all project files in a single `MorphProject` instance instead of one per file, reducing ts-morph overhead on large projects
+- **Enriched embedding context** — chunks now include `[Symbols: class Foo, function bar]` tag when the chunk overlaps known symbol definitions, improving semantic search quality for partial/truncated chunks. **Requires full re-index** (`rag-index /path --reindex`) — existing embeddings were built without symbol context and will produce degraded similarity scores against new chunks if mixed.
+- **`endLine` added to `SymbolEntry`** — enables accurate chunk-to-symbol overlap detection used by enriched prompts
+- **`analyzeProject` error isolation** — parse failures are caught per-file; one broken file no longer aborts the entire project scan
+- **Memory cleanup in `analyzeProject`** — source files are explicitly removed from `MorphProject` after parsing to release memory
+- **Logging improvements** — `AstParser: analyzeProject done` debug log reports total files, parsed count, and elapsed ms; per-file `depsMs` renamed to `astMs` (now ~0 since AST work is done upfront)
+
 ## [0.0.15-alpha] - 2026-05-02
 
 ### Changed

package/README.md

@@ -6,13 +6,15 @@ Ask Claude things like *"where is the payment retry logic?"* or *"show me how au
 
 > **Alpha** — works well locally, API may change before 1.0.
 
+See `CHANGELOG.md` for version history.
+
 ## How it works
 
 1. `rag-index` scans your projects, chunks source files, embeds them with [bge-m3](https://huggingface.co/BAAI/bge-m3) via Ollama, and stores vectors in PostgreSQL
 2. `rag-mcp` exposes an MCP server — Claude calls it automatically when you ask about code
 3. Incremental — only changed files are re-indexed on subsequent runs
 
-**Stack:** TypeScript · TypeORM · PostgreSQL + pgvector · Ollama (bge-m3) · LangChain text splitters · ts-morph
+**Stack:** TypeScript · Drizzle ORM · PostgreSQL + pgvector · Ollama (bge-m3) · LangChain text splitters · ts-morph
 
 ## Requirements
 
@@ -32,24 +34,24 @@ rag-setup
 ```
 
 Walks you through:
-- **Local Docker** — copies `docker-compose.yml`, starts PostgreSQL + Ollama, pulls `bge-m3` automatically
-- **Remote DB** — enter connection details for Supabase, Railway, or self-hosted; connection is verified before saving
+- **Database** — enter connection details; optionally starts Docker containers automatically
+- **Ollama** — configure API URL
 - **Logging** — choose log level and directory (defaults: `error` level, `~/.config/codesearch-mcp/logs/`)
 
-Config is saved to `~/.config/codesearch-mcp/.env`.
+Config is saved to `~/.config/codesearch-mcp/config.json`.
 
 ## Index your projects
 
 ```bash
-rag-index /home/user/Projects
+rag-index
 ```
 
-On first run you will be prompted to select which projects to index. Selections are saved in `.ragprojects` / `.ragskip` at the workspace root.
+`workspaceRoot` (set by `rag-setup` or `rag-config set workspaceRoot /path`) determines which directory is scanned. On first run — or when no projects are selected — the selector launches automatically. Selections are saved in `.ragprojects` / `.ragskip` at the workspace root.
 
 ```bash
-rag-index /path --select          # re-run project selection
-rag-index /path --reindex         # force re-embed all files (use after model change)
-rag-index /path --select --reindex
+rag-index --select          # re-run project selection
+rag-index --reindex         # force re-embed all files (use after model change)
+rag-index --select --reindex
 ```
 
 ## Register with Claude Code
@@ -64,14 +66,15 @@ Then ask Claude anything about your code — it will use the tools below automat
 
 | Tool | Description |
 |------|-------------|
-| `search_codebase` | Semantic search across all indexed projects |
+| `search_codebase` | Semantic search across all indexed projects. Accepts `include_graph_context` to append direct imports/dependents to each result, and `include_neighbors` for surrounding chunks |
 | `list_projects` | List projects with metadata and chunk counts |
 | `find_symbol` | Find a function, class, or type by exact name — faster than semantic search |
 | `list_files` | Browse the directory tree of a project |
 | `read_file` | Read a complete file by absolute path |
 | `read_file_range` | Read a specific line range from an indexed file |
-| `get_dependencies` | Show what files a given file imports |
-| `get_dependents` | Show which files import a given file |
+| `get_dependencies` | Show what files a given file imports (direct or transitive) |
+| `get_dependents` | Show which files import a given file (direct or transitive) |
+| `get_callers` | Find all call sites of a function or method by exact name |
 
 ## Project metadata
 
@@ -90,6 +93,39 @@ Add `.ragmeta.json` to a project root to enrich `list_projects` and generate a v
 
 After each indexing run an interactive `project-graph.html` is written to the workspace root.
 
+## Graph context
+
+Pass `include_graph_context: true` to `search_codebase` to see direct imports and dependents inline with each result — without extra `get_dependencies` / `get_dependents` calls:
+
+```
+**File:** src/services/InvoiceService.ts  **Line:** 45
+...code...
+**Relevance:** 0.32
+**Imports:** src/repositories/InvoiceRepo.ts · src/dto/CreateInvoiceDto.ts
+**Used by:** src/controllers/InvoiceController.ts
+```
+
+Useful for immediately understanding a file's role in the dependency graph.
+
+## Cross-encoder reranking
+
+By default, results are ordered by cosine distance (vector similarity). Enable cross-encoder reranking to reorder candidates by semantic relevance — better for queries where the exact wording differs from how the code is written.
+
+Requires Ollama ≥ 0.6 and a reranker model:
+
+```bash
+ollama pull qllama/bge-reranker-v2-m3
+```
+
+```bash
+rag-config set reranker.enabled true
+rag-config set reranker.model qllama/bge-reranker-v2-m3
+# rag-config set reranker.url http://localhost:11434/api/rerank  # default
+# rag-config set reranker.overfetch 3                            # fetch limit×3 candidates before reranking
+```
+
+When enabled, `search_codebase` fetches `limit × reranker.overfetch` vector candidates, then the cross-encoder reranks them and returns the top `limit`. Falls back gracefully to vector order if the reranker is unreachable.
+
 ## Excluding files
 
 Create `.ragignore` in a project root — same syntax as `.gitignore`:
@@ -110,31 +146,36 @@ tail -f ~/.config/codesearch-mcp/logs/indexer/current.log
 npx pino-pretty < ~/.config/codesearch-mcp/logs/indexer/current.log
 
 # Detailed indexing diagnostics (timing per file: deps / embed / db)
-LOG_LEVEL=debug rag-index /path/to/workspace
+rag-config set logging.level debug
 
 # Disable file logging
-LOG_DIR=false rag-index /path/to/workspace
+rag-config set logging.dir false
 ```
 
-## Environment variables
-
-All set by `rag-setup`. Override any of them in `~/.config/codesearch-mcp/.env`.
-
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `DB_HOST` | — | PostgreSQL host |
-| `DB_PORT` | `5433` | PostgreSQL port |
-| `DB_USER` | — | PostgreSQL user |
-| `DB_PASS` | — | PostgreSQL password |
-| `DB_NAME` | `rag_<os-username>` | Database name — auto-created on first run |
-| `WORKSPACE_ROOT` | — | Root of your projects directory |
-| `OLLAMA_HOST` | `http://localhost:11434` | Ollama API URL |
-| `OLLAMA_MODEL` | `bge-m3` | Embedding model |
-| `SIMILARITY_THRESHOLD` | `0.6` | Max cosine distance — raise if search returns nothing |
-| `AUTO_TRANSLATE` | `false` | Translate non-English queries to English before embedding |
-| `TRANSLATE_MODEL` | `llama3.2` | Ollama model for translation (requires `ollama pull llama3.2`) |
-| `LOG_LEVEL` | `error` | Log level written to file: `error` \| `warn` \| `info` \| `debug` |
-| `LOG_DIR` | `~/.config/codesearch-mcp/logs` | Base log directory, or `false` to disable |
+## Configuration
+
+All set by `rag-setup`. Override individual keys with `rag-config set <key> <value>`. Stored in `~/.config/codesearch-mcp/config.json`.
+
+| Key | Default | Description |
+|-----|---------|-------------|
+| `db.host` | — | PostgreSQL host |
+| `db.port` | `5433` | PostgreSQL port |
+| `db.user` | — | PostgreSQL user |
+| `db.password` | — | PostgreSQL password |
+| `db.name` | `rag_<os-username>` | Database name — auto-created on first run |
+| `workspaceRoot` | — | Root of your projects directory |
+| `ollama.host` | `http://localhost:11434` | Ollama API URL |
+| `ollama.model` | `bge-m3` | Embedding model |
+| `search.similarityThreshold` | `0.6` | Max cosine distance — raise if search returns nothing |
+| `search.autoTranslate` | `false` | Translate non-English queries to English before embedding |
+| `search.translateModel` | `llama3.2` | Ollama model for translation (requires `ollama pull llama3.2`) |
+| `indexing.astBatchSize` | `3000` | Max files per ts-morph batch — lower if indexing large projects causes OOM |
+| `reranker.enabled` | `false` | Enable cross-encoder reranking (requires Ollama ≥ 0.6 and `reranker.model`) |
+| `reranker.model` | — | Reranker model name (e.g. `qllama/bge-reranker-v2-m3`) |
+| `reranker.url` | `${ollama.host}/api/rerank` | Override rerank endpoint URL |
+| `reranker.overfetch` | `3` | Candidate multiplier before reranking (`limit × N`, max 20) |
+| `logging.level` | `error` | Log level written to file: `error` \| `warn` \| `info` \| `debug` |
+| `logging.dir` | `~/.config/codesearch-mcp/logs` | Base log directory, or `"false"` to disable |
 
 ## License
 

package/dist/app.d.ts

@@ -1 +1 @@
-import './src/env-loader';
+export {};

package/dist/app.js

@@ -34,38 +34,89 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-require("./src/env-loader");
 const path = __importStar(require("path"));
-const container_1 = require("./src/container");
 const help_1 = require("./src/help");
+const container_1 = require("./src/container");
+const config_1 = require("./src/config");
 const IndexCommand_1 = require("./src/commands/IndexCommand");
 const McpCommand_1 = require("./src/commands/McpCommand");
-const SetupCommand_1 = require("./src/commands/SetupCommand");
 const BackfillCommand_1 = require("./src/commands/BackfillCommand");
+const ConfigCommand_1 = require("./src/commands/ConfigCommand");
+const setup_1 = require("./src/setup");
 async function main() {
     const argv1 = path.basename(process.argv[1] ?? '');
-    const isIndex = argv1 === 'rag-index' || process.argv[2] === 'index';
-    const isMcp = argv1 === 'rag-mcp' || process.argv[2] === 'mcp';
-    const isSetup = argv1 === 'rag-setup' || process.argv[2] === 'setup';
-    const isBackfill = (argv1 === 'rag-index' || process.argv[2] === 'backfill') && process.argv[2] === 'backfill';
-    const mode = isBackfill ? 'backfill' : isIndex ? 'index' : isMcp ? 'mcp' : isSetup ? 'setup' : (process.argv[2] ?? '');
+    const isIndex = argv1 === 'rag-index' || process.argv[2] === 'index' || process.argv[2] === 'rag-index';
+    const isMcp = argv1 === 'rag-mcp' || process.argv[2] === 'mcp' || process.argv[2] === 'rag-mcp';
+    const isSetup = argv1 === 'rag-setup' || process.argv[2] === 'setup' || process.argv[2] === 'rag-setup';
+    const isConfig = argv1 === 'rag-config' || process.argv[2] === 'config' || process.argv[2] === 'rag-config';
+    const isBackfill = process.argv[2] === 'backfill' ||
+        (process.argv[2] === 'rag-index' && process.argv[3] === 'backfill');
+    const mode = isBackfill ? 'backfill' : isIndex ? 'index' : isMcp ? 'mcp' : isSetup ? 'setup' : isConfig ? 'config' : (process.argv[2] ?? '');
+    const isBinary = ['rag-index', 'rag-mcp', 'rag-setup', 'rag-config'].includes(argv1);
     if (process.argv.includes('--help') || process.argv.includes('-h')) {
-        (0, help_1.printHelp)(argv1 !== 'app.js' ? argv1 : mode);
+        (0, help_1.printHelp)(isBinary ? argv1 : mode);
         process.exit(0);
     }
-    const loggerName = mode === 'index' || mode === 'backfill' ? 'indexer' : mode === 'mcp' ? 'mcp' : mode === 'setup' ? 'setup' : undefined;
-    const container = (0, container_1.createContainer)(loggerName);
-    if (!container.config.workspaceRoot && mode !== 'setup') {
+    const effectiveArgs = process.argv.slice(isBinary ? 2 : 3);
+    // Arg validation
+    if (mode === 'index') {
+        const knownFlags = new Set(['--reindex', '--select']);
+        const unknown = effectiveArgs.filter(a => !a.startsWith('-') || !knownFlags.has(a));
+        if (unknown.length > 0) {
+            console.error(`Unexpected argument: ${unknown[0]}\n`);
+            (0, help_1.printHelp)(isBinary ? argv1 : 'rag-index');
+            process.exit(1);
+        }
+    }
+    else if (mode === 'mcp' || mode === 'setup') {
+        if (effectiveArgs.length > 0) {
+            console.error(`Unexpected argument: ${effectiveArgs[0]}\n`);
+            (0, help_1.printHelp)(isBinary ? argv1 : `rag-${mode}`);
+            process.exit(1);
+        }
+    }
+    else if (mode === 'backfill') {
+        const knownBackfillFlags = new Set(['--calls']);
+        const backfillIdx = process.argv.indexOf('backfill');
+        const backfillArgs = backfillIdx >= 0 ? process.argv.slice(backfillIdx + 1) : [];
+        const unknown = backfillArgs.filter(a => !knownBackfillFlags.has(a));
+        if (unknown.length > 0) {
+            console.error(`Unexpected argument: ${unknown[0]}\n`);
+            (0, help_1.printHelp)('rag-index');
+            process.exit(1);
+        }
+    }
+    if (mode === 'setup') {
+        await (0, setup_1.runSetup)();
+        process.exit(0);
+    }
+    if (mode === 'config') {
+        await new ConfigCommand_1.ConfigCommand(effectiveArgs).execute();
+        process.exit(0);
+    }
+    // All other modes require a valid config.json
+    const loggerName = mode === 'index' || mode === 'backfill' ? 'indexer' : mode === 'mcp' ? 'mcp' : undefined;
+    let container;
+    try {
+        container = (0, container_1.createContainer)(loggerName);
+    }
+    catch (e) {
+        if (e instanceof config_1.ConfigError) {
+            console.error(e.message);
+            process.exit(1);
+        }
+        throw e;
+    }
+    if (!container.config.workspaceRoot) {
         const hint = argv1 === 'rag-mcp'
-            ? 'Set WORKSPACE_ROOT in ~/.config/codesearch-mcp/.env or run `rag-setup`.'
-            : 'Run `rag-setup` to configure WORKSPACE_ROOT.';
-        console.error(`WORKSPACE_ROOT is not configured. ${hint}`);
+            ? 'Run rag-setup or: rag-config set workspaceRoot /path/to/projects'
+            : 'Run rag-setup to configure workspaceRoot.';
+        console.error(`workspaceRoot is not configured. ${hint}`);
         process.exit(1);
     }
     const commands = {
         index: new IndexCommand_1.IndexCommand(container, argv1),
         mcp: new McpCommand_1.McpCommand(container),
-        setup: new SetupCommand_1.SetupCommand(container),
         backfill: new BackfillCommand_1.BackfillCommand(container),
     };
     const cmd = commands[mode];

package/dist/src/commands/BackfillCommand.js

@@ -10,14 +10,24 @@ class BackfillCommand {
     async execute() {
         const { db, indexer } = this.container;
         await db.initDbWithSchema();
+        const doCalls = process.argv.includes('--calls');
         const controller = new AbortController();
         const teardown = (0, interrupt_1.setupInterrupt)(controller);
         try {
-            console.log('Backfilling symbol index...\n');
-            const stats = await indexer.backfillSymbols(controller.signal);
-            if (controller.signal.aborted)
-                console.log('\nBackfill interrupted.');
-            console.log(`\nDone. Total: ${stats.total}, Processed: ${stats.processed}, Skipped (not on disk): ${stats.skipped}, Failed: ${stats.failed}`);
+            if (doCalls) {
+                console.log('Backfilling call graph...\n');
+                const stats = await indexer.backfillCalls(controller.signal);
+                if (controller.signal.aborted)
+                    console.log('\nBackfill interrupted.');
+                console.log(`\nDone. Total: ${stats.total}, Processed: ${stats.processed}, Skipped (not on disk): ${stats.skipped}, Failed: ${stats.failed}`);
+            }
+            else {
+                console.log('Backfilling symbol index...\n');
+                const stats = await indexer.backfillSymbols(controller.signal);
+                if (controller.signal.aborted)
+                    console.log('\nBackfill interrupted.');
+                console.log(`\nDone. Total: ${stats.total}, Processed: ${stats.processed}, Skipped (not on disk): ${stats.skipped}, Failed: ${stats.failed}`);
+            }
         }
         finally {
             teardown();

package/dist/src/commands/ConfigCommand.d.ts

@@ -0,0 +1,12 @@
+import { ALL_KEYS } from '../config-store';
+import type { ICommand } from './ICommand';
+export declare class ConfigCommand implements ICommand {
+    private readonly args;
+    constructor(args: string[]);
+    execute(): Promise<void>;
+    private show;
+    private get;
+    private set;
+    private reset;
+}
+export { ALL_KEYS };

package/dist/src/commands/ConfigCommand.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_KEYS = exports.ConfigCommand = void 0;
+const config_store_1 = require("../config-store");
+Object.defineProperty(exports, "ALL_KEYS", { enumerable: true, get: function () { return config_store_1.ALL_KEYS; } });
+const help_1 = require("../help");
+class ConfigCommand {
+    args;
+    constructor(args) {
+        this.args = args;
+    }
+    async execute() {
+        const [sub, key, value] = this.args;
+        switch (sub) {
+            case 'show': return this.show();
+            case 'get': return this.get(key);
+            case 'set': return this.set(key, value);
+            case 'reset': return this.reset(key);
+            default:
+                if (sub)
+                    console.error(`Unknown subcommand: ${sub}\n`);
+                (0, help_1.printHelp)('rag-config');
+                process.exit(sub ? 1 : 0);
+        }
+    }
+    show() {
+        let cfg = null;
+        try {
+            cfg = (0, config_store_1.readConfigJson)();
+        }
+        catch (e) {
+            console.error(e.message);
+            process.exit(1);
+        }
+        if (!cfg) {
+            console.log(`No config found at ${config_store_1.CONFIG_FILE}. Run rag-setup.`);
+            return;
+        }
+        // redact password for display
+        const display = JSON.parse(JSON.stringify(cfg));
+        if (display.db?.password !== undefined)
+            display.db.password = '***';
+        console.log(JSON.stringify(display, null, 2));
+    }
+    get(key) {
+        if (!key) {
+            console.error('Usage: rag-config get <key>');
+            process.exit(1);
+        }
+        let cfg = null;
+        try {
+            cfg = (0, config_store_1.readConfigJson)();
+        }
+        catch (e) {
+            console.error(e.message);
+            process.exit(1);
+        }
+        if (!cfg) {
+            console.log('(no config)');
+            return;
+        }
+        const val = (0, config_store_1.getNestedValue)(cfg, key);
+        console.log(val === undefined ? '(not set)' : String(val));
+    }
+    set(key, value) {
+        if (!key || value === undefined) {
+            console.error('Usage: rag-config set <key> <value>');
+            process.exit(1);
+        }
+        try {
+            const cfg = (0, config_store_1.readConfigJson)() ?? {};
+            const updated = (0, config_store_1.setNestedValue)(cfg, key, value);
+            (0, config_store_1.writeConfigJson)(updated);
+            console.log(`${key} = ${value}`);
+        }
+        catch (e) {
+            console.error(e.message);
+            process.exit(1);
+        }
+    }
+    reset(key) {
+        if (!key) {
+            console.error('Usage: rag-config reset <key>');
+            process.exit(1);
+        }
+        try {
+            const cfg = (0, config_store_1.readConfigJson)() ?? {};
+            const updated = (0, config_store_1.deleteNestedValue)(cfg, key);
+            (0, config_store_1.writeConfigJson)(updated);
+            console.log(`${key} reset to default`);
+        }
+        catch (e) {
+            console.error(e.message);
+            process.exit(1);
+        }
+    }
+}
+exports.ConfigCommand = ConfigCommand;

package/dist/src/commands/IndexCommand.js

@@ -22,7 +22,7 @@ class IndexCommand {
         const teardown = (0, interrupt_1.setupInterrupt)(controller);
         try {
             const discovered = indexer.discoverProjects(config.workspaceRoot);
-            const projects = await (0, project_selector_1.selectProjects)(discovered, config.workspaceRoot, forceSelect);
+            const projects = await new project_selector_1.ProjectSelector(config.workspaceRoot).select(discovered, forceSelect);
             if (projects.length === 0)
                 return;
             const filesPerProject = projects.map(p => (0, file_utils_1.collectFiles)(p.path, (0, file_utils_1.loadIgnore)(p.path), p.path));

package/dist/src/config-store.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+export declare const CONFIG_DIR: string;
+export declare const CONFIG_FILE: string;
+declare const jsonSchema: z.ZodObject<{
+    db: z.ZodOptional<z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        user: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    ollama: z.ZodOptional<z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    indexing: z.ZodOptional<z.ZodObject<{
+        chunkSize: z.ZodOptional<z.ZodNumber>;
+        chunkOverlap: z.ZodOptional<z.ZodNumber>;
+        embedBatchSize: z.ZodOptional<z.ZodNumber>;
+        astBatchSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    search: z.ZodOptional<z.ZodObject<{
+        similarityThreshold: z.ZodOptional<z.ZodNumber>;
+        defaultLimit: z.ZodOptional<z.ZodNumber>;
+        maxLimit: z.ZodOptional<z.ZodNumber>;
+        autoTranslate: z.ZodOptional<z.ZodBoolean>;
+        translateModel: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    reranker: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        model: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        overfetch: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    logging: z.ZodOptional<z.ZodObject<{
+        level: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            debug: "debug";
+            info: "info";
+            warn: "warn";
+        }>>;
+        dir: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    workspaceRoot: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type JsonConfig = z.infer<typeof jsonSchema>;
+export declare const ALL_KEYS: string[];
+export declare function readConfigJson(): JsonConfig | null;
+export declare function writeConfigJson(data: JsonConfig): void;
+export declare function getNestedValue(cfg: JsonConfig, key: string): unknown;
+export declare function setNestedValue(cfg: JsonConfig, key: string, raw: string): JsonConfig;
+export declare function deleteNestedValue(cfg: JsonConfig, key: string): JsonConfig;
+export {};