codesearch-mcp 0.2.2-alpha → 0.3.0-alpha

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

@@ -6,7 +6,6 @@ import * as schema from '../db/schema';
 type Schema = typeof schema;
 export type DrizzleDb = NodePgDatabase<Schema>;
 export type DrizzleTx = NodePgTransaction<Schema, ExtractTablesWithRelations<Schema>>;
-export declare const CURRENT_SYMBOL_INDEX_VERSION = 2;
 export declare class DatabaseService implements IDatabase {
     private config;
     private pool;
@@ -14,17 +13,13 @@ export declare class DatabaseService implements IDatabase {
     constructor(config: Config);
     get orm(): DrizzleDb;
     query<T = any>(sql: string, params?: any[]): Promise<T>;
+    queryWithLocalSettings<T = any>(settings: Record<string, string | number>, sql: string, params?: any[]): Promise<T>;
+    pgvectorVersion(): Promise<string | null>;
     transaction<T>(fn: (tx: DrizzleTx) => Promise<T>): Promise<T>;
     destroy(): Promise<void>;
     initDb(): Promise<void>;
     initDbWithSchema(): Promise<void>;
-    /**
-     * Create `code_chunk` at `dimensions` if it does not exist, plus its HNSW and
-     * (serviceName, filePath) indexes and the additive `contentHash`/`ownerPath`
-     * columns for pre-existing tables. Idempotent — safe to call repeatedly.
-     */
     ensureChunkTable(dimensions: number): Promise<void>;
-    /** Drop and recreate `code_chunk` at `dimensions` — used on a dimension change. */
     recreateChunkTable(dimensions: number): Promise<void>;
     readIndexMeta(): Promise<IndexMeta | null>;
     writeIndexMeta(meta: IndexMeta): Promise<void>;
@@ -32,18 +27,6 @@ export declare class DatabaseService implements IDatabase {
     deleteFiles(project: string, filePaths: string[]): Promise<void>;
     listIndexedProjects(): Promise<string[]>;
     deleteProject(name: string): Promise<void>;
-    listProjectsWithIndexRows(): Promise<string[]>;
-    /**
-     * Among `projectNames` (or every project with rows when null), those with at
-     * least one row in `code_chunk`/`code_symbol` and a `symbol_index_version`
-     * below `CURRENT_SYMBOL_INDEX_VERSION` (a missing row counts as version 1).
-     * A missing `symbol_index_version` table (un-migrated DB, `rag-mcp`/`rag-web`
-     * bootstrapped with `initDb`) counts as "no marker rows" — every project with
-     * rows is then outdated. Any other database error propagates.
-     */
-    listOutdatedProjects(projectNames: string[] | null): Promise<string[]>;
-    upsertSymbolIndexVersion(project: string): Promise<void>;
-    /** Guard against SQL injection — the dimension is interpolated into DDL. */
     private assertDim;
     private assertMinPostgresVersion;
     private ensureDatabaseExists;

package/dist/src/services/DatabaseService.js

@@ -33,14 +33,15 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseService = exports.CURRENT_SYMBOL_INDEX_VERSION = void 0;
+exports.DatabaseService = void 0;
 const node_postgres_1 = require("drizzle-orm/node-postgres");
 const pg_1 = require("pg");
 const drizzle_orm_1 = require("drizzle-orm");
 const schema = __importStar(require("../db/schema"));
 const db_1 = require("../db");
 const MIN_PG_VERSION_NUM = 150000;
-exports.CURRENT_SYMBOL_INDEX_VERSION = 2;
+const SETTING_NAME = /^[a-z_]+(\.[a-z_]+)*$/;
+const SETTING_VALUE = /^[A-Za-z0-9_]+$/;
 class DatabaseService {
     config;
     pool;
@@ -53,6 +54,41 @@ class DatabaseService {
         const result = await this.pool.query(sql, params);
         return result.rows;
     }
+    async queryWithLocalSettings(settings, sql, params) {
+        const setStatements = Object.entries(settings).map(([name, value]) => {
+            if (!SETTING_NAME.test(name) || !SETTING_VALUE.test(String(value))) {
+                throw new Error(`DatabaseService: invalid local setting ${JSON.stringify(name)} = ${JSON.stringify(value)}`);
+            }
+            return `SET LOCAL ${name} = ${value}`;
+        });
+        const client = await this.pool.connect();
+        let began = false;
+        let broken;
+        const onError = (err) => { broken ??= err; };
+        client.on('error', onError);
+        try {
+            await client.query('BEGIN');
+            began = true;
+            for (const statement of setStatements)
+                await client.query(statement);
+            const result = await client.query(sql, params);
+            await client.query('COMMIT');
+            return result.rows;
+        }
+        catch (err) {
+            if (began)
+                await client.query('ROLLBACK').catch((e) => { broken ??= e; });
+            throw err;
+        }
+        finally {
+            client.removeListener('error', onError);
+            client.release(broken);
+        }
+    }
+    async pgvectorVersion() {
+        const rows = await this.query(`SELECT extversion FROM pg_extension WHERE extname = 'vector'`);
+        return rows[0]?.extversion ?? null;
+    }
     transaction(fn) {
         return this._db.transaction(fn);
     }
@@ -70,17 +106,8 @@ class DatabaseService {
     async initDbWithSchema() {
         await this.ensureDatabaseExists();
         await this.initDb();
-        // Read as the very first statement on the application database, before any
-        // CREATE TABLE / CREATE INDEX / ALTER TABLE / DROP — `NULLS NOT DISTINCT`
-        // (used below) requires PostgreSQL 15+, and the DROP/CREATE pair must never
-        // run against an older server (it would fail after the DROP and leave
-        // code_symbol without a unique index).
         await this.assertMinPostgresVersion();
-        // code_chunk table — created at the legacy default width (1024) so search
-        // tools always have a table. IndexerService recreates it at the resolved
-        // width before indexing when the active model's dimension differs.
         await this.ensureChunkTable(1024);
-        // index_meta table — source of truth for the model that built the index.
         await this.query(`
       CREATE TABLE IF NOT EXISTS index_meta (
         id          BOOLEAN PRIMARY KEY DEFAULT true,
@@ -90,7 +117,6 @@ class DatabaseService {
         "indexedAt" TIMESTAMPTZ NOT NULL DEFAULT now()
       )
     `);
-        // code_dependency table
         const [{ existsDep }] = await this.query(`
       SELECT EXISTS (
         SELECT 1 FROM information_schema.tables
@@ -115,7 +141,6 @@ class DatabaseService {
         await this.query(`DROP INDEX IF EXISTS idx_dep_from`);
         await this.query(`DROP INDEX IF EXISTS idx_dep_to`);
         await this.query(`DROP INDEX IF EXISTS idx_dep_project`);
-        // code_symbol table
         const [{ existsSym }] = await this.query(`
       SELECT EXISTS (
         SELECT 1 FROM information_schema.tables
@@ -140,23 +165,13 @@ class DatabaseService {
         await this.query(`CREATE INDEX IF NOT EXISTS idx_symbol_file   ON code_symbol (project, "filePath")`);
         await this.query(`ALTER TABLE code_symbol ADD COLUMN IF NOT EXISTS container TEXT`);
         await this.query(`ALTER TABLE code_symbol ADD COLUMN IF NOT EXISTS "isStatic" BOOLEAN NOT NULL DEFAULT false`);
-        // DDL is transactional in PostgreSQL — either both statements apply or
-        // neither does, so a failure here never leaves code_symbol without a
-        // unique index (the old idx_symbol_unique is dropped only once the new
-        // one is confirmed to exist).
+        await this.query(`ALTER TABLE code_symbol ADD COLUMN IF NOT EXISTS "target" TEXT`);
         await this.transaction(async (tx) => {
             await tx.execute('DROP INDEX IF EXISTS idx_symbol_unique');
             await tx.execute('CREATE UNIQUE INDEX IF NOT EXISTS idx_symbol_unique_v2 ' +
                 'ON code_symbol (project, "filePath", container, name, kind, line) NULLS NOT DISTINCT');
         });
         await this.query(`
-      CREATE TABLE IF NOT EXISTS symbol_index_version (
-        project TEXT PRIMARY KEY,
-        version INT NOT NULL
-      )
-    `);
-        // code_call table
-        await this.query(`
       CREATE TABLE IF NOT EXISTS code_call (
         id             UUID PRIMARY KEY DEFAULT gen_random_uuid(),
         project        TEXT NOT NULL,
@@ -173,11 +188,6 @@ class DatabaseService {
         await this.query(`CREATE INDEX IF NOT EXISTS idx_call_callee_file ON code_call (project, "calleeFile")`);
         await this.query(`CREATE INDEX IF NOT EXISTS idx_call_from        ON code_call (project, "fromFile")`);
     }
-    /**
-     * Create `code_chunk` at `dimensions` if it does not exist, plus its HNSW and
-     * (serviceName, filePath) indexes and the additive `contentHash`/`ownerPath`
-     * columns for pre-existing tables. Idempotent — safe to call repeatedly.
-     */
     async ensureChunkTable(dimensions) {
         const dim = this.assertDim(dimensions);
         await this.query(`
@@ -190,15 +200,16 @@ class DatabaseService {
         embedding     vector(${dim}) NOT NULL,
         "lastModified" DOUBLE PRECISION,
         "contentHash"  VARCHAR(64),
-        "ownerPath"    VARCHAR
+        "ownerPath"    VARCHAR,
+        "endLine"      INT
       )
     `);
         await this.query(`ALTER TABLE code_chunk ADD COLUMN IF NOT EXISTS "contentHash" varchar(64) NULL`);
         await this.query(`ALTER TABLE code_chunk ADD COLUMN IF NOT EXISTS "ownerPath" varchar NULL`);
+        await this.query(`ALTER TABLE code_chunk ADD COLUMN IF NOT EXISTS "endLine" integer NULL`);
         await this.query(`CREATE INDEX IF NOT EXISTS idx_code_chunk_embedding ON code_chunk USING hnsw (embedding vector_cosine_ops)`);
         await this.query(`CREATE INDEX IF NOT EXISTS idx_code_chunk_service_file ON code_chunk ("serviceName", "filePath")`);
     }
-    /** Drop and recreate `code_chunk` at `dimensions` — used on a dimension change. */
     async recreateChunkTable(dimensions) {
         const dim = this.assertDim(dimensions);
         await this.query(`DROP TABLE IF EXISTS code_chunk`);
@@ -211,7 +222,6 @@ class DatabaseService {
             return row ? { provider: row.provider, model: row.model, dimensions: Number(row.dimensions) } : null;
         }
         catch {
-            // Table absent (un-migrated DB) — treat as "no metadata".
             return null;
         }
     }
@@ -237,8 +247,6 @@ class DatabaseService {
     async deleteFiles(project, filePaths) {
         if (filePaths.length === 0)
             return;
-        // PostgreSQL limits ~32 767 bind params per statement; OR queries bind the
-        // array twice (fromFile + calleeFile), so cap each batch at 10 000 entries.
         const BATCH = 10_000;
         await this.transaction(async (tx) => {
             for (let i = 0; i < filePaths.length; i += BATCH) {
@@ -268,51 +276,6 @@ class DatabaseService {
             await tx.delete(db_1.codeDependency).where((0, drizzle_orm_1.eq)(db_1.codeDependency.project, name));
         });
     }
-    async listProjectsWithIndexRows() {
-        const rows = await this.query(`SELECT DISTINCT name FROM (
-         SELECT "serviceName" AS name FROM code_chunk
-         UNION
-         SELECT project AS name FROM code_symbol
-       ) t`);
-        return rows.map(r => r.name);
-    }
-    /**
-     * Among `projectNames` (or every project with rows when null), those with at
-     * least one row in `code_chunk`/`code_symbol` and a `symbol_index_version`
-     * below `CURRENT_SYMBOL_INDEX_VERSION` (a missing row counts as version 1).
-     * A missing `symbol_index_version` table (un-migrated DB, `rag-mcp`/`rag-web`
-     * bootstrapped with `initDb`) counts as "no marker rows" — every project with
-     * rows is then outdated. Any other database error propagates.
-     */
-    async listOutdatedProjects(projectNames) {
-        const rowsUnion = `
-      SELECT "serviceName" AS name FROM code_chunk
-      UNION
-      SELECT project AS name FROM code_symbol
-    `;
-        const filterSql = projectNames ? 'AND t.name = ANY($1)' : '';
-        const params = projectNames ? [projectNames] : [];
-        try {
-            const rows = await this.query(`SELECT DISTINCT t.name FROM (${rowsUnion}) t
-         WHERE NOT EXISTS (
-           SELECT 1 FROM symbol_index_version v
-           WHERE v.project = t.name AND v.version >= ${exports.CURRENT_SYMBOL_INDEX_VERSION}
-         )
-         ${filterSql}`, params);
-            return rows.map(r => r.name);
-        }
-        catch (err) {
-            if (!/relation "symbol_index_version" does not exist/i.test(err.message))
-                throw err;
-            const rows = await this.query(`SELECT DISTINCT t.name FROM (${rowsUnion}) t ${projectNames ? 'WHERE t.name = ANY($1)' : ''}`, params);
-            return rows.map(r => r.name);
-        }
-    }
-    async upsertSymbolIndexVersion(project) {
-        await this.query(`INSERT INTO symbol_index_version (project, version) VALUES ($1, $2)
-       ON CONFLICT (project) DO UPDATE SET version = EXCLUDED.version`, [project, exports.CURRENT_SYMBOL_INDEX_VERSION]);
-    }
-    /** Guard against SQL injection — the dimension is interpolated into DDL. */
     assertDim(dimensions) {
         if (!Number.isInteger(dimensions) || dimensions <= 0 || dimensions > 2000) {
             throw new Error(`Invalid vector dimension: ${dimensions} (must be an integer 1–2000)`);
@@ -326,7 +289,7 @@ class DatabaseService {
             versionNum = Number(rows[0]?.v);
         }
         catch (err) {
-            throw new Error(`Failed to read PostgreSQL server_version_num (requires PostgreSQL 15+): ${err.message}`);
+            throw new Error(`Failed to read PostgreSQL server_version_num (requires PostgreSQL 15+): ${err.message}`, { cause: err });
         }
         if (!Number.isFinite(versionNum) || versionNum < MIN_PG_VERSION_NUM) {
             throw new Error(`PostgreSQL 15+ is required (server_version_num=${versionNum}) — ` +
@@ -360,7 +323,7 @@ class DatabaseService {
         catch (err) {
             await client.end().catch(() => { });
             const msg = err instanceof Error ? err.message : String(err);
-            throw new Error(`Failed to ensure database "${database}" exists: ${msg}`);
+            throw new Error(`Failed to ensure database "${database}" exists: ${msg}`, { cause: err });
         }
     }
 }

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

@@ -2,8 +2,4 @@ import type { Config } from '../config';
 import type { IEmbedder } from '../interfaces/IEmbedder';
 import type { ILogger } from '../interfaces/ILogger';
 import { type EmbedderDeps } from './OpenAICompatibleEmbedder';
-/**
- * Construct the `IEmbedder` implementation selected by `config.embedding.provider`.
- * The default (`infinity`) is the recommended local backend.
- */
 export declare function createEmbedder(config: Config, logger?: ILogger, deps?: EmbedderDeps): IEmbedder;

package/dist/src/services/EmbedderFactory.js

@@ -5,10 +5,6 @@ const LoggerService_1 = require("./LoggerService");
 const OpenAICompatibleEmbedder_1 = require("./OpenAICompatibleEmbedder");
 const InfinityEmbedder_1 = require("./InfinityEmbedder");
 const VoyageEmbedder_1 = require("./VoyageEmbedder");
-/**
- * Construct the `IEmbedder` implementation selected by `config.embedding.provider`.
- * The default (`infinity`) is the recommended local backend.
- */
 function createEmbedder(config, logger = LoggerService_1.LoggerService.silent(), deps = {}) {
     switch (config.embedding.provider) {
         case 'openai-compatible':
@@ -18,7 +14,6 @@ function createEmbedder(config, logger = LoggerService_1.LoggerService.silent(),
         case 'voyage':
             return new VoyageEmbedder_1.VoyageEmbedder(config, logger, deps);
         default: {
-            // The Zod enum should already reject this; guard anyway for a clear message.
             const p = config.embedding.provider;
             throw new Error(`Unknown embedding provider: "${p}". Expected one of: openai-compatible, voyage, infinity.`);
         }

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

@@ -3,6 +3,7 @@ import type { IEmbedder } from '../interfaces/IEmbedder';
 import type { IAstParser } from '../interfaces/IAstParser';
 import type { IChunker } from '../interfaces/IChunker';
 import type { IDatabase } from '../interfaces/IDatabase';
+import type { DiscoveredProject } from '../interfaces/IProjectDiscovery';
 import type { ILogger } from '../interfaces/ILogger';
 import type { IndexMeta } from '../interfaces/IDatabase';
 export interface IndexStats {
@@ -22,16 +23,6 @@ export declare class IndexerService {
     private config;
     private logger;
     constructor(db: IDatabase, embedder: IEmbedder, ast: IAstParser, chunker: IChunker, config: Config, logger?: ILogger);
-    /**
-     * Resolve the active embedding dimension (config override → registry → probe),
-     * reconcile it against `index_meta`, and prepare `code_chunk` accordingly:
-     * a dimension change drops+recreates the table; a same-dimension model/provider
-     * change clears its rows (vector spaces are not comparable across models); an
-     * unchanged model keeps the rows for incremental indexing. Back-compat: an
-     * existing populated table with no `index_meta` row is treated as the legacy
-     * `ollama`/`bge-m3`/1024 index. Writes `index_meta` to reflect the active model.
-     * Call once per run, before the scan loop.
-     */
     prepareEmbeddingSchema(): Promise<IndexMeta>;
     private reconcileIndex;
     private countChunks;
@@ -39,6 +30,7 @@ export declare class IndexerService {
     scanAndIndex(dir: string, serviceName: string, force?: boolean, signal?: AbortSignal, preCollectedFiles?: string[], opts?: {
         rootTsConfigPath?: string;
     }): Promise<IndexStats>;
+    scanProjects(targets: DiscoveredProject[], force: boolean, signal: AbortSignal, filesPerProject: string[][]): Promise<IndexStats[]>;
     pruneProjects(keep: string[]): Promise<{
         removed: string[];
         failed: string[];

package/dist/src/services/IndexerService.js

@@ -40,13 +40,17 @@ const crypto_1 = require("crypto");
 const cli_progress_1 = require("cli-progress");
 const drizzle_orm_1 = require("drizzle-orm");
 const owner_path_1 = require("../owner-path");
+const DeclarationTree_1 = require("../declarations/DeclarationTree");
+const SourceLines_1 = require("../declarations/SourceLines");
 const enriched_prompt_1 = require("../enriched-prompt");
 const symbol_rows_1 = require("../symbol-rows");
 const db_1 = require("../db");
 const file_utils_1 = require("../file-utils");
 const LoggerService_1 = require("./LoggerService");
 const constants_1 = require("../constants");
+const error_record_1 = require("../error-record");
 const SCHEMA_EXTENSIONS = /\.(prisma|graphql|gql)$/;
+const JSX_EXTENSIONS = /\.(tsx|jsx|js)$/;
 class IndexerService {
     db;
     embedder;
@@ -62,16 +66,6 @@ class IndexerService {
         this.config = config;
         this.logger = logger;
     }
-    /**
-     * Resolve the active embedding dimension (config override → registry → probe),
-     * reconcile it against `index_meta`, and prepare `code_chunk` accordingly:
-     * a dimension change drops+recreates the table; a same-dimension model/provider
-     * change clears its rows (vector spaces are not comparable across models); an
-     * unchanged model keeps the rows for incremental indexing. Back-compat: an
-     * existing populated table with no `index_meta` row is treated as the legacy
-     * `ollama`/`bge-m3`/1024 index. Writes `index_meta` to reflect the active model.
-     * Call once per run, before the scan loop.
-     */
     async prepareEmbeddingSchema() {
         const { provider, model, dimensions: override } = this.config.embedding;
         const next = {
@@ -86,13 +80,11 @@ class IndexerService {
         if (!meta) {
             const chunkCount = await this.countChunks();
             if (chunkCount === 0) {
-                // Fresh index — create the table at the resolved width and record it.
                 await this.db.recreateChunkTable(next.dimensions);
                 await this.db.writeIndexMeta(next);
                 this.logger.debug('IndexerService: prepared fresh index', { ...next });
                 return next;
             }
-            // Legacy index (pre-index_meta): assume the historical default model.
             await this.reconcileIndex({ provider: 'ollama', model: 'bge-m3', dimensions: 1024 }, next);
             return next;
         }
@@ -118,9 +110,6 @@ class IndexerService {
             return Number(rows[0]?.n ?? 0);
         }
         catch (err) {
-            // A missing table means a fresh install → 0. Any other (transient) error
-            // must propagate — returning 0 here could wrongly recreate/drop a populated
-            // table on the `!meta` path.
             if (/does not exist/i.test(err.message))
                 return 0;
             throw err;
@@ -142,9 +131,6 @@ class IndexerService {
         const startTime = Date.now();
         this.logger.debug('IndexerService: scanAndIndex start', { serviceName, dir, force });
         if (force) {
-            // Reset incremental state and clear the project's symbol/call rows in one
-            // transaction: a file whose re-ingestion later fails must hold no rows at
-            // all, never rows in the previous (pre-member-extraction) format.
             await this.db.transaction(async (tx) => {
                 await tx.update(db_1.codeChunk)
                     .set({ lastModified: null, contentHash: null })
@@ -250,16 +236,10 @@ class IndexerService {
                 ]);
             }
             catch (err) {
-                this.logger.error('IndexerService: mtime refresh batch failed', { reason: err.message });
+                this.logger.error('IndexerService: mtime refresh batch failed', { err });
             }
         }
         this.ast.clearCache(dir);
-        // The marker is written exactly when the scan reaches here without having
-        // been interrupted — never on the early-return abort path above, and never
-        // when anything in this method throws (the error propagates instead).
-        if (!signal?.aborted) {
-            await this.db.upsertSymbolIndexVersion(serviceName);
-        }
         stats.elapsedSec = Math.round((Date.now() - startTime) / 100) / 10;
         this.logger.debug('IndexerService: project indexed', {
             project: serviceName,
@@ -271,6 +251,16 @@ class IndexerService {
         });
         return stats;
     }
+    async scanProjects(targets, force, signal, filesPerProject) {
+        const allStats = [];
+        for (let i = 0; i < targets.length; i++) {
+            if (signal.aborted)
+                break;
+            const stats = await this.scanAndIndex(targets[i].path, targets[i].name, force, signal, filesPerProject[i], { rootTsConfigPath: targets[i].rootTsConfigPath ?? undefined });
+            allStats.push(stats);
+        }
+        return allStats;
+    }
     async pruneProjects(keep) {
         if (keep.length === 0)
             return { removed: [], failed: [] };
@@ -286,7 +276,7 @@ class IndexerService {
             }
             catch (err) {
                 console.error(`Failed to prune project ${name}: ${err.message}`);
-                this.logger.error('IndexerService: pruneProject failed', { name, reason: err.message });
+                this.logger.error('IndexerService: pruneProject failed', { name, err });
                 failed.push(name);
             }
         }
@@ -303,21 +293,17 @@ class IndexerService {
                 .from(db_1.codeChunk)
                 .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(db_1.codeChunk.serviceName, serviceName), (0, drizzle_orm_1.eq)(db_1.codeChunk.filePath, relFilePath)))
                 .limit(1);
-            // Fast path: mtime unchanged — skip without reading file
             if (existing?.lastModified === mtimeMs) {
                 return { status: 'skipped', chunks: 0 };
             }
             const t0 = Date.now();
             const code = fs.readFileSync(filePath, 'utf-8');
             const hash = IndexerService.hashContent(code);
-            // Content unchanged (mtime drifted — DB transfer, git clone, touch)
             if (existing !== undefined && existing.contentHash !== null && existing.contentHash === hash) {
                 return { status: 'skipped', chunks: 0, pendingMtimeRefresh: relFilePath };
             }
             const tAst = Date.now();
-            const { edges: rawEdges, symbols: rawSymbols, members: rawMembers = [], calls: rawCalls, ownerRanges: rawOwnerRanges = [], } = analysis ?? { edges: [], symbols: [], calls: [] };
-            // astMs is near-zero — actual AST time is spent upfront in analyzeProject()
-            // Normalize edges to workspace-relative paths
+            const { edges: rawEdges, symbols: rawSymbols, members: rawMembers = [], calls: rawCalls, graphqlNames: rawGraphqlNames = [], } = analysis ?? { edges: [], symbols: [], calls: [] };
             const edges = rawEdges
                 .filter(e => e.toFile.startsWith(this.config.workspaceRoot))
                 .map(e => ({
@@ -325,7 +311,6 @@ class IndexerService {
                 fromFile: path.relative(this.config.workspaceRoot, e.fromFile),
                 toFile: path.relative(this.config.workspaceRoot, e.toFile),
             }));
-            // Normalize call edges to workspace-relative paths; keep only resolved internal calls
             const calls = rawCalls
                 .filter(c => c.calleeFile.startsWith(this.config.workspaceRoot))
                 .map(c => ({
@@ -338,26 +323,25 @@ class IndexerService {
                 line: c.line,
                 col: c.col,
             }));
-            // symbols ∪ members → code_symbol rows: overload sets collapse to their
-            // representative row, then a final dedup by (container, name, kind, line).
-            const symbolRows = (0, symbol_rows_1.buildSymbolRows)(rawSymbols, rawMembers).map(s => ({ ...s, filePath: relFilePath }));
+            const symbolRows = (0, symbol_rows_1.buildSymbolRows)(rawSymbols, rawMembers, rawGraphqlNames).map(s => ({ ...s, filePath: relFilePath }));
+            const promptEdges = edges.filter(e => e.depType !== 'import-side-effect');
             const astMs = Date.now() - tAst;
+            const jsx = JSX_EXTENSIONS.test(filePath);
             const chunks = await this.chunker.chunk(code, {
                 strategy: this.config.indexer.chunkStrategy,
                 isSchemaFile: SCHEMA_EXTENSIONS.test(filePath),
-                symbols: rawSymbols,
+                declarations: analysis?.declarations,
+                jsx,
             });
             const relPath = path.relative(projectRoot, filePath);
-            // Ownership ranges (decorator-inclusive, symbols ∪ members minus
-            // method_signature) are built by AstParserService — the deepest range
-            // containing a chunk's start line wins.
-            const ownerRanges = rawOwnerRanges;
+            const sourceLines = new SourceLines_1.SourceLines(code, { jsx });
+            const ownerTree = analysis?.declarations ?? DeclarationTree_1.DeclarationTree.EMPTY;
             const t2 = Date.now();
             const records = [];
             const embedBatchSize = this.config.embedding.batchSize;
             for (let i = 0; i < chunks.length; i += embedBatchSize) {
                 const batch = chunks.slice(i, i + embedBatchSize);
-                const prompts = batch.map(piece => (0, enriched_prompt_1.getEnrichedPrompt)(piece, relPath, serviceName, edges, rawSymbols));
+                const prompts = batch.map(piece => (0, enriched_prompt_1.getEnrichedPrompt)(piece, relPath, serviceName, promptEdges, rawSymbols));
                 const vectors = await this.embedder.embedBatch(prompts, 'document');
                 for (let j = 0; j < batch.length; j++) {
                     const piece = batch[j];
@@ -367,7 +351,8 @@ class IndexerService {
                         embedding: `[${vectors[j]}]`,
                         lastModified: mtimeMs,
                         contentHash: hash,
-                        ownerPath: (0, owner_path_1.resolveOwnerPath)(piece.startLine, ownerRanges),
+                        ownerPath: (0, owner_path_1.ownerOf)(piece, ownerTree, sourceLines),
+                        endLine: piece.startLine + (piece.content.match(/\n/g)?.length ?? 0),
                     });
                 }
             }
@@ -398,9 +383,8 @@ class IndexerService {
             return { status: 'indexed', chunks: chunks.length };
         }
         catch (err) {
-            const reason = err.message;
-            console.error(`\n[indexer] Failed: ${filePath} — ${reason}`);
-            this.logger.error('IndexerService: failed to index file', { file: filePath, reason });
+            console.error(`\n[indexer] Failed: ${filePath} — ${(0, error_record_1.rootCauseMessage)(err)}`);
+            this.logger.error('IndexerService: failed to index file', { file: filePath, err });
             return { status: 'failed', chunks: 0 };
         }
     }

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

@@ -4,35 +4,14 @@ import { OpenAICompatibleEmbedder, type EmbedderDeps } from './OpenAICompatibleE
 import { serverRoot, probeInfinityHealth, listInfinityModels, type ProvisioningDeps } from './infinity-provisioning';
 export { serverRoot, probeInfinityHealth, listInfinityModels };
 export type { CommandResult } from './infinity-provisioning';
-/** Extra injection seams for `InfinityEmbedder` beyond the shared `EmbedderDeps`. */
 export interface InfinityDeps extends EmbedderDeps, ProvisioningDeps {
-    /**
-     * Path to the managed docker-compose.yml. Defaults to the file `rag-setup`
-     * writes into `~/.config/codesearch-mcp/`. A missing file (or one without an
-     * `infinity` service) means "external backend" — the Docker path is skipped.
-     */
     composePath?: string;
 }
-/**
- * Embedder for a local Infinity server. Inherits the OpenAI-style `/embeddings`
- * HTTP path, batching, retry, and reranker wiring from `OpenAICompatibleEmbedder`
- * unchanged — it adds ONLY container-readiness behavior (`ensureModelAvailable`,
- * `listModels`), delegating to the standalone `infinity-provisioning` primitive
- * because Infinity binds its model set at container startup and exposes no
- * runtime model-pull API.
- */
 export declare class InfinityEmbedder extends OpenAICompatibleEmbedder {
     private readonly base;
     private readonly composePath;
     private readonly provisioningDeps;
     constructor(config: Config, logger?: ILogger, deps?: InfinityDeps);
-    /**
-     * Index-time embed readiness (see `local-backend-provisioning`): verifies only
-     * the embedding model — indexing does not use the reranker, so a missing
-     * reranker model never blocks or restarts indexing. Whenever a recreate is
-     * needed, the full configured set is written so an already-served reranker
-     * model is never dropped. Called by `IndexCommand` before indexing.
-     */
     ensureModelAvailable(): Promise<void>;
     listModels(): Promise<string[]>;
 }

package/dist/src/services/InfinityEmbedder.js

@@ -42,14 +42,6 @@ Object.defineProperty(exports, "serverRoot", { enumerable: true, get: function (
 Object.defineProperty(exports, "probeInfinityHealth", { enumerable: true, get: function () { return infinity_provisioning_1.probeInfinityHealth; } });
 Object.defineProperty(exports, "listInfinityModels", { enumerable: true, get: function () { return infinity_provisioning_1.listInfinityModels; } });
 const path = __importStar(require("path"));
-/**
- * Embedder for a local Infinity server. Inherits the OpenAI-style `/embeddings`
- * HTTP path, batching, retry, and reranker wiring from `OpenAICompatibleEmbedder`
- * unchanged — it adds ONLY container-readiness behavior (`ensureModelAvailable`,
- * `listModels`), delegating to the standalone `infinity-provisioning` primitive
- * because Infinity binds its model set at container startup and exposes no
- * runtime model-pull API.
- */
 class InfinityEmbedder extends OpenAICompatibleEmbedder_1.OpenAICompatibleEmbedder {
     base;
     composePath;
@@ -65,13 +57,6 @@ class InfinityEmbedder extends OpenAICompatibleEmbedder_1.OpenAICompatibleEmbedd
             readinessTimeoutMs: deps.readinessTimeoutMs,
         };
     }
-    /**
-     * Index-time embed readiness (see `local-backend-provisioning`): verifies only
-     * the embedding model — indexing does not use the reranker, so a missing
-     * reranker model never blocks or restarts indexing. Whenever a recreate is
-     * needed, the full configured set is written so an already-served reranker
-     * model is never dropped. Called by `IndexCommand` before indexing.
-     */
     async ensureModelAvailable() {
         await (0, infinity_provisioning_1.ensureBackendReady)({
             baseURL: this.config.embedding.baseURL,

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

@@ -3,17 +3,19 @@ import type { ILogger } from '../interfaces/ILogger';
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 export declare class LoggerService implements ILogger {
     private readonly logger;
-    private readonly metricsLogger;
-    constructor(logger: pino.Logger, metricsLogger?: pino.Logger | null);
+    private readonly context;
+    private constructor();
     static silent(): LoggerService;
     static fromConfig(cfg: {
         level: string;
         dir?: string;
-    }, name?: string): LoggerService;
-    private static buildFromPath;
+    }, name?: string, bindings?: Record<string, unknown>): LoggerService;
+    static toStream(level: LogLevel, stream: pino.DestinationStream, bindings?: Record<string, unknown>): LoggerService;
+    private static fileTransport;
+    private static build;
     debug(msg: string, data?: Record<string, unknown>): void;
     info(msg: string, data?: Record<string, unknown>): void;
     warn(msg: string, data?: Record<string, unknown>): void;
     error(msg: string, data?: Record<string, unknown>): void;
-    metric(msg: string, data?: Record<string, unknown>): void;
+    withContext<T>(context: Record<string, unknown>, fn: () => Promise<T>): Promise<T>;
 }