codesearch-mcp 0.3.0-alpha → 0.4.0-alpha

package/dist/src/commands/index/legacy-ollama-guard.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refusesLegacyOllamaIndex = refusesLegacyOllamaIndex;
+const legacy_ollama_index_1 = require("../../services/legacy-ollama-index");
+async function refusesLegacyOllamaIndex(db, config) {
+    let identity;
+    try {
+        identity = await (0, legacy_ollama_index_1.resolveIndexedIdentity)(db);
+    }
+    catch (err) {
+        console.error(`\n${err.message}`);
+        process.exitCode = 1;
+        return true;
+    }
+    if (identity?.provider === 'ollama') {
+        console.error(`\nThe existing index was built with ${identity.provider}/${identity.model}, but "ollama" is no ` +
+            `longer a supported embedding provider (configured: ${config.embedding.provider}/${config.embedding.model}). ` +
+            `Run \`rag-index --reindex\` to confirm rebuilding the index under the configured provider.`);
+        process.exitCode = 1;
+        return true;
+    }
+    return false;
+}

package/dist/src/commands/index/prune-step.d.ts

@@ -0,0 +1,3 @@
+import type { IndexerService } from '../../services/IndexerService';
+import type { DiscoveredProject } from '../../interfaces';
+export declare function pruneUnselected(indexer: IndexerService, projects: DiscoveredProject[]): Promise<boolean>;

package/dist/src/commands/index/prune-step.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pruneUnselected = pruneUnselected;
+async function pruneUnselected(indexer, projects) {
+    let pruneResult;
+    try {
+        pruneResult = await indexer.pruneProjects(projects.map(p => p.name));
+    }
+    catch (err) {
+        console.error(`\nPruning failed: ${err.message}`);
+        process.exitCode = 1;
+        return false;
+    }
+    const { removed, failed } = pruneResult;
+    for (const name of removed) {
+        console.log(`Removed project ${name} (not selected)`);
+    }
+    if (failed.length > 0) {
+        process.exitCode = 1;
+    }
+    return true;
+}

package/dist/src/commands/index/scan-targets.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from '../../config';
+import type { IndexArgs } from '../../index-args';
+import type { DiscoveredProject, IProjectDiscovery } from '../../interfaces';
+export interface ScanTargets {
+    discovered: DiscoveredProject[];
+    scanTargets?: DiscoveredProject[];
+}
+export declare function resolveScanTargets(discovery: IProjectDiscovery, config: Config, args: IndexArgs): Promise<ScanTargets | null>;

package/dist/src/commands/index/scan-targets.js

@@ -0,0 +1,107 @@
+"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.resolveScanTargets = resolveScanTargets;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const project_selector_1 = require("../../project-selector");
+const project_scope_1 = require("../../project-scope");
+async function resolveScanTargets(discovery, config, args) {
+    const { projectFlag, requireCwd } = args;
+    let discovered;
+    try {
+        discovered = discovery.discover(config.workspaceRoot);
+    }
+    catch (err) {
+        console.error(`\n${err.message}`);
+        process.exitCode = 1;
+        return null;
+    }
+    if (requireCwd && projectFlag.name === undefined) {
+        console.error('\n--require-cwd needs --project <name>.');
+        process.exitCode = 1;
+        return null;
+    }
+    let scanTargets;
+    if (projectFlag.present) {
+        let name = projectFlag.name;
+        if (name === undefined) {
+            if (discovered.length === 0) {
+                console.error('\nNo projects available to select.');
+                process.exitCode = 1;
+                return null;
+            }
+            name = await (0, project_selector_1.selectSingleProject)(discovered);
+            if (name === undefined) {
+                process.exitCode = 1;
+                return null;
+            }
+        }
+        const { targets, notFound } = (0, project_scope_1.resolveProjectNames)([name], discovered);
+        if (notFound.length > 0) {
+            const available = (0, project_scope_1.listAvailableNames)(discovered).join(', ');
+            console.error(`\nProject '${notFound[0]}' not found. Available projects: ${available}`);
+            process.exitCode = 1;
+            return null;
+        }
+        if (requireCwd && !isInProjectDir(config, name, discovered)) {
+            process.exitCode = 1;
+            return null;
+        }
+        scanTargets = targets;
+    }
+    return { discovered, scanTargets };
+}
+function isInProjectDir(config, name, discovered) {
+    const { workspaceRoot } = config;
+    if (!path.isAbsolute(workspaceRoot)) {
+        console.error(`\nworkspaceRoot '${workspaceRoot}' is relative, so it moves with the current directory and --require-cwd cannot tell checkouts apart.`);
+        return false;
+    }
+    let cwd;
+    let projectDir;
+    try {
+        cwd = fs.realpathSync.native(process.cwd());
+        projectDir = fs.realpathSync.native((0, project_scope_1.matchedProjectDir)(name, discovered));
+    }
+    catch (err) {
+        console.error(`\n${err.message}`);
+        return false;
+    }
+    if (cwd === projectDir)
+        return true;
+    console.error(`\nCurrent directory ${cwd} is not the directory of project '${name}' (${projectDir}).`);
+    return false;
+}

