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

package/dist/src/services/OpenAICompatibleEmbedder.d.ts

@@ -0,0 +1,25 @@
+import type { Config } from '../config';
+import type { IEmbedder, InputType } from '../interfaces/IEmbedder';
+import type { ILogger } from '../interfaces/ILogger';
+export interface EmbedderDeps {
+    fetchImpl?: typeof fetch;
+    baseDelayMs?: number;
+}
+/**
+ * Embedder for any server exposing an OpenAI-style `/embeddings` endpoint:
+ * OpenAI cloud, Infinity, TEI, vLLM, LM Studio, LocalAI. One request carries all
+ * inputs (`{ input: string[], model, dimensions? }`) and returns
+ * `{ data: [{ embedding, index }] }`, re-ordered to input order.
+ */
+export declare class OpenAICompatibleEmbedder implements IEmbedder {
+    protected config: Config;
+    private logger;
+    readonly dimensions: number;
+    rerank?: (query: string, documents: string[], topN: number) => Promise<number[]>;
+    private readonly url;
+    private readonly doFetch;
+    private readonly baseDelayMs?;
+    constructor(config: Config, logger?: ILogger, deps?: EmbedderDeps);
+    embed(text: string, inputType?: InputType): Promise<number[]>;
+    embedBatch(texts: string[], _inputType?: InputType): Promise<number[][]>;
+}

package/dist/src/services/OpenAICompatibleEmbedder.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAICompatibleEmbedder = void 0;
+const LoggerService_1 = require("./LoggerService");
+const config_1 = require("../config");
+const reranker_1 = require("./reranker");
+const http_retry_1 = require("./http-retry");
+const constants_1 = require("../constants");
+/**
+ * Embedder for any server exposing an OpenAI-style `/embeddings` endpoint:
+ * OpenAI cloud, Infinity, TEI, vLLM, LM Studio, LocalAI. One request carries all
+ * inputs (`{ input: string[], model, dimensions? }`) and returns
+ * `{ data: [{ embedding, index }] }`, re-ordered to input order.
+ */
+class OpenAICompatibleEmbedder {
+    config;
+    logger;
+    dimensions;
+    rerank;
+    url;
+    doFetch;
+    baseDelayMs;
+    constructor(config, logger = LoggerService_1.LoggerService.silent(), deps = {}) {
+        this.config = config;
+        this.logger = logger;
+        const base = config.embedding.baseURL.replace(/\/+$/, '');
+        // Allow a baseURL that already includes the path (…/v1) or not.
+        this.url = /\/embeddings$/.test(base) ? base : `${base}/embeddings`;
+        this.doFetch = deps.fetchImpl ?? fetch;
+        this.baseDelayMs = deps.baseDelayMs;
+        this.dimensions = config.embedding.dimensions ?? (0, constants_1.registryDimension)(config.embedding.model) ?? 0;
+        this.rerank = (0, reranker_1.makeReranker)(config, logger, deps);
+    }
+    async embed(text, inputType) {
+        const [v] = await this.embedBatch([text], inputType);
+        return v;
+    }
+    async embedBatch(texts, _inputType) {
+        if (texts.length === 0)
+            return [];
+        return (0, http_retry_1.withRetry)(async () => {
+            const headers = { 'Content-Type': 'application/json' };
+            // Resolve the key lazily — an unset `env:` ref throws here (request time),
+            // not at construction, so `rag-web`/`rag-mcp` still start.
+            const apiKey = (0, config_1.resolveEnvRef)(this.config.embedding.apiKey);
+            if (apiKey)
+                headers['Authorization'] = `Bearer ${apiKey}`;
+            const body = { model: this.config.embedding.model, input: texts };
+            if (this.config.embedding.dimensions != null)
+                body.dimensions = this.config.embedding.dimensions;
+            const res = await this.doFetch(this.url, {
+                method: 'POST',
+                headers,
+                signal: AbortSignal.timeout(120_000),
+                body: JSON.stringify(body),
+            });
+            if (!res.ok) {
+                const errBody = (await res.text().catch(() => res.statusText)).slice(0, 200);
+                throw new http_retry_1.HttpError(res.status, `embeddings request failed: ${res.status} ${errBody}`);
+            }
+            const data = await res.json();
+            // Guard against a partial/mismatched response — a missing vector would
+            // otherwise be inserted as "[undefined]" and fail the whole file, or (with
+            // reordering + no index) silently misalign vectors to the wrong chunks.
+            if (!Array.isArray(data.data) || data.data.length !== texts.length) {
+                throw new Error(`embeddings response returned ${data.data?.length ?? 0} vectors for ${texts.length} inputs`);
+            }
+            // Sort by `index` so vectors line up with input order regardless of server ordering.
+            return [...data.data]
+                .sort((a, b) => (a.index ?? 0) - (b.index ?? 0))
+                .map(d => d.embedding);
+        }, { logger: this.logger, baseDelayMs: this.baseDelayMs, label: 'openai-embed' });
+    }
+}
+exports.OpenAICompatibleEmbedder = OpenAICompatibleEmbedder;

