codesearch-mcp 0.3.0-alpha → 0.4.0-alpha

package/dist/src/search/SymbolLookup.d.ts

@@ -0,0 +1,24 @@
+import type { Config } from '../config';
+import type { IDatabase, ILogger } from '../interfaces';
+import type { FindSymbolResult, GrepSymbolResult, ISymbolLookup, SymbolKind } from '../interfaces/ISymbolLookup';
+import type { GrepRunner } from '../workspace/GrepRunner';
+import type { ProjectRoots } from '../workspace/ProjectRoots';
+import type { ToolPaths } from '../workspace/ToolPaths';
+export declare class SymbolLookup implements ISymbolLookup {
+    private db;
+    private grep;
+    private roots;
+    private paths;
+    private config;
+    private logger;
+    private readonly textSearch;
+    private readonly gate;
+    private readonly indexQuery;
+    private readonly grepFallback;
+    constructor(db: IDatabase, grep: GrepRunner, roots: ProjectRoots, paths: ToolPaths, config: Config, logger: ILogger);
+    grepSymbol(symbol: string, rootDir: string, excludeFile: string): Promise<GrepSymbolResult>;
+    findSymbol(name: string, project: string | null, kind: SymbolKind): Promise<FindSymbolResult>;
+    private findSymbolFromIndex;
+    private indexedElsewhere;
+    private similarOrNone;
+}

package/dist/src/search/SymbolLookup.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolLookup = void 0;
+const symbol_name_1 = require("../symbol-name");
+const symbol_sql_1 = require("./symbol-sql");
+const find_symbol_constants_1 = require("./symbols/find-symbol-constants");
+const SymbolGrepFallback_1 = require("./symbols/SymbolGrepFallback");
+const SymbolIndexQuery_1 = require("./symbols/SymbolIndexQuery");
+const SymbolTextSearch_1 = require("./symbols/SymbolTextSearch");
+const TargetColumnGate_1 = require("./symbols/TargetColumnGate");
+const NO_SIMILAR = { names: [], truncated: false };
+class SymbolLookup {
+    db;
+    grep;
+    roots;
+    paths;
+    config;
+    logger;
+    textSearch;
+    gate;
+    indexQuery;
+    grepFallback;
+    constructor(db, grep, roots, paths, config, logger) {
+        this.db = db;
+        this.grep = grep;
+        this.roots = roots;
+        this.paths = paths;
+        this.config = config;
+        this.logger = logger;
+        this.textSearch = new SymbolTextSearch_1.SymbolTextSearch(grep, roots, config, logger);
+        this.gate = new TargetColumnGate_1.TargetColumnGate(db);
+        this.indexQuery = new SymbolIndexQuery_1.SymbolIndexQuery(db, this.gate);
+        this.grepFallback = new SymbolGrepFallback_1.SymbolGrepFallback(grep, paths, config, logger);
+    }
+    grepSymbol(symbol, rootDir, excludeFile) {
+        return this.textSearch.search(symbol, rootDir, excludeFile);
+    }
+    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);
+    }
+    async findSymbolFromIndex(parsed, project, kind) {
+        const t0 = Date.now();
+        this.logger.debug('SymbolLookup: findSymbol', { parsed, project, kind, source: 'index' });
+        const isGraphqlKind = find_symbol_constants_1.GRAPHQL_KINDS.has(kind);
+        const grepped = parsed.form === 'bare' || parsed.form === 'qualified';
+        let indexed;
+        try {
+            indexed = await this.indexQuery.query(parsed, project, kind);
+            this.logger.debug('SymbolLookup: findSymbol result', { source: 'index', hits: indexed.hits.length, truncated: indexed.truncated, ms: Date.now() - t0 });
+        }
+        catch (err) {
+            this.logger.warn('SymbolLookup: symbol index unavailable', { err, ms: Date.now() - t0 });
+            if (isGraphqlKind)
+                throw err;
+            if (!grepped)
+                return { hits: [], truncated: false, grep: find_symbol_constants_1.COMPLETE, similar: NO_SIMILAR };
+            return { ...(await this.grepFallback.run(parsed, project, kind)), similar: NO_SIMILAR };
+        }
+        if (indexed.hits.length > 0)
+            return { ...indexed, grep: find_symbol_constants_1.COMPLETE, similar: NO_SIMILAR };
+        if (isGraphqlKind || !grepped)
+            return { hits: [], truncated: false, grep: find_symbol_constants_1.COMPLETE, similar: NO_SIMILAR };
+        let found;
+        if (parsed.form === 'qualified' && await this.indexedElsewhere(parsed.name, project, kind)) {
+            found = { hits: [], truncated: false, grep: { outcome: 'other-container' } };
+        }
+        else {
+            found = await this.grepFallback.run(parsed, project, kind);
+        }
+        if (found.hits.length > 0)
+            return { ...found, similar: NO_SIMILAR };
+        const exactFirst = found.grep.outcome === 'other-container' || kind !== 'all';
+        return { ...found, similar: await this.similarOrNone(parsed.name, project, exactFirst) };
+    }
+    async indexedElsewhere(name, project, kind) {
+        try {
+            return await (0, symbol_sql_1.symbolIndexedElsewhere)(this.db, name, project, kind);
+        }
+        catch (err) {
+            this.logger.warn('SymbolLookup: findSymbol other-container check failed', { err, name, project });
+            return false;
+        }
+    }
+    async similarOrNone(name, project, exactFirst) {
+        try {
+            return await (0, symbol_sql_1.similarSymbolNames)(this.db, name, project, exactFirst);
+        }
+        catch (err) {
+            this.logger.warn('SymbolLookup: findSymbol similar-name lookup failed', { err, name, project });
+            return NO_SIMILAR;
+        }
+    }
+}
+exports.SymbolLookup = SymbolLookup;