package/dist/src/config-store.d.ts

@@ -75,7 +75,6 @@ export declare const CONFIG_DEFAULTS: {
     readonly 'indexing.embedBatchSize': 5;
     readonly 'indexing.astBatchSize': 3000;
     readonly 'indexing.chunkStrategy': "ast";
-    readonly 'search.similarityThreshold': 0.6;
     readonly 'search.defaultLimit': 5;
     readonly 'search.maxLimit': 20;
     readonly 'reranker.enabled': true;

package/dist/src/config-store.js

@@ -79,7 +79,7 @@ const jsonSchema = zod_1.z.object({
         chunkStrategy: zod_1.z.enum(['ast', 'character']).describe('How TS/JS files are chunked: ast = symbol-aligned boundaries, character = fixed-size recursive splitter (default ast)').optional(),
     }).optional(),
     search: zod_1.z.object({
-        similarityThreshold: zod_1.z.number().min(0).max(1).describe('Max cosine distance 0–1; lower = stricter (default 0.6)').optional(),
+        similarityThreshold: zod_1.z.number().min(0).max(1).describe('Max cosine distance 0–1, lower = stricter. Unset: recommended value for the embedding model').optional(),
         defaultLimit: zod_1.z.number().int().describe('Default result count (default 5)').optional(),
         maxLimit: zod_1.z.number().int().describe('Hard cap on results (default 20)').optional(),
     }).optional(),
@@ -90,8 +90,8 @@ const jsonSchema = zod_1.z.object({
         apiKey: zod_1.z.string().describe('API key, or env:VAR_NAME. Empty for local servers; required for voyage.').optional(),
         model: zod_1.z.string().describe('Reranker model name (default mixedbread-ai/mxbai-rerank-xsmall-v1 for openai-compatible, rerank-3 for voyage)').optional(),
         url: zod_1.z.string().describe('Full URL of the rerank endpoint (default derived from provider + baseURL)').optional(),
-        overfetch: zod_1.z.number().int().min(1).max(20).describe('Candidate multiplier before reranking (limit × N, default 5)').optional(),
-        candidateFloor: zod_1.z.number().int().min(1).describe('Minimum candidate pool fed to the reranker regardless of limit; fetchLimit = min(max(limit × overfetch, candidateFloor), 200) (default 80)').optional(),
+        overfetch: zod_1.z.number().int().min(1).max(20).describe('Candidate multiplier before reranking (limit × N, default 5); also sizes the pool of a search without reranking whose per-file limit is below limit').optional(),
+        candidateFloor: zod_1.z.number().int().min(1).describe('Minimum candidate pool fed to the reranker regardless of limit; fetchLimit = min(max(limit × overfetch, candidateFloor), 200) (default 80); the same pool serves a search without reranking whose per-file limit is below limit').optional(),
     }).optional(),
     logging: zod_1.z.object({
         level: zod_1.z.enum(['debug', 'info', 'warn', 'error']).describe('File log level (default error)').optional(),
@@ -143,7 +143,6 @@ exports.CONFIG_DEFAULTS = {
     'indexing.embedBatchSize': 5,
     'indexing.astBatchSize': 3000,
     'indexing.chunkStrategy': 'ast',
-    'search.similarityThreshold': 0.6,
     'search.defaultLimit': 5,
     'search.maxLimit': 20,
     'reranker.enabled': true,

package/dist/src/config.d.ts

@@ -43,9 +43,9 @@ export declare class Config {
         chunkStrategy: "ast" | "character";
     };
     get search(): {
-        similarityThreshold: number;
         defaultLimit: number;
         maxLimit: number;
+        similarityThreshold?: number | undefined;
     };
     get logging(): {
         level: "error" | "debug" | "info" | "warn";

package/dist/src/config.js

@@ -111,7 +111,7 @@ const resolvedSchema = zod_1.z.object({
         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']),
+        similarityThreshold: zod_1.z.number().min(0).max(1).optional(),
         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']),
     }),

package/dist/src/constants.d.ts

@@ -8,9 +8,24 @@ export interface ModelInfo {
     dimConfigurable?: boolean;
     maxIndexable?: number;
     maxDim?: number;
+    defaultThreshold?: number;
 }
 export declare const MODEL_REGISTRY: Record<string, ModelInfo>;
 export declare const DEFAULT_EMBED_MODEL = "jinaai/jina-embeddings-v2-base-code";
 export declare const FORMER_OLLAMA_MODELS: readonly ["bge-m3", "nomic-embed-text", "mxbai-embed-large"];
 export declare function registryDimension(model: string): number | undefined;
+export type ThresholdSource = 'call' | 'config' | 'model' | 'fallback';
+export interface ResolvedThreshold {
+    value: number;
+    source: ThresholdSource;
+}
+export declare const FALLBACK_THRESHOLD = 1;
+export declare function resolveThreshold({ callValue, configValue, model, registry }: {
+    callValue?: number;
+    configValue?: number;
+    model: string;
+    registry?: Record<string, ModelInfo>;
+}): ResolvedThreshold;
+export declare function formatThreshold(value: number): string;
+export declare function thresholdMismatchWarning(configValue: number | undefined, model: string, registry?: Record<string, ModelInfo>): string | null;
 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,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FORMER_OLLAMA_MODELS = exports.DEFAULT_EMBED_MODEL = exports.MODEL_REGISTRY = exports.MAX_EMBED_DIM = exports.VOYAGE_RERANK_MODELS = void 0;
+exports.FALLBACK_THRESHOLD = exports.FORMER_OLLAMA_MODELS = exports.DEFAULT_EMBED_MODEL = exports.MODEL_REGISTRY = exports.MAX_EMBED_DIM = exports.VOYAGE_RERANK_MODELS = void 0;
 exports.registryDimension = registryDimension;
+exports.resolveThreshold = resolveThreshold;
+exports.formatThreshold = formatThreshold;
+exports.thresholdMismatchWarning = thresholdMismatchWarning;
 exports.resolveDimension = resolveDimension;
 exports.VOYAGE_RERANK_MODELS = ['rerank-3', 'rerank-3-lite'];
 exports.MAX_EMBED_DIM = 2000;
@@ -9,18 +12,43 @@ exports.MODEL_REGISTRY = {
     '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-4': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048 },
-    'voyage-4-large': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048 },
-    'voyage-4': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048 },
-    'voyage-4-lite': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048 },
+    'voyage-code-4': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048, defaultThreshold: 0.95 },
+    'voyage-4-large': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048, defaultThreshold: 0.95 },
+    'voyage-4': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048, defaultThreshold: 0.95 },
+    'voyage-4-lite': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048, defaultThreshold: 0.95 },
     'BAAI/bge-m3': { provider: 'infinity', dimensions: 1024 },
