codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

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

@@ -1,29 +1,24 @@
-import type { NodePgDatabase, NodePgTransaction } from 'drizzle-orm/node-postgres';
-import type { ExtractTablesWithRelations } from 'drizzle-orm/relations';
 import type { Config } from '../config';
-import type { IDatabase, IndexMeta } from '../interfaces/IDatabase';
-import * as schema from '../db/schema';
-type Schema = typeof schema;
-export type DrizzleDb = NodePgDatabase<Schema>;
-export type DrizzleTx = NodePgTransaction<Schema, ExtractTablesWithRelations<Schema>>;
+import type { IDatabase, IndexMeta, InitDbOptions } from '../interfaces/IDatabase';
+import type { ILogger } from '../interfaces/ILogger';
+import type { DrizzleDb, DrizzleTx } from '../db';
 export declare class DatabaseService implements IDatabase {
     private config;
+    private logger;
     private pool;
     private _db;
-    constructor(config: Config);
+    private probeTimeoutMs;
+    constructor(config: Config, logger?: ILogger);
     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>;
+    initDb(options?: InitDbOptions): Promise<void>;
+    probe(): 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>;
@@ -31,9 +26,7 @@ export declare class DatabaseService implements IDatabase {
     deleteFiles(project: string, filePaths: string[]): Promise<void>;
     listIndexedProjects(): Promise<string[]>;
     deleteProject(name: string): Promise<void>;
-    /** Guard against SQL injection — the dimension is interpolated into DDL. */
     private assertDim;
     private assertMinPostgresVersion;
     private ensureDatabaseExists;
 }
-export {};

package/dist/src/services/DatabaseService.js

@@ -34,24 +34,67 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabaseService = void 0;
+const async_hooks_1 = require("async_hooks");
 const node_postgres_1 = require("drizzle-orm/node-postgres");
 const pg_1 = require("pg");
 const drizzle_orm_1 = require("drizzle-orm");
+const LoggerService_1 = require("./LoggerService");
 const schema = __importStar(require("../db/schema"));
 const db_1 = require("../db");
+const schema_steps_1 = require("../db/schema-steps");
 const MIN_PG_VERSION_NUM = 150000;
+const SETTING_NAME = /^[a-z_]+(\.[a-z_]+)*$/;
+const SETTING_VALUE = /^[A-Za-z0-9_]+$/;
 class DatabaseService {
     config;
+    logger;
     pool;
     _db;
-    constructor(config) {
+    probeTimeoutMs;
+    constructor(config, logger = LoggerService_1.LoggerService.silent()) {
         this.config = config;
+        this.logger = logger;
     }
     get orm() { return this._db; }
     async query(sql, params) {
         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);
     }
@@ -60,118 +103,32 @@ class DatabaseService {
             return Promise.resolve();
         return this.pool.end();
     }
-    async initDb() {
+    async initDb(options = {}) {
         const { host, port, username, password, database } = this.config.db;
-        this.pool = new pg_1.Pool({ host, port, user: username, password, database });
+        const { connectionTimeoutMs } = options;
+        this.probeTimeoutMs = connectionTimeoutMs;
+        this.pool = new pg_1.Pool({
+            host, port, user: username, password, database,
+            ...(connectionTimeoutMs !== undefined ? { connectionTimeoutMillis: connectionTimeoutMs } : {}),
+        });
+        this.pool.on('error', async_hooks_1.AsyncResource.bind((err) => {
+            this.logger.warn('DatabaseService: idle client error', { err });
+        }));
         this._db = (0, node_postgres_1.drizzle)(this.pool, { schema });
         await this.pool.query('SELECT 1');
     }
+    async probe() {
+        if (!this.pool)
+            throw new Error('DatabaseService: probe() called before initDb()');
+        const query = { text: 'SELECT 1', query_timeout: this.probeTimeoutMs };
+        await this.pool.query(query);
+    }
     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,
-        provider    TEXT NOT NULL,
-        model       TEXT NOT NULL,
-        dimensions  INT  NOT NULL,
-        "indexedAt" TIMESTAMPTZ NOT NULL DEFAULT now()
-      )
-    `);
-        // code_dependency table
-        const [{ existsDep }] = await this.query(`
-      SELECT EXISTS (
-        SELECT 1 FROM information_schema.tables
-        WHERE table_schema = 'public' AND table_name = 'code_dependency'
-      ) AS "existsDep"
-    `);
-        if (!existsDep) {
-            await this.query(`
-        CREATE TABLE code_dependency (
-          id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-          project      TEXT NOT NULL,
-          "fromFile"   TEXT NOT NULL,
-          "fromSymbol" TEXT,
-          "toFile"     TEXT NOT NULL,
-          "toSymbol"   TEXT,
-          "depType"    TEXT NOT NULL
-        )
-      `);
-        }
-        await this.query(`CREATE INDEX IF NOT EXISTS idx_dep_project_from ON code_dependency (project, "fromFile")`);
-        await this.query(`CREATE INDEX IF NOT EXISTS idx_dep_project_to   ON code_dependency (project, "toFile")`);
-        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
-        WHERE table_schema = 'public' AND table_name = 'code_symbol'
-      ) AS "existsSym"
-    `);
-        if (!existsSym) {
-            await this.query(`
-        CREATE TABLE code_symbol (
-          id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-          project    TEXT NOT NULL,
-          "filePath" TEXT NOT NULL,
-          name       TEXT NOT NULL,
-          kind       TEXT NOT NULL,
-          signature  TEXT,
-          line       INT,
-          col        INT
-        )
-      `);
-        }
-        await this.query(`CREATE INDEX IF NOT EXISTS idx_symbol_name   ON code_symbol (name, project)`);
-        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`);
-        await this.query(`ALTER TABLE code_symbol ADD COLUMN IF NOT EXISTS "target" TEXT`);
-        // 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.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');
-        });
-        // 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,
-        "fromFile"     TEXT NOT NULL,
-        "fromSymbol"   TEXT,
-        "calleeName"   TEXT NOT NULL,
-        "calleeFile"   TEXT NOT NULL,
-        "calleeSymbol" TEXT,
-        line           INT,
-        col            INT
-      )
-    `);
-        await this.query(`CREATE INDEX IF NOT EXISTS idx_call_callee      ON code_call (project, "calleeName")`);
-        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")`);
+        await (0, schema_steps_1.runSchemaSteps)(this);
     }