package/dist/src/search/chunks/CandidateFetcher.d.ts

@@ -0,0 +1,19 @@
+import type { IDatabase } from '../../interfaces';
+import type { SearchResult } from '../../interfaces/IChunkSearch';
+import type { IterativeScanGate } from './IterativeScanGate';
+import type { SearchPlan } from './search-plan';
+export interface CandidatePool {
+    candidates: SearchResult[];
+    poolSaturated: boolean;
+    indexParams: {
+        efSearch: number;
+        iterativeScan: string;
+    };
+    dbMs: number;
+}
+export declare class CandidateFetcher {
+    private db;
+    private gate;
+    constructor(db: IDatabase, gate: IterativeScanGate);
+    fetch(embedding: number[], plan: SearchPlan, project: string | null): Promise<CandidatePool>;
+}

package/dist/src/search/chunks/CandidateFetcher.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CandidateFetcher = void 0;
+const hnsw_settings_1 = require("../../hnsw-settings");
+class CandidateFetcher {
+    db;
+    gate;
+    constructor(db, gate) {
+        this.db = db;
+        this.gate = gate;
+    }
+    async fetch(embedding, plan, project) {
+        const params = [`[${embedding}]`, plan.threshold.value, plan.dbLimit];
+        let projectFilter = '';
+        if (project) {
+            params.push(project);
+            projectFilter = `AND "serviceName" = $${params.length}`;
+        }
+        const iterative = await this.gate.enabled();
+        const settings = (0, hnsw_settings_1.hnswSettings)(plan.dbLimit, iterative);
+        const indexParams = {
+            efSearch: settings['hnsw.ef_search'],
+            iterativeScan: iterative ? hnsw_settings_1.ITERATIVE_SCAN_MODE : 'off',
+        };
+        const tDb0 = Date.now();
+        const fetched = await this.db.queryWithLocalSettings(settings, `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;
+        fetched.sort((a, b) => a.score - b.score);
+        const poolSaturated = fetched.length > plan.fetchLimit;
+        const candidates = fetched.slice(0, plan.fetchLimit);
+        return { candidates, poolSaturated, indexParams, dbMs };
+    }
+}
+exports.CandidateFetcher = CandidateFetcher;

package/dist/src/search/chunks/IterativeScanGate.d.ts

@@ -0,0 +1,10 @@
+import type { IDatabase, ILogger } from '../../interfaces';
+export declare class IterativeScanGate {
+    private db;
+    private logger;
+    private pgvectorVersionRead?;
+    private degradedScanWarned;
+    constructor(db: IDatabase, logger: ILogger);
+    enabled(): Promise<boolean>;
+    private warnDegraded;
+}

package/dist/src/search/chunks/IterativeScanGate.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IterativeScanGate = void 0;
+const hnsw_settings_1 = require("../../hnsw-settings");
+class IterativeScanGate {
+    db;
+    logger;
+    pgvectorVersionRead;
+    degradedScanWarned = false;
+    constructor(db, logger) {
+        this.db = db;
+        this.logger = logger;
+    }
+    async enabled() {
+        const read = this.pgvectorVersionRead ??= this.db.pgvectorVersion().then(v => {
+            if (v === null)
+                throw new Error('vector extension not found in pg_extension');
+            return v;
+        });
+        let version;
+        try {
+            version = await read;
+        }
+        catch (err) {
+            if (this.pgvectorVersionRead === read)
+                this.pgvectorVersionRead = undefined;
+            this.warnDegraded('unknown', err);
+            return false;
+        }
+        if ((0, hnsw_settings_1.supportsIterativeScan)(version))
+            return true;
+        this.warnDegraded(version);
+        return false;
+    }
+    warnDegraded(version, err) {
+        if (this.degradedScanWarned)
+            return;
+        this.degradedScanWarned = true;
+        this.logger.warn(`IterativeScanGate: pgvector ${version} lacks hnsw.iterative_scan — filtered searches on large projects may return fewer candidates than requested; upgrade to pgvector ≥ 0.8`, err ? { err } : undefined);
+    }
+}
+exports.IterativeScanGate = IterativeScanGate;

package/dist/src/search/chunks/RerankStage.d.ts

@@ -0,0 +1,15 @@
+import type { IEmbedder, ILogger } from '../../interfaces';
+import type { ChunkRow, SearchResult } from '../../interfaces/IChunkSearch';
+import type { SearchPlan } from './search-plan';
+export declare function rerankDocument(row: ChunkRow): string;
+export interface RerankOutcome {
+    reranked: SearchResult[];
+    rerankFailed: boolean;
+    rerankMs: number;
+}
+export declare class RerankStage {
+    private embedder;
+    private logger;
+    constructor(embedder: IEmbedder, logger: ILogger);
+    run(query: string, candidates: SearchResult[], vector: SearchResult[], plan: SearchPlan, startedAt: number): Promise<RerankOutcome>;
+}

package/dist/src/search/chunks/RerankStage.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RerankStage = void 0;
+exports.rerankDocument = rerankDocument;
+const result_shaping_1 = require("../result-shaping");
+function rerankDocument(row) {
+    const symbol = row.ownerPath ? ` | Symbol: ${oneLine(row.ownerPath)}` : '';
+    return `File: ${oneLine(row.filePath)}${symbol}\n${row.content}`;
+}
+function oneLine(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+class RerankStage {
+    embedder;
+    logger;
+    constructor(embedder, logger) {
+        this.embedder = embedder;
+        this.logger = logger;
+    }
+    async run(query, candidates, vector, plan, startedAt) {
+        if (candidates.length === 0)
+            return { reranked: [], rerankFailed: false, rerankMs: 0 };
+        const tRerank0 = Date.now();
+        try {
+            const topN = plan.perFileActive ? candidates.length : plan.limit;
+            const indices = await this.embedder.rerank(query, candidates.map(rerankDocument), topN);
+            const rerankMs = Date.now() - tRerank0;
+            this.logger.debug('RerankStage: searchChunks rerank done', { indices, ms: Date.now() - startedAt });
+            const order = indices.filter(i => i >= 0 && i < candidates.length).map(i => candidates[i]);
+            return { reranked: (0, result_shaping_1.limitPerFile)(order, plan.limit, plan.perFile), rerankFailed: false, rerankMs };
+        }
+        catch (err) {
+            const rerankMs = Date.now() - tRerank0;
+            this.logger.warn('RerankStage: rerank failed, falling back to vector order', {
+                err,
+                ms: Date.now() - startedAt,
+            });
+            return { reranked: vector, rerankFailed: true, rerankMs };
+        }
+    }
+}
+exports.RerankStage = RerankStage;

package/dist/src/search/chunks/search-metrics.d.ts

@@ -0,0 +1,18 @@
+import type { ResolvedThreshold } from '../../constants';
+import type { SearchResult } from '../../interfaces/IChunkSearch';
+export interface SearchMetricsInput {
+    fetchLimit: number;
+    candidates: SearchResult[];
+    results: SearchResult[];
+    poolSaturated: boolean;
+    indexParams: {
+        efSearch: number;
+        iterativeScan: string;
+    };
+    threshold: ResolvedThreshold;
+    embedMs: number;
+    dbMs: number;
+    rerankMs: number;
+    totalMs: number;
+}
+export declare function searchMetrics(query: string, m: SearchMetricsInput): Record<string, unknown>;

package/dist/src/search/chunks/search-metrics.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchMetrics = searchMetrics;
+function searchMetrics(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;
+    return {
+        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,
+        efSearch: m.indexParams.efSearch,
+        iterativeScan: m.indexParams.iterativeScan,
+        threshold: m.threshold.value,
+        thresholdSource: m.threshold.source,
+        embedMs: m.embedMs,
+        rerankMs: m.rerankMs,
+        dbMs: m.dbMs,
+        totalMs: m.totalMs,
+    };
+}

package/dist/src/search/chunks/search-plan.d.ts

@@ -0,0 +1,18 @@
+import type { Config } from '../../config';
+import { type ResolvedThreshold } from '../../constants';
+export interface SearchPlan {
+    limit: number;
+    perFile: number;
+    threshold: ResolvedThreshold;
+    reranking: boolean;
+    perFileActive: boolean;
+    fetchLimit: number;
+    dbLimit: number;
+}
+export declare function planSearch(call: {
+    limit: number;
+    perFile: number;
+    threshold?: number;
+    rerankOverride?: boolean;
+    rerankAvailable: boolean;
+}, config: Config): SearchPlan;

package/dist/src/search/chunks/search-plan.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planSearch = planSearch;
+const constants_1 = require("../../constants");
+function planSearch(call, config) {
+    const { limit, perFile, threshold, rerankOverride } = call;
+    const resolvedThreshold = (0, constants_1.resolveThreshold)({
+        callValue: threshold,
+        configValue: config.search.similarityThreshold,
+        model: config.embedding.model,
+    });
+    const reranking = rerankOverride === false ? false : call.rerankAvailable;
+    const perFileActive = perFile < limit;
+    const fetchLimit = reranking || perFileActive
+        ? Math.min(Math.max(limit * config.reranker.overfetch, config.reranker.candidateFloor), 200)
+        : limit;
+    const dbLimit = fetchLimit + 1;
+    return { limit, perFile, threshold: resolvedThreshold, reranking, perFileActive, fetchLimit, dbLimit };
+}

package/dist/src/search/create-search-services.d.ts

@@ -0,0 +1,26 @@
+import type { Config } from '../config';
+import type { IDatabase, IEmbedder, ILogger, IProjectDiscovery } from '../interfaces';
+import { type WorkspaceFs } from '../workspace/fs-access';
+import { ProjectRoots } from '../workspace/ProjectRoots';
+import { ToolPaths } from '../workspace/ToolPaths';
+import { WorkspaceFiles } from '../workspace/WorkspaceFiles';
+import { GrepRunner } from '../workspace/GrepRunner';
+import { SymbolLookup } from './SymbolLookup';
+import { CallGraph } from './CallGraph';
+import { DependencyGraph } from './DependencyGraph';
+import { IndexIdentityGuard } from './IndexIdentityGuard';
+import { ChunkSearch } from './ChunkSearch';
+import { ProjectCatalog } from './ProjectCatalog';
+export interface SearchServices {
+    readonly roots: ProjectRoots;
+    readonly paths: ToolPaths;
+    readonly files: WorkspaceFiles;
+    readonly grep: GrepRunner;
+    readonly symbols: SymbolLookup;
+    readonly calls: CallGraph;
+    readonly dependencies: DependencyGraph;
+    readonly identity: IndexIdentityGuard;
+    readonly chunks: ChunkSearch;
+    readonly catalog: ProjectCatalog;
+}
+export declare function createSearchServices(db: IDatabase, embedder: IEmbedder, discovery: IProjectDiscovery, config: Config, logger?: ILogger, fsDeps?: Partial<WorkspaceFs>): SearchServices;

package/dist/src/search/create-search-services.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSearchServices = createSearchServices;
+const LoggerService_1 = require("../services/LoggerService");
+const fs_access_1 = require("../workspace/fs-access");
+const ProjectRoots_1 = require("../workspace/ProjectRoots");
+const ToolPaths_1 = require("../workspace/ToolPaths");
+const WorkspaceFiles_1 = require("../workspace/WorkspaceFiles");
+const GrepRunner_1 = require("../workspace/GrepRunner");
+const SymbolLookup_1 = require("./SymbolLookup");
+const CallGraph_1 = require("./CallGraph");
+const DependencyGraph_1 = require("./DependencyGraph");
+const IndexIdentityGuard_1 = require("./IndexIdentityGuard");
+const ChunkSearch_1 = require("./ChunkSearch");
+const ProjectCatalog_1 = require("./ProjectCatalog");
+function createSearchServices(db, embedder, discovery, config, logger = LoggerService_1.LoggerService.silent(), fsDeps = {}) {
+    const fs = { ...fs_access_1.NODE_FS, ...fsDeps };
+    const roots = new ProjectRoots_1.ProjectRoots(discovery, config);
+    const paths = new ToolPaths_1.ToolPaths(db, roots, logger, fs);
+    const files = new WorkspaceFiles_1.WorkspaceFiles(paths, roots, logger, fs);
+    const grep = new GrepRunner_1.GrepRunner(logger);
+    const symbols = new SymbolLookup_1.SymbolLookup(db, grep, roots, paths, config, logger);
+    const calls = new CallGraph_1.CallGraph(db, logger);
+    const dependencies = new DependencyGraph_1.DependencyGraph(db, roots, config, logger);
+    const identity = new IndexIdentityGuard_1.IndexIdentityGuard(db, embedder, config);
+    const chunks = new ChunkSearch_1.ChunkSearch(db, embedder, identity, config, logger);
+    const catalog = new ProjectCatalog_1.ProjectCatalog(db, roots, fs);
+    return { roots, paths, files, grep, symbols, calls, dependencies, identity, chunks, catalog };
+}

package/dist/src/search/index-paths.d.ts

@@ -0,0 +1 @@
+export declare const OUTSIDE_WORKSPACE_VALUE: (col: string) => string;

package/dist/src/search/index-paths.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUTSIDE_WORKSPACE_VALUE = void 0;
+const OUTSIDE_WORKSPACE_VALUE = (col) => `(${col} = '..' OR ${col} LIKE '../%')`;
+exports.OUTSIDE_WORKSPACE_VALUE = OUTSIDE_WORKSPACE_VALUE;

package/dist/src/search/symbol-sql.d.ts

@@ -0,0 +1,13 @@
+import type { IDatabase } from '../interfaces';
+import type { SymbolKind } from '../interfaces/ISymbolLookup';
+export declare function symbolMatch(name: string, container: string | null, params: unknown[]): {
+    filter: string;
+    exactRank: string | null;
+};
+export declare const QUALIFIED_SQL = "COALESCE(container || '.', '') || name";
+export declare const SIMILAR_NAMES_LIMIT = 5;
+export declare function similarSymbolNames(db: IDatabase, name: string, project: string | null, exactFirst: boolean): Promise<{
+    names: string[];
+    truncated: boolean;
+}>;
+export declare function symbolIndexedElsewhere(db: IDatabase, name: string, project: string | null, kind: SymbolKind): Promise<boolean>;

package/dist/src/search/symbol-sql.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIMILAR_NAMES_LIMIT = exports.QUALIFIED_SQL = void 0;
+exports.symbolMatch = symbolMatch;
+exports.similarSymbolNames = similarSymbolNames;
+exports.symbolIndexedElsewhere = symbolIndexedElsewhere;
+const symbol_name_1 = require("../symbol-name");
+function symbolMatch(name, container, params) {
+    params.push(name);
+    const nameFilter = `name = $${params.length}`;
+    if (container === null)
+        return { filter: nameFilter, exactRank: null };
+    params.push(container);
+    const exactParam = params.length;
+    params.push(`%.${(0, symbol_name_1.escapeLike)(container)}`);
+    const suffixParam = params.length;
+    return {
+        filter: `${nameFilter} AND (container = $${exactParam} OR container LIKE $${suffixParam} ESCAPE '\\')`,
+        exactRank: `(CASE WHEN container = $${exactParam} THEN 0 ELSE 1 END)`,
+    };
+}
+exports.QUALIFIED_SQL = `COALESCE(container || '.', '') || name`;
+exports.SIMILAR_NAMES_LIMIT = 5;
+async function similarSymbolNames(db, name, project, exactFirst) {
+    const params = [];
+    let projectFilter = '';
+    if (project !== null) {
+        params.push(project);
+        projectFilter = `project = $${params.length} AND `;
+    }
+    params.push(`${(0, symbol_name_1.escapeLike)(name)}%`);
+    const likeParam = params.length;
+    let exactRank = '';
+    if (exactFirst) {
+        params.push(name);
+        exactRank = `(CASE WHEN name = $${params.length} THEN 0 ELSE 1 END), `;
+    }
+    params.push(exports.SIMILAR_NAMES_LIMIT + 1);
+    const rows = await db.query(`SELECT qualified
+     FROM (
+       SELECT DISTINCT name, ${exports.QUALIFIED_SQL} AS qualified
+       FROM code_symbol
+       WHERE ${projectFilter}name ILIKE $${likeParam} ESCAPE '\\'
+     ) AS suggestions
+     ORDER BY ${exactRank}name COLLATE "C", qualified COLLATE "C"
+     LIMIT $${params.length}`, params);
+    return {
+        names: rows.slice(0, exports.SIMILAR_NAMES_LIMIT).map(r => r.qualified),
+        truncated: rows.length > exports.SIMILAR_NAMES_LIMIT,
+    };
+}
+async function symbolIndexedElsewhere(db, name, project, kind) {
+    const params = [name];
+    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}`;
+    }
+    const rows = await db.query(`SELECT EXISTS (SELECT 1 FROM code_symbol WHERE name = $1 ${projectFilter} ${kindFilter}) AS present`, params);
+    return !!rows[0]?.present;
+}

package/dist/src/search/symbols/SymbolGrepFallback.d.ts

@@ -0,0 +1,19 @@
+import type { Config } from '../../config';
+import type { ILogger } from '../../interfaces';
+import type { FindSymbolGrep, SymbolHit, SymbolKind } from '../../interfaces/ISymbolLookup';
+import type { FindSymbolQuery } from '../../symbol-name';
+import type { GrepRunner } from '../../workspace/GrepRunner';
+import type { ToolPaths } from '../../workspace/ToolPaths';
+export type GrepFindResult = {
+    hits: SymbolHit[];
+    truncated: boolean;
+    grep: FindSymbolGrep;
+};
+export declare class SymbolGrepFallback {
+    private grep;
+    private paths;
+    private config;
+    private logger;
+    constructor(grep: GrepRunner, paths: ToolPaths, config: Config, logger: ILogger);
+    run(parsed: FindSymbolQuery, project: string | null, kind: SymbolKind): Promise<GrepFindResult>;
+}

package/dist/src/search/symbols/SymbolGrepFallback.js

@@ -0,0 +1,106 @@
+"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.SymbolGrepFallback = void 0;
+const path = __importStar(require("path"));
+const find_symbol_constants_1 = require("./find-symbol-constants");
+const grep_args_1 = require("./grep-args");
+const grep_patterns_1 = require("./grep-patterns");
+const FIND_SYMBOL_RAW_LIMIT = find_symbol_constants_1.FIND_SYMBOL_LIMIT * 10;
+class SymbolGrepFallback {
+    grep;
+    paths;
+    config;
+    logger;
+    constructor(grep, paths, config, logger) {
+        this.grep = grep;
+        this.paths = paths;
+        this.config = config;
+        this.logger = logger;
+    }
+    async run(parsed, project, kind) {
+        const t0 = Date.now();
+        const grepName = parsed.name;
+        this.logger.debug('SymbolGrepFallback: findSymbol', { grepName, project, kind, source: 'grep' });
+        const pattern = (0, grep_patterns_1.buildFindSymbolPattern)(grepName, kind);
+        if (pattern === null)
+            return { hits: [], truncated: false, grep: find_symbol_constants_1.COMPLETE };
+        const searchDir = project ? await this.paths.grepSearchDir(project) : this.config.workspaceRoot;
+        if (searchDir === null)
+            return { hits: [], truncated: false, grep: { outcome: 'no-project-directory' } };
+        const result = await this.grep.run([
+            '-rn', '-E',
+            grep_args_1.GREP_BINARY_AS_TEXT,
+            '-m', String(FIND_SYMBOL_RAW_LIMIT),
+            ...grep_args_1.SOURCE_INCLUDES,
+            ...grep_args_1.GREP_EXCLUDE_DIRS,
+            pattern,
+            searchDir,
+        ]);
+        if (!result.ok)
+            this.logger.warn('SymbolGrepFallback: findSymbol grep failed', { grepName, project, failure: result.failure });
+        const parsedHits = [];
+        for (const raw of (result.output ?? '').split('\n').slice(0, -1)) {
+            const m = raw.match(/^(.+?):(\d+):(.*)$/s);
+            if (!m)
+                continue;
+            const [, absFile, lineNumStr, matchedLine] = m;
+            const lineNum = parseInt(lineNumStr, 10);
+            if (isNaN(lineNum))
+                continue;
+            const col = (0, grep_patterns_1.wholeWordIndex)(matchedLine, grepName);
+            if (col === -1)
+                continue;
+            parsedHits.push({
+                filePath: path.relative(this.config.workspaceRoot, absFile),
+                line: lineNum,
+                column: col + 1,
+                kind: (0, grep_patterns_1.inferKind)(matchedLine, grepName),
+                signature: matchedLine.trim(),
+                qualified: grepName,
+                isStatic: false,
+                source: 'grep',
+                target: null,
+            });
+        }
+        const truncated = parsedHits.length > find_symbol_constants_1.FIND_SYMBOL_LIMIT;
+        this.logger.debug('SymbolGrepFallback: findSymbol result', { source: 'grep', hits: Math.min(parsedHits.length, find_symbol_constants_1.FIND_SYMBOL_LIMIT), truncated, partial: !result.ok, ms: Date.now() - t0 });
+        let grep = find_symbol_constants_1.COMPLETE;
+        if (!result.ok)
+            grep = parsedHits.length > 0 ? { outcome: 'partial' } : { outcome: 'failed', cause: result.failure ?? 'unknown' };
+        return { hits: parsedHits.slice(0, find_symbol_constants_1.FIND_SYMBOL_LIMIT), truncated, grep };
+    }
+}
+exports.SymbolGrepFallback = SymbolGrepFallback;