codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

package/dist/src/services/SearcherService.js

@@ -1,1199 +0,0 @@
-"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.SearcherService = void 0;
-const fs = __importStar(require("fs"));
-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 MonorepoAwareDiscoveryService_1 = require("./MonorepoAwareDiscoveryService");
-const legacy_ollama_index_1 = require("./legacy-ollama-index");
-const symbol_name_1 = require("../symbol-name");
-const dependency_traversal_1 = require("../dependency-traversal");
-const SILENT_LOGGER = {
-    debug() { },
-    info() { },
-    warn() { },
-    error() { },
-    metric() { },
-};
-const NODE_FS = {
-    realpath: p => fs.promises.realpath(p),
-    stat: p => fs.promises.stat(p),
-    readdir: p => fs.promises.readdir(p, { withFileTypes: true }),
-    createReadStream: p => fs.createReadStream(p, { encoding: 'utf-8' }),
-};
-const GRAPHQL_KINDS = new Set([
-    'graphql_query', 'graphql_mutation', 'graphql_subscription', 'graphql_field', 'graphql_type',
-]);
-const EMPTY_META = { description: null, stack: null, notes: null, relations: null };
-const GREP_MAX_RESULTS = 200;
-const GREP_RAW_LIMIT = GREP_MAX_RESULTS * 5;
-const GREP_EXCLUDE_DIRS = [...file_utils_1.IGNORE_DIRS].map(d => `--exclude-dir=${d}`);
-const FIND_SYMBOL_LIMIT = 50;
-const FIND_SYMBOL_RAW_LIMIT = FIND_SYMBOL_LIMIT * 10;
-const PATH_CANDIDATE_LIMIT = 3;
-/** Every path column of the index; `content` marks those whose file the indexer read. */
-const INDEX_PATH_COLUMNS = [
-    { table: 'code_chunk', column: '"filePath"', content: true },
-    { table: 'code_symbol', column: '"filePath"', content: true },
-    { table: 'code_dependency', column: '"fromFile"', content: true },
-    { table: 'code_call', column: '"fromFile"', content: true },
-    { table: 'code_dependency', column: '"toFile"', content: false },
-    { table: 'code_call', column: '"calleeFile"', content: false },
-];
-const OUTSIDE_WORKSPACE_VALUE = (col) => `(${col} = '..' OR ${col} LIKE '../%')`;
-function stripTrailingSlash(p) {
-    return p.length > 1 && p.endsWith('/') ? p.slice(0, -1) : p;
-}
-/** Segment-boundary containment: `/ws-other` is not within `/ws`; `.` contains every relative path. */
-function isWithin(p, root) {
-    if (root === '.')
-        return true;
-    if (root === '/')
-        return p.startsWith('/');
-    return p === root || p.startsWith(root + '/');
-}
-function errorCode(err) {
-    return err?.code ?? 'EIO';
-}
-class SearcherService {
-    db;
-    embedder;
-    discovery;
-    config;
-    logger;
-    fs;
-    constructor(db, embedder, discovery, config, logger = SILENT_LOGGER, fsDeps = {}) {
-        this.db = db;
-        this.embedder = embedder;
-        this.discovery = discovery;
-        this.config = config;
-        this.logger = logger;
-        this.fs = { ...NODE_FS, ...fsDeps };
-    }
-    /**
-     * Whether `code_symbol.target` exists — `true` once a check finds it (never
-     * re-checked again in this process), `false` until then (re-checked on
-     * every lookup, so a `rag-index` run that adds the column takes effect
-     * without restarting `rag-mcp`). See "find_symbol works before the target
-     * column exists" (`graphql-symbols`).
-     */
-    targetColumnPresent = false;
-    /** Real path of `workspaceRoot`; cached only once resolved, so a transient failure is retried. */
-    realRootCache;
-    /** 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);
-    }
-    toRel(absPath) {
-        return path.relative(this.config.workspaceRoot, absPath) || '.';
-    }
-    toAbs(relPath) {
-        return relPath === '.' ? this.workspaceRoot() : path.join(this.workspaceRoot(), relPath);
-    }
-    workspaceRoot() {
-        return stripTrailingSlash(path.posix.normalize(this.config.workspaceRoot));
-    }
-    async realWorkspaceRoot() {
-        if (this.realRootCache !== undefined)
-            return this.realRootCache;
-        try {
-            this.realRootCache = await this.fs.realpath(this.workspaceRoot());
-            return this.realRootCache;
-        }
-        catch (err) {
-            this.logger.warn('SearcherService: workspaceRoot real path unavailable', { reason: errorCode(err) });
-            return null;
-        }
-    }
-    /**
-     * Lexical validation of a tool path argument: refusals for an empty value,
-     * `\`, an absolute path and a `..` escape; otherwise the canonical
-     * workspace-relative form. The only filesystem access is the cached real path
-     * of `workspaceRoot`.
-     */
-    async resolveToolPath(input) {
-        if (input == null || input === '')
-            return { ok: false, reason: 'invalid', missing: true };
-        if (input.includes('\\'))
-            return { ok: false, reason: 'invalid', missing: false };
-        if (path.posix.isAbsolute(input)) {
-            const abs = stripTrailingSlash(path.posix.normalize(input));
-            const realRoot = await this.realWorkspaceRoot();
-            for (const root of realRoot ? [this.workspaceRoot(), realRoot] : [this.workspaceRoot()]) {
-                if (!isWithin(abs, root))
-                    continue;
-                const relative = abs === root ? '.' : abs.slice(root === '/' ? 1 : root.length + 1);
-                return { ok: false, reason: 'absolute', relative };
-            }
-            return { ok: false, reason: 'outside_workspace' };
-        }
-        const relPath = stripTrailingSlash(path.posix.normalize(input));
-        if (relPath === '..' || relPath.startsWith('../'))
-            return { ok: false, reason: 'outside_workspace' };
-        return { ok: true, relPath, absPath: this.toAbs(relPath) };
-    }
-    /**
-     * Whether the real location of `absPath` — of the target, else of its nearest
-     * existing ancestor plus the remaining segments — lies under the real
-     * workspace root.
-     */
-    async realLocation(absPath) {
-        const root = (await this.realWorkspaceRoot()) ?? this.workspaceRoot();
-        let existing = absPath;
-        const rest = [];
-        for (;;) {
-            try {
-                const real = path.join(await this.fs.realpath(existing), ...rest);
-                return { ok: true, inside: isWithin(real, root) };
-            }
-            catch (err) {
-                if (errorCode(err) !== 'ENOENT')
-                    return { ok: false, code: errorCode(err) };
-                const parent = path.dirname(existing);
-                if (parent === existing)
-                    return { ok: true, inside: false };
-                rest.unshift(path.basename(existing));
-                existing = parent;
-            }
-        }
-    }
-    /**
-     * Workspace boundary of the disk tools. A real location outside the workspace
-     * is allowed only for content the indexer already read (a symlinked share):
-     * the file itself for `file`, any file below it for `dir`.
-     */
-    async checkRealLocation(relPath, absPath, kind) {
-        const loc = await this.realLocation(absPath);
-        if (!loc.ok)
-            return { ok: false, reason: 'unreadable', code: loc.code };
-        if (loc.inside)
-            return { ok: true };
-        const exempt = kind === 'file' ? await this.isContentPath(relPath) : await this.hasContentUnder(relPath);
-        return exempt ? { ok: true } : { ok: false, reason: 'outside_workspace' };
-    }
-    async pathExists(columns, predicate, param) {
-        const branches = columns.map(c => `SELECT 1 FROM ${c.table} WHERE ${predicate.replace(/\$col/g, c.column)}`);
-        const [{ exists }] = await this.db.query(`SELECT EXISTS (${branches.join(' UNION ALL ')}) AS exists`, [param]);
-        return exists;
-    }
-    /** Whether any table of the index holds `relPath` (a canonical path, never `../…`). */
-    isIndexedPath(relPath) {
-        return this.pathExists(INDEX_PATH_COLUMNS, '$col = $1', relPath);
-    }
-    /** Whether the indexer read the file at `relPath`. */
-    isContentPath(relPath) {
-        return this.pathExists(INDEX_PATH_COLUMNS.filter(c => c.content), '$col = $1', relPath);
-    }
-    hasContentUnder(relPath) {
-        const prefix = relPath === '.' ? '' : (0, symbol_name_1.escapeLike)(relPath) + '/';
-        return this.pathExists(INDEX_PATH_COLUMNS.filter(c => c.content), `$col LIKE $1 ESCAPE '\\'`, prefix + '%');
-    }
-    /**
-     * Up to three index paths ending in `/<relPath>` (`file`) or directories
-     * ending in `/<relPath>` that hold one (`dir`), in byte order. For `dir`, the
-     * root of a project named `relPath` comes first.
-     */
-    async findPathCandidates(relPath, kind) {
-        const union = INDEX_PATH_COLUMNS.map(c => `SELECT ${c.column} AS p FROM ${c.table}`).join(' UNION ALL ');
-        const notOutside = `NOT ${OUTSIDE_WORKSPACE_VALUE('p')}`;
-        if (kind === 'file') {
-            const substituted = await this.substituteProjectName(relPath);
-            const rows = await this.db.query(`SELECT p FROM (${union}) s
-         WHERE p LIKE $1 ESCAPE '\\' AND ${notOutside}
-         GROUP BY p ORDER BY p COLLATE "C" LIMIT ${PATH_CANDIDATE_LIMIT + 1}`, ['%/' + (0, symbol_name_1.escapeLike)(relPath)]);
-            const first = substituted ? [substituted] : [];
-            return [...first, ...rows.map(r => r.p).filter(p => p !== substituted)].slice(0, PATH_CANDIDATE_LIMIT);
-        }
-        const projectRoot = this.findProjectRootByName(relPath);
-        const first = projectRoot && projectRoot !== relPath ? [projectRoot] : [];
-        const rows = await this.db.query(`SELECT d AS p FROM (
-         SELECT substring(p FROM 1 FOR position($2::text IN p) + length($3::text)) AS d
-         FROM (${union}) s
-         WHERE p LIKE $1 ESCAPE '\\' AND ${notOutside}
-       ) dirs
-       GROUP BY d ORDER BY d COLLATE "C" LIMIT ${PATH_CANDIDATE_LIMIT + 1}`, ['%/' + (0, symbol_name_1.escapeLike)(relPath) + '/%', '/' + relPath + '/', relPath]);
-        const rest = rows.map(r => r.p).filter(p => !first.includes(p));
-        return [...first, ...rest].slice(0, PATH_CANDIDATE_LIMIT);
-    }
-    /** `findPathCandidates`, with a failed lookup logged and answered by no candidates. */
-    async candidatesOrNone(relPath, kind) {
-        try {
-            return await this.findPathCandidates(relPath, kind);
-        }
-        catch (err) {
-            this.logger.error('SearcherService: path candidate lookup failed', { relPath, reason: err.message });
-            return [];
-        }
-    }
-    /**
-     * `relPath` with a leading project name replaced by that project's root
-     * (`repo/app/src/x.ts` → `repo/apps/app/src/x.ts`), or null when no name
-     * prefixes it, the root equals the name, or the result names nothing.
-     */
-    async substituteProjectName(relPath) {
-        let named = [];
-        for (let attempt = 0; attempt < 2 && named.length === 0; attempt++) {
-            if (attempt === 1)
-                this.rootMap = undefined;
-            named = [...this.projectRootMap().entries()].filter(([name]) => relPath.startsWith(name + '/'));
-        }
-        const longest = named.sort((a, b) => b[0].length - a[0].length)[0];
-        if (!longest)
-            return null;
-        const [name, absRoot] = longest;
-        const root = this.toRel(absRoot);
-        if (root === name)
-            return null;
-        const candidate = (root === '.' ? '' : root + '/') + relPath.slice(name.length + 1);
-        if (await this.isIndexedPath(candidate))
-            return candidate;
-        try {
-            return (await this.fs.stat(this.toAbs(candidate))).isFile() ? candidate : null;
-        }
-        catch {
-            return null;
-        }
-    }
-    findProjectRootByName(name) {
-        let root = this.projectRootMap().get(name);
-        if (root === undefined) {
-            this.rootMap = undefined;
-            root = this.projectRootMap().get(name);
-        }
-        return root === undefined ? null : this.toRel(root);
-    }
-    /** Longest workspace-relative project root accepted by `match`; discovery is re-run once before giving up. */
-    findProjectRoot(match) {
-        for (let attempt = 0; attempt < 2; attempt++) {
-            if (attempt === 1)
-                this.rootMap = undefined;
-            const best = [...this.projectRootMap().entries()]
-                .map(([name, abs]) => ({ name, rel: this.toRel(abs) }))
-                .filter(r => match(r.rel))
-                .sort((a, b) => b.rel.length - a.rel.length)[0];
-            if (best)
-                return best;
-        }
-        return null;
-    }
-    /** Root directory (workspace-relative) of the project the text-search fallback for `relPath` runs in. */
-    fallbackRoot(relPath) {
-        return this.findProjectRoot(r => isWithin(relPath, r))?.rel ?? null;
-    }
-    /**
-     * Why a graph tool has no data for `relPath`, or null when the path is in the
-     * index path set. Touches the disk only for an unknown path, and answers a
-     * real location outside the workspace as `not_found` without looking at it.
-     */
-    async checkGraphPath(relPath) {
-        if (await this.isIndexedPath(relPath))
-            return null;
-        const absPath = this.toAbs(relPath);
-        const loc = await this.realLocation(absPath);
-        if (!loc.ok)
-            return { ok: false, reason: 'unreadable', code: loc.code };
-        if (!loc.inside)
-            return { ok: false, reason: 'not_found', candidates: await this.candidatesOrNone(relPath, 'file') };
-        let stat;
-        try {
-            stat = await this.fs.stat(absPath);
-        }
-        catch (err) {
-            if (errorCode(err) !== 'ENOENT')
-                return { ok: false, reason: 'unreadable', code: errorCode(err) };
-            return { ok: false, reason: 'not_found', candidates: await this.candidatesOrNone(relPath, 'file') };
-        }
-        if (!stat.isFile())
-            return { ok: false, reason: 'not_a_file' };
-        return { ok: false, reason: 'not_indexed', explanation: await this.explainNotIndexed(relPath) };
-    }
-    async explainNotIndexed(relPath) {
-        const owner = this.findProjectRoot(r => r !== relPath && isWithin(relPath, r));
-        if (!owner)
-            return { kind: 'no_project' };
-        const inProject = owner.rel === '.' ? relPath : relPath.slice(owner.rel.length + 1);
-        const exclusion = (0, file_utils_1.indexingExclusion)(inProject, (0, file_utils_1.loadIgnore)(this.toAbs(owner.rel)));
-        if (exclusion)
-            return exclusion;
-        const [{ exists }] = await this.db.query(`SELECT EXISTS (
-         SELECT 1 FROM code_chunk WHERE "serviceName" = $1
-         UNION ALL SELECT 1 FROM code_symbol WHERE project = $1
-         UNION ALL SELECT 1 FROM code_dependency WHERE project = $1
-         UNION ALL SELECT 1 FROM code_call WHERE project = $1
-       ) AS exists`, [owner.name]);
-        return exists ? { kind: 'unknown' } : { kind: 'project_not_indexed', project: owner.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 });
-        }
-        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` row with an empty (or altogether absent) `code_chunk`
-     * does not block — but a *populated* `code_chunk` with no `index_meta` row is a
-     * pre-`index_meta` install, treated as the legacy `ollama`/`bge-m3` index (same
-     * interpretation as the `rag-index` legacy-Ollama guard), read-only — this check
-     * never writes `index_meta`.
-     */
-    async assertIndexMatches() {
-        const meta = await this.db.readIndexMeta();
-        if (meta) {
-            this.compareIndexed(meta.provider, meta.model, meta.dimensions);
-            return;
-        }
-        // No row — a missing code_chunk table counts as empty; any other DB error
-        // while counting propagates rather than being read as "not indexed".
-        if (await (0, legacy_ollama_index_1.hasIndexedChunks)(this.db)) {
-            this.compareIndexed(legacy_ollama_index_1.LEGACY_OLLAMA_IDENTITY.provider, legacy_ollama_index_1.LEGACY_OLLAMA_IDENTITY.model, null);
-        }
-    }
-    compareIndexed(indexedProvider, indexedModel, indexedDimensions) {
-        const { provider, model } = this.config.embedding;
-        if (indexedProvider !== provider || indexedModel !== model) {
-            throw new Error(`Index was built with ${indexedProvider}/${indexedModel} 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).
-        // `indexedDimensions` is null for the legacy-inferred identity, whose provider
-        // can never match a configured provider (ollama is no longer selectable), so
-        // this branch is unreached in that case.
-        const dim = this.embedder.dimensions;
-        if (indexedDimensions != null && dim > 0 && dim !== indexedDimensions) {
-            throw new Error(`Index was built at ${indexedDimensions} 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 Promise.all(rows.map(async (r) => {
-            const projectRoot = this.resolveProjectRoot(r.serviceName);
-            const meta = (0, file_utils_1.readRagMeta)(projectRoot);
-            let rootError = null;
-            try {
-                await this.fs.stat(projectRoot);
-            }
-            catch (err) {
-                rootError = errorCode(err);
-            }
-            return {
-                ...r, path: projectRoot, relPath: this.toRel(projectRoot), rootError,
-                ...(typeof meta === 'object' ? meta : EMPTY_META),
-            };
-        }));
-    }
-    async searchChunks(query, limit, project, threshold, rerankOverride) {
-        const t0 = Date.now();
-        await this.assertIndexMatches();
-        const effectiveThreshold = threshold ?? this.config.search.similarityThreshold;
-        const reranking = rerankOverride === false ? false : !!this.embedder.rerank;
-        // Candidate floor: decouple the pool size from `limit` so a small `limit`
-        // (e.g. the default 5) still gives the reranker a large-enough menu. Without
-        // a reranker the extra candidates are never reordered, so keep `limit`.
-        const fetchLimit = reranking
-            ? Math.min(Math.max(limit * this.config.reranker.overfetch, this.config.reranker.candidateFloor), 200)
-            : limit;
-        // With metrics on, fetch one extra row to detect a saturated pool (more
-        // under-threshold candidates existed than the window took). The extra row is
-        // dropped before reranking so it never affects results.
-        const metricsOn = this.config.logging.searchMetrics;
-        const dbLimit = metricsOn ? fetchLimit + 1 : fetchLimit;
-        this.logger.debug('SearcherService: searchChunks', {
-            query: query.slice(0, 120), limit, fetchLimit, project, threshold: effectiveThreshold,
-        });
-        const tEmbed0 = Date.now();
-        const embedding = await this.embedder.embed(query, 'query');
-        const embedMs = Date.now() - tEmbed0;
-        const params = [`[${embedding}]`, effectiveThreshold, dbLimit];
-        let projectFilter = '';
-        if (project) {
-            params.push(project);
-            projectFilter = `AND "serviceName" = $${params.length}`;
-        }
-        const tDb0 = Date.now();
-        const fetched = 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
-       ${projectFilter}
-       ORDER BY embedding <=> $1
-       LIMIT $3`, params);
-        const dbMs = Date.now() - tDb0;
-        // Saturated iff the extra probe row came back — more candidates were under
-        // the threshold than `fetchLimit`. Trim the probe row before reranking.
-        const poolSaturated = metricsOn && fetched.length > fetchLimit;
-        const candidates = fetched.slice(0, fetchLimit);
-        this.logger.debug('SearcherService: searchChunks candidates', {
-            count: candidates.length,
-            scores: candidates.map(r => r.score),
-            files: candidates.map(r => r.filePath),
-            ms: Date.now() - t0,
-        });
-        let results;
-        let rerankMs = 0;
-        if (!reranking || candidates.length === 0) {
-            results = candidates.slice(0, limit);
-        }
-        else {
-            const tRerank0 = Date.now();
-            try {
-                const indices = await this.embedder.rerank(query, candidates.map(r => r.content), limit);
-                rerankMs = Date.now() - tRerank0;
-                this.logger.debug('SearcherService: searchChunks rerank done', { indices, ms: Date.now() - t0 });
-                // Cap at `limit`: some rerank servers ignore `top_n` and echo back every
-                // candidate, so slicing here keeps the result count within the request.
-                results = indices.filter(i => i >= 0 && i < candidates.length).slice(0, limit).map(i => candidates[i]);
-            }
-            catch (err) {
-                rerankMs = Date.now() - tRerank0;
-                this.logger.warn('SearcherService: rerank failed, falling back to vector order', {
-                    reason: err instanceof Error ? err.message : String(err),
-                    ms: Date.now() - t0,
-                });
-                results = candidates.slice(0, limit);
-            }
-        }
-        if (metricsOn) {
-            this.emitSearchMetrics(query, {
-                fetchLimit, candidates, results, poolSaturated, embedMs, dbMs, rerankMs, totalMs: Date.now() - t0,
-            });
-        }
-        return results;
-    }
-    /**
-     * Emit one structured search-tuning line (via `logger.metric`, at `info`
-     * regardless of `logging.level`). `candidates` are in cosine order, so a
-     * candidate's array index is its cosine rank — `maxCosineRankSurvived` is the
-     * deepest cosine position that survived reranking into the returned set. Read
-     * it alongside `poolSaturated` to tune `candidateFloor`/`overfetch`/threshold
-     * per hardware. Never logs chunk content, embeddings, or credentials.
-     */
-    emitSearchMetrics(query, m) {
-        const { candidates, results } = m;
-        const contentIndex = new Map(candidates.map((c, i) => [c, i]));
-        const maxCosineRankSurvived = results.reduce((max, r) => Math.max(max, contentIndex.get(r) ?? -1), -1);
-        const fileCounts = new Map();
-        for (const r of results)
-            fileCounts.set(r.filePath, (fileCounts.get(r.filePath) ?? 0) + 1);
-        const topFileCount = results.length ? Math.max(...fileCounts.values()) : 0;
-        this.logger.metric('search metrics', {
-            query: query.slice(0, 120),
-            fetchLimit: m.fetchLimit,
-            candidatesReturned: candidates.length,
-            poolSaturated: m.poolSaturated,
-            maxCosineRankSurvived,
-            resultCount: results.length,
-            distinctFilesInResult: fileCounts.size,
-            topFileShare: results.length ? +(topFileCount / results.length).toFixed(3) : 0,
-            bestResultScore: results.length ? Math.min(...results.map(r => r.score)) : null,
-            worstResultScore: results.length ? Math.max(...results.map(r => r.score)) : null,
-            embedMs: m.embedMs,
-            rerankMs: m.rerankMs,
-            dbMs: m.dbMs,
-            totalMs: m.totalMs,
-        });
-    }
-    async fetchNeighbors(results) {
-        const t0 = Date.now();
-        if (results.length === 0)
-            return [];
-        this.logger.debug('SearcherService: fetchNeighbors', { count: results.length });
-        const values = results.map((_, i) => `(${i}, $${i * 2 + 1}, $${i * 2 + 2}::int)`).join(',');
-        const params = results.flatMap(r => [r.filePath, r.startLine]);
-        const rows = await this.db.query(`SELECT r.idx,
-              prev."serviceName" AS prev_sn, prev."filePath" AS prev_fp, prev."startLine" AS prev_sl, prev.content AS prev_c,
-              next."serviceName" AS next_sn, next."filePath" AS next_fp, next."startLine" AS next_sl, next.content AS next_c
-       FROM (VALUES ${values}) r(idx, fp, sl)
-       LEFT JOIN LATERAL (
-         SELECT "serviceName", "filePath", "startLine", content
-         FROM code_chunk WHERE "filePath" = r.fp AND "startLine" < r.sl
-         ORDER BY "startLine" DESC LIMIT 1
-       ) prev ON true
-       LEFT JOIN LATERAL (
-         SELECT "serviceName", "filePath", "startLine", content
-         FROM code_chunk WHERE "filePath" = r.fp AND "startLine" > r.sl
-         ORDER BY "startLine" ASC LIMIT 1
-       ) next ON true
-       ORDER BY r.idx`, params);
-        const neighbors = rows.map((row, i) => ({
-            result: results[i],
-            prevChunk: row.prev_fp ? { serviceName: row.prev_sn, filePath: row.prev_fp, startLine: row.prev_sl, content: row.prev_c } : null,
-            nextChunk: row.next_fp ? { serviceName: row.next_sn, filePath: row.next_fp, startLine: row.next_sl, content: row.next_c } : null,
-        }));
-        this.logger.debug('SearcherService: fetchNeighbors result', {
-            withPrev: neighbors.filter(n => n.prevChunk).length,
-            withNext: neighbors.filter(n => n.nextChunk).length,
-            ms: Date.now() - t0,
-        });
-        return neighbors;
-    }
-    async fetchGraphContext(results) {
-        const t0 = Date.now();
-        const files = [...new Set(results.map(r => r.filePath))];
-        this.logger.debug('SearcherService: fetchGraphContext', { files: files.length });
-        if (files.length === 0)
-            return new Map();
-        // Use proportional limit: 50 imports + 50 usedBy per file
-        const proportionalLimit = Math.max(2000, files.length * 100);
-        const values = files.map((_, i) => `($${i + 1}::text)`).join(', ');
-        const rows = await this.db.query(`SELECT r.fp AS "filePath", 'import' AS direction, d."toFile" AS related
-         FROM (VALUES ${values}) AS r(fp)
-         JOIN code_dependency d ON d."fromFile" = r.fp
-         WHERE NOT ${OUTSIDE_WORKSPACE_VALUE('d."toFile"')}
-
-         UNION ALL
-
-         SELECT r.fp AS "filePath", 'usedby' AS direction, d."fromFile" AS related
-         FROM (VALUES ${values}) AS r(fp)
-         JOIN code_dependency d ON d."toFile" = r.fp
-         WHERE NOT ${OUTSIDE_WORKSPACE_VALUE('d."fromFile"')}
-
-         LIMIT ${proportionalLimit}`, files);
-        const ctx = new Map();
-        for (const filePath of files)
-            ctx.set(filePath, { imports: new Set(), usedBy: new Set() });
-        for (const row of rows) {
-            const g = ctx.get(row.filePath);
-            if (row.direction === 'import')
-                g.imports.add(row.related);
-            else
-                g.usedBy.add(row.related);
-        }
-        this.logger.debug('SearcherService: fetchGraphContext result', { files: files.length, rows: rows.length, ms: Date.now() - t0 });
-        const result = new Map();
-        for (const [fp, g] of ctx)
-            result.set(fp, {
-                imports: [...g.imports].slice(0, 50),
-                usedBy: [...g.usedBy].slice(0, 50),
-            });
-        return result;
-    }
-    async getDependencies(filePath, symbol = null, transitive = false) {
-        const t0 = Date.now();
-        this.logger.debug('SearcherService: getDependencies', { filePath, symbol, transitive });
-        const params = [filePath];
-        let symbolFilter = '';
-        if (symbol) {
-            params.push(symbol);
-            symbolFilter = `AND "toSymbol" = $${params.length}`;
-        }
-        const direct = await this.db.query(`SELECT DISTINCT "fromFile", "fromSymbol", "toFile", "toSymbol", "depType"
-       FROM code_dependency
-       WHERE "fromFile" = $1 AND NOT ${OUTSIDE_WORKSPACE_VALUE('"toFile"')}
-       ${symbolFilter}
-       ORDER BY "toFile"`, params);
-        if (!transitive) {
-            this.logger.debug('SearcherService: getDependencies result', { direct: direct.length, ms: Date.now() - t0 });
-            return direct;
-        }
-        const neighbours = async (frontier) => {
-            const rows = await this.db.query(`SELECT DISTINCT "fromFile", "toFile" FROM code_dependency
-         WHERE "fromFile" = ANY($1::text[]) AND NOT ${OUTSIDE_WORKSPACE_VALUE('"toFile"')}`, [frontier]);
-            return rows.map(r => ({ from: r.fromFile, to: r.toFile }));
-        };
-        const indirect = (await (0, dependency_traversal_1.traverse)(filePath, neighbours)).map(r => ({
-            toFile: r.file, depth: r.depth, via: r.via,
-            fromFile: null, fromSymbol: null, toSymbol: null, depType: null,
-        }));
-        this.logger.debug('SearcherService: getDependencies result', { direct: direct.length, indirect: indirect.length, ms: Date.now() - t0 });
-        return [...direct, ...indirect];
-    }
-    async getDependents(filePath, symbol = null, transitive = false) {
-        const t0 = Date.now();
-        this.logger.debug('SearcherService: getDependents', { filePath, symbol, transitive });
-        const params = [filePath];
-        let symbolFilter = '';
-        if (symbol) {
-            params.push(symbol);
-            symbolFilter = `AND "toSymbol" = $${params.length}`;
-        }
-        const direct = await this.db.query(`SELECT DISTINCT "fromFile", "fromSymbol", "toFile", "toSymbol", "depType"
-       FROM code_dependency
-       WHERE "toFile" = $1 AND NOT ${OUTSIDE_WORKSPACE_VALUE('"fromFile"')}
-       ${symbolFilter}
-       ORDER BY "fromFile"`, params);
-        if (!transitive) {
-            this.logger.debug('SearcherService: getDependents result', { direct: direct.length, ms: Date.now() - t0 });
-            return direct;
-        }
-        const neighbours = async (frontier) => {
-            const rows = await this.db.query(`SELECT DISTINCT "fromFile", "toFile" FROM code_dependency
-         WHERE "toFile" = ANY($1::text[]) AND NOT ${OUTSIDE_WORKSPACE_VALUE('"fromFile"')}`, [frontier]);
-            return rows.map(r => ({ from: r.toFile, to: r.fromFile }));
-        };
-        const indirect = (await (0, dependency_traversal_1.traverse)(filePath, neighbours)).map(r => ({
-            fromFile: r.file, depth: r.depth, via: r.via,
-            toFile: null, fromSymbol: null, toSymbol: null, depType: null,
-        }));
-        this.logger.debug('SearcherService: getDependents result', { direct: direct.length, indirect: indirect.length, ms: Date.now() - t0 });
-        return [...direct, ...indirect];
-    }
-    async getCallers(symbol, project, calleeFile = null) {
-        const t0 = Date.now();
-        this.logger.debug('SearcherService: getCallers', { symbol, project, calleeFile });
-        const parsed = (0, symbol_name_1.parseCallerSymbol)(symbol);
-        if (!parsed)
-            throw new Error('Invalid symbol name');
-        const params = [project];
-        let nameFilter;
-        if (parsed.form === 'bare') {
-            params.push(parsed.name);
-            nameFilter = `"calleeName" = $${params.length}`;
-        }
-        else {
-            params.push(`${parsed.container}.${parsed.name}`);
-            const exactParam = params.length;
-            params.push(`%.${(0, symbol_name_1.escapeLike)(parsed.container)}.${(0, symbol_name_1.escapeLike)(parsed.name)}`);
-            const suffixParam = params.length;
-            nameFilter = `("calleeSymbol" = $${exactParam} OR "calleeSymbol" LIKE $${suffixParam} ESCAPE '\\')`;
-        }
-        let fileFilter = '';
-        if (calleeFile) {
-            params.push(calleeFile);
-            fileFilter = `AND "calleeFile" = $${params.length}`;
-        }
-        const rows = await this.db.query(`SELECT "fromFile", "fromSymbol", "calleeName", "calleeFile", line
-       FROM code_call
-       WHERE project = $1 AND ${nameFilter}
-       ${fileFilter}
-       ORDER BY "fromFile", line
-       LIMIT 200`, params);
-        this.logger.debug('SearcherService: getCallers result', { count: rows.length, ms: Date.now() - t0 });
-        return rows;
-    }
-    /**
-     * Whole-word text search for `symbol` under `rootDir` (workspace-relative).
-     * grep exiting ≥ 2 after printing matches is a partial result; without
-     * matches, or when grep cannot be spawned, the search failed.
-     */
-    async grepSymbol(symbol, rootDir, excludeFile) {
-        const t0 = Date.now();
-        this.logger.debug('SearcherService: grepSymbol', { symbol, rootDir, excludeFile });
-        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,
-            this.toAbs(rootDir),
-        ]);
-        if (!result.ok && result.output === null)
-            return { ok: false };
-        const excludeAbsPath = path.join(this.config.workspaceRoot, excludeFile);
-        const all = (result.output ?? '').split('\n').flatMap(line => {
-            const match = line.match(/^(.+?):(\d+):/);
-            if (!match)
-                return [];
-            const [, absFile, lineNum] = match;
-            if (absFile === excludeAbsPath)
-                return [];
-            return [{ filePath: path.relative(this.config.workspaceRoot, absFile), line: parseInt(lineNum, 10) }];
-        });
-        const truncated = all.length > GREP_MAX_RESULTS;
-        this.logger.debug('SearcherService: grepSymbol result', { matches: Math.min(all.length, GREP_MAX_RESULTS), truncated, partial: !result.ok, ms: Date.now() - t0 });
-        return { ok: true, matches: all.slice(0, GREP_MAX_RESULTS), truncated, partial: !result.ok };
-    }
-    // Sync wrapper: validates name (throws synchronously), then returns Promise.
-    // Every kind, including 'method', is looked up in the index first.
-    findSymbol(name, project, kind) {
-        const parsed = (0, symbol_name_1.parseFindSymbolName)(name);
-        if (!parsed)
-            throw new Error('Invalid symbol name');
-        return this.findSymbolFromIndex(parsed, project, kind);
-    }
-    /**
-     * Whether `code_symbol.target` exists. A present result is cached for the
-     * process; an absent one is re-checked on every call. Propagates on a
-     * failing check, same as any other failed index query.
-     */
-    async hasTargetColumn() {
-        if (this.targetColumnPresent)
-            return true;
-        const rows = await this.db.query(`SELECT EXISTS (
-         SELECT 1 FROM information_schema.columns
-         WHERE table_schema = 'public' AND table_name = 'code_symbol' AND column_name = 'target'
-       ) AS present`);
-        const present = !!rows[0]?.present;
-        if (present)
-            this.targetColumnPresent = true;
-        return present;
-    }
-    async findSymbolFromIndex(parsed, project, kind) {
-        const t0 = Date.now();
-        this.logger.debug('SearcherService: findSymbol', { parsed, project, kind, source: 'index' });
-        const container = 'container' in parsed ? parsed.container : null;
-        const isGraphqlKind = GRAPHQL_KINDS.has(kind);
-        try {
-            const hasTarget = await this.hasTargetColumn();
-            const params = [parsed.name];
-            let nameFilter = 'name = $1';
-            let orderPrefix = '';
-            if (container !== null) {
-                params.push(container);
-                const exactParam = params.length;
-                params.push(`%.${(0, symbol_name_1.escapeLike)(container)}`);
-                const suffixParam = params.length;
-                nameFilter += ` AND (container = $${exactParam} OR container LIKE $${suffixParam} ESCAPE '\\')`;
-                orderPrefix = `(CASE WHEN container = $${exactParam} THEN 0 ELSE 1 END), `;
-            }
-            let projectFilter = '';
-            if (project) {
-                params.push(project);
-                projectFilter = `AND project = $${params.length}`;
-            }
-            let kindFilter = '';
-            if (kind !== 'all') {
-                params.push(kind);
-                kindFilter = `AND kind = $${params.length}`;
-            }
-            params.push(FIND_SYMBOL_LIMIT + 1);
-            const targetSelect = hasTarget ? '"target"' : 'NULL AS target';
-            const rows = await this.db.query(`SELECT "filePath", name, kind, signature, line, col, container, "isStatic", ${targetSelect}
-         FROM code_symbol
-         WHERE ${nameFilter} ${projectFilter} ${kindFilter}
-         ORDER BY ${orderPrefix}project, "filePath", line, col, kind COLLATE "C", container COLLATE "C" NULLS FIRST
-         LIMIT $${params.length}`, params);
-            const truncated = rows.length > FIND_SYMBOL_LIMIT;
-            const hits = rows.slice(0, FIND_SYMBOL_LIMIT).map(row => ({
-                filePath: row.filePath,
-                line: row.line ?? 1,
-                column: row.col ?? 1,
-                kind: row.kind,
-                signature: row.signature ?? row.name,
-                qualified: row.container ? `${row.container}.${row.name}` : row.name,
-                isStatic: !!row.isStatic,
-                source: 'index',
-                target: row.target ?? null,
-            }));
-            this.logger.debug('SearcherService: findSymbol result', { source: 'index', hits: hits.length, truncated, ms: Date.now() - t0 });
-            if (hits.length > 0)
-                return { hits, truncated, grepFailed: false };
-            // GraphQL kinds never grep — an empty result just means no row yet (stale index).
-            if (isGraphqlKind)
-                return { hits: [], truncated: false, grepFailed: false };
-            if (parsed.form === 'quoted' || parsed.form === 'computed')
-                return { hits: [], truncated: false, grepFailed: false };
-            return this.grepFindSymbol(parsed, project, kind);
-        }
-        catch (err) {
-            this.logger.warn('SearcherService: symbol index unavailable', { reason: err.message, ms: Date.now() - t0 });
-            // GraphQL kinds never grep — a failing index query propagates as an error response instead.
-            if (isGraphqlKind)
-                throw err;
-            if (parsed.form === 'quoted' || parsed.form === 'computed')
-                return { hits: [], truncated: false, grepFailed: false };
-            return this.grepFindSymbol(parsed, project, kind);
-        }
-    }
-    async grepFindSymbol(parsed, project, kind) {
-        const t0 = Date.now();
-        const grepName = parsed.name; // qualified names are grepped by their last segment, no container filter
-        this.logger.debug('SearcherService: findSymbol', { grepName, project, kind, source: 'grep' });
-        const pattern = this.buildFindSymbolPattern(grepName, kind);
-        if (pattern === null)
-            return { hits: [], truncated: false, grepFailed: false };
-        const searchDir = project
-            ? this.resolveProjectRoot(project)
-            : this.config.workspaceRoot;
-        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,
-        ]);
-        if (!result.ok) {
-            this.logger.warn('SearcherService: findSymbol grep failed', { grepName, project });
-            return { hits: [], truncated: false, grepFailed: true };
-        }
-        if (result.output === null)
-            return { hits: [], truncated: false, grepFailed: false };
-        const parsedHits = [];
-        for (const raw of result.output.split('\n')) {
-            const m = raw.match(/^(.+?):(\d+):(.*)$/);
-            if (!m)
-                continue;
-            const [, absFile, lineNumStr, matchedLine] = m;
-            const lineNum = parseInt(lineNumStr, 10);
-            if (isNaN(lineNum))
-                continue;
-            const col = SearcherService.wholeWordIndex(matchedLine, grepName);
-            if (col === -1)
-                continue;
-            parsedHits.push({
-                filePath: path.relative(this.config.workspaceRoot, absFile),
-                line: lineNum,
-                column: col + 1,
-                kind: this.inferKind(matchedLine, grepName),
-                signature: matchedLine.trim(),
-                qualified: grepName,
-                isStatic: false,
-                source: 'grep',
-                target: null,
-            });
-        }
-        const truncated = parsedHits.length > FIND_SYMBOL_LIMIT;
-        this.logger.debug('SearcherService: findSymbol result', { source: 'grep', hits: Math.min(parsedHits.length, FIND_SYMBOL_LIMIT), truncated, ms: Date.now() - t0 });
-        return { hits: parsedHits.slice(0, FIND_SYMBOL_LIMIT), truncated, grepFailed: false };
-    }
-    async listFiles(relPath, depth, pattern) {
-        const t0 = Date.now();
-        this.logger.debug('SearcherService: listFiles', { relPath, depth, pattern });
-        const absPath = this.toAbs(relPath);
-        const loc = await this.checkRealLocation(relPath, absPath, 'dir');
-        if (!loc.ok)
-            return loc;
-        let stat;
-        try {
-            stat = await this.fs.stat(absPath);
-        }
-        catch (err) {
-            if (errorCode(err) !== 'ENOENT')
-                return { ok: false, reason: 'unreadable', code: errorCode(err) };
-            return { ok: false, reason: 'not_found', candidates: await this.candidatesOrNone(relPath, 'dir') };
-        }
-        if (!stat.isDirectory())
-            return { ok: false, reason: 'not_a_directory' };
-        const clampedDepth = Math.min(5, Math.max(1, depth));
-        const lines = [];
-        try {
-            await this.walkDir(absPath, 0, clampedDepth - 1, pattern, lines);
-        }
-        catch (err) {
-            return { ok: false, reason: 'unreadable', code: errorCode(err) };
-        }
-        this.logger.debug('SearcherService: listFiles result', { entries: lines.length, ms: Date.now() - t0 });
-        if (lines.length === 0) {
-            return { ok: true, tree: pattern ? `No files matching "${pattern}" found.` : '(empty directory)' };
-        }
-        return { ok: true, tree: lines.join('\n') };
-    }
-    /**
-     * The read tools' common front: workspace boundary, then existence and type.
-     * A missing file still in the index is `deleted`; otherwise `not_found`.
-     */
-    async openableFile(relPath, absPath) {
-        const loc = await this.checkRealLocation(relPath, absPath, 'file');
-        if (!loc.ok)
-            return loc;
-        let stat;
-        try {
-            stat = await this.fs.stat(absPath);
-        }
-        catch (err) {
-            if (errorCode(err) !== 'ENOENT')
-                return { ok: false, reason: 'unreadable', code: errorCode(err) };
-            if (await this.isIndexedPath(relPath))
-                return { ok: false, reason: 'deleted' };
-            return { ok: false, reason: 'not_found', candidates: await this.candidatesOrNone(relPath, 'file') };
-        }
-        // Checked before opening: a FIFO or device would block the reader.
-        return stat.isFile() ? null : { ok: false, reason: 'not_a_file' };
-    }
-    /**
-     * Streams the file's lines (as `readline` yields them) to `onLine` until it
-     * returns false. An open or read error discards everything read so far.
-     */
-    async readLines(absPath, onLine) {
-        const stream = this.fs.createReadStream(absPath);
-        const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-        let lineNo = 0;
-        try {
-            for await (const line of rl) {
-                lineNo++;
-                if (!onLine(line, lineNo))
-                    break;
-            }
-            return { ok: true, lineCount: lineNo };
-        }
-        catch (err) {
-            return { ok: false, code: errorCode(err) };
-        }
-        finally {
-            rl.close();
-            stream.destroy?.();
-        }
-    }
-    async readFile(relPath, maxLines) {
-        const t0 = Date.now();
-        this.logger.debug('SearcherService: readFile', { relPath, maxLines });
-        const absPath = this.toAbs(relPath);
-        const failure = await this.openableFile(relPath, absPath);
-        if (failure)
-            return failure;
-        const lines = [];
-        let hasMore = false;
-        const read = await this.readLines(absPath, line => {
-            if (lines.length < maxLines) {
-                lines.push(line);
-                return true;
-            }
-            hasMore = true;
-            return false;
-        });
-        if (!read.ok)
-            return { ok: false, reason: 'unreadable', code: read.code };
-        this.logger.debug('SearcherService: readFile result', { linesRead: lines.length, hasMore, ms: Date.now() - t0 });
-        return { ok: true, filePath: relPath, startLine: 1, endLine: lines.length, lines, hasMore };
-    }
-    async readFileRange(relPath, startLine, endLine) {
-        const t0 = Date.now();
-        this.logger.debug('SearcherService: readFileRange', { relPath, startLine, endLine });
-        if (endLine < startLine)
-            return { ok: false, reason: 'bad_range', startLine, endLine };
-        const absPath = this.toAbs(relPath);
-        const failure = await this.openableFile(relPath, absPath);
-        if (failure)
-            return failure;
-        const lines = [];
-        let lastRead = 0;
-        let hasMore = false;
-        const read = await this.readLines(absPath, (line, lineNo) => {
-            if (lineNo > endLine) {
-                hasMore = true;
-                return false;
-            }
-            if (lineNo >= startLine)
-                lines.push(line);
-            lastRead = lineNo;
-            return true;
-        });
-        if (!read.ok)
-            return { ok: false, reason: 'unreadable', code: read.code };
-        if (!hasMore && startLine > Math.max(read.lineCount, 1)) {
-            return { ok: false, reason: 'past_end', lineCount: read.lineCount, startLine };
-        }
-        this.logger.debug('SearcherService: readFileRange result', { linesRead: lines.length, hasMore, ms: Date.now() - t0 });
-        return { ok: true, filePath: relPath, startLine, endLine: Math.min(endLine, lastRead), lines, hasMore };
-    }
-    /** Throws when `absDir` itself cannot be read; an unreadable subdirectory is marked in place. */
-    async walkDir(absDir, currentDepth, maxDepth, pattern, lines) {
-        const entries = await this.fs.readdir(absDir);
-        entries.sort((a, b) => {
-            const ad = a.isDirectory() ? 0 : 1;
-            const bd = b.isDirectory() ? 0 : 1;
-            if (ad !== bd)
-                return ad - bd;
-            return a.name.localeCompare(b.name);
-        });
-        for (const entry of entries) {
-            if (file_utils_1.IGNORE_DIRS.has(entry.name))
-                continue;
-            const indent = '  '.repeat(currentDepth);
-            if (entry.isDirectory()) {
-                const at = lines.push(`${indent}${entry.name}/`) - 1;
-                if (currentDepth < maxDepth) {
-                    try {
-                        await this.walkDir(path.join(absDir, entry.name), currentDepth + 1, maxDepth, pattern, lines);
-                    }
-                    catch {
-                        lines[at] += ' (unreadable)';
-                    }
-                }
-            }
-            else {
-                if (pattern && !entry.name.includes(pattern))
-                    continue;
-                lines.push(`${indent}${entry.name}`);
-            }
-        }
-    }
-    /**
-     * ERE pattern for a grep-fallback kind, or null when that kind is never
-     * grepped (`function_property`/`method_signature` are index-only; a bare
-     * `constructor` search only makes sense when the name itself is `constructor`).
-     */
-    buildFindSymbolPattern(name, kind) {
-        if (kind === 'function_property' || kind === 'method_signature')
-            return null;
-        if (GRAPHQL_KINDS.has(kind))
-            return null;
-        if (kind === 'constructor')
-            return name === 'constructor' ? `(^|[[:space:]])constructor[[:space:]]*\\(` : null;
-        const esc = name.replace(/\$/g, '\\$'); // ERE end-of-line metachar
-        const MODIFIER = '(public|private|protected|static|abstract|async|override)';
-        const BOUNDARY = '(^|[^[:alnum:]_$])';
-        const patterns = {
-            function: `(export[[:space:]]+)?(async[[:space:]]+)?function[[:space:]]+${esc}[[:space:](<]`,
-            class: `(export[[:space:]]+)?(abstract[[:space:]]+)?class[[:space:]]+${esc}[[:space:]{<]`,
-            type: `(export[[:space:]]+)?type[[:space:]]+${esc}[[:space:]=<]`,
-            interface: `(export[[:space:]]+)?interface[[:space:]]+${esc}[[:space:]{<]`,
-            variable: `(export[[:space:]]+)?(const|let|var)[[:space:]]+${esc}[[:space:]=:]`,
-            method: `${BOUNDARY}(${MODIFIER}[[:space:]]+)+\\*?[[:space:]]*${esc}[[:space:]]*[(<]`,
-            get_accessor: `(^|[[:space:]])get[[:space:]]+${esc}[[:space:]]*\\(`,
-            set_accessor: `(^|[[:space:]])set[[:space:]]+${esc}[[:space:]]*\\(`,
-        };
-        if (kind === 'all')
-            return Object.values(patterns).join('|');
-        return patterns[kind];
-    }
-    /** 1-based index of the first whole-word occurrence of `name` in `line`, or -1. */
-    static wholeWordIndex(line, name) {
-        const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const re = new RegExp(`(?<![\\w$#])${escaped}(?![\\w$#])`);
-        const m = re.exec(line);
-        return m ? m.index : -1;
-    }
-    inferKind(line, name) {
-        if (name === 'constructor')
-            return 'constructor';
-        const idx = SearcherService.wholeWordIndex(line, name);
-        const before = idx === -1 ? line : line.slice(0, idx);
-        const tokens = before.trim().split(/\s+/).filter(Boolean);
-        const last = (tokens[tokens.length - 1] ?? '').replace(/\*$/, '');
-        if (last === 'get')
-            return 'get_accessor';
-        if (last === 'set')
-            return 'set_accessor';
-        if (last === 'function')
-            return 'function';
-        if (last === 'class')
-            return 'class';
-        if (last === 'interface')
-            return 'interface';
-        if (last === 'type')
-            return 'type';
-        if (['public', 'private', 'protected', 'static', 'abstract', 'async', 'override'].includes(last))
-            return 'method';
-        return 'variable';
-    }
-    /**
-     * Async wrapper around grep to avoid blocking the event loop. `ok: false`
-     * means grep could not be spawned (`output: null`) or exited with status ≥ 2,
-     * keeping whatever it printed — distinguishable from a clean "no matches",
-     * which is `ok: true, output: null`.
-     */
-    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({ ok: false, output: null });
-            });
-            proc.on('close', (code) => {
-                const output = chunks.length === 0 ? null : Buffer.concat(chunks).toString('utf-8');
-                // grep returns 1 for "no matches" — not an error; 2+ is a real failure
-                if (code !== null && code >= 2) {
-                    this.logger.warn('SearcherService: grep exited with code', { code });
-                    resolve({ ok: false, output });
-                    return;
-                }
-                resolve({ ok: true, output });
-            });
-        });
-    }
-}
-exports.SearcherService = SearcherService;