codesearch-mcp 0.3.0-alpha → 0.4.0-alpha

package/dist/src/indexing/analysis-rows.js

@@ -0,0 +1,65 @@
+"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.workspaceEdges = workspaceEdges;
+exports.workspaceCalls = workspaceCalls;
+exports.toPromptEdges = toPromptEdges;
+const path = __importStar(require("path"));
+function workspaceEdges(rawEdges, workspaceRoot) {
+    return rawEdges
+        .filter(e => e.toFile.startsWith(workspaceRoot))
+        .map(e => ({
+        ...e,
+        fromFile: path.relative(workspaceRoot, e.fromFile),
+        toFile: path.relative(workspaceRoot, e.toFile),
+    }));
+}
+function workspaceCalls(rawCalls, serviceName, relFilePath, workspaceRoot) {
+    return rawCalls
+        .filter(c => c.calleeFile.startsWith(workspaceRoot))
+        .map(c => ({
+        project: serviceName,
+        fromFile: relFilePath,
+        fromSymbol: c.fromSymbol,
+        calleeName: c.calleeName,
+        calleeFile: path.relative(workspaceRoot, c.calleeFile),
+        calleeSymbol: c.calleeSymbol,
+        line: c.line,
+        col: c.col,
+    }));
+}
+function toPromptEdges(edges) {
+    return edges.filter(e => e.depType !== 'import-side-effect');
+}

package/dist/src/indexing/project-notices.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectNotice } from '../interfaces';
+export declare function collectProjectNotices(dir: string, fileCount: number, batchSize: number): ProjectNotice[];

package/dist/src/indexing/project-notices.js

@@ -0,0 +1,63 @@
+"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.collectProjectNotices = collectProjectNotices;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const file_utils_1 = require("../file-utils");
+function collectProjectNotices(dir, fileCount, batchSize) {
+    const notices = [];
+    const meta = (0, file_utils_1.readRagMeta)(dir);
+    if (meta === 'invalid') {
+        const msg = `.ragmeta.json found but invalid JSON`;
+        notices.push({ mark: '⚠', message: msg, warning: true });
+    }
+    else if (meta !== 'missing') {
+        const parts = [meta.description, meta.stack && `[${meta.stack}]`].filter(Boolean).join(' ');
+        notices.push({ mark: '✓', message: `.ragmeta.json: ${parts || '(no fields)'}`, warning: false });
+    }
+    else {
+        const msg = `No .ragmeta.json — add {"description":"...","stack":"...","notes":"..."} so list_projects can describe this project`;
+        notices.push({ mark: '⚠', message: msg, warning: true });
+    }
+    if (!fs.existsSync(path.join(dir, '.ragignore'))) {
+        const msg = `No .ragignore — create one to exclude generated/codegen files (e.g. src/gql/graphql.ts, **/__snapshots__/**)`;
+        notices.push({ mark: '⚠', message: msg, warning: true });
+    }
+    if (fileCount > batchSize) {
+        notices.push({ mark: '⚠', message: `Large project (${fileCount} files) — AST analysis uses batches of ${batchSize}; cross-batch dependency edges may be incomplete`, warning: false });
+    }
+    return notices;
+}

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

@@ -7,7 +7,8 @@ export interface DepEdge {
     toSymbol: string | null;
     depType: string;
 }
