codesearch-mcp 0.0.17-alpha.1 → 0.1.0-alpha

package/CHANGELOG.md

@@ -3,6 +3,54 @@
 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/).
 
+## [Unreleased]
+
+## [0.1.0-alpha] - 2026-07-12
+
+### Added
+
+- **`infinity` embedding provider** — a first-class local backend (`embedding.provider = infinity`) that serves both `/embeddings` and `/rerank` from a single [Infinity](https://github.com/michaelfeil/infinity) container (e.g. `jinaai/jina-embeddings-v2-base-code` + `Alibaba-NLP/gte-reranker-modernbert-base`), so local reranking works out of the box — something Ollama does not provide. Reuses the OpenAI-compatible HTTP path and adds only container-readiness behavior. Selecting `infinity` in `rag-setup` optionally provisions a reranker model and auto-wires `reranker.*` to the same server. Managed provisioning vs. an external/already-running server is decided by a `/health` probe (no config flag) — the same "already running?" probe now also defaults `rag-setup`'s "start Docker?" prompt to no for a reachable Ollama. The managed container prefers an NVIDIA GPU and falls back to CPU, and is recreated when the configured model set changes (Infinity binds models at startup). The managed container also gets `restart: unless-stopped` (survives host reboot) and disables Infinity's model warmup on CPU (a multi-minute benchmark at every boot; kept on for GPU where it is cheap). `jinaai/jina-embeddings-v2-base-code` (768 dims, the Infinity default) and `BAAI/bge-m3` (1024) are added to the model registry so their dimension resolves without a probe.
+- **Reranking is `openai-compatible`-only** — `reranker.provider` no longer accepts `ollama` (Ollama has no rerank API — the previous `/api/rerank` path always 404'd and silently fell back to vector order); the only valid backend is an OpenAI-compatible `/rerank` server (Infinity, TEI, vLLM). The default provider is now `openai-compatible`, and an existing `reranker.provider: 'ollama'` is migrated automatically on read. The embedding provider stays independent of the rerank server, so Ollama embeddings + an Infinity reranker is a valid combination.
+- **Pluggable embedding backends** — the embedder is now selected by `embedding.provider` via a factory, with three implementations: `ollama` (native `/api/embed`, the **backward-compatible default**), `openai-compatible` (one code path covering **OpenAI cloud, Infinity, TEI, vLLM, LM Studio, LocalAI** via a configurable `embedding.baseURL`), and `voyage` (native schema with mandatory `input_type`). To run a faster local backend or a cloud embedder you now edit config, not code.
+- **Batch embedding with retry** — `IEmbedder` gains `embedBatch(texts, inputType?)`; indexing sends one request per batch (`embedding.batchSize`, default 32) instead of one call per chunk, with bounded exponential backoff on HTTP 429/5xx. Makes cloud/Infinity indexing of a whole monorepo practical.
+- **Query/document input-type asymmetry** — `embed`/`embedBatch` take an optional `inputType` (`query` | `document`); search embeds as `query`, indexing as `document`. Voyage forwards it as `input_type`; Ollama and the OpenAI-compatible `/embeddings` endpoint ignore it (OpenAI has no such field).
+- **Flexible vector dimension** — the `code_chunk.embedding` column width now derives from the active model (`embedding.dimensions` override → model registry → one-shot runtime probe) instead of a hardcoded 1024, capped at ≤ 2000 (pgvector HNSW limit); larger cloud models reduce via the Matryoshka `dimensions`/`output_dimension` request parameter.
+- **`index_meta` source-of-truth table + mismatch guard** — a single-row table records `{ provider, model, dimensions }`. `search_codebase` (before embedding a query) and `rag-mcp` (at start) refuse with a clear "run `rag-index --reindex`" error when the configured model disagrees with the indexed one, instead of returning noise from a foreign vector space. A dimension change drops+recreates `code_chunk` at the new width on re-index; a same-dimension model change clears its rows.
+- **API-key secrets via `.env`** — keys live in `~/.config/codesearch-mcp/.env` (chmod 600), loaded into the environment at startup before config is read (a real env var wins over the file), so the client-spawned `rag-mcp` sees them too. Config values support an `env:VAR_NAME` reference; a missing referenced variable fails with a clear error. The dashboard shows `✔ set via <VAR>` for `env:` refs and masks raw keys.
+- **Auto-pull of local Ollama models with live progress** — `rag-index` now pulls the configured Ollama model if it is not present locally (only for `provider: ollama`; a no-op for cloud providers), so switching to (or back to) a local model that was never pulled just works without re-running `rag-setup`. The pull streams progress: a live single-line bar on a TTY (`downloading [██████░░░░] 62% (245.7/393.2 MB)`), de-duplicated status lines otherwise. `rag-setup`'s in-container pull now renders Ollama's native progress bar (allocates a TTY via `docker exec -t` when interactive) and pulls the model you actually chose (previously hardcoded to `bge-m3`).
+- **Cloud providers skip the Ollama container** — when a non-Ollama provider is selected, `rag-setup`'s Docker helper starts only the database service (`docker compose up -d db`) and skips the Ollama wait + model pull, instead of bringing up an unused Ollama container.
+- **Owner-symbol breadcrumb in search results** — each `search_codebase` result now shows a `Symbol:` line naming the declaration the chunk belongs to (`IndexerService.ingestFile`, `collectFiles`, …), so the enclosing class/method is visible without opening the file. Computed at index time into a new nullable `code_chunk.ownerPath` column (added via `ADD COLUMN IF NOT EXISTS`): the deepest declaration containing the chunk's start line wins, so a method beats its enclosing class. Method/constructor/accessor ranges are extracted purely for this breadcrumb and are **not** written to `code_symbol`, so `find_symbol` is unchanged. Module-scope chunks (imports) and rows indexed before this release show no breadcrumb; re-index to populate. No embedding-dimension change.
+- **AST-aware chunking** — TS/JS files are now chunked along top-level declaration boundaries (functions, classes, interfaces, types, exported variables) instead of at fixed character offsets, so a declaration is no longer split across chunks and search-hit line ranges map to coherent units of code. Declarations larger than `indexing.chunkSize` and the gaps between them (imports, top-level code) are sub-split by the recursive splitter, so no chunk exceeds the size limit and no source line is dropped. Reuses the symbol ranges already produced during indexing — no extra parse. New config key `indexing.chunkStrategy` (`ast` \| `character`, default `ast`); set it to `character` to restore the previous fixed-size behavior. Schema files (`.prisma`/`.graphql`/`.gql`) and files without symbol analysis keep the character splitter. Takes effect on the next re-index; no embedding-dimension or DB-schema change.
+
+### Changed (breaking)
+
+- **Config restructure** — the `ollama.*` section is replaced by `embedding.*` (`provider`, `baseURL`, `apiKey`, `model`, `dimensions`, `batchSize`); `reranker.*` gains `provider`/`baseURL`/`apiKey` mirroring the embedding taxonomy (Infinity can serve both from one server). **Legacy `ollama.host`/`ollama.model` configs are migrated to `embedding.*` automatically on read**, so existing installs keep working without manual edits.
+- **Query translation removed** — the `IEmbedder.translate` method and the `search.autoTranslate` / `search.translateModel` config keys are gone; queries are embedded as-is. The keys are silently ignored if still present.
+- **Re-index required on model/dimension change** — switching the embedding model, provider, or dimension now requires `rag-index --reindex` (a dimension change recreates `code_chunk`). Staying on Ollama + `bge-m3` keeps dimension 1024, backfills `index_meta`, and forces no re-index. The mismatch guard makes any disagreement loud rather than silently corrupting results.
+
+## [0.0.18-alpha] - 2026-07-04
+
+### Added
+
+- **Web dashboard (`rag-web`)** — a local browser UI at `http://127.0.0.1:4319` (`--port` to change), bound to `127.0.0.1` only, no auth (single-user local tool). Three tabs: a **schema-driven config editor** (form generated from the config JSON Schema; shows the applied default for any unset key, a strict dropdown for the embedding model, and comboboxes suggesting the user's installed Ollama models for the translate/reranker models), a **project overview**, and the **interactive dependency graph** (the same page as `project-graph.html`, embedded via iframe — filters, legend, and project toggles included). The DB password never reaches the browser (masked as `********`, preserved on save). Requires a valid `config.json`; a failed DB/Ollama connection is non-fatal (config editing still works). Full reference: `docs/web-dashboard.md`.
+- **Config JSON Schema + `rag-config edit`** — `config.json` now gets a generated `config.schema.json` sibling, referenced via `"$schema"`, so schema-aware editors (VS Code, JetBrains) provide key autocomplete, type hints, and inline validation. `rag-config edit` opens the config in `$VISUAL` / `$EDITOR` (falls back to `nano` / `notepad`) and re-validates on save.
+- **Nx monorepo support** — when `workspaceRoot` is an Nx workspace (detected by `nx.json`), projects under `apps/`, `libs/`, and `packages/` are discovered as separate indexed projects instead of a single flat scan. Cross-project imports (`@scope/lib`) resolve through the workspace-wide `tsconfig.base.json` path aliases, so `get_dependencies` / `get_dependents` see edges across projects. Non-Nx (flat) workspaces are unaffected.
+- **`IMonorepoResolver` interface + `NxMonorepoResolver`** — resolver abstraction for monorepo tooling. `NxMonorepoResolver` detects `nx.json`, discovers projects via `workspace.json` / `angular.json` or an `apps/`/`libs/`/`packages/` scan for `project.json` / `package.json`, and resolves the root tsconfig (`tsconfig.base.json`, falling back to `tsconfig.json`).
+- **`MonorepoAwareDiscoveryService`** — implements `IProjectDiscovery` and is wired as the default discovery in the container. Uses the resolver when a monorepo is detected; otherwise delegates to `ProjectDiscoveryService` (flat `package.json` scan). Exposes `analyzeWorkspace()` for full workspace metadata.
+- **`DiscoveredProject` metadata** — discovery now carries optional `packageName` (npm scope + name), `type` (`app` | `lib`), and `rootTsConfigPath` per project.
+- **Nested Nx monorepo under a flat workspace** — when `workspaceRoot` is a flat directory but one of its top-level subdirectories is itself an Nx repo, that repo is discovered as a single selectable unit whose sub-projects (`<repo>/<project>`, e.g. `micros-learning/account`) are expanded and indexed individually. `DiscoveredProject` gains an optional `children` field; the exported `toLeafProjects()` helper expands units into their leaf projects and is shared by `IndexCommand` (indexing loop) and `SearcherService` (name → path resolution). Each sub-project carries the repo's `tsconfig.base.json` as `rootTsConfigPath` for cross-project alias resolution.
+- **Root-level Nx libs via `tsconfig.base.json` paths** — `NxMonorepoResolver` now also discovers projects referenced only through `compilerOptions.paths` aliases (e.g. `contracts/`, `interfaces/` living at the repo root), which the `apps/`/`libs/`/`packages/` scan misses. Only targets that resolve to a real project (with `project.json` / `package.json`) are added; the `tsconfig` reader tolerates JSONC (comments, trailing commas).
+- **Tabbed project graph** — `project-graph.html` and the dashboard's `/graph` now have inner tabs: a **Workspace** tab (flat projects + each nested Nx repo collapsed to one node, double-click to open) and **one tab per Nx repo** showing its sub-projects with real import edges between them. Intra-repo edges come from `SearcherService.getProjectEdges()`, which aggregates `code_dependency` (file → file) into project → project links (most-specific owner wins). `getProjectEdges` is exposed on `ISearcher`.
+
+### Changed
+
+- **Single source of truth for config defaults** — built-in defaults now live once in `CONFIG_DEFAULTS` (`config-store.ts`); `config.ts` references them in its schema `.default(...)` calls, so the runtime default and the value the dashboard shows for an unset key cannot diverge. No behavior change.
+- **`analyzeProject` / `scanAndIndex` accept `rootTsConfigPath`** — for monorepo projects the AST parser loads the workspace-wide tsconfig (`tsconfig.base.json`) so ts-morph resolves cross-project path aliases; flat-workspace projects continue to use their local `tsconfig.json`.
+- **`workspace.json` parsing hardened** — a project entry missing a valid `root` is skipped with a warning instead of aborting discovery of the remaining projects in that file.
+- **Nx project discovery deduplicated across strategies** — `workspace.json` / `angular.json`, the directory scan, `tsconfig` paths, and the root-level fallback are now merged and deduped by absolute project path, so a project surfaced by more than one strategy is reported once.
+- **`SearcherService` resolves project names to real roots** — takes the discovery service and builds a lazily-cached `name → filesystem root` map, so nested-monorepo names (`repo/app`) map to their true path (`repo/apps/app`) instead of a naïve `workspaceRoot/name` join. The cache rebuilds on a miss, so projects added or renamed while a long-running `rag-mcp` / `rag-web` server is up are picked up without a restart. `listProjects`, `grepSymbol`, `find_symbol` grep fallback, and `list_files` use it.
+- **Project graph build is non-fatal in `rag-index`** — a failure while computing import edges or writing `project-graph.html` after a successful index is now caught and logged instead of failing the whole run.
+
 ## [0.0.17-alpha] - 2026-05-13
 
 ### Added

package/README.md

@@ -35,7 +35,7 @@ rag-setup
 
 Walks you through:
 - **Database** — enter connection details; optionally starts Docker containers automatically
-- **Ollama** — configure API URL
+- **Embedding backend** — pick a provider (`ollama` / `infinity` / `openai-compatible` / `voyage`), its model, and an API key if the provider needs one (see [Embedding providers](#embedding-providers))
 - **Logging** — choose log level and directory (defaults: `error` level, `~/.config/codesearch-mcp/logs/`)
 
 Config is saved to `~/.config/codesearch-mcp/config.json`.
@@ -54,6 +54,14 @@ rag-index --reindex         # force re-embed all files (use after model change)
 rag-index --select --reindex
 ```
 
+## Monorepo support
+
+If `workspaceRoot` is an [Nx](https://nx.dev) workspace (detected by `nx.json`), `rag-index` discovers each project under `apps/`, `libs/`, and `packages/` as a **separate indexed project** rather than scanning the workspace as one blob. Cross-project imports like `@scope/shared` resolve through the workspace `tsconfig.base.json` path aliases, so `get_dependencies` / `get_dependents` report edges **across** projects.
+
+**Nested Nx repos.** `workspaceRoot` may also be a plain directory that *contains* an Nx repo in one of its immediate subdirectories (alongside ordinary projects). That nested repo is detected and expanded into its own projects, named `<repo>/<project>` (e.g. `micros-learning/account`), each resolved with the repo's own `tsconfig.base.json`. In the project selector the whole Nx repo appears as **one** selectable entry (so `.ragprojects` stores just `micros-learning`); selecting it indexes all its sub-projects. Ordinary sibling directories are unaffected.
+
+No configuration needed — detection is automatic. Plain (non-Nx) workspaces keep the original behavior: each immediate subdirectory with a `package.json` is one project.
+
 ## Register with Claude Code
 
 ```bash
@@ -62,6 +70,18 @@ claude mcp add codesearch-mcp -s user -- rag-mcp
 
 Then ask Claude anything about your code — it will use the tools below automatically.
 
+## Web dashboard
+
+```bash
+rag-web                 # http://127.0.0.1:4319  (--port to change)
+```
+
+A local web UI (bound to `127.0.0.1` only) with a schema-driven config editor,
+an overview of indexed projects, and the interactive dependency graph. The
+config form shows the applied default for any unset key and offers dropdowns for
+model fields (the embedding model is restricted to dimension-compatible models).
+See [docs/web-dashboard.md](docs/web-dashboard.md) for the full reference.
+
 ## MCP Tools
 
 | Tool | Description |
@@ -98,7 +118,9 @@ After each indexing run an interactive `project-graph.html` is written to the wo
 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
+**File:** src/services/InvoiceService.ts
+**Symbol:** InvoiceService.create
+**Line:** 45
 ...code...
 **Relevance:** 0.32
 **Imports:** src/repositories/InvoiceRepo.ts · src/dto/CreateInvoiceDto.ts
@@ -107,6 +129,8 @@ Pass `include_graph_context: true` to `search_codebase` to see direct imports an
 
 Useful for immediately understanding a file's role in the dependency graph.
 
+Each result also shows a **Symbol** breadcrumb — the declaration the chunk belongs to (`InvoiceService.create`, `collectFiles`, …) — so you can see the enclosing class/method without opening the file. It is omitted for module-scope chunks and for projects indexed before this feature (re-index to populate).
+
 ## Excluding files
 
 Create `.ragignore` in a project root — same syntax as `.gitignore`:
@@ -152,15 +176,80 @@ rag-config reset <key>               # remove key (reverts to default)
 | `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 |
+| `embedding.provider` | `ollama` | Embedding backend: `ollama` \| `infinity` \| `openai-compatible` \| `voyage` |
+| `embedding.baseURL` | per-provider | Backend base URL (ollama `http://localhost:11434`, OpenAI `https://api.openai.com/v1`, Infinity/TEI/vLLM `http://localhost:7997`, Voyage `https://api.voyageai.com/v1`) |
+| `embedding.apiKey` | `''` | API key, or `env:VAR_NAME` to read from `.env`/environment. Empty for local servers |
+| `embedding.model` | `bge-m3` | Embedding model |
+| `embedding.dimensions` | (derived) | Vector width override; required for models whose native width exceeds 2000 (Matryoshka). Otherwise derived from model → registry → runtime probe |
+| `embedding.batchSize` | `32` | Texts per batch embedding request |
 | `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`) |
+| `reranker.enabled` | `false` | Enable cross-encoder reranking; requires `reranker.model` |
+| `reranker.provider` | `openai-compatible` | Rerank backend — `openai-compatible` `/rerank` only (Infinity, TEI, vLLM). Ollama has no rerank API |
+| `reranker.baseURL` | `embedding.baseURL` | Rerank server base URL (Infinity serves embed + rerank from one server) |
+| `reranker.model` | `''` | Reranker model name (e.g. `qllama/bge-reranker-v2-m3`) |
 | `indexing.astBatchSize` | `3000` | Max files per ts-morph batch — lower if indexing large projects causes OOM |
+| `indexing.chunkStrategy` | `ast` | How TS/JS files are chunked: `ast` = boundaries aligned to functions/classes, `character` = fixed-size splitter. Re-index to apply |
 | `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 |
 
+## Embedding providers
+
+`embedding.provider` selects the backend. All four produce vectors the same way; they differ in where they run and which models they offer.
+
+### Choosing a provider
+
+| Provider | When to use | Needs |
+|----------|-------------|-------|
+| `ollama` | Default. Local, zero-setup, general-purpose (`bge-m3`); auto-pulls the model. | Ollama running (Docker or native) |
+| `infinity` | Local, best quality **plus a real reranker** in one container; GPU or CPU. | Docker (managed) or a running Infinity server |
+| `openai-compatible` | OpenAI cloud, or any OpenAI-style server (TEI, vLLM, LM Studio, LocalAI). | `baseURL` (+ `apiKey` for cloud) |
+| `voyage` | Voyage AI cloud, code-specialized embeddings. | Voyage `apiKey` |
+
+Easiest path: `rag-setup` asks for the provider, model, and any API key. Haven't run setup? It's the place to start. To change things later, edit config directly (below).
+
+### Switching provider or changing the model
+
+Any change to the provider, model, or dimension requires a **re-index** — the mismatch guard blocks search until you do it. The index is a rebuildable cache, so there's no data migration.
+
+```bash
+# Switch provider (example: OpenAI cloud)
+rag-config set embedding.provider openai-compatible
+rag-config set embedding.baseURL  https://api.openai.com/v1
+rag-config set embedding.model    text-embedding-3-small
+rag-config set embedding.apiKey   env:OPENAI_API_KEY     # key lives in .env, not config.json
+rag-index --reindex
+
+# Change only the model on the current provider
+rag-config set embedding.model <model-name>
+rag-index --reindex
+```
+
+Per-provider notes:
+
+- **ollama** — `rag-index` auto-pulls the model if it isn't present locally (`bge-m3`, `nomic-embed-text`, `mxbai-embed-large`, …). No API key. Change model: `rag-config set embedding.model nomic-embed-text`.
+- **infinity** — the model set is bound at container startup, so changing `embedding.model` (or the reranker model) **recreates** the managed container on the next `rag-index`. Defaults: `jinaai/jina-embeddings-v2-base-code` + reranker `Alibaba-NLP/gte-reranker-modernbert-base`.
+- **openai-compatible** — point `embedding.baseURL` at the server; set `embedding.apiKey` (as `env:VAR`) for cloud, leave empty for local servers (TEI/vLLM/LM Studio). E.g. `text-embedding-3-small`, `text-embedding-3-large`.
+- **voyage** — set `embedding.apiKey`; e.g. `voyage-code-3`, `voyage-3`.
+
+The vector **dimension** is derived automatically (model registry → one-shot probe); set `embedding.dimensions` only to force a Matryoshka-reduced width for models whose native size exceeds 2000.
+
+### Infinity — local embeddings + reranking in one container
+
+Select `infinity` in `rag-setup` (or set `embedding.provider = infinity`) to run [Infinity](https://github.com/michaelfeil/infinity), which serves both `/embeddings` and `/rerank` from a single container — so you get a real cross-encoder reranker locally, which Ollama does not offer. During setup you're asked for an embedding model (default `jinaai/jina-embeddings-v2-base-code`, 768 dims) and an optional reranker model (default `Alibaba-NLP/gte-reranker-modernbert-base`); when a reranker is given, `reranker.*` is auto-wired to the same server.
+
+Managed vs. external is decided by a `/health` probe at `embedding.baseURL` (default `http://localhost:7997`) — no config flag:
+
+- **Managed** — if nothing answers the probe, `rag-setup` (and `rag-index`) bring up the bundled `infinity` Docker service with your model set. It **prefers an NVIDIA GPU and falls back to CPU** automatically (GPU layered via `docker-compose.infinity-gpu.yml` only when `nvidia-smi` is present). Because Infinity binds its models at startup, changing `embedding.model`/reranker model **recreates** the container.
+- **External** — if a server already answers (your own Infinity, remote host, CI), it is used as-is and no Docker command runs. Point `embedding.baseURL` at it.
+
+The same "already running?" probe now also applies to Ollama: a reachable backend defaults `rag-setup`'s "start Docker?" prompt to no.
+
+### Secrets & external embedders
+
+API keys live in `~/.config/codesearch-mcp/.env` (chmod 600), **not** in `config.json`. Reference them with `env:VAR_NAME`, e.g. `embedding.apiKey = env:OPENAI_API_KEY` with `OPENAI_API_KEY=sk-…` in `.env`. The file is loaded into the environment at startup (a real environment variable wins over the file), so all binaries — including the client-spawned `rag-mcp` — see it identically.
+
+Switching the embedding model, provider, or dimension is applied by **re-indexing** (`rag-index --reindex`) — the index is a rebuildable cache, so there is no data migration. A single-row `index_meta` table records which model built the index; `search_codebase` and `rag-mcp` refuse with a clear "re-index required" error when the configured model disagrees, rather than returning noise from a foreign vector space. Staying on Ollama + `bge-m3` keeps dimension 1024 and forces no re-index.
+
 ## License
 
 MIT

package/dist/app.js

@@ -34,25 +34,63 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const help_1 = require("./src/help");
 const container_1 = require("./src/container");
 const config_1 = require("./src/config");
+const config_store_1 = require("./src/config-store");
 const IndexCommand_1 = require("./src/commands/IndexCommand");
 const McpCommand_1 = require("./src/commands/McpCommand");
 const BackfillCommand_1 = require("./src/commands/BackfillCommand");
 const ConfigCommand_1 = require("./src/commands/ConfigCommand");
+const WebCommand_1 = require("./src/commands/WebCommand");
 const setup_1 = require("./src/setup");
+/**
+ * Load `~/.config/codesearch-mcp/.env` into `process.env` before config is read.
+ * All five binaries share this file — `rag-mcp` in particular is spawned by the
+ * MCP client and does not inherit shell exports. A real `process.env` value
+ * always wins over the file. Minimal `KEY=VALUE` parser (no `dotenv` dep):
+ * skips blanks and `#` comments, strips one layer of surrounding quotes.
+ */
+function loadDotEnv(file) {
+    let text;
+    try {
+        text = fs.readFileSync(file, 'utf-8');
+    }
+    catch {
+        return; // absent / unreadable → no-op
+    }
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const eq = line.indexOf('=');
+        if (eq === -1)
+            continue;
+        const key = line.slice(0, eq).trim();
+        if (!key)
+            continue;
+        let val = line.slice(eq + 1).trim();
+        if (val.length >= 2 && ((val[0] === '"' && val.at(-1) === '"') || (val[0] === "'" && val.at(-1) === "'"))) {
+            val = val.slice(1, -1);
+        }
+        if (!(key in process.env))
+            process.env[key] = val; // real env wins
+    }
+}
 async function main() {
+    loadDotEnv(config_store_1.ENV_FILE);
     const argv1 = path.basename(process.argv[1] ?? '');
     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 isWeb = argv1 === 'rag-web' || process.argv[2] === 'web' || process.argv[2] === 'rag-web';
     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);
+    const mode = isBackfill ? 'backfill' : isIndex ? 'index' : isMcp ? 'mcp' : isSetup ? 'setup' : isConfig ? 'config' : isWeb ? 'web' : (process.argv[2] ?? '');
+    const isBinary = ['rag-index', 'rag-mcp', 'rag-setup', 'rag-config', 'rag-web'].includes(argv1);
     if (process.argv.includes('--help') || process.argv.includes('-h')) {
         (0, help_1.printHelp)(isBinary ? argv1 : mode);
         process.exit(0);
@@ -75,6 +113,24 @@ async function main() {
             process.exit(1);
         }
     }
+    else if (mode === 'web') {
+        for (let i = 0; i < effectiveArgs.length; i++) {
+            if (effectiveArgs[i] === '--port') {
+                const raw = effectiveArgs[i + 1];
+                const n = Number(raw);
+                if (!raw || !Number.isInteger(n) || n < 1 || n > 65535) {
+                    console.error(`Invalid --port value: ${raw ?? '(missing)'}\n`);
+                    (0, help_1.printHelp)(isBinary ? argv1 : 'rag-web');
+                    process.exit(1);
+                }
+                i++;
+                continue; // skip its (validated) value
+            }
+            console.error(`Unexpected argument: ${effectiveArgs[i]}\n`);
+            (0, help_1.printHelp)(isBinary ? argv1 : 'rag-web');
+            process.exit(1);
+        }
+    }
     else if (mode === 'backfill') {
         const knownBackfillFlags = new Set(['--calls']);
         const backfillIdx = process.argv.indexOf('backfill');
@@ -95,7 +151,7 @@ async function main() {
         process.exit(0);
     }
     // All other modes require a valid config.json
-    const loggerName = mode === 'index' || mode === 'backfill' ? 'indexer' : mode === 'mcp' ? 'mcp' : undefined;
+    const loggerName = mode === 'index' || mode === 'backfill' ? 'indexer' : mode === 'mcp' ? 'mcp' : mode === 'web' ? 'web' : undefined;
     let container;
     try {
         container = (0, container_1.createContainer)(loggerName);
@@ -114,20 +170,24 @@ async function main() {
         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),
-        backfill: new BackfillCommand_1.BackfillCommand(container),
+    // Construct only the selected command — building every command eagerly would
+    // run each constructor's arg parsing (e.g. WebCommand's --port) for modes that
+    // never use it.
+    const factories = {
+        index: () => new IndexCommand_1.IndexCommand(container, argv1),
+        mcp: () => new McpCommand_1.McpCommand(container),
+        backfill: () => new BackfillCommand_1.BackfillCommand(container),
+        web: () => new WebCommand_1.WebCommand(container, effectiveArgs),
     };
-    const cmd = commands[mode];
-    if (!cmd) {
+    const factory = factories[mode];
+    if (!factory) {
         const hasUnknownArg = mode !== '';
         if (hasUnknownArg)
             console.error(`Unknown command: ${mode}\n`);
         (0, help_1.printHelp)('default');
         process.exit(hasUnknownArg ? 1 : 0);
     }
-    await cmd.execute();
+    await factory().execute();
     await container.db.destroy();
     process.exit(0);
 }

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

@@ -8,5 +8,6 @@ export declare class ConfigCommand implements ICommand {
     private get;
     private set;
     private reset;
+    private edit;
 }
 export { ALL_KEYS };

package/dist/src/commands/ConfigCommand.js

@@ -1,6 +1,41 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ALL_KEYS = exports.ConfigCommand = void 0;
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
 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");
@@ -16,6 +51,7 @@ class ConfigCommand {
             case 'get': return this.get(key);
             case 'set': return this.set(key, value);
             case 'reset': return this.reset(key);
+            case 'edit': return this.edit();
             default:
                 if (sub)
                     console.error(`Unknown subcommand: ${sub}\n`);
@@ -29,7 +65,7 @@ class ConfigCommand {
             cfg = (0, config_store_1.readConfigJson)();
         }
         catch (e) {
-            console.error(e.message);
+            console.error(e instanceof Error ? e.message : String(e));
             process.exit(1);
         }
         if (!cfg) {
@@ -52,7 +88,7 @@ class ConfigCommand {
             cfg = (0, config_store_1.readConfigJson)();
         }
         catch (e) {
-            console.error(e.message);
+            console.error(e instanceof Error ? e.message : String(e));
             process.exit(1);
         }
         if (!cfg) {
@@ -74,7 +110,7 @@ class ConfigCommand {
             console.log(`${key} = ${value}`);
         }
         catch (e) {
-            console.error(e.message);
+            console.error(e instanceof Error ? e.message : String(e));
             process.exit(1);
         }
     }
@@ -90,7 +126,51 @@ class ConfigCommand {
             console.log(`${key} reset to default`);
         }
         catch (e) {
-            console.error(e.message);
+            console.error(e instanceof Error ? e.message : String(e));
+            process.exit(1);
+        }
+    }
+    edit() {
+        // Ensure config + schema exist so the editor has something to open and
+        // resolve the schema against.
+        try {
+            if (!fs.existsSync(config_store_1.CONFIG_FILE)) {
+                (0, config_store_1.writeConfigJson)({});
+            }
+            else {
+                (0, config_store_1.writeSchemaFile)();
+                // Migrate existing configs: re-add the "$schema" reference if absent
+                // (rewrite through writeConfigJson) so editors bind to the schema.
+                // Skip silently if the file is currently invalid — the user will fix
+                // it in the editor and validation runs on save.
+                try {
+                    const cfg = (0, config_store_1.readConfigJson)();
+                    if (cfg)
+                        (0, config_store_1.writeConfigJson)(cfg);
+                }
+                catch { /* invalid file — leave as-is for the user to edit */ }
+            }
+        }
+        catch (e) {
+            console.error(e instanceof Error ? e.message : String(e));
+            process.exit(1);
+        }
+        const editor = process.env.VISUAL ||
+            process.env.EDITOR ||
+            (process.platform === 'win32' ? 'notepad' : 'nano');
+        const res = (0, child_process_1.spawnSync)(editor, [config_store_1.CONFIG_FILE], { stdio: 'inherit' });
+        if (res.error) {
+            console.error(`Cannot launch editor "${editor}": ${res.error.message}`);
+            console.error('Set $EDITOR or edit the file directly: ' + config_store_1.CONFIG_FILE);
+            process.exit(1);
+        }
+        // Validate what the user saved; readConfigJson throws with a helpful message.
+        try {
+            (0, config_store_1.readConfigJson)();
+            console.log('Config OK');
+        }
+        catch (e) {
+            console.error(e instanceof Error ? e.message : String(e));
             process.exit(1);
         }
     }

package/dist/src/commands/IndexCommand.js

@@ -4,6 +4,7 @@ exports.IndexCommand = void 0;
 const interrupt_1 = require("../interrupt");
 const project_selector_1 = require("../project-selector");
 const graph_1 = require("../graph");
+const MonorepoAwareDiscoveryService_1 = require("../services/MonorepoAwareDiscoveryService");
 const file_utils_1 = require("../file-utils");
 class IndexCommand {
     container;
@@ -13,18 +14,34 @@ class IndexCommand {
         this.argv1 = argv1;
     }
     async execute() {
-        const { db, indexer, config } = this.container;
+        const { db, indexer, searcher, config, discovery, embedder } = this.container;
         const args = process.argv.slice(this.argv1 === 'rag-index' ? 2 : 3);
         const force = args.includes('--reindex');
         const forceSelect = args.includes('--select');
         await db.initDbWithSchema();
+        // Ensure the local model is pulled (Ollama only — no-op for cloud), then
+        // resolve the active embedding dimension and reconcile it with index_meta
+        // (recreate code_chunk on a dimension change, clear rows on a model change)
+        // before scanning. A clear error here beats a mid-run vector width mismatch.
+        try {
+            await embedder.ensureModelAvailable?.();
+            const meta = await indexer.prepareEmbeddingSchema();
+            console.log(`Embedding: ${meta.provider} / ${meta.model} (${meta.dimensions} dims)`);
+        }
+        catch (err) {
+            console.error(`\nEmbedding setup failed: ${err.message}`);
+            return;
+        }
         const controller = new AbortController();
         const teardown = (0, interrupt_1.setupInterrupt)(controller);
         try {
-            const discovered = indexer.discoverProjects(config.workspaceRoot);
-            const projects = await new project_selector_1.ProjectSelector(config.workspaceRoot).select(discovered, forceSelect);
-            if (projects.length === 0)
+            const discovered = discovery.discover(config.workspaceRoot);
+            const selected = await new project_selector_1.ProjectSelector(config.workspaceRoot).select(discovered, forceSelect);
+            if (selected.length === 0)
                 return;
+            // Expand any selected nested-monorepo unit (e.g. an Nx repo) into its
+            // sub-projects; ordinary projects pass through unchanged.
+            const projects = (0, MonorepoAwareDiscoveryService_1.toLeafProjects)(selected);
             const filesPerProject = projects.map(p => (0, file_utils_1.collectFiles)(p.path, (0, file_utils_1.loadIgnore)(p.path), p.path));
             const totalFiles = filesPerProject.reduce((sum, f) => sum + f.length, 0);
             console.log(`\n${projects.length} projects — ${totalFiles} files total`);
@@ -34,7 +51,7 @@ class IndexCommand {
             for (let i = 0; i < projects.length; i++) {
                 if (controller.signal.aborted)
                     break;
-                const stats = await indexer.scanAndIndex(projects[i].path, projects[i].name, force, controller.signal, filesPerProject[i]);
+                const stats = await indexer.scanAndIndex(projects[i].path, projects[i].name, force, controller.signal, filesPerProject[i], { rootTsConfigPath: projects[i].rootTsConfigPath ?? undefined });
                 allStats.push(stats);
                 const remaining = projects.length - allStats.length;
                 if (remaining > 0 && !controller.signal.aborted) {
@@ -45,8 +62,19 @@ class IndexCommand {
             if (controller.signal.aborted)
                 console.log('\nIndexing interrupted.');
             this.printSummary(allStats);
-            if (!controller.signal.aborted)
-                (0, graph_1.generateProjectGraph)(projects, config.workspaceRoot);
+            if (!controller.signal.aborted) {
+                // The graph is a post-index nicety — a failure here (DB dropped after a
+                // long run, unreadable dir) must not fail the whole run: indexing already
+                // succeeded and the summary is printed.
+                try {
+                    // Real import edges (code_dependency, just written) → intra-repo graph links.
+                    const projectEdges = await searcher.getProjectEdges();
+                    (0, graph_1.generateProjectGraph)(projects, projectEdges, config.workspaceRoot);
+                }
+                catch (err) {
+                    console.error(`  ⚠ Could not build project graph: ${err.message}`);
+                }
+            }
         }
         finally {
             teardown();

package/dist/src/commands/McpCommand.js

@@ -7,20 +7,25 @@ class McpCommand {
         this.container = container;
     }
     async execute() {
-        const { db, mcp, logger } = this.container;
+        const { db, mcp, searcher, logger } = this.container;
         let startupError;
         try {
             await db.initDb();
+            // Refuse to serve searches embedded into a foreign vector space — surface
+            // the mismatch through the existing startup-error plumbing so every tool
+            // call reports it clearly.
+            await searcher.assertIndexMatches();
         }
         catch (err) {
-            startupError = err;
-            logger.error('McpCommand: database connection failed', { reason: err.message });
+            startupError = err instanceof Error ? err : new Error(String(err));
+            logger.error('McpCommand: startup check failed', { reason: startupError.message });
         }
         try {
             await mcp.start(startupError);
         }
         catch (err) {
-            logger.error('McpCommand: MCP server failed to start', { reason: err.message });
+            const reason = err instanceof Error ? err.message : String(err);
+            logger.error('McpCommand: MCP server failed to start', { reason });
             return;
         }
         // server.connect() resolves immediately after setup; keep the process alive

package/dist/src/commands/{SetupCommand.d.ts → WebCommand.d.ts}

@@ -1,7 +1,8 @@
 import type { Container } from '../container';
 import type { ICommand } from './ICommand';
-export declare class SetupCommand implements ICommand {
+export declare class WebCommand implements ICommand {
     private container;
-    constructor(container: Container);
+    private readonly port;
+    constructor(container: Container, args?: string[]);
     execute(): Promise<void>;
 }