codesearch-mcp 0.0.18-alpha → 0.1.0-alpha

package/dist/src/config.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Config = exports.ConfigError = void 0;
+exports.resolveEnvRef = resolveEnvRef;
 const os = __importStar(require("os"));
 const zod_1 = require("zod");
 const config_store_1 = require("./config-store");
@@ -44,6 +45,41 @@ class ConfigError extends Error {
     }
 }
 exports.ConfigError = ConfigError;
+/**
+ * Resolve a config value that may reference an environment variable. A value of
+ * the form `env:VAR_NAME` resolves to `process.env.VAR_NAME`; any other string
+ * (including empty) is returned verbatim. A referenced-but-unset variable throws
+ * a clear error naming the variable and the `.env` file. Pure aside from the
+ * injected env map. See `src/app.ts` for how `.env` is loaded into the process.
+ */
+function resolveEnvRef(value, env = process.env) {
+    if (!value.startsWith('env:'))
+        return value;
+    const name = value.slice(4).trim();
+    const resolved = name ? env[name] : undefined;
+    if (resolved == null || resolved === '') {
+        throw new ConfigError(`Config references environment variable "${name}" (as "env:${name}") but it is not set. ` +
+            `Define ${name} in ${config_store_1.ENV_FILE} or export it in the environment.`);
+    }
+    return resolved;
+}
+const DEFAULT_BASE_URLS = {
+    'ollama': 'http://localhost:11434',
+    'openai-compatible': 'https://api.openai.com/v1',
+    'voyage': 'https://api.voyageai.com/v1',
+    'infinity': 'http://localhost:7997',
+};
+function defaultBaseURL(provider) {
+    return DEFAULT_BASE_URLS[provider] ?? DEFAULT_BASE_URLS.ollama;
+}
+// Reranking is served only by OpenAI-compatible `/rerank` endpoints (Infinity,
+// TEI, vLLM, Jina/Cohere-shape). Ollama has no rerank API, so there is a single
+// endpoint shape. Normalize a trailing `/embeddings` or `/v1` to the server root
+// so a baseURL written with an OpenAI-style suffix still yields `<root>/rerank`.
+function deriveRerankUrl(baseURL) {
+    const root = baseURL.replace(/\/+$/, '').replace(/\/(embeddings|v1)$/, '');
+    return `${root}/rerank`;
+}
 const resolvedSchema = zod_1.z.object({
     db: zod_1.z.object({
         host: zod_1.z.string().min(1, 'required — run rag-setup'),
@@ -52,26 +88,34 @@ const resolvedSchema = zod_1.z.object({
         password: zod_1.z.string().min(1, 'required — run rag-setup'),
         database: zod_1.z.string().min(1),
     }),
-    ollama: zod_1.z.object({
-        host: zod_1.z.string().min(1).default(config_store_1.CONFIG_DEFAULTS['ollama.host']),
-        model: zod_1.z.string().min(1).default(config_store_1.CONFIG_DEFAULTS['ollama.model']),
-        rerankerModel: zod_1.z.string().default(config_store_1.CONFIG_DEFAULTS['reranker.model']),
-        rerankerUrl: zod_1.z.string().min(1),
+    embedding: zod_1.z.object({
+        provider: zod_1.z.enum(['ollama', 'openai-compatible', 'voyage', 'infinity']).default(config_store_1.CONFIG_DEFAULTS['embedding.provider']),
+        baseURL: zod_1.z.string().min(1),
+        apiKey: zod_1.z.string().default(config_store_1.CONFIG_DEFAULTS['embedding.apiKey']),
+        model: zod_1.z.string().min(1).default(config_store_1.CONFIG_DEFAULTS['embedding.model']),
+        dimensions: zod_1.z.number().int().positive().nullable().default(null),
+        batchSize: zod_1.z.number().int().positive().default(config_store_1.CONFIG_DEFAULTS['embedding.batchSize']),
+    }),
+    reranker: zod_1.z.object({
+        enabled: zod_1.z.boolean().default(config_store_1.CONFIG_DEFAULTS['reranker.enabled']),
+        provider: zod_1.z.enum(['openai-compatible']).default(config_store_1.CONFIG_DEFAULTS['reranker.provider']),
+        baseURL: zod_1.z.string().min(1),
+        apiKey: zod_1.z.string().default(config_store_1.CONFIG_DEFAULTS['reranker.apiKey']),
+        model: zod_1.z.string().default(config_store_1.CONFIG_DEFAULTS['reranker.model']),
+        url: zod_1.z.string().min(1),
+        overfetch: zod_1.z.number().int().min(1).max(20).default(config_store_1.CONFIG_DEFAULTS['reranker.overfetch']),
     }),
     indexer: zod_1.z.object({
         chunkSize: zod_1.z.number().int().positive().default(config_store_1.CONFIG_DEFAULTS['indexing.chunkSize']),
         chunkOverlap: zod_1.z.number().int().min(0).default(config_store_1.CONFIG_DEFAULTS['indexing.chunkOverlap']),
         batchSize: zod_1.z.number().int().positive().default(config_store_1.CONFIG_DEFAULTS['indexing.embedBatchSize']),
         astBatchSize: zod_1.z.number().int().positive().default(config_store_1.CONFIG_DEFAULTS['indexing.astBatchSize']),
+        chunkStrategy: zod_1.z.enum(['ast', 'character']).default(config_store_1.CONFIG_DEFAULTS['indexing.chunkStrategy']),
     }),
     search: zod_1.z.object({
         similarityThreshold: zod_1.z.number().min(0).max(1).default(config_store_1.CONFIG_DEFAULTS['search.similarityThreshold']),
         defaultLimit: zod_1.z.number().int().positive().default(config_store_1.CONFIG_DEFAULTS['search.defaultLimit']),
         maxLimit: zod_1.z.number().int().positive().default(config_store_1.CONFIG_DEFAULTS['search.maxLimit']),
-        autoTranslate: zod_1.z.boolean().default(config_store_1.CONFIG_DEFAULTS['search.autoTranslate']),
-        translateModel: zod_1.z.string().default(config_store_1.CONFIG_DEFAULTS['search.translateModel']),
-        rerankerEnabled: zod_1.z.boolean().default(config_store_1.CONFIG_DEFAULTS['reranker.enabled']),
-        rerankerOverfetch: zod_1.z.number().int().min(1).max(20).default(config_store_1.CONFIG_DEFAULTS['reranker.overfetch']),
     }),
     logging: zod_1.z.object({
         level: zod_1.z.enum(['debug', 'info', 'warn', 'error']).default(config_store_1.CONFIG_DEFAULTS['logging.level']),
@@ -82,7 +126,16 @@ const resolvedSchema = zod_1.z.object({
 class Config {
     data;
     get db() { return this.data.db; }
-    get ollama() { return this.data.ollama; }
+    /**
+     * Embedding config. `apiKey` is returned **raw** (possibly an `env:VAR` ref) —
+     * callers resolve it lazily via `resolveEnvRef` at the moment they build a
+     * request, so an unset referenced variable fails only when the key is actually
+     * needed (during embed/search) rather than crashing container construction and
+     * locking the user out of `rag-web`/`rag-mcp`.
+     */
+    get embedding() { return this.data.embedding; }
+    /** Reranker config. `apiKey` is raw — resolve lazily with `resolveEnvRef`. */
+    get reranker() { return this.data.reranker; }
     get indexer() { return this.data.indexer; }
     get search() { return this.data.search; }
     get logging() { return this.data.logging; }
@@ -91,7 +144,10 @@ class Config {
         const raw = (0, config_store_1.readConfigJson)();
         if (!raw)
             throw new ConfigError('Config not found. Run rag-setup.');
-        const ollamaHost = raw.ollama?.host ?? 'http://localhost:11434';
+        const embProvider = (raw.embedding?.provider ?? config_store_1.CONFIG_DEFAULTS['embedding.provider']);
+        const embBaseURL = raw.embedding?.baseURL ?? defaultBaseURL(embProvider);
+        const rerankBaseURL = raw.reranker?.baseURL ?? embBaseURL;
+        const rerankUrl = raw.reranker?.url ?? deriveRerankUrl(rerankBaseURL);
         const result = resolvedSchema.safeParse({
             db: {
                 host: raw.db?.host,
@@ -100,26 +156,34 @@ class Config {
                 password: raw.db?.password,
                 database: raw.db?.name ?? this.deriveDbName(),
             },
-            ollama: {
-                host: raw.ollama?.host,
-                model: raw.ollama?.model,
-                rerankerModel: raw.reranker?.model,
-                rerankerUrl: raw.reranker?.url ?? `${ollamaHost}/api/rerank`,
+            embedding: {
+                provider: raw.embedding?.provider,
+                baseURL: embBaseURL,
+                apiKey: raw.embedding?.apiKey,
+                model: raw.embedding?.model,
+                dimensions: raw.embedding?.dimensions,
+                batchSize: raw.embedding?.batchSize,
+            },
+            reranker: {
+                enabled: raw.reranker?.enabled,
+                provider: raw.reranker?.provider,
+                baseURL: rerankBaseURL,
+                apiKey: raw.reranker?.apiKey,
+                model: raw.reranker?.model,
+                url: rerankUrl,
+                overfetch: raw.reranker?.overfetch,
             },
             indexer: {
                 chunkSize: raw.indexing?.chunkSize,
                 chunkOverlap: raw.indexing?.chunkOverlap,
                 batchSize: raw.indexing?.embedBatchSize,
                 astBatchSize: raw.indexing?.astBatchSize,
+                chunkStrategy: raw.indexing?.chunkStrategy,
             },
             search: {
                 similarityThreshold: raw.search?.similarityThreshold,
                 defaultLimit: raw.search?.defaultLimit,
                 maxLimit: raw.search?.maxLimit,
-                autoTranslate: raw.search?.autoTranslate,
-                translateModel: raw.search?.translateModel,
-                rerankerEnabled: raw.reranker?.enabled,
-                rerankerOverfetch: raw.reranker?.overfetch,
             },
             logging: {
                 level: raw.logging?.level,

package/dist/src/constants.d.ts

@@ -1,2 +1,36 @@
-export declare const SUPPORTED_EMBED_MODELS: readonly ["bge-m3"];
-export declare const DEFAULT_EMBED_MODEL: string;
+export type EmbeddingProvider = 'ollama' | 'openai-compatible' | 'voyage' | 'infinity';
+/**
+ * pgvector's HNSW / IVFFlat index hard limit. The effective embedding dimension
+ * must not exceed this; larger cloud models must reduce via the Matryoshka
+ * `dimensions` request parameter (`embedding.dimensions`).
+ */
+export declare const MAX_EMBED_DIM = 2000;
+export interface ModelInfo {
+    provider: EmbeddingProvider;
+    /** Native / default output width. */
+    dimensions: number;
+    /** Model supports Matryoshka dimension reduction via a request parameter. */
+    dimConfigurable?: boolean;
+    /** Max width that can be indexed under the pgvector cap (advisory). */
+    maxIndexable?: number;
+    /** Max width the model itself can emit (advisory). */
+    maxDim?: number;
+}
+/**
+ * Advisory (NOT exhaustive) registry of known embedding models. Used to resolve
+ * a model's dimension without a runtime probe and to suggest models in the
+ * dashboard. Models absent here still work — their dimension is probed at index
+ * time (see `resolveDimension`).
+ */
+export declare const MODEL_REGISTRY: Record<string, ModelInfo>;
+export declare const DEFAULT_EMBED_MODEL = "bge-m3";
+/** Advisory dimension for a model, or `undefined` when the model is unknown. */
+export declare function registryDimension(model: string): number | undefined;
+/**
+ * Resolve the effective vector dimension: explicit override → registry → probe.
+ * Validates the result is ≤ MAX_EMBED_DIM, throwing an error that names
+ * `embedding.dimensions` as the fix. `probeFn` embeds a short string once and
+ * returns the observed length; only called when neither override nor registry
+ * yields a value. Pure aside from the injected probe.
+ */
+export declare function resolveDimension(override: number | null | undefined, model: string, probeFn: () => Promise<number>, registry?: Record<string, ModelInfo>): Promise<number>;

package/dist/src/constants.js

@@ -1,9 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_EMBED_MODEL = exports.SUPPORTED_EMBED_MODELS = void 0;
-// Embedding model is tied to the vector column dimension (bge-m3 → 1024).
-// Only 1024-dim models belong here — switching requires dropping/recreating the
-// `embedding` column and re-indexing. The dashboard offers this list as a strict
-// dropdown for ollama.model (no free text) so a mismatched model can't be set.
-exports.SUPPORTED_EMBED_MODELS = ['bge-m3'];
-exports.DEFAULT_EMBED_MODEL = exports.SUPPORTED_EMBED_MODELS[0];
+exports.DEFAULT_EMBED_MODEL = exports.MODEL_REGISTRY = exports.MAX_EMBED_DIM = void 0;
+exports.registryDimension = registryDimension;
+exports.resolveDimension = resolveDimension;
+/**
+ * pgvector's HNSW / IVFFlat index hard limit. The effective embedding dimension
+ * must not exceed this; larger cloud models must reduce via the Matryoshka
+ * `dimensions` request parameter (`embedding.dimensions`).
+ */
+exports.MAX_EMBED_DIM = 2000;
+/**
+ * Advisory (NOT exhaustive) registry of known embedding models. Used to resolve
+ * a model's dimension without a runtime probe and to suggest models in the
+ * dashboard. Models absent here still work — their dimension is probed at index
+ * time (see `resolveDimension`).
+ */
+exports.MODEL_REGISTRY = {
+    'bge-m3': { provider: 'ollama', dimensions: 1024 },
+    'nomic-embed-text': { provider: 'ollama', dimensions: 768 },
+    'mxbai-embed-large': { provider: 'ollama', dimensions: 1024 },
+    'text-embedding-3-small': { provider: 'openai-compatible', dimensions: 1536, dimConfigurable: true },
+    'text-embedding-3-large': { provider: 'openai-compatible', dimensions: 3072, dimConfigurable: true, maxIndexable: 2000 },
+    'text-embedding-ada-002': { provider: 'openai-compatible', dimensions: 1536 },
+    'voyage-code-3': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048 },
+    'voyage-3': { provider: 'voyage', dimensions: 1024, dimConfigurable: true },
+    'voyage-3-lite': { provider: 'voyage', dimensions: 512 },
+    'BAAI/bge-m3': { provider: 'infinity', dimensions: 1024 },
+    'jinaai/jina-embeddings-v2-base-code': { provider: 'infinity', dimensions: 768 },
+};
+exports.DEFAULT_EMBED_MODEL = 'bge-m3';
+/** Advisory dimension for a model, or `undefined` when the model is unknown. */
+function registryDimension(model) {
+    return exports.MODEL_REGISTRY[model]?.dimensions;
+}
+/**
+ * Resolve the effective vector dimension: explicit override → registry → probe.
+ * Validates the result is ≤ MAX_EMBED_DIM, throwing an error that names
+ * `embedding.dimensions` as the fix. `probeFn` embeds a short string once and
+ * returns the observed length; only called when neither override nor registry
+ * yields a value. Pure aside from the injected probe.
+ */
+async function resolveDimension(override, model, probeFn, registry = exports.MODEL_REGISTRY) {
+    let dim;
+    if (override != null) {
+        dim = override;
+    }
+    else {
+        const known = registry[model]?.dimensions;
+        dim = known != null ? known : await probeFn();
+    }
+    if (!Number.isInteger(dim) || dim <= 0) {
+        throw new Error(`Could not resolve a valid embedding dimension for model "${model}" (got ${dim}). Set embedding.dimensions explicitly.`);
+    }
+    if (dim > exports.MAX_EMBED_DIM) {
+        throw new Error(`Embedding dimension ${dim} for model "${model}" exceeds the pgvector limit of ${exports.MAX_EMBED_DIM}. ` +
+            `Set embedding.dimensions to a value ≤ ${exports.MAX_EMBED_DIM} to request dimension-reduced (Matryoshka) vectors.`);
+    }
+    return dim;
+}

package/dist/src/container.js

@@ -3,8 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createContainer = createContainer;
 const config_1 = require("./config");
 const DatabaseService_1 = require("./services/DatabaseService");
-const OllamaEmbedder_1 = require("./services/OllamaEmbedder");
+const EmbedderFactory_1 = require("./services/EmbedderFactory");
 const AstParserService_1 = require("./services/AstParserService");
+const AstChunker_1 = require("./services/AstChunker");
 const IndexerService_1 = require("./services/IndexerService");
 const SearcherService_1 = require("./services/SearcherService");
 const McpServer_1 = require("./services/McpServer");
@@ -15,10 +16,11 @@ function createContainer(loggerName) {
     const config = new config_1.Config();
     const logger = LoggerService_1.LoggerService.fromConfig(config.logging, loggerName);
     const db = new DatabaseService_1.DatabaseService(config);
-    const embedder = new OllamaEmbedder_1.OllamaEmbedder(config, logger);
+    const embedder = (0, EmbedderFactory_1.createEmbedder)(config, logger);
     const ast = new AstParserService_1.AstParserService(logger);
+    const chunker = new AstChunker_1.AstChunker(config);
     const discovery = new MonorepoAwareDiscoveryService_1.MonorepoAwareDiscoveryService([new NxMonorepoResolver_1.NxMonorepoResolver(logger)], logger);
-    const indexer = new IndexerService_1.IndexerService(db, embedder, ast, config, logger);
+    const indexer = new IndexerService_1.IndexerService(db, embedder, ast, chunker, config, logger);
     const searcher = new SearcherService_1.SearcherService(db, embedder, discovery, config, logger);
     const mcp = new McpServer_1.McpServer(searcher, config, logger);
     return { config, db, embedder, indexer, searcher, mcp, logger, discovery };

package/dist/src/db/index.d.ts

@@ -1,2 +1,2 @@
-export { codeChunk, codeDependency, codeSymbol, codeCall } from './schema';
+export { codeChunk, codeDependency, codeSymbol, codeCall, indexMeta } from './schema';
 export type { CodeChunkInsert } from './schema';

package/dist/src/db/index.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.codeCall = exports.codeSymbol = exports.codeDependency = exports.codeChunk = void 0;
+exports.indexMeta = exports.codeCall = exports.codeSymbol = exports.codeDependency = exports.codeChunk = void 0;
 var schema_1 = require("./schema");
 Object.defineProperty(exports, "codeChunk", { enumerable: true, get: function () { return schema_1.codeChunk; } });
 Object.defineProperty(exports, "codeDependency", { enumerable: true, get: function () { return schema_1.codeDependency; } });
 Object.defineProperty(exports, "codeSymbol", { enumerable: true, get: function () { return schema_1.codeSymbol; } });
 Object.defineProperty(exports, "codeCall", { enumerable: true, get: function () { return schema_1.codeCall; } });
+Object.defineProperty(exports, "indexMeta", { enumerable: true, get: function () { return schema_1.indexMeta; } });

package/dist/src/db/schema.d.ts

@@ -142,6 +142,25 @@ export declare const codeChunk: import("drizzle-orm/pg-core").PgTableWithColumns
         }, {}, {
             length: 64;
         }>;
+        ownerPath: import("drizzle-orm/pg-core").PgColumn<{
+            name: "ownerPath";
+            tableName: "code_chunk";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
     };
     dialect: "pg";
 }>;
@@ -574,4 +593,96 @@ export declare const codeCall: import("drizzle-orm/pg-core").PgTableWithColumns<
     };
     dialect: "pg";
 }>;
+export declare const indexMeta: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "index_meta";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "index_meta";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        provider: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provider";
+            tableName: "index_meta";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        model: import("drizzle-orm/pg-core").PgColumn<{
+            name: "model";
+            tableName: "index_meta";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dimensions: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dimensions";
+            tableName: "index_meta";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        indexedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "indexedAt";
+            tableName: "index_meta";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
 export type CodeChunkInsert = typeof codeChunk.$inferInsert;

package/dist/src/db/schema.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.codeCall = exports.codeSymbol = exports.codeDependency = exports.codeChunk = void 0;
+exports.indexMeta = exports.codeCall = exports.codeSymbol = exports.codeDependency = exports.codeChunk = void 0;
 const pg_core_1 = require("drizzle-orm/pg-core");
+// NOTE: the `dimensions` literal below is nominal only. `dataType()` is invoked
+// solely by drizzle-kit DDL generation, which this project does not use — the
+// `code_chunk` table is created by raw SQL in DatabaseService at the dimension
+// resolved from the active model, and the real width is recorded in index_meta.
 const vector = (0, pg_core_1.customType)({
     dataType(config) { return `vector(${config?.dimensions ?? 1024})`; },
 });
@@ -14,6 +18,7 @@ exports.codeChunk = (0, pg_core_1.pgTable)('code_chunk', {
     embedding: vector('embedding', { dimensions: 1024 }).notNull(),
     lastModified: (0, pg_core_1.doublePrecision)('lastModified'),
     contentHash: (0, pg_core_1.varchar)('contentHash', { length: 64 }),
+    ownerPath: (0, pg_core_1.varchar)('ownerPath'),
 });
 exports.codeDependency = (0, pg_core_1.pgTable)('code_dependency', {
     id: (0, pg_core_1.uuid)('id').primaryKey().defaultRandom(),
@@ -45,3 +50,12 @@ exports.codeCall = (0, pg_core_1.pgTable)('code_call', {
     line: (0, pg_core_1.integer)('line'),
     col: (0, pg_core_1.integer)('col'),
 });
+// Single-row source of truth for which model built the current index. The
+// `id` column is a boolean pinned to `true` so at most one row can exist.
+exports.indexMeta = (0, pg_core_1.pgTable)('index_meta', {
+    id: (0, pg_core_1.boolean)('id').primaryKey().default(true),
+    provider: (0, pg_core_1.text)('provider').notNull(),
+    model: (0, pg_core_1.text)('model').notNull(),
+    dimensions: (0, pg_core_1.integer)('dimensions').notNull(),
+    indexedAt: (0, pg_core_1.timestamp)('indexedAt', { withTimezone: true }).defaultNow().notNull(),
+});

package/dist/src/help.js

@@ -50,13 +50,14 @@ function printHelp(command) {
             console.log('');
             console.log('Keys:');
             console.log('  db.host, db.port, db.user, db.password, db.name');
-            console.log('  ollama.host, ollama.model');
+            console.log('  embedding.provider, embedding.baseURL, embedding.apiKey, embedding.model,');
+            console.log('  embedding.dimensions, embedding.batchSize');
             console.log('  indexing.chunkSize, indexing.chunkOverlap, indexing.embedBatchSize');
             console.log('  search.similarityThreshold, search.defaultLimit, search.maxLimit');
-            console.log('  search.autoTranslate, search.translateModel');
-            console.log('  reranker.enabled, reranker.model, reranker.url, reranker.overfetch');
+            console.log('  reranker.enabled, reranker.provider, reranker.baseURL, reranker.apiKey,');
+            console.log('  reranker.model, reranker.url, reranker.overfetch');
             console.log('  logging.level, logging.dir');
-            console.log('  workspaceRoot');
+            console.log('  workspaceRoot  (API keys: use env:VAR_NAME → ~/.config/codesearch-mcp/.env)');
             break;
         case 'rag-web':
         case 'web':

package/dist/src/interfaces/IAstParser.d.ts

@@ -26,10 +26,24 @@ export interface CallEdge {
     line: number | null;
     col: number | null;
 }
+/**
+ * Line range of a named scope used only to compute a chunk's owning declaration
+ * (`ownerPath`). Method/constructor/accessor ranges carry their enclosing class
+ * as `container`; top-level declarations use `container: null`. These are NOT
+ * persisted to `code_symbol` — they exist only for chunk ownership.
+ */
+export interface OwnerRange {
+    name: string;
+    container: string | null;
+    line: number;
+    endLine: number;
+}
 export interface FileAnalysis {
     edges: DepEdge[];
     symbols: SymbolEntry[];
     calls: CallEdge[];
+    /** Method/accessor/constructor ranges for owner-path resolution (Phase 2). */
+    ownerRanges?: OwnerRange[];
 }
 export interface AnalyzeProjectOpts {
     skipDependencyResolution?: boolean;

package/dist/src/interfaces/IChunker.d.ts

@@ -0,0 +1,24 @@
+import type { SymbolEntry } from './IAstParser';
+/** One embeddable unit of source with its 1-based inclusive line range. */
+export interface ChunkPiece {
+    content: string;
+    startLine: number;
+    endLine: number;
+}
+export interface ChunkOpts {
+    /** 'ast' = symbol-aligned boundaries; 'character' = fixed-size recursive splitter. */
+    strategy: 'ast' | 'character';
+    /** Schema files (.prisma/.graphql/.gql) always use the schema separator splitter. */
+    isSchemaFile: boolean;
+    /** Top-level symbol ranges for the file; may be empty (no analysis available). */
+    symbols: SymbolEntry[];
+}
+export interface IChunker {
+    /**
+     * Split source into embeddable pieces. AST strategy aligns boundaries to
+     * top-level declaration ranges and never emits a piece longer than the
+     * configured chunk size; falls back to the character splitter for schema
+     * files, empty-symbol files, or when strategy is 'character'.
+     */
+    chunk(code: string, opts: ChunkOpts): Promise<ChunkPiece[]>;
+}

package/dist/src/interfaces/IChunker.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/interfaces/IDatabase.d.ts

@@ -1,4 +1,10 @@
 import type { DrizzleDb, DrizzleTx } from '../services/DatabaseService';
+/** Single-row record of which embedding model built the current index. */
+export interface IndexMeta {
+    provider: string;
+    model: string;
+    dimensions: number;
+}
 /**
  * Database abstraction — services depend on this interface
  * rather than the concrete DatabaseService.
@@ -10,4 +16,12 @@ export interface IDatabase {
     initDb(): Promise<void>;
     initDbWithSchema(): Promise<void>;
     destroy(): Promise<void>;
+    /** Read the single `index_meta` row, or null when absent (table missing → null). */
+    readIndexMeta(): Promise<IndexMeta | null>;
+    /** Upsert the single `index_meta` row. */
+    writeIndexMeta(meta: IndexMeta): Promise<void>;
+    /** Create `code_chunk` (+ HNSW/service indexes) at `dimensions` if absent. */
+    ensureChunkTable(dimensions: number): Promise<void>;
+    /** Drop and recreate `code_chunk` at `dimensions` (dimension change). */
+    recreateChunkTable(dimensions: number): Promise<void>;
 }

package/dist/src/interfaces/IEmbedder.d.ts

@@ -1,6 +1,18 @@
+export type InputType = 'query' | 'document';
 export interface IEmbedder {
-    embed(text: string): Promise<number[]>;
-    translate?(text: string, model: string): Promise<string>;
+    /**
+     * The vector width this embedder produces, when known without a probe:
+     * `embedding.dimensions` override → model registry, else `0` for models whose
+     * width is only knowable by embedding once (see `resolveDimension`). Read by
+     * `SearcherService.assertIndexMatches` to catch a dimension change on the
+     * search side (skipped when `0`). Indexing resolves the true width via
+     * `resolveDimension` (which probes when needed), not this field.
+     */
+    readonly dimensions: number;
+    embed(text: string, inputType?: InputType): Promise<number[]>;
+    /** One vector per input, in input order. The indexing path. */
+    embedBatch(texts: string[], inputType?: InputType): Promise<number[][]>;
     rerank?(query: string, documents: string[], topN: number): Promise<number[]>;
     listModels?(): Promise<string[]>;
+    ensureModelAvailable?(): Promise<void>;
 }

package/dist/src/interfaces/ISearcher.d.ts

@@ -8,6 +8,7 @@ export interface ISearcher {
         query: string;
         translated: boolean;
     }>;
+    assertIndexMatches(): Promise<void>;
     listProjects(): Promise<ProjectRow[]>;
     getProjectEdges(): Promise<{
         from: string;

package/dist/src/interfaces/index.d.ts

@@ -1,5 +1,6 @@
-export type { IEmbedder } from './IEmbedder';
+export type { IEmbedder, InputType } from './IEmbedder';
 export type { IAstParser, DepEdge, SymbolEntry, CallEdge, FileAnalysis } from './IAstParser';
+export type { IChunker, ChunkPiece, ChunkOpts } from './IChunker';
 export type { ILogger } from './ILogger';
 export type { IDatabase } from './IDatabase';
 export type { ISearcher } from './ISearcher';

package/dist/src/owner-path.d.ts

@@ -0,0 +1,10 @@
+import type { OwnerRange } from './interfaces/IAstParser';
+/**
+ * Resolve the owning declaration for a chunk given its 1-based start line and a
+ * flat list of candidate ranges (top-level symbols + method ranges). The
+ * deepest range containing the start line wins (smallest `endLine - line` span),
+ * so a method beats its enclosing class. Returns `Container.name` for methods
+ * (via `container`) or `name` for top-level declarations, and `null` when the
+ * start line lies outside every range (imports / module-scope gaps).
+ */
+export declare function resolveOwnerPath(startLine: number, ranges: OwnerRange[]): string | null;