-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';
+import type { SymbolKind } from './SymbolKind';
+export type { SymbolKind };
 export interface SymbolEntry {
     project: string;
     filePath: string;

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

@@ -0,0 +1,28 @@
+export interface CallerRow {
+    fromFile: string;
+    fromSymbol: string | null;
+    calleeName: string;
+    calleeFile: string;
+    line: number | null;
+}
+export type NoCallersCause = {
+    kind: 'no-call-graph';
+} | {
+    kind: 'unknown-symbol';
+    suggestions: string[];
+    truncated: boolean;
+} | {
+    kind: 'no-recorded-calls';
+    definitions: {
+        qualified: string;
+        filePath: string;
+        line: number | null;
+    }[];
+    truncated: boolean;
+} | {
+    kind: 'lookup-failed';
+};
+export interface ICallGraph {
+    getCallers(symbol: string, project: string, calleeFile?: string | null): Promise<CallerRow[]>;
+    explainNoCallers(symbol: string, project: string): Promise<NoCallersCause>;
+}

package/dist/src/interfaces/ICallGraph.js

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

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

@@ -0,0 +1,42 @@
+import type { ResolvedThreshold } from '../constants';
+export interface ChunkRow {
+    serviceName: string;
+    filePath: string;
+    startLine: number;
+    content: string;
+    ownerPath?: string | null;
+}
+export interface SearchResult extends ChunkRow {
+    score: number;
+}
+export interface NeighborResult {
+    result: SearchResult;
+    prevChunk: ChunkRow | null;
+    nextChunk: ChunkRow | null;
+}
+export type StageName = 'vector' | 'reranked';
+export interface StagedSearchResult {
+    pool: SearchResult[];
+    stages: {
+        vector: SearchResult[];
+        reranked?: SearchResult[];
+    };
+    rerankFailed: boolean;
+    fetchLimit: number;
+    indexParams: {
+        efSearch: number | null;
+        iterativeScan: string;
+    };
+    threshold: ResolvedThreshold;
+}
+export type NoResultsCause = 'empty-scope' | 'no-candidates' | 'lookup-failed';
+export interface IChunkSearch {
+    prepareQuery(raw: string): Promise<{
+        query: string;
+        translated: boolean;
+    }>;
+    searchChunks(query: string, limit: number, project: string | null, threshold?: number, rerankOverride?: boolean, perFile?: number): Promise<SearchResult[]>;
+    searchChunksWithStages(query: string, limit: number, project: string | null, threshold?: number, rerankOverride?: boolean, perFile?: number): Promise<StagedSearchResult>;
+    explainNoResults(project: string | null): Promise<NoResultsCause>;
+    fetchNeighbors(results: SearchResult[]): Promise<NeighborResult[]>;
+}

package/dist/src/interfaces/IChunkSearch.js

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

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

@@ -1,16 +1,20 @@
-import type { DrizzleDb, DrizzleTx } from '../services/DatabaseService';
+import type { DrizzleDb, DrizzleTx } from '../db';
 export interface IndexMeta {
     provider: string;
     model: string;
     dimensions: number;
 }
+export interface InitDbOptions {
+    connectionTimeoutMs?: number;
+}
 export interface IDatabase {
     readonly 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>;
-    initDb(): Promise<void>;
+    initDb(options?: InitDbOptions): Promise<void>;
+    probe(): Promise<void>;
     initDbWithSchema(): Promise<void>;
     destroy(): Promise<void>;
     readIndexMeta(): Promise<IndexMeta | null>;

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

@@ -0,0 +1,24 @@
+import type { SearchResult } from './IChunkSearch';
+export interface GraphContext {
+    imports: string[];
+    usedBy: string[];
+}
+export interface DependencyRow {
+    fromFile: string;
+    fromSymbol: string | null;
+    toFile: string;
+    toSymbol: string | null;
+    depType: string;
+    depth?: number;
+    via?: string;
+    id?: string;
+}
+export interface IDependencyGraph {
+    getProjectEdges(): Promise<{
+        from: string;
+        to: string;
+    }[]>;
+    fetchGraphContext(results: SearchResult[]): Promise<Map<string, GraphContext>>;
+    getDependencies(filePath: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
+    getDependents(filePath: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
+}

package/dist/src/interfaces/IDependencyGraph.js

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

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

@@ -0,0 +1,3 @@
+export interface IIndexIdentityGuard {
+    assertIndexMatches(): Promise<void>;
+}

package/dist/src/interfaces/IIndexIdentityGuard.js

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

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

@@ -0,0 +1,10 @@
+import type { Node } from 'ts-morph';
+export interface IndexedNodeDescription {
+    name: string;
+    container: string[];
+}
+export interface IIndexedNodeResolver {
+    describeIndexedNode(node: Node): IndexedNodeDescription | null;
+    qualifiedName(described: IndexedNodeDescription): string;
+    findFromSymbol(node: Node): string | null;
+}

package/dist/src/interfaces/IIndexedNodeResolver.js

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

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

@@ -0,0 +1,12 @@
+export interface ReadinessFailure {
+    ok: false;
+    err: unknown;
+}
+export type ReadinessCheck = {
+    ok: true;
+} | ReadinessFailure;
+export interface IMcpReadiness {
+    start(): Promise<ReadinessCheck>;
+    ensureReady(): Promise<ReadinessCheck>;
+    readonly ready: boolean;
+}

package/dist/src/interfaces/IMcpReadiness.js

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

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

@@ -0,0 +1,13 @@
+import type { ProjectMeta } from '../file-utils';
+export interface ProjectRow extends ProjectMeta {
+    serviceName: string;
+    chunks: number;
+    packageName?: string | null;
+    type?: 'app' | 'lib';
+    path?: string;
+    relPath?: string;
+    rootError?: string | null;
+}
+export interface IProjectCatalog {
+    listProjects(): Promise<ProjectRow[]>;
+}

package/dist/src/interfaces/IProjectCatalog.js

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

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

@@ -0,0 +1,3 @@
+export interface IProjectRoots {
+    fallbackRoot(relPath: string): string | null;
+}

package/dist/src/interfaces/IProjectRoots.js

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

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

@@ -1,4 +1,5 @@
-import type { StageName } from './ISearcher';
+import type { StageName } from './IChunkSearch';
+import type { ResolvedThreshold, ThresholdSource } from '../constants';
 export type { StageName };
 export type EvalCategory = 'identifier' | 'behaviour' | 'concept';
 export interface ExpectedAnswer {
@@ -38,6 +39,7 @@ export interface StagedHits {
         efSearch: number | null;
         iterativeScan: string;
     };
+    threshold: ResolvedThreshold;
 }
 export type SearchFn = (query: string, limit: number, project: string | null, threshold?: number) => Promise<StagedHits>;
 export interface IndexInspector {
@@ -128,6 +130,7 @@ export interface ObservedSearchParams {
     fetchLimit: number[];
     efSearch: (number | null)[];
     iterativeScan: string[];
+    thresholds: ResolvedThreshold[];
 }
 export interface EvalOutcome {
     run: EvalRunResult;
@@ -144,8 +147,12 @@ export interface CaseProgress {
 export interface IRetrievalEvaluator {
     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 {
-    similarityThreshold: number;
+    thresholds: ThresholdCondition[];
     overfetch: number;
     candidateFloor: number;
     fetchLimit: number[];
@@ -166,9 +173,21 @@ export interface ResultMetadata {
     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;

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/project-scope.d.ts

@@ -4,4 +4,5 @@ export interface ResolveProjectNamesResult {
     notFound: string[];
 }
 export declare function resolveProjectNames(names: string[], units: DiscoveredProject[]): ResolveProjectNamesResult;
+export declare function matchedProjectDir(name: string, units: DiscoveredProject[]): string | undefined;
 export declare function listAvailableNames(units: DiscoveredProject[]): string[];

package/dist/src/project-scope.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveProjectNames = resolveProjectNames;
+exports.matchedProjectDir = matchedProjectDir;
 exports.listAvailableNames = listAvailableNames;
 const MonorepoAwareDiscoveryService_1 = require("./services/MonorepoAwareDiscoveryService");
 function resolveProjectNames(names, units) {
@@ -24,6 +25,10 @@ function resolveProjectNames(names, units) {
     }
     return { targets, notFound };
 }
+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/retrieval-eval.d.ts

@@ -1,4 +1,4 @@
-import type { EvalSuite, EvalCase, EvalCategory, CorpusRef, SearchFn, IndexInspector, IRetrievalEvaluator, EvalOutcome, StageName, PairedChange, CaseProgress, EvalResultFile, CompareResult } from './interfaces/IRetrievalEvaluator';
+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;
@@ -18,6 +18,7 @@ export interface RankedCase {
 }
 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, onCase?: (p: CaseProgress) => void): Promise<EvalOutcome>;
 }