package/dist/src/services/ProjectDiscoveryService.d.ts

@@ -0,0 +1,8 @@
+import type { IProjectDiscovery, DiscoveredProject } from '../interfaces/IProjectDiscovery';
+/**
+ * Default project discovery: finds immediate subdirectories
+ * of the workspace root that contain a package.json.
+ */
+export declare class ProjectDiscoveryService implements IProjectDiscovery {
+    discover(rootDir: string): DiscoveredProject[];
+}

package/dist/src/{env-loader.js → services/ProjectDiscoveryService.js}

@@ -33,9 +33,20 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-const dotenv = __importStar(require("dotenv"));
+exports.ProjectDiscoveryService = void 0;
+const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-// Global config first, then local .env overrides (for development)
-dotenv.config({ path: path.join(os.homedir(), '.config', 'codesearch-mcp', '.env') });
-dotenv.config();
+const file_utils_1 = require("../file-utils");
+/**
+ * Default project discovery: finds immediate subdirectories
+ * of the workspace root that contain a package.json.
+ */
+class ProjectDiscoveryService {
+    discover(rootDir) {
+        return fs.readdirSync(rootDir, { withFileTypes: true })
+            .filter(d => d.isDirectory() && !file_utils_1.IGNORE_DIRS.has(d.name))
+            .map(d => ({ name: d.name, path: path.join(rootDir, d.name) }))
+            .filter(p => fs.existsSync(path.join(p.path, 'package.json')));
+    }
+}
+exports.ProjectDiscoveryService = ProjectDiscoveryService;

package/dist/src/services/SearcherService.d.ts

@@ -1,13 +1,15 @@
 import type { Config } from '../config';
-import type { IEmbedder } from '../interfaces/IEmbedder';
-import type { DatabaseService } from './DatabaseService';
+import type { IEmbedder } from '../interfaces';
+import type { IDatabase } from '../interfaces';
 import { type ProjectMeta } from '../file-utils';
