codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

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

@@ -1,3 +1,6 @@
+import type { StageName } from './IChunkSearch';
+import type { ResolvedThreshold, ThresholdSource } from '../constants';
+export type { StageName };
 export type EvalCategory = 'identifier' | 'behaviour' | 'concept';
 export interface ExpectedAnswer {
     file: string;
@@ -10,20 +13,39 @@ export interface EvalCase {
     query: string;
     expect: ExpectedAnswer[];
     threshold?: number;
+    corpus?: string | null;
+}
+export interface CorpusRef {
+    root: string;
+    commit: string;
 }
 export interface EvalSuite {
     version: 1;
+    corpus?: CorpusRef;
     cases: EvalCase[];
 }
 export interface SearchHit {
     filePath: string;
     ownerPath: string | null;
 }
-export type SearchFn = (query: string, limit: number, project: string | null, threshold?: number) => Promise<SearchHit[]>;
-/** Index-inspection callbacks used to validate a case's expected answers before scoring. */
+export interface StagedHits {
+    pool: SearchHit[];
+    stages: {
+        vector: SearchHit[];
+    } & Partial<Record<StageName, SearchHit[]>>;
+    rerankFailed: boolean;
+    fetchLimit: number;
+    indexParams: {
+        efSearch: number | null;
+        iterativeScan: string;
+    };
+    threshold: ResolvedThreshold;
+}
+export type SearchFn = (query: string, limit: number, project: string | null, threshold?: number) => Promise<StagedHits>;
 export interface IndexInspector {
     isFileIndexed(project: string, file: string): Promise<boolean>;
     ownerPathsOfFile(project: string, file: string): Promise<string[]>;
+    projectDir(project: string): Promise<string | null>;
 }
 export interface Metrics {
     count: number;
@@ -31,14 +53,20 @@ export interface Metrics {
     hit5: number;
     mrr10: number;
 }
+export interface StageRank {
+    rank: number | null;
+    matched: SearchHit | null;
+}
 export interface CaseResult {
     id: string;
     project: string;
     category: EvalCategory;
     query: string;
-    /** 1-based position of the first matching result within the top 10, null when unranked. */
-    rank: number | null;
-    matched: SearchHit | null;
+    stages: Partial<Record<StageName, StageRank>>;
+    poolRank: number | null;
+    poolSize: number;
+    rerankFailed: boolean;
+    corpus: string | null;
 }
 export interface InvalidCase {
     id: string;
@@ -49,17 +77,87 @@ export interface PartialWarning {
     id: string;
     droppedExpects: ExpectedAnswer[];
 }
+export interface StageMetrics {
+    overall: Metrics;
+    byCategory: Partial<Record<EvalCategory, Metrics>>;
+}
+export interface PoolMetrics {
+    count: number;
+    recall: number;
+    short: number;
+}
+export interface PairCounts {
+    improved: number;
+    worsened: number;
+    unchanged: number;
+    signTestP: number;
+}
+export interface PairedChange {
+    overall: PairCounts;
+    byCategory: Partial<Record<EvalCategory, PairCounts>>;
+    hit5Gained: string[];
+    hit5Lost: string[];
+}
+export interface StageChange {
+    from: StageName;
+    to: StageName;
+    change: PairedChange;
+}
 export interface EvalRunResult {
     cases: CaseResult[];
     invalid: InvalidCase[];
     warnings: PartialWarning[];
-    metrics: {
-        overall: Metrics;
-        byCategory: Partial<Record<EvalCategory, Metrics>>;
+    stages: StageName[];
+    metrics: Partial<Record<StageName, StageMetrics>>;
+    pool: {
+        overall: PoolMetrics;
+        byCategory: Partial<Record<EvalCategory, PoolMetrics>>;
+    };
+    stageChanges: StageChange[];
+    rerankFailures: number;
+    byCorpus: Record<string, CorpusRunMetrics>;
+}
+export interface CorpusRunMetrics {
+    cases: number;
+    metrics: Partial<Record<StageName, StageMetrics>>;
+    pool: {
+        overall: PoolMetrics;
+        byCategory: Partial<Record<EvalCategory, PoolMetrics>>;
     };
+    stageChanges: StageChange[];
+}
+export interface ObservedSearchParams {
+    fetchLimit: number[];
+    efSearch: (number | null)[];
+    iterativeScan: string[];
+    thresholds: ResolvedThreshold[];
+}
+export interface EvalOutcome {
+    run: EvalRunResult;
+    observed: ObservedSearchParams;
+}
+export interface CaseProgress {
+    index: number;
+    total: number;
+    id: string;
+    result: CaseResult | null;
+    invalid: InvalidCase | null;
+    ms: number;
 }
 export interface IRetrievalEvaluator {
-    evaluate(suite: EvalSuite, search: SearchFn, inspect: IndexInspector): Promise<EvalRunResult>;
+    evaluate(suite: EvalSuite, search: SearchFn, inspect: IndexInspector, onCase?: (p: CaseProgress) => void): Promise<EvalOutcome>;
+}
+export interface ThresholdCondition {
+    value: number;
+    source: ThresholdSource | 'not recorded';
+}
+export interface SearchConditions {
+    thresholds: ThresholdCondition[];
+    overfetch: number;
+    candidateFloor: number;
+    fetchLimit: number[];
+    efSearch: (number | null)[];
+    iterativeScan: string[];
 }
 export interface ResultMetadata {
     suitePath: string;
@@ -74,10 +172,33 @@ export interface ResultMetadata {
     } | null;
     gitCommit: string;
     timestamp: string;
+    conditions: SearchConditions | null;
+    vectorIndex: VectorIndexRecord | null;
+    corpora: CorpusRecord[];
+    liveCases: number;
+}
+export interface VectorIndexRecord {
+    pgvector: string | null;
+    indexes: {
+        name: string;
+        method: string;
+        opclass: string;
+        params: Record<string, string>;
+    }[];
+    maxScanTuples: number | null;
+    scanMemMultiplier: number | null;
+}
+export interface CorpusRecord {
+    root: string;
+    commit: string;
+    projects: string[];
+    chunks: number;
+    fingerprint: string;
 }
 export interface EvalResultFile {
     metadata: ResultMetadata;
     run: EvalRunResult;
+    legacy?: true;
 }
 export interface MetricDelta {
     baseline: number;
@@ -85,10 +206,30 @@ export interface MetricDelta {
     delta: number;
 }
 export type MetricsDelta = Record<keyof Metrics, MetricDelta>;
-export interface CompareResult {
+export interface StageComparison {
+    stage: StageName;
     overall: MetricsDelta;
     byCategory: Partial<Record<EvalCategory, MetricsDelta>>;
-    hit5Gained: string[];
-    hit5Lost: string[];
+    change: PairedChange;
+}
+export interface PoolValueDelta {
+    baseline: number | null;
+    current: number;
+    delta: number | null;
+}
+export interface PoolDelta {
+    recall: PoolValueDelta;
+    short: PoolValueDelta;
+}
+export interface CompareResult {
+    stages: StageComparison[];
+    unmatchedStages: {
+        stage: StageName;
+        side: 'baseline' | 'current';
+    }[];
+    pool: {
+        overall: PoolDelta;
+        byCategory: Partial<Record<EvalCategory, PoolDelta>>;
+    };
     conditionWarnings: string[];
 }

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

@@ -0,0 +1,13 @@
+export interface ProjectNotice {
+    mark: '✓' | '⚠';
+    message: string;
+    warning: boolean;
+}
+export interface IScanReporter {
+    staleRemoved(relFile: string): void;
+    begin(serviceName: string, fileCount: number, notices: ProjectNotice[]): void;
+    file(relToDir: string): void;
+    advance(): void;
+    interrupted(serviceName: string): void;
+    end(): void;
+}

package/dist/src/interfaces/IScanReporter.js

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

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

@@ -0,0 +1,49 @@
+export type GrepSymbolResult = {
+    ok: true;
+    matches: GrepMatch[];
+    truncated: boolean;
+    partial: boolean;
+} | {
+    ok: false;
+};
+export interface GrepMatch {
+    filePath: string;
+    line: number;
+}
+export type SymbolKind = 'function' | 'class' | 'type' | 'interface' | 'variable' | 'method' | 'get_accessor' | 'set_accessor' | 'constructor' | 'function_property' | 'method_signature' | 'graphql_query' | 'graphql_mutation' | 'graphql_subscription' | 'graphql_field' | 'graphql_type' | 'all';
+export interface SymbolHit {
+    filePath: string;
+    line: number;
+    column: number;
+    kind: Exclude<SymbolKind, 'all'>;
+    signature: string;
+    qualified: string;
+    isStatic: boolean;
+    source: 'index' | 'grep';
+    target: string | null;
+}
+export type FindSymbolGrep = {
+    outcome: 'complete';
+} | {
+    outcome: 'partial';
+} | {
+    outcome: 'failed';
+    cause: string;
+} | {
+    outcome: 'no-project-directory';
+} | {
+    outcome: 'other-container';
+};
+export interface FindSymbolResult {
+    hits: SymbolHit[];
+    truncated: boolean;
+    grep: FindSymbolGrep;
+    similar: {
+        names: string[];
+        truncated: boolean;
+    };
+}
+export interface ISymbolLookup {
+    grepSymbol(symbol: string, rootDir: string, excludeFile: string): Promise<GrepSymbolResult>;
+    findSymbol(name: string, project: string | null, kind: SymbolKind): Promise<FindSymbolResult>;
+}

package/dist/src/interfaces/ISymbolLookup.js

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

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

@@ -0,0 +1,62 @@
+import type { IndexingExclusion } from '../file-utils';
+export type PathRefusal = {
+    ok: false;
+    reason: 'invalid';
+    missing: boolean;
+} | {
+    ok: false;
+    reason: 'absolute';
+    relative: string;
+} | {
+    ok: false;
+    reason: 'outside_workspace';
+} | {
+    ok: false;
+    reason: 'unreadable';
+    code: string;
+};
+export type ResolvedToolPath = {
+    ok: true;
+    relPath: string;
+    absPath: string;
+} | PathRefusal;
+export type NotIndexedExplanation = IndexingExclusion | {
+    kind: 'no_project';
+} | {
+    kind: 'project_not_indexed';
+    project: string;
+} | {
+    kind: 'unknown';
+};
+export type PathFailure = {
+    ok: false;
+    reason: 'outside_workspace';
+} | {
+    ok: false;
+    reason: 'unreadable';
+    code: string;
+} | {
+    ok: false;
+    reason: 'not_found';
+    candidates: string[];
+} | {
+    ok: false;
+    reason: 'deleted';
+} | {
+    ok: false;
+    reason: 'not_indexed';
+    explanation: NotIndexedExplanation;
+} | {
+    ok: false;
+    reason: 'not_a_file';
+} | {
+    ok: false;
+    reason: 'not_a_directory';
+} | {
+    ok: false;
+    reason: 'binary';
+};
+export interface IToolPaths {
+    resolveToolPath(input: string | null | undefined): Promise<ResolvedToolPath>;
+    checkGraphPath(relPath: string): Promise<PathFailure | null>;
+}

package/dist/src/interfaces/IToolPaths.js

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

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

@@ -0,0 +1,28 @@
+import type { PathFailure } from './IToolPaths';
+export type FileRangeResult = {
+    ok: true;
+    filePath: string;
+    startLine: number;
+    endLine: number;
+    lines: string[];
+    hasMore: boolean;
+} | PathFailure | {
+    ok: false;
+    reason: 'past_end';
+    lineCount: number;
+    startLine: number;
+} | {
+    ok: false;
+    reason: 'bad_range';
+    startLine: number;
+    endLine: number;
+};
+export type ListFilesResult = {
+    ok: true;
+    tree: string;
+} | PathFailure;
+export interface IWorkspaceFiles {
+    listFiles(relPath: string, depth: number, pattern: string | null): Promise<ListFilesResult>;
+    readFile(relPath: string, maxLines: number): Promise<FileRangeResult>;
+    readFileRange(relPath: string, startLine: number, endLine: number): Promise<FileRangeResult>;
+}

package/dist/src/interfaces/IWorkspaceFiles.js

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

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

@@ -0,0 +1 @@
+export type SymbolKind = 'function' | 'class' | 'interface' | 'type' | 'variable' | 'method' | 'get_accessor' | 'set_accessor' | 'constructor' | 'function_property' | 'method_signature' | 'graphql_query' | 'graphql_mutation' | 'graphql_subscription' | 'graphql_field' | 'graphql_type';

package/dist/src/interfaces/SymbolKind.js

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

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

@@ -3,7 +3,18 @@ export type { IAstParser, DepEdge, SymbolEntry, CallEdge, FileAnalysis } from '.
 export type { IChunker, ChunkPiece, ChunkOpts } from './IChunker';
 export type { ILogger } from './ILogger';
 export type { IDatabase } from './IDatabase';
-export type { ISearcher } from './ISearcher';
+export type { IToolPaths } from './IToolPaths';
+export type { IProjectRoots } from './IProjectRoots';
+export type { IWorkspaceFiles } from './IWorkspaceFiles';
+export type { IChunkSearch } from './IChunkSearch';
+export type { IDependencyGraph } from './IDependencyGraph';
+export type { ICallGraph } from './ICallGraph';
+export type { ISymbolLookup } from './ISymbolLookup';
+export type { IProjectCatalog } from './IProjectCatalog';
+export type { IIndexIdentityGuard } from './IIndexIdentityGuard';
+export type { IIndexedNodeResolver, IndexedNodeDescription } from './IIndexedNodeResolver';
 export type { IProjectDiscovery, DiscoveredProject } from './IProjectDiscovery';
+export type { IMcpReadiness, ReadinessCheck, ReadinessFailure } from './IMcpReadiness';
 export type { IMcpToolHandler, ToolDefinition, ToolResponse } from './IMcpToolHandler';
+export type { IScanReporter, ProjectNotice } from './IScanReporter';
 export type { EvalCategory, ExpectedAnswer, EvalCase, EvalSuite, SearchHit, SearchFn, IndexInspector, Metrics, CaseResult, InvalidCase, PartialWarning, EvalRunResult, IRetrievalEvaluator, ResultMetadata, EvalResultFile, MetricDelta, MetricsDelta, CompareResult, } from './IRetrievalEvaluator';

package/dist/src/interrupt.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupInterrupt = setupInterrupt;
-// Graceful interruption for long-running CLI operations.
-// Caller creates the AbortController; this function wires stdin and returns a cleanup function.
 function setupInterrupt(controller) {
     if (!process.stdin.isTTY)
         return () => { };

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

@@ -1,10 +1,9 @@
-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;
+import type { DeclarationTree } from './declarations/DeclarationTree';
+import type { SourceLines } from './declarations/SourceLines';
+interface LineSpan {
+    startLine: number;
+    endLine: number;
+}
+export declare function ownedLines(piece: LineSpan, declarations: DeclarationTree, lines: SourceLines): number[];
+export declare function ownerOf(piece: LineSpan, declarations: DeclarationTree, lines: SourceLines): string | null;
+export {};

package/dist/src/owner-path.js

@@ -1,27 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveOwnerPath = resolveOwnerPath;
-/**
- * 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).
- */
-function resolveOwnerPath(startLine, ranges) {
-    let best = null;
-    let bestSpan = Infinity;
-    for (const r of ranges) {
-        if (r.line <= startLine && startLine <= r.endLine) {
-            const span = r.endLine - r.line;
-            if (span < bestSpan) {
-                bestSpan = span;
-                best = r;
-            }
-        }
+exports.ownedLines = ownedLines;
+exports.ownerOf = ownerOf;
+function ownedLines(piece, declarations, lines) {
+    const owned = [];
+    for (let n = piece.startLine; n <= piece.endLine; n++) {
+        if (lines.isSignificant(n) && declarations.contains(n))
+            owned.push(n);
     }
-    if (!best)
-        return null;
-    return best.container ? `${best.container}.${best.name}` : best.name;
+    return owned;
+}
+function ownerOf(piece, declarations, lines) {
+    return declarations.smallestContaining(ownedLines(piece, declarations, lines))?.qualifiedName ?? null;
 }

package/dist/src/project-scope.d.ts

@@ -3,17 +3,6 @@ export interface ResolveProjectNamesResult {
     targets: DiscoveredProject[];
     notFound: string[];
 }
-/**
- * Resolve one or more `--project`-style names against discovered units: a
- * unit name expands to all of its children, a leaf name resolves to itself.
- * Units are tried before leaves so a top-level project named the same as a
- * nested-monorepo child's bare name can never shadow it. Targets are
- * deduplicated by leaf name and ordered by first-resolving input name.
- */
 export declare function resolveProjectNames(names: string[], units: DiscoveredProject[]): ResolveProjectNamesResult;
-/**
- * Every name `--project` would accept as a match, in discovery order: each
- * unit's own name, immediately followed by its expanded leaf names (an
- * ordinary project — no children — contributes only its own name once).
- */
+export declare function matchedProjectDir(name: string, units: DiscoveredProject[]): string | undefined;
 export declare function listAvailableNames(units: DiscoveredProject[]): string[];

package/dist/src/project-scope.js

@@ -1,15 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveProjectNames = resolveProjectNames;
+exports.matchedProjectDir = matchedProjectDir;
 exports.listAvailableNames = listAvailableNames;
 const MonorepoAwareDiscoveryService_1 = require("./services/MonorepoAwareDiscoveryService");
-/**
- * Resolve one or more `--project`-style names against discovered units: a
- * unit name expands to all of its children, a leaf name resolves to itself.
- * Units are tried before leaves so a top-level project named the same as a
- * nested-monorepo child's bare name can never shadow it. Targets are
- * deduplicated by leaf name and ordered by first-resolving input name.
- */
 function resolveProjectNames(names, units) {
     const leaves = (0, MonorepoAwareDiscoveryService_1.toLeafProjects)(units);
     const targets = [];
@@ -31,11 +25,10 @@ function resolveProjectNames(names, units) {
     }
     return { targets, notFound };
 }
-/**
- * Every name `--project` would accept as a match, in discovery order: each
- * unit's own name, immediately followed by its expanded leaf names (an
- * ordinary project — no children — contributes only its own name once).
- */
+function matchedProjectDir(name, units) {
+    const unit = units.find(u => u.name === name);
+    return unit ? unit.path : (0, MonorepoAwareDiscoveryService_1.toLeafProjects)(units).find(l => l.name === name)?.path;
+}
 function listAvailableNames(units) {
     const names = [];
     for (const unit of units) {

package/dist/src/project-selector.d.ts

@@ -2,11 +2,6 @@ export interface Project {
     name: string;
     path: string;
 }
-/**
- * One-off single-choice prompt for `--project` with no name — distinct from
- * the multi-select `checkbox` flow: it reads/writes nothing persisted.
- * Resolves to `undefined` if the user cancels (e.g. Ctrl+C).
- */
 export declare function selectSingleProject(units: Project[]): Promise<string | undefined>;
 export declare class ProjectSelector {
     private readonly workspaceDir;

package/dist/src/project-selector.js

@@ -38,11 +38,6 @@ exports.selectSingleProject = selectSingleProject;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const prompts_1 = require("@inquirer/prompts");
-/**
- * One-off single-choice prompt for `--project` with no name — distinct from
- * the multi-select `checkbox` flow: it reads/writes nothing persisted.
- * Resolves to `undefined` if the user cancels (e.g. Ctrl+C).
- */
 async function selectSingleProject(units) {
     try {
         return await (0, prompts_1.select)({
@@ -66,9 +61,6 @@ async function loadLines(filePath) {
         return new Set();
     }
 }
-// Write the set if non-empty, otherwise delete the file so state is deterministic.
-// Previously .ragskip could be left stale (last entry removed but file not rewritten);
-// treating both files the same way avoids that drift.
 async function saveLines(filePath, names) {
     if (names.size > 0) {
         await fs.promises.writeFile(filePath, [...names].sort().join('\n') + '\n');
@@ -94,13 +86,10 @@ class ProjectSelector {
         await this.load();
         const newProjects = allProjects.filter(p => !this.included.has(p.name) && !this.skipped.has(p.name));
         const previouslySelected = allProjects.filter(p => this.included.has(p.name));
-        // Nothing new and something already selected — return silently
         if (newProjects.length === 0 && !forceSelect && previouslySelected.length > 0) {
             return previouslySelected;
         }
-        // No previous selection — treat as implicit --select so the user picks projects now
         const autoSelect = !forceSelect && previouslySelected.length === 0;
-        // In --select / auto-select mode show all non-skipped projects; otherwise only new ones
         const toShow = (forceSelect || autoSelect)
             ? allProjects.filter(p => !this.skipped.has(p.name))
             : newProjects;

package/dist/src/retrieval-eval.d.ts

@@ -1,16 +1,25 @@
-import type { EvalSuite, SearchFn, IndexInspector, IRetrievalEvaluator, EvalRunResult, EvalResultFile, CompareResult } from './interfaces/IRetrievalEvaluator';
-/** Thrown by `parseSuite` before any search runs — names the offending case and field. */
+import type { EvalSuite, EvalCase, EvalCategory, CorpusRef, SearchFn, IndexInspector, IRetrievalEvaluator, EvalOutcome, StageName, PairedChange, CaseProgress, EvalResultFile, ThresholdCondition, CompareResult } from './interfaces/IRetrievalEvaluator';
+export declare const STAGE_ORDER: readonly StageName[];
 export declare class EvalSuiteError extends Error {
     readonly caseId: string | null;
     readonly field: string | null;
     constructor(message: string, caseId: string | null, field: string | null);
 }
-/** Validates a loaded suite object against the schema; rejects before any search runs. */
 export declare function parseSuite(raw: unknown): EvalSuite;
-/** Merges several suites (already parsed) into one; case ids must be unique across all of them. */
+export declare function corporaOf(suites: EvalSuite[]): CorpusRef[];
+export declare function isUnderRoot(dir: string, root: string): boolean;
+export declare function checkCaseCorpora(cases: EvalCase[], projectDir: (project: string) => Promise<string | null>): Promise<void>;
 export declare function mergeSuites(suites: EvalSuite[]): EvalSuite;
+export declare function signTest(improved: number, worsened: number): number;
+export interface RankedCase {
+    id: string;
+    category: EvalCategory;
+    rank: number | null;
+}
+export declare function pairedChange(from: RankedCase[], to: RankedCase[]): PairedChange;
+export declare const LIVE_GROUP = "live";
+export declare function formatThresholdConditions(pairs: ThresholdCondition[]): string;
 export declare class RetrievalEvaluator implements IRetrievalEvaluator {
-    evaluate(suite: EvalSuite, search: SearchFn, inspect: IndexInspector): Promise<EvalRunResult>;
+    evaluate(suite: EvalSuite, search: SearchFn, inspect: IndexInspector, onCase?: (p: CaseProgress) => void): Promise<EvalOutcome>;
 }
-/** Pure comparison of two result files; prints a warning (never refuses) on mismatched conditions. */
 export declare function compare(baseline: EvalResultFile, current: EvalResultFile): CompareResult;