-    'jinaai/jina-embeddings-v2-base-code': { provider: 'infinity', dimensions: 768 },
+    'jinaai/jina-embeddings-v2-base-code': { provider: 'infinity', dimensions: 768, defaultThreshold: 0.6 },
 };
 exports.DEFAULT_EMBED_MODEL = 'jinaai/jina-embeddings-v2-base-code';
 exports.FORMER_OLLAMA_MODELS = ['bge-m3', 'nomic-embed-text', 'mxbai-embed-large'];
 function registryDimension(model) {
     return exports.MODEL_REGISTRY[model]?.dimensions;
 }
+exports.FALLBACK_THRESHOLD = 1.0;
+const THRESHOLD_MISMATCH_TOLERANCE = 0.1;
+const FLOAT_EPSILON = 1e-9;
+function resolveThreshold({ callValue, configValue, model, registry = exports.MODEL_REGISTRY }) {
+    if (callValue !== undefined)
+        return { value: callValue, source: 'call' };
+    if (configValue !== undefined)
+        return { value: configValue, source: 'config' };
+    const recommended = registry[model]?.defaultThreshold;
+    if (recommended !== undefined)
+        return { value: recommended, source: 'model' };
+    return { value: exports.FALLBACK_THRESHOLD, source: 'fallback' };
+}
+function formatThreshold(value) {
+    return Number.isInteger(value) ? value.toFixed(1) : String(value);
+}
+function thresholdMismatchWarning(configValue, model, registry = exports.MODEL_REGISTRY) {
+    const recommended = registry[model]?.defaultThreshold;
+    if (configValue === undefined || recommended === undefined)
+        return null;
+    if (Math.abs(configValue - recommended) <= THRESHOLD_MISMATCH_TOLERANCE + FLOAT_EPSILON)
+        return null;
+    return `search.similarityThreshold is ${formatThreshold(configValue)}, but the recommended value for ${model} is ${formatThreshold(recommended)}. `
+        + 'Searches may miss relevant code or return weak matches. Remove the key to follow the model, or retune it (rag-config edit).';
+}
 async function resolveDimension(override, model, probeFn, registry = exports.MODEL_REGISTRY) {
     let dim;
     if (override != null) {

package/dist/src/container.d.ts

@@ -1,18 +1,20 @@
 import { Config } from './config';
 import { IndexerService } from './services/IndexerService';
+import { type SearchServices } from './search/create-search-services';
 import { McpServer } from './services/McpServer';
 import { LoggerService } from './services/LoggerService';
 import type { IDatabase } from './interfaces';
 import type { IEmbedder } from './interfaces';
-import type { ISearcher } from './interfaces';
 import type { ILogger } from './interfaces';
 import type { IProjectDiscovery } from './interfaces';
+import type { IMcpReadiness } from './interfaces';
 export interface Container {
     config: Config;
     db: IDatabase;
     embedder: IEmbedder;
     indexer: IndexerService;
-    searcher: ISearcher;
+    search: SearchServices;
+    readiness: IMcpReadiness;
     mcp: McpServer;
     logger: ILogger;
     discovery: IProjectDiscovery;

package/dist/src/container.js

@@ -10,8 +10,9 @@ const EmbedderFactory_1 = require("./services/EmbedderFactory");
 const AstParserService_1 = require("./services/AstParserService");
 const create_chunker_1 = require("./chunking/create-chunker");
 const IndexerService_1 = require("./services/IndexerService");
-const SearcherService_1 = require("./services/SearcherService");
+const create_search_services_1 = require("./search/create-search-services");
 const McpServer_1 = require("./services/McpServer");
+const McpReadiness_1 = require("./services/McpReadiness");
 const LoggerService_1 = require("./services/LoggerService");
 const MonorepoAwareDiscoveryService_1 = require("./services/MonorepoAwareDiscoveryService");
 const NxMonorepoResolver_1 = require("./services/NxMonorepoResolver");
@@ -24,13 +25,14 @@ function createLogger(cfg, loggerName) {
 function createContainer(loggerName) {
     const config = new config_1.Config();
     const logger = createLogger(config.logging, loggerName);
-    const db = new DatabaseService_1.DatabaseService(config);
+    const db = new DatabaseService_1.DatabaseService(config, logger);
     const embedder = (0, EmbedderFactory_1.createEmbedder)(config, logger);
     const ast = new AstParserService_1.AstParserService(logger);
     const chunker = (0, create_chunker_1.createChunker)(config);
     const discovery = new MonorepoAwareDiscoveryService_1.MonorepoAwareDiscoveryService([new NxMonorepoResolver_1.NxMonorepoResolver(logger)], 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 };
+    const search = (0, create_search_services_1.createSearchServices)(db, embedder, discovery, config, logger);
+    const readiness = new McpReadiness_1.McpReadiness(db, search.identity, logger);
+    const mcp = new McpServer_1.McpServer(search, readiness, config, logger);
+    return { config, db, embedder, indexer, search, readiness, mcp, logger, discovery };
 }

package/dist/src/db/drizzle-types.d.ts

@@ -0,0 +1,7 @@
+import type { NodePgDatabase, NodePgTransaction } from 'drizzle-orm/node-postgres';
+import type { ExtractTablesWithRelations } from 'drizzle-orm/relations';
+import * as schema from './schema';
+type Schema = typeof schema;
+export type DrizzleDb = NodePgDatabase<Schema>;
+export type DrizzleTx = NodePgTransaction<Schema, ExtractTablesWithRelations<Schema>>;
+export {};

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

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

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

@@ -0,0 +1,8 @@
+import type { IDatabase } from '../interfaces/IDatabase';
+export type SchemaDb = Pick<IDatabase, 'query' | 'transaction' | 'ensureChunkTable'>;
+export interface SchemaStep {
+    readonly name: string;
+    run(db: SchemaDb): Promise<void>;
+}
+export declare const SCHEMA_STEPS: readonly SchemaStep[];
+export declare function runSchemaSteps(db: SchemaDb, steps?: readonly SchemaStep[]): Promise<void>;

package/dist/src/db/schema-steps.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEMA_STEPS = void 0;
+exports.runSchemaSteps = runSchemaSteps;
+async function codeChunkTable(db) {
+    await db.ensureChunkTable(1024);
+}
+async function indexMetaTable(db) {
+    await db.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()
+    )
+  `);
+}
+async function codeDependencyTable(db) {
+    const [{ existsDep }] = await db.query(`
+    SELECT EXISTS (
+      SELECT 1 FROM information_schema.tables
+      WHERE table_schema = 'public' AND table_name = 'code_dependency'
+    ) AS "existsDep"
+  `);
+    if (!existsDep) {
+        await db.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 db.query(`CREATE INDEX IF NOT EXISTS idx_dep_project_from ON code_dependency (project, "fromFile")`);
+    await db.query(`CREATE INDEX IF NOT EXISTS idx_dep_project_to   ON code_dependency (project, "toFile")`);
+    await db.query(`DROP INDEX IF EXISTS idx_dep_from`);
+    await db.query(`DROP INDEX IF EXISTS idx_dep_to`);
+    await db.query(`DROP INDEX IF EXISTS idx_dep_project`);
+}
+async function codeSymbolTable(db) {
+    const [{ existsSym }] = await db.query(`
+    SELECT EXISTS (
+      SELECT 1 FROM information_schema.tables
+      WHERE table_schema = 'public' AND table_name = 'code_symbol'
+    ) AS "existsSym"
+  `);
+    if (!existsSym) {
+        await db.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 db.query(`CREATE INDEX IF NOT EXISTS idx_symbol_name   ON code_symbol (name, project)`);
+    await db.query(`CREATE INDEX IF NOT EXISTS idx_symbol_file   ON code_symbol (project, "filePath")`);
+    await db.query(`ALTER TABLE code_symbol ADD COLUMN IF NOT EXISTS container TEXT`);
+    await db.query(`ALTER TABLE code_symbol ADD COLUMN IF NOT EXISTS "isStatic" BOOLEAN NOT NULL DEFAULT false`);
+    await db.query(`ALTER TABLE code_symbol ADD COLUMN IF NOT EXISTS "target" TEXT`);
+    await db.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');
+    });
+}
+async function codeCallTable(db) {
+    await db.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 db.query(`CREATE INDEX IF NOT EXISTS idx_call_callee      ON code_call (project, "calleeName")`);
+    await db.query(`CREATE INDEX IF NOT EXISTS idx_call_callee_file ON code_call (project, "calleeFile")`);
+    await db.query(`CREATE INDEX IF NOT EXISTS idx_call_from        ON code_call (project, "fromFile")`);
+}
+exports.SCHEMA_STEPS = [
+    { name: 'codeChunkTable', run: codeChunkTable },
+    { name: 'indexMetaTable', run: indexMetaTable },
+    { name: 'codeDependencyTable', run: codeDependencyTable },
+    { name: 'codeSymbolTable', run: codeSymbolTable },
+    { name: 'codeCallTable', run: codeCallTable },
+];
+async function runSchemaSteps(db, steps = exports.SCHEMA_STEPS) {
+    for (const step of steps)
+        await step.run(db);
+}

package/dist/src/declarations/DeclarationTree.d.ts

@@ -1,4 +1,4 @@
-import type { SymbolKind } from '../interfaces/IAstParser';
+import type { SymbolKind } from '../interfaces/SymbolKind';
 import type { LineRange } from './SourceLines';
 export interface DeclarationNode {
     start: number;

package/dist/src/eval-results.js

@@ -43,6 +43,8 @@ exports.normaliseResultFile = normaliseResultFile;
 exports.readResultFile = readResultFile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const retrieval_eval_1 = require("./retrieval-eval");
+const eval_vector_index_1 = require("./eval-vector-index");
 const CATEGORIES = ['identifier', 'behaviour', 'concept'];
 const STAGE_LABEL = {
     vector: 'vector (reranker input order, not a rerank-off search)',
@@ -147,11 +149,12 @@ function renderMarkdown(result, comparison) {
     if (metadata.indexMeta) {
         lines.push(`**Index:** ${metadata.indexMeta.provider}/${metadata.indexMeta.model} (${metadata.indexMeta.dimensions} dims)`);
     }
+    lines.push(`**Vector index:** ${(0, eval_vector_index_1.formatVectorIndex)(metadata.vectorIndex)}`);
     const corpora = corpusLines(metadata);
     lines.push(corpora.length === 1 ? `**Corpus:** ${corpora[0]}` : `**Corpora:** ${corpora.join('; ')}`);
     const c = metadata.conditions;
     if (c) {
-        lines.push(`**Search conditions:** threshold ${c.similarityThreshold} | overfetch ${c.overfetch} | candidateFloor ${c.candidateFloor} | fetchLimit ${formatList(c.fetchLimit)} | ef_search ${formatList(c.efSearch)} | iterative scan ${formatList(c.iterativeScan)}`);
+        lines.push(`**Search conditions:** threshold ${(0, retrieval_eval_1.formatThresholdConditions)(c.thresholds)} | overfetch ${c.overfetch} | candidateFloor ${c.candidateFloor} | fetchLimit ${formatList(c.fetchLimit)} | ef_search ${formatList(c.efSearch)} | iterative scan ${formatList(c.iterativeScan)}`);
     }
     else {
         lines.push('**Search conditions:** not recorded');
@@ -238,6 +241,7 @@ function renderSummary(result) {
     lines.push('', `Evaluated ${run.cases.length} case(s) (${run.invalid.length} invalid) against ${metadata.embeddingProvider}/${metadata.embeddingModel}`);
     for (const line of corpusLines(metadata))
         lines.push(`  corpus: ${line}`);
+    lines.push(`  vector index: ${(0, eval_vector_index_1.formatVectorIndex)(metadata.vectorIndex)}`);
     for (const stage of run.stages) {
         const m = run.metrics[stage];
         if (!m)
@@ -357,7 +361,7 @@ const EMPTY_POOL = { count: 0, recall: 0, short: 0 };
 function normaliseResultFile(raw) {
     const run = raw?.run;
     if (!run || run.stages !== undefined || run.metrics?.overall === undefined)
-        return withCorpusMetadata(raw);
+        return withThresholdConditions(withCorpusMetadata(raw));
     const stage = raw.metadata?.rerankerModel != null ? 'reranked' : 'vector';
     const cases = run.cases.map(c => ({
         id: c.id, project: c.project, category: c.category, query: c.query,
@@ -392,6 +396,16 @@ function withCorpusMetadata(file) {
         run: { ...file.run, cases: file.run.cases.map(c => ({ ...c, corpus: c.corpus ?? null })), byCorpus: file.run.byCorpus ?? {} },
     };
 }
+function withThresholdConditions(file) {
+    const conditions = file?.metadata?.conditions;
+    if (conditions?.similarityThreshold === undefined)
+        return file;
+    const { similarityThreshold, ...rest } = conditions;
+    return {
+        ...file,
+        metadata: { ...file.metadata, conditions: { ...rest, thresholds: [{ value: similarityThreshold, source: 'not recorded' }] } },
+    };
+}
 function readResultFile(filePath) {
     return normaliseResultFile(JSON.parse(fs.readFileSync(filePath, 'utf-8')));
 }

package/dist/src/eval-vector-index.d.ts

@@ -0,0 +1,5 @@
+import type { IDatabase } from './interfaces/IDatabase';
+import type { VectorIndexRecord } from './interfaces/IRetrievalEvaluator';
+export declare function describeVectorIndex(db: Pick<IDatabase, 'query' | 'pgvectorVersion'>): Promise<VectorIndexRecord>;
+export declare function formatIndexes(record: VectorIndexRecord): string;
+export declare function formatVectorIndex(record: VectorIndexRecord | null): string;

package/dist/src/eval-vector-index.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeVectorIndex = describeVectorIndex;
+exports.formatIndexes = formatIndexes;
+exports.formatVectorIndex = formatVectorIndex;
+const BUILD_DEFAULTS = {
+    hnsw: { m: '16', ef_construction: '64' },
+    ivfflat: { lists: '100' },
+};
+const INDEX_SQL = `
+  SELECT c.relname AS name, am.amname AS method, oc.opcname AS opclass, c.reloptions AS options
+  FROM pg_index i
+  JOIN pg_class c ON c.oid = i.indexrelid
+  JOIN pg_am am ON am.oid = c.relam
+  JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = i.indkey[0]
+  JOIN pg_opclass oc ON oc.oid = i.indclass[0]
+  WHERE i.indrelid = to_regclass('code_chunk') AND a.attname = 'embedding' AND i.indisvalid
+  ORDER BY c.relname`;
+const SCAN_SETTINGS_SQL = `
+  SELECT current_setting('hnsw.max_scan_tuples', true) AS max_scan_tuples,
+         current_setting('hnsw.scan_mem_multiplier', true) AS scan_mem_multiplier
+  FROM (SELECT '[1]'::vector) AS loaded`;
+function numericSetting(value) {
+    if (value == null || value === '')
+        return null;
+    const n = Number(value);
+    return Number.isFinite(n) ? n : null;
+}
+function parseOptions(options) {
+    const params = {};
+    for (const option of options ?? []) {
+        const eq = option.indexOf('=');
+        if (eq > 0)
+            params[option.slice(0, eq)] = option.slice(eq + 1);
+    }
+    return params;
+}
+async function describeVectorIndex(db) {
+    const rows = await db.query(INDEX_SQL);
+    const [settings] = await db.query(SCAN_SETTINGS_SQL);
+    return {
+        pgvector: await db.pgvectorVersion(),
+        indexes: rows.map(r => ({
+            name: r.name,
+            method: r.method,
+            opclass: r.opclass,
+            params: { ...BUILD_DEFAULTS[r.method], ...parseOptions(r.options) },
+        })),
+        maxScanTuples: numericSetting(settings?.max_scan_tuples),
+        scanMemMultiplier: numericSetting(settings?.scan_mem_multiplier),
+    };
+}
+function formatIndexes(record) {
+    return record.indexes.map(i => `${i.name} ${i.method} (${[i.opclass, ...Object.entries(i.params).map(([k, v]) => `${k}=${v}`)].join(', ')})`).join('; ') || 'none';
+}
+function formatVectorIndex(record) {
+    if (!record)
+        return 'not recorded';
+    return `${formatIndexes(record)} | pgvector ${record.pgvector ?? 'not installed'} | hnsw.max_scan_tuples ${record.maxScanTuples ?? 'not defined'} | hnsw.scan_mem_multiplier ${record.scanMemMultiplier ?? 'not defined'}`;
+}