-import { LoggerService } from './LoggerService';
+import type { ILogger } from '../interfaces';
+import type { IProjectDiscovery } from '../interfaces';
 export interface ChunkRow {
     serviceName: string;
     filePath: string;
     startLine: number;
     content: string;
+    ownerPath?: string | null;
 }
 export interface SearchResult extends ChunkRow {
     score: number;
@@ -44,6 +46,10 @@ export interface DependencyRow {
 export interface ProjectRow extends ProjectMeta {
     serviceName: string;
     chunks: number;
+    packageName?: string | null;
+    type?: 'app' | 'lib';
+    /** Real filesystem root of the project (resolved via discovery). */
+    path?: string;
 }
 export interface GrepMatch {
     filePath: string;
@@ -67,13 +73,42 @@ export interface SymbolHit {
 export declare class SearcherService {
     private db;
     private embedder;
+    private discovery;
     private config;
     private logger;
-    constructor(db: DatabaseService, embedder: IEmbedder, config: Config, logger?: LoggerService);
+    constructor(db: IDatabase, embedder: IEmbedder, discovery: IProjectDiscovery, config: Config, logger?: ILogger);
+    /** Lazily-built, cached map of project name → real filesystem root. */
+    private rootMap?;
+    /** Cached, lazily-built map of leaf project name → real filesystem root (via discovery). */
+    private projectRootMap;
+    /**
+     * Resolve a project name to its real filesystem root. Uses discovery (leaf
+     * projects) so nested-monorepo names like `repo/app` map to their true path;
+     * falls back to `join(workspaceRoot, name)` when the name is unknown (e.g. a
+     * project since removed from disk, or a flat project not surfaced by discovery).
+     */
+    private resolveProjectRoot;
+    /**
+     * Project-level dependency edges aggregated from `code_dependency`: an edge
+     * `A → B` means some file in project A imports a file owned by project B.
+     * Used by the graph to draw links between a monorepo's sub-projects. Only
+     * edges whose target file belongs to an indexed project are returned (targets
+     * outside any indexed project — e.g. unindexed libs — are skipped).
+     */
+    getProjectEdges(): Promise<{
+        from: string;
+        to: string;
+    }[]>;
     prepareQuery(raw: string): Promise<{
         query: string;
         translated: boolean;
     }>;
+    /**
+     * Refuse when the configured embedding model disagrees with the one that built
+     * the index — embedding a query into a foreign vector space returns noise. A
+     * missing `index_meta` (un-migrated DB / not yet indexed) does not block.
+     */
+    assertIndexMatches(): Promise<void>;
     listProjects(): Promise<ProjectRow[]>;
     searchChunks(query: string, limit: number, project: string | null, threshold?: number): Promise<SearchResult[]>;
     fetchNeighbors(results: SearchResult[]): Promise<NeighborResult[]>;
@@ -81,10 +116,10 @@ export declare class SearcherService {
     getDependencies(filePath: string, project: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
     getDependents(filePath: string, project: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
     getCallers(symbol: string, project: string, calleeFile?: string | null): Promise<CallerRow[]>;
-    grepSymbol(symbol: string, project: string, excludeFile: string): {
+    grepSymbol(symbol: string, project: string, excludeFile: string): Promise<{
         matches: GrepMatch[];
         truncated: boolean;
-    };
+    }>;
     findSymbol(name: string, project: string | null, kind: SymbolKind): Promise<{
         hits: SymbolHit[];
         truncated: boolean;
@@ -97,8 +132,12 @@ export declare class SearcherService {
     };
     readFileAbsolute(absPath: string, maxLines: number): Promise<FileRangeResult>;
     readFileRange(filePath: string, startLine: number, endLine: number): Promise<FileRangeResult>;
-    private isNonEnglish;
     private walkDir;
     private buildFindSymbolPattern;
     private inferKind;
+    /**
+     * Async wrapper around grep to avoid blocking the event loop.
+     * Returns stdout as a string, or null if grep returned no results or errored.
+     */
+    private spawnGrep;
 }

package/dist/src/services/SearcherService.js

@@ -39,7 +39,13 @@ const path = __importStar(require("path"));
 const readline = __importStar(require("readline"));
 const child_process_1 = require("child_process");
 const file_utils_1 = require("../file-utils");
-const LoggerService_1 = require("./LoggerService");
+const MonorepoAwareDiscoveryService_1 = require("./MonorepoAwareDiscoveryService");
+const SILENT_LOGGER = {
+    debug() { },
+    info() { },
+    warn() { },
+    error() { },
+};
 const EMPTY_META = { description: null, stack: null, notes: null, relations: null };
 const GREP_MAX_RESULTS = 200;
 const GREP_RAW_LIMIT = GREP_MAX_RESULTS * 5;
@@ -49,51 +55,138 @@ const FIND_SYMBOL_RAW_LIMIT = FIND_SYMBOL_LIMIT * 10;
 class SearcherService {
     db;
     embedder;
+    discovery;
     config;
     logger;
-    constructor(db, embedder, config, logger = LoggerService_1.LoggerService.silent()) {
+    constructor(db, embedder, discovery, config, logger = SILENT_LOGGER) {
         this.db = db;
         this.embedder = embedder;
+        this.discovery = discovery;
         this.config = config;
         this.logger = logger;
     }
-    async prepareQuery(raw) {
-        const t0 = Date.now();
-        if (this.config.search.autoTranslate && this.isNonEnglish(raw) && this.embedder.translate) {
-            const query = await this.embedder.translate(raw, this.config.search.translateModel);
-            this.logger.debug('SearcherService: prepareQuery', { translated: true, raw: raw.slice(0, 120), query: query.slice(0, 120), ms: Date.now() - t0 });
-            return { query, translated: true };
+    /** Lazily-built, cached map of project name → real filesystem root. */
+    rootMap;
+    /** Cached, lazily-built map of leaf project name → real filesystem root (via discovery). */
+    projectRootMap() {
+        if (!this.rootMap) {
+            this.rootMap = new Map((0, MonorepoAwareDiscoveryService_1.toLeafProjects)(this.discovery.discover(this.config.workspaceRoot)).map(p => [p.name, p.path]));
+        }
+        return this.rootMap;
+    }
+    /**
+     * Resolve a project name to its real filesystem root. Uses discovery (leaf
+     * projects) so nested-monorepo names like `repo/app` map to their true path;
+     * falls back to `join(workspaceRoot, name)` when the name is unknown (e.g. a
+     * project since removed from disk, or a flat project not surfaced by discovery).
+     */
+    resolveProjectRoot(name) {
+        let root = this.projectRootMap().get(name);
+        if (root === undefined) {
+            // Cache miss — the project may have been added/renamed on disk since the
+            // map was built (mcp/web servers are long-lived). Rebuild once and retry
+            // before the flat fallback, which is wrong for nested-monorepo names
+            // (`repo/app` lives at `repo/apps/app`, not `repo/app`).
+            this.rootMap = undefined;
+            root = this.projectRootMap().get(name);
+        }
+        return root ?? path.join(this.config.workspaceRoot, name);
+    }
+    /**
+     * Project-level dependency edges aggregated from `code_dependency`: an edge
+     * `A → B` means some file in project A imports a file owned by project B.
+     * Used by the graph to draw links between a monorepo's sub-projects. Only
+     * edges whose target file belongs to an indexed project are returned (targets
+     * outside any indexed project — e.g. unindexed libs — are skipped).
+     */
+    async getProjectEdges() {
+        const rows = await this.db.query(`SELECT DISTINCT project, "toFile" FROM code_dependency`);
+        // Reverse map: workspace-relative project root → name, longest first so the
+        // most specific owner wins (e.g. repo/apps/account before repo).
+        const byRelPath = [...this.projectRootMap().entries()]
+            .map(([name, abs]) => ({ name, rel: path.relative(this.config.workspaceRoot, abs) }))
+            .sort((a, b) => b.rel.length - a.rel.length);
+        const ownerOf = (toFile) => {
+            for (const { name, rel } of byRelPath) {
+                if (toFile === rel || toFile.startsWith(rel + path.sep) || toFile.startsWith(rel + '/'))
+                    return name;
+            }
+            return null;
+        };
+        const seen = new Set();
+        const edges = [];
+        for (const { project, toFile } of rows) {
+            const to = ownerOf(toFile);
+            if (!to || to === project)
+                continue;
+            const key = project + ' ' + to;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            edges.push({ from: project, to });
         }
-        this.logger.debug('SearcherService: prepareQuery', { translated: false, query: raw.slice(0, 120), ms: Date.now() - t0 });
+        return edges;
+    }
+    // Query translation was removed (legacy). The query is embedded as-is; the
+    // method is kept so the tool layer needs no change and `translated` is always
+    // false.
+    async prepareQuery(raw) {
         return { query: raw, translated: false };
     }
+    /**
+     * Refuse when the configured embedding model disagrees with the one that built
+     * the index — embedding a query into a foreign vector space returns noise. A
+     * missing `index_meta` (un-migrated DB / not yet indexed) does not block.
+     */
+    async assertIndexMatches() {
+        const meta = await this.db.readIndexMeta();
+        if (!meta)
+            return;
+        const { provider, model } = this.config.embedding;
+        if (meta.provider !== provider || meta.model !== model) {
+            throw new Error(`Index was built with ${meta.provider}/${meta.model} but the config selects ${provider}/${model}. ` +
+                `Run \`rag-index --reindex\` to rebuild the index for the new model.`);
+        }
+        // Same model but a changed dimension (e.g. a Matryoshka `embedding.dimensions`
+        // override) would embed the query at a width the column can't hold — pgvector
+        // would throw an opaque "different vector dimensions" error mid-query. Catch
+        // it here with the friendly hint. `embedder.dimensions` is 0 when the width is
+        // only knowable by probing, in which case we skip (can't compare cheaply).
+        const dim = this.embedder.dimensions;
+        if (dim > 0 && dim !== meta.dimensions) {
+            throw new Error(`Index was built at ${meta.dimensions} dimensions but ${provider}/${model} now resolves to ${dim}. ` +
+                `Run \`rag-index --reindex\` to rebuild the index at the new dimension.`);
+        }
+    }
     async listProjects() {
         const rows = await this.db.query(`SELECT "serviceName", COUNT(*)::int AS chunks
        FROM code_chunk
        GROUP BY "serviceName"
        ORDER BY "serviceName"`);
         return rows.map(r => {
-            const meta = (0, file_utils_1.readRagMeta)(path.join(this.config.workspaceRoot, r.serviceName));
-            return { ...r, ...(typeof meta === 'object' ? meta : EMPTY_META) };
+            const projectRoot = this.resolveProjectRoot(r.serviceName);
+            const meta = (0, file_utils_1.readRagMeta)(projectRoot);
+            return { ...r, path: projectRoot, ...(typeof meta === 'object' ? meta : EMPTY_META) };
         });
     }
     async searchChunks(query, limit, project, threshold) {
         const t0 = Date.now();
+        await this.assertIndexMatches();
         const effectiveThreshold = threshold ?? this.config.search.similarityThreshold;
         const fetchLimit = this.embedder.rerank
-            ? Math.min(limit * this.config.search.rerankerOverfetch, 200)
+            ? Math.min(limit * this.config.reranker.overfetch, 200)
             : limit;
         this.logger.debug('SearcherService: searchChunks', {
             query: query.slice(0, 120), limit, fetchLimit, project, threshold: effectiveThreshold,
         });
-        const embedding = await this.embedder.embed(query);
+        const embedding = await this.embedder.embed(query, 'query');
         const params = [`[${embedding}]`, effectiveThreshold, fetchLimit];
         let projectFilter = '';
         if (project) {
             params.push(project);
             projectFilter = `AND "serviceName" = $${params.length}`;
         }
-        const candidates = await this.db.query(`SELECT "serviceName", "filePath", "startLine", content,
+        const candidates = await this.db.query(`SELECT "serviceName", "filePath", "startLine", content, "ownerPath",
               ROUND((embedding <=> $1)::numeric, 4)::float8 AS score
        FROM code_chunk
        WHERE embedding <=> $1 < $2
@@ -111,11 +204,13 @@ class SearcherService {
         try {
             const indices = await this.embedder.rerank(query, candidates.map(r => r.content), limit);
             this.logger.debug('SearcherService: searchChunks rerank done', { indices, ms: Date.now() - t0 });
-            return indices.filter(i => i >= 0 && i < candidates.length).map(i => candidates[i]);
+            // Cap at `limit`: some rerank servers ignore `top_n` and echo back every
+            // candidate, so slicing here keeps the result count within the request.
+            return indices.filter(i => i >= 0 && i < candidates.length).slice(0, limit).map(i => candidates[i]);
         }
         catch (err) {
             this.logger.warn('SearcherService: rerank failed, falling back to vector order', {
-                reason: err.message,
+                reason: err instanceof Error ? err.message : String(err),
                 ms: Date.now() - t0,
             });
             return candidates.slice(0, limit);
@@ -168,6 +263,8 @@ class SearcherService {
         if (pairs.length === 0)
             return new Map();
         const n = pairs.length;
+        // Use proportional limit: 50 imports + 50 usedBy per file
+        const proportionalLimit = Math.max(2000, n * 100);
         const firstHalf = pairs.map((_, i) => `($${i * 2 + 1}::text, $${i * 2 + 2}::text)`).join(', ');
         const secondHalf = pairs.map((_, i) => `($${n * 2 + i * 2 + 1}::text, $${n * 2 + i * 2 + 2}::text)`).join(', ');
         const params = [
@@ -184,7 +281,7 @@ class SearcherService {
          FROM (VALUES ${secondHalf}) AS r(fp, proj)
          JOIN code_dependency d ON d."toFile" = r.fp AND d.project = r.proj
 
-         LIMIT 2000`, params);
+         LIMIT ${proportionalLimit}`, params);
         const ctx = new Map();
         for (const { filePath } of pairs)
             ctx.set(filePath, { imports: new Set(), usedBy: new Set() });
@@ -227,7 +324,7 @@ class SearcherService {
          FROM code_dependency
          WHERE "fromFile" = $1 AND project = $2
 
-         UNION
+         UNION ALL
 
          SELECT d."toFile", deps.depth + 1, deps."toFile" AS via
          FROM code_dependency d
@@ -270,7 +367,7 @@ class SearcherService {
          FROM code_dependency
          WHERE "toFile" = $1 AND project = $2
 
-         UNION
+         UNION ALL
 
          SELECT d."fromFile", rdeps.depth + 1, rdeps."fromFile" AS via
          FROM code_dependency d
@@ -308,25 +405,23 @@ class SearcherService {
         this.logger.debug('SearcherService: getCallers result', { count: rows.length, ms: Date.now() - t0 });
         return rows;
     }
-    grepSymbol(symbol, project, excludeFile) {
+    async grepSymbol(symbol, project, excludeFile) {
         const t0 = Date.now();
         this.logger.debug('SearcherService: grepSymbol', { symbol, project, excludeFile });
-        const projectDir = path.join(this.config.workspaceRoot, project);
-        const result = (0, child_process_1.spawnSync)('grep', [
+        const projectDir = this.resolveProjectRoot(project);
+        const result = await this.spawnGrep([
             '-rn', '-F', '-w',
             '-m', String(GREP_RAW_LIMIT),
             '--include=*.ts', '--include=*.tsx', '--include=*.js', '--include=*.jsx',
             ...GREP_EXCLUDE_DIRS,
             symbol,
             projectDir,
-        ], { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
-        if (result.error || !result.stdout) {
-            if (result.error)
-                this.logger.error('SearcherService: grep failed', { method: 'grepSymbol', reason: result.error.message });
+        ]);
+        if (!result) {
             return { matches: [], truncated: false };
         }
         const excludeAbsPath = path.join(this.config.workspaceRoot, excludeFile);
-        const all = result.stdout.split('\n').flatMap(line => {
+        const all = result.split('\n').flatMap(line => {
             const match = line.match(/^(.+?):(\d+):/);
             if (!match)
                 return [];
@@ -345,7 +440,7 @@ class SearcherService {
         if (!/^[\w$]+$/.test(name))
             throw new Error('Invalid symbol name');
         if (kind === 'method')
-            return Promise.resolve(this.grepFindSymbol(name, project, kind));
+            return this.grepFindSymbol(name, project, kind);
         return this.findSymbolFromIndex(name, project, kind);
     }
     async findSymbolFromIndex(name, project, kind) {
@@ -385,29 +480,25 @@ class SearcherService {
             return this.grepFindSymbol(name, project, kind);
         }
     }
-    grepFindSymbol(name, project, kind) {
+    async grepFindSymbol(name, project, kind) {
         const t0 = Date.now();
         this.logger.debug('SearcherService: findSymbol', { name, project, kind, source: 'grep' });
         const searchDir = project
-            ? path.join(this.config.workspaceRoot, project)
+            ? this.resolveProjectRoot(project)
             : this.config.workspaceRoot;
         const pattern = this.buildFindSymbolPattern(name, kind);
-        const result = (0, child_process_1.spawnSync)('grep', [
+        const result = await this.spawnGrep([
             '-rn', '-E',
             '-m', String(FIND_SYMBOL_RAW_LIMIT),
             '--include=*.ts', '--include=*.tsx', '--include=*.js', '--include=*.jsx',
             ...GREP_EXCLUDE_DIRS,
             pattern,
             searchDir,
-        ], { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
-        if (result.error) {
-            this.logger.error('SearcherService: grep failed', { method: 'findSymbol', reason: result.error.message });
-            return { hits: [], truncated: false };
-        }
-        if (!result.stdout)
+        ]);
+        if (!result)
             return { hits: [], truncated: false };
         const hits = [];
-        for (const raw of result.stdout.split('\n')) {
+        for (const raw of result.split('\n')) {
             if (hits.length >= FIND_SYMBOL_LIMIT)
                 break;
             const m = raw.match(/^(.+?):(\d+):(.*)$/);
@@ -434,7 +525,7 @@ class SearcherService {
     listFiles(relativePath, project, depth, pattern) {
         const t0 = Date.now();
         this.logger.debug('SearcherService: listFiles', { relativePath, project, depth, pattern });
-        const projectRoot = path.join(this.config.workspaceRoot, project);
+        const projectRoot = this.resolveProjectRoot(project);
         const resolvedTarget = path.resolve(projectRoot, relativePath);
         const resolvedProject = path.resolve(projectRoot);
         if (resolvedTarget !== resolvedProject && !resolvedTarget.startsWith(resolvedProject + path.sep)) {
@@ -512,25 +603,29 @@ class SearcherService {
         let lineNo = 0;
         let lastRead = 0;
         let hasMore = false;
-        for await (const line of rl) {
-            lineNo++;
-            if (lineNo >= startLine && lineNo <= endLine)
-                lines.push(line);
-            if (lineNo <= endLine)
-                lastRead = lineNo;
-            if (lineNo > endLine) {
-                hasMore = true;
-                rl.close();
-                stream.destroy();
-                break;
+        try {
+            for await (const line of rl) {
+                lineNo++;
+                if (lineNo >= startLine && lineNo <= endLine)
+                    lines.push(line);
+                if (lineNo <= endLine)
+                    lastRead = lineNo;
+                if (lineNo > endLine) {
+                    hasMore = true;
+                    rl.close();
+                    stream.destroy();
+                    break;
+                }
             }
         }
+        catch (err) {
+            rl.close();
+            stream.destroy();
+            throw err;
+        }
         this.logger.debug('SearcherService: readFileRange result', { linesRead: lines.length, hasMore, ms: Date.now() - t0 });
         return { ok: true, filePath, startLine, endLine: Math.min(endLine, lastRead), lines, hasMore };
     }
-    isNonEnglish(text) {
-        return /[^\x00-\x7F]/.test(text);
-    }
     walkDir(absDir, currentDepth, maxDepth, pattern, lines) {
         let entries;
         try {
@@ -590,5 +685,40 @@ class SearcherService {
             return 'method';
         return 'variable';
     }
+    /**
+     * Async wrapper around grep to avoid blocking the event loop.
+     * Returns stdout as a string, or null if grep returned no results or errored.
+     */
+    spawnGrep(args) {
+        return new Promise((resolve) => {
+            const proc = (0, child_process_1.spawn)('grep', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+            const chunks = [];
+            let totalBytes = 0;
+            const MAX_BUFFER = 10 * 1024 * 1024;
+            proc.stdout.on('data', (chunk) => {
+                totalBytes += chunk.length;
+                if (totalBytes <= MAX_BUFFER) {
+                    chunks.push(chunk);
+                }
+            });
+            proc.stderr.on('data', () => { });
+            proc.on('error', (err) => {
+                this.logger.error('SearcherService: grep spawn failed', { reason: err.message });
+                resolve(null);
+            });
+            proc.on('close', (code) => {
+                // grep returns 1 for "no matches" — not an error
+                if (code !== 0 && code !== 1) {
+                    this.logger.warn('SearcherService: grep exited with code', { code });
+                }
+                if (chunks.length === 0) {
+                    resolve(null);
+                }
+                else {
+                    resolve(Buffer.concat(chunks).toString('utf-8'));
+                }
+            });
+        });
+    }
 }
 exports.SearcherService = SearcherService;

package/dist/src/services/VoyageEmbedder.d.ts

@@ -0,0 +1,22 @@
+import type { Config } from '../config';
+import type { IEmbedder, InputType } from '../interfaces/IEmbedder';
+import type { ILogger } from '../interfaces/ILogger';
+import type { EmbedderDeps } from './OpenAICompatibleEmbedder';
+/**
+ * Voyage AI embedder. Voyage's schema differs from OpenAI's: `input` is an array
+ * of strings, `input_type` (`query` | `document`) is required for best quality,
+ * and the optional `output_dimension` requests Matryoshka truncation. Response
+ * is `{ data: [{ embedding, index }] }`.
+ */
+export declare class VoyageEmbedder implements IEmbedder {
+    private config;
+    private logger;
+    readonly dimensions: number;
+    rerank?: (query: string, documents: string[], topN: number) => Promise<number[]>;
+    private readonly url;
+    private readonly doFetch;
+    private readonly baseDelayMs?;
+    constructor(config: Config, logger?: ILogger, deps?: EmbedderDeps);
+    embed(text: string, inputType?: InputType): Promise<number[]>;
+    embedBatch(texts: string[], inputType?: InputType): Promise<number[][]>;
+}