codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

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/result-shaping.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_PER_FILE = 2;
+export declare function limitPerFile<T extends {
+    filePath: string;
+}>(ranked: T[], limit: number, perFile: number): T[];

package/dist/src/search/result-shaping.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PER_FILE = void 0;
+exports.limitPerFile = limitPerFile;
+exports.DEFAULT_PER_FILE = 2;
+function limitPerFile(ranked, limit, perFile) {
+    const taken = [];
+    const perFileCount = new Map();
+    for (const entry of ranked) {
+        if (taken.length >= limit)
+            break;
+        const count = perFileCount.get(entry.filePath) ?? 0;
+        if (count >= perFile)
+            continue;
+        perFileCount.set(entry.filePath, count + 1);
+        taken.push(entry);
+    }
+    return taken;
+}

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;

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

@@ -0,0 +1,14 @@
+import type { IDatabase } from '../../interfaces';
+import type { SymbolHit, SymbolKind } from '../../interfaces/ISymbolLookup';
+import type { FindSymbolQuery } from '../../symbol-name';
+import type { TargetColumnGate } from './TargetColumnGate';
+export interface IndexedSymbols {
+    hits: SymbolHit[];
+    truncated: boolean;
+}
+export declare class SymbolIndexQuery {
+    private db;
+    private gate;
+    constructor(db: IDatabase, gate: TargetColumnGate);
+    query(parsed: FindSymbolQuery, project: string | null, kind: SymbolKind): Promise<IndexedSymbols>;
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolIndexQuery = void 0;
+const symbol_sql_1 = require("../symbol-sql");
+const find_symbol_constants_1 = require("./find-symbol-constants");
+class SymbolIndexQuery {
+    db;
+    gate;
+    constructor(db, gate) {
+        this.db = db;
+        this.gate = gate;
+    }
+    async query(parsed, project, kind) {
+        const container = 'container' in parsed ? parsed.container : null;
+        const hasTarget = await this.gate.present();
+        const params = [];
+        const { filter: nameFilter, exactRank } = (0, symbol_sql_1.symbolMatch)(parsed.name, container, params);
+        const orderPrefix = exactRank ? `${exactRank}, ` : '';
+        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_constants_1.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);
+        return {
+            truncated: rows.length > find_symbol_constants_1.FIND_SYMBOL_LIMIT,
+            hits: rows.slice(0, find_symbol_constants_1.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,
+            })),
+        };
+    }
+}
+exports.SymbolIndexQuery = SymbolIndexQuery;

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

@@ -0,0 +1,13 @@
+import type { Config } from '../../config';
+import type { ILogger } from '../../interfaces';
+import type { GrepSymbolResult } from '../../interfaces/ISymbolLookup';
+import type { GrepRunner } from '../../workspace/GrepRunner';
+import type { ProjectRoots } from '../../workspace/ProjectRoots';
+export declare class SymbolTextSearch {
+    private grep;
+    private roots;
+    private config;
+    private logger;
+    constructor(grep: GrepRunner, roots: ProjectRoots, config: Config, logger: ILogger);
+    search(symbol: string, rootDir: string, excludeFile: string): Promise<GrepSymbolResult>;
+}

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

@@ -0,0 +1,84 @@
+"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.SymbolTextSearch = void 0;
+const path = __importStar(require("path"));
+const grep_args_1 = require("./grep-args");
+const GREP_MAX_RESULTS = 200;
+const GREP_RAW_LIMIT = GREP_MAX_RESULTS * 5;
+class SymbolTextSearch {
+    grep;
+    roots;
+    config;
+    logger;
+    constructor(grep, roots, config, logger) {
+        this.grep = grep;
+        this.roots = roots;
+        this.config = config;
+        this.logger = logger;
+    }
+    async search(symbol, rootDir, excludeFile) {
+        const t0 = Date.now();
+        this.logger.debug('SymbolTextSearch: grepSymbol', { symbol, rootDir, excludeFile });
+        if (symbol.includes('\n'))
+            return { ok: true, matches: [], truncated: false, partial: false };
+        const result = await this.grep.run([
+            '-rn', '-F', '-w',
+            grep_args_1.GREP_BINARY_AS_TEXT,
+            '-m', String(GREP_RAW_LIMIT),
+            ...grep_args_1.SOURCE_INCLUDES,
+            ...grep_args_1.GREP_EXCLUDE_DIRS,
+            '--',
+            symbol,
+            this.roots.toAbs(rootDir),
+        ]);
+        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) }];
+        });
+        if (!result.ok && all.length === 0)
+            return { ok: false };
+        const truncated = all.length > GREP_MAX_RESULTS;
+        this.logger.debug('SymbolTextSearch: 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 };
+    }
+}
+exports.SymbolTextSearch = SymbolTextSearch;

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

@@ -0,0 +1,7 @@
+import type { IDatabase } from '../../interfaces';
+export declare class TargetColumnGate {
+    private db;
+    private targetColumnPresent;
+    constructor(db: IDatabase);
+    present(): Promise<boolean>;
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TargetColumnGate = void 0;
+class TargetColumnGate {
+    db;
+    targetColumnPresent = false;
+    constructor(db) {
+        this.db = db;
+    }
+    async present() {
+        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;
+    }
+}
+exports.TargetColumnGate = TargetColumnGate;

package/dist/src/search/symbols/find-symbol-constants.d.ts

@@ -0,0 +1,4 @@
+import type { FindSymbolGrep, SymbolKind } from '../../interfaces/ISymbolLookup';
+export declare const GRAPHQL_KINDS: ReadonlySet<SymbolKind>;
+export declare const FIND_SYMBOL_LIMIT = 50;
+export declare const COMPLETE: FindSymbolGrep;