-    /**
-     * 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(`
@@ -184,15 +141,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(`CREATE INDEX IF NOT EXISTS idx_code_chunk_embedding ON code_chunk USING hnsw (embedding vector_cosine_ops)`);
+        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) WITH (m = 32, ef_construction = 200)`);
         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`);
@@ -204,9 +162,10 @@ class DatabaseService {
             const row = rows[0];
             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;
+        catch (err) {
+            if (err?.code === '42P01')
+                return null;
+            throw err;
         }
     }
     async writeIndexMeta(meta) {
@@ -231,8 +190,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) {
@@ -262,7 +219,6 @@ class DatabaseService {
             await tx.delete(db_1.codeDependency).where((0, drizzle_orm_1.eq)(db_1.codeDependency.project, name));
         });
     }
-    /** 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)`);
@@ -276,7 +232,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}) — ` +
@@ -310,7 +266,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

@@ -2,10 +2,9 @@ import type { Config } from '../config';
 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 { IDatabase, IndexMeta } from '../interfaces/IDatabase';
 import type { DiscoveredProject } from '../interfaces/IProjectDiscovery';
 import type { ILogger } from '../interfaces/ILogger';
-import type { IndexMeta } from '../interfaces/IDatabase';
 export interface IndexStats {
     serviceName: string;
     indexed: number;
@@ -17,40 +16,22 @@ export interface IndexStats {
 }
 export declare class IndexerService {
     private db;
-    private embedder;
     private ast;
-    private chunker;
-    private config;
     private logger;
+    private readonly store;
+    private readonly stalePruner;
+    private readonly batcher;
+    private readonly chunkEmbedder;
+    private readonly ingestor;
+    private readonly schema;
     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;
-    private writeDepEdges;
     scanAndIndex(dir: string, serviceName: string, force?: boolean, signal?: AbortSignal, preCollectedFiles?: string[], opts?: {
         rootTsConfigPath?: string;
     }): Promise<IndexStats>;
-    /**
-     * Scan several leaf projects in one call, each with its own `rootTsConfigPath`
-     * (a unit's children may belong to different monorepos). No pruning, no
-     * console output — callers (CLI or a future hook) own reporting. A rejecting
-     * `scanAndIndex` call stops the loop before the next target and propagates.
-     */
     scanProjects(targets: DiscoveredProject[], force: boolean, signal: AbortSignal, filesPerProject: string[][]): Promise<IndexStats[]>;
     pruneProjects(keep: string[]): Promise<{
         removed: string[];
         failed: string[];
     }>;
-    private static hashContent;
-    private ingestFile;
 }