@rlynjb/aptkit-core 0.1.0

package/node_modules/@aptkit/context/dist/src/index.js

@@ -0,0 +1,2 @@
+export * from './workspace-descriptor.js';
+export * from './workspace-summary.js';

package/node_modules/@aptkit/context/dist/src/workspace-descriptor.d.ts

@@ -0,0 +1,25 @@
+export type WorkspaceEventDescriptor = {
+    name: string;
+    properties: string[];
+    eventCount: number;
+};
+export type WorkspaceCatalogDescriptor = {
+    id?: string;
+    name: string;
+};
+export type DataHorizon = {
+    from: string;
+    to: string;
+    durationDays: number;
+};
+export type WorkspaceDescriptor = {
+    projectId: string;
+    projectName: string;
+    events: WorkspaceEventDescriptor[];
+    customerProperties: string[];
+    catalogs: WorkspaceCatalogDescriptor[];
+    totalCustomers: number;
+    totalEvents: number;
+    oldestTimestamp: number | null;
+    dataHorizon?: DataHorizon;
+};

package/node_modules/@aptkit/context/dist/src/workspace-descriptor.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@aptkit/context/dist/src/workspace-summary.d.ts

@@ -0,0 +1,9 @@
+import type { WorkspaceDescriptor } from './workspace-descriptor.js';
+export type WorkspaceSummaryOptions = {
+    maxEvents?: number;
+    maxEventProperties?: number;
+    maxCustomerProperties?: number;
+    horizonStyle?: 'arrow-with-query-rule' | 'plain';
+    eventHeading?: string;
+};
+export declare function schemaSummary(workspace: WorkspaceDescriptor, options?: WorkspaceSummaryOptions): string;

package/node_modules/@aptkit/context/dist/src/workspace-summary.js

@@ -0,0 +1,38 @@
+export function schemaSummary(workspace, options = {}) {
+    const { maxEvents = 20, maxEventProperties = 10, maxCustomerProperties = 30, horizonStyle = 'arrow-with-query-rule', eventHeading = 'Top events (name, eventCount: properties):', } = options;
+    const oldestDate = workspace.oldestTimestamp
+        ? new Date(workspace.oldestTimestamp).toISOString().slice(0, 10)
+        : 'unknown';
+    const eventsText = workspace.events
+        .slice(0, maxEvents)
+        .map((event) => {
+        const props = event.properties.slice(0, maxEventProperties).join(', ');
+        return `  - ${event.name} (${event.eventCount}): ${props || '(no properties)'}`;
+    })
+        .join('\n');
+    const customerPropsText = workspace.customerProperties
+        .slice(0, maxCustomerProperties)
+        .join(', ') || 'none';
+    const horizonLine = formatDataHorizon(workspace, horizonStyle);
+    return [
+        `Project: ${workspace.projectName} (${workspace.projectId})`,
+        `Total customers: ${workspace.totalCustomers.toLocaleString()}`,
+        `Total events: ${workspace.totalEvents.toLocaleString()}`,
+        `Oldest data: ${oldestDate}`,
+        ...(horizonLine ? [horizonLine] : []),
+        `Catalogs: ${workspace.catalogs.map((catalog) => catalog.name).join(', ') || 'none'}`,
+        '',
+        eventHeading,
+        eventsText,
+        '',
+        `Customer properties: ${customerPropsText}`,
+    ].join('\n');
+}
+function formatDataHorizon(workspace, horizonStyle) {
+    if (!workspace.dataHorizon)
+        return null;
+    if (horizonStyle === 'plain') {
+        return `Data horizon: ${workspace.dataHorizon.from} to ${workspace.dataHorizon.to} (${workspace.dataHorizon.durationDays} days; to exclusive).`;
+    }
+    return `Data horizon: ${workspace.dataHorizon.from} -> ${workspace.dataHorizon.to} (${workspace.dataHorizon.durationDays} days; to exclusive). ALL queries MUST land inside this window.`;
+}

package/node_modules/@aptkit/context/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@aptkit/context",
+  "version": "0.0.0",
+  "type": "module",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "README.md",
+    "dist/src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test dist/test/*.test.js"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0"
+  }
+}

package/node_modules/@aptkit/evals/dist/src/assertions.d.ts

@@ -0,0 +1,13 @@
+import { type StructuralDiffResult } from './structural-diff.js';
+export type EvalAssertionResult = StructuralDiffResult & {
+    name: string;
+};
+export declare function assertRecommendationShape(output: unknown): EvalAssertionResult;
+export declare function assertAnomalyShape(output: unknown): EvalAssertionResult;
+export declare function assertCapabilityReplayArtifactShape(output: unknown): EvalAssertionResult;
+export declare function assertQueryAnswerShape(output: unknown): EvalAssertionResult;
+export declare function assertReplayArtifactShape(output: unknown): EvalAssertionResult;
+export declare function assertMonitoringReplayArtifactShape(output: unknown): EvalAssertionResult;
+export declare function assertDiagnosticShape(output: unknown): EvalAssertionResult;
+export declare function assertDiagnosticReplayArtifactShape(output: unknown): EvalAssertionResult;
+export declare function assertQueryReplayArtifactShape(output: unknown): EvalAssertionResult;

package/node_modules/@aptkit/evals/dist/src/assertions.js

@@ -0,0 +1,351 @@
+import { assertRequiredPaths } from './structural-diff.js';
+export function assertRecommendationShape(output) {
+    const result = assertRequiredPaths(output, [
+        '0.title',
+        '0.rationale',
+        '0.bloomreachFeature',
+        '0.steps',
+        '0.estimatedImpact',
+        '0.confidence',
+    ]);
+    return { name: 'recommendation-shape', ...result };
+}
+export function assertAnomalyShape(output) {
+    if (Array.isArray(output) && output.length === 0) {
+        return { name: 'anomaly-shape', ok: true, issues: [] };
+    }
+    const result = assertRequiredPaths(output, [
+        '0.metric',
+        '0.scope',
+        '0.change.value',
+        '0.change.direction',
+        '0.change.baseline',
+        '0.severity',
+    ]);
+    return { name: 'anomaly-shape', ...result };
+}
+export function assertCapabilityReplayArtifactShape(output) {
+    if (isRecord(output) && (output.capabilityId === 'query-agent' || typeof output.answer === 'string')) {
+        return assertQueryReplayArtifactShape(output);
+    }
+    if (isRecord(output) && (output.capabilityId === 'diagnostic-investigation-agent' || isRecord(output.diagnosis))) {
+        return assertDiagnosticReplayArtifactShape(output);
+    }
+    if (isRecord(output) && (output.capabilityId === 'anomaly-monitoring-agent' || Array.isArray(output.anomalies))) {
+        return assertMonitoringReplayArtifactShape(output);
+    }
+    return assertReplayArtifactShape(output);
+}
+export function assertQueryAnswerShape(output) {
+    const issues = [];
+    if (typeof output !== 'string') {
+        issues.push({ path: '', message: 'answer must be a string' });
+    }
+    else if (output.trim().length < 20) {
+        issues.push({ path: '', message: 'answer is too short to be useful' });
+    }
+    return { name: 'query-answer-shape', ok: issues.length === 0, issues };
+}
+export function assertReplayArtifactShape(output) {
+    const result = assertRequiredPaths(output, [
+        'schemaVersion',
+        'createdAt',
+        'durationMs',
+        'provider.id',
+        'provider.model',
+        'fixture.id',
+        'fixture.path',
+        'recommendations',
+        'trace',
+        'eval.name',
+        'eval.ok',
+        'modelTurns',
+    ]);
+    const issues = [...result.issues];
+    if (!isRecord(output)) {
+        return {
+            name: 'replay-artifact-shape',
+            ok: false,
+            issues: [{ path: '', message: 'artifact must be an object' }, ...issues],
+        };
+    }
+    if (output.schemaVersion !== 1) {
+        issues.push({ path: 'schemaVersion', message: 'expected schemaVersion 1' });
+    }
+    if (typeof output.createdAt !== 'string' || Number.isNaN(Date.parse(output.createdAt))) {
+        issues.push({ path: 'createdAt', message: 'expected an ISO timestamp string' });
+    }
+    if (typeof output.durationMs !== 'number' || output.durationMs < 0) {
+        issues.push({ path: 'durationMs', message: 'expected a non-negative number' });
+    }
+    if (typeof output.modelTurns !== 'number' || output.modelTurns < 0) {
+        issues.push({ path: 'modelTurns', message: 'expected a non-negative number' });
+    }
+    if (!Array.isArray(output.trace)) {
+        issues.push({ path: 'trace', message: 'expected an array' });
+    }
+    const recommendations = output.recommendations;
+    if (!Array.isArray(recommendations)) {
+        issues.push({ path: 'recommendations', message: 'expected an array' });
+    }
+    else {
+        const recommendationResult = assertRecommendationShape(recommendations);
+        for (const issue of recommendationResult.issues) {
+            issues.push({ path: `recommendations.${issue.path}`, message: issue.message });
+        }
+    }
+    const replayEval = output.eval;
+    if (!isRecord(replayEval) || replayEval.ok !== true) {
+        issues.push({ path: 'eval.ok', message: 'expected embedded replay eval to pass' });
+    }
+    validatePromptPackageProvenance(output, issues);
+    const secretIssue = findSecretLikeString(output);
+    if (secretIssue) {
+        issues.push(secretIssue);
+    }
+    return { name: 'replay-artifact-shape', ok: issues.length === 0, issues };
+}
+export function assertMonitoringReplayArtifactShape(output) {
+    const result = assertRequiredPaths(output, [
+        'schemaVersion',
+        'capabilityId',
+        'createdAt',
+        'durationMs',
+        'provider.id',
+        'provider.model',
+        'fixture.id',
+        'fixture.path',
+        'anomalies',
+        'trace',
+        'eval.name',
+        'eval.ok',
+        'modelTurns',
+    ]);
+    const issues = [...result.issues];
+    if (!isRecord(output)) {
+        return {
+            name: 'monitoring-replay-artifact-shape',
+            ok: false,
+            issues: [{ path: '', message: 'artifact must be an object' }, ...issues],
+        };
+    }
+    if (output.schemaVersion !== 1) {
+        issues.push({ path: 'schemaVersion', message: 'expected schemaVersion 1' });
+    }
+    if (output.capabilityId !== 'anomaly-monitoring-agent') {
+        issues.push({ path: 'capabilityId', message: 'expected anomaly-monitoring-agent' });
+    }
+    if (typeof output.createdAt !== 'string' || Number.isNaN(Date.parse(output.createdAt))) {
+        issues.push({ path: 'createdAt', message: 'expected an ISO timestamp string' });
+    }
+    if (typeof output.durationMs !== 'number' || output.durationMs < 0) {
+        issues.push({ path: 'durationMs', message: 'expected a non-negative number' });
+    }
+    if (typeof output.modelTurns !== 'number' || output.modelTurns < 0) {
+        issues.push({ path: 'modelTurns', message: 'expected a non-negative number' });
+    }
+    if (!Array.isArray(output.trace)) {
+        issues.push({ path: 'trace', message: 'expected an array' });
+    }
+    const anomalies = output.anomalies;
+    if (!Array.isArray(anomalies)) {
+        issues.push({ path: 'anomalies', message: 'expected an array' });
+    }
+    else {
+        const anomalyResult = assertAnomalyShape(anomalies);
+        for (const issue of anomalyResult.issues) {
+            issues.push({ path: `anomalies.${issue.path}`, message: issue.message });
+        }
+    }
+    const replayEval = output.eval;
+    if (!isRecord(replayEval) || replayEval.ok !== true) {
+        issues.push({ path: 'eval.ok', message: 'expected embedded replay eval to pass' });
+    }
+    validatePromptPackageProvenance(output, issues);
+    const secretIssue = findSecretLikeString(output);
+    if (secretIssue) {
+        issues.push(secretIssue);
+    }
+    return { name: 'monitoring-replay-artifact-shape', ok: issues.length === 0, issues };
+}
+export function assertDiagnosticShape(output) {
+    const result = assertRequiredPaths(output, [
+        'conclusion',
+        'evidence',
+        'hypothesesConsidered',
+    ]);
+    const issues = [...result.issues];
+    if (!isRecord(output)) {
+        return {
+            name: 'diagnosis-shape',
+            ok: false,
+            issues: [{ path: '', message: 'diagnosis must be an object' }, ...issues],
+        };
+    }
+    if (!Array.isArray(output.evidence)) {
+        issues.push({ path: 'evidence', message: 'expected an array' });
+    }
+    if (!Array.isArray(output.hypothesesConsidered)) {
+        issues.push({ path: 'hypothesesConsidered', message: 'expected an array' });
+    }
+    return { name: 'diagnosis-shape', ok: issues.length === 0, issues };
+}
+export function assertDiagnosticReplayArtifactShape(output) {
+    const result = assertRequiredPaths(output, [
+        'schemaVersion',
+        'capabilityId',
+        'createdAt',
+        'durationMs',
+        'provider.id',
+        'provider.model',
+        'fixture.id',
+        'fixture.path',
+        'diagnosis',
+        'trace',
+        'eval.name',
+        'eval.ok',
+        'modelTurns',
+    ]);
+    const issues = [...result.issues];
+    if (!isRecord(output)) {
+        return {
+            name: 'diagnostic-replay-artifact-shape',
+            ok: false,
+            issues: [{ path: '', message: 'artifact must be an object' }, ...issues],
+        };
+    }
+    if (output.schemaVersion !== 1) {
+        issues.push({ path: 'schemaVersion', message: 'expected schemaVersion 1' });
+    }
+    if (output.capabilityId !== 'diagnostic-investigation-agent') {
+        issues.push({ path: 'capabilityId', message: 'expected diagnostic-investigation-agent' });
+    }
+    if (typeof output.createdAt !== 'string' || Number.isNaN(Date.parse(output.createdAt))) {
+        issues.push({ path: 'createdAt', message: 'expected an ISO timestamp string' });
+    }
+    if (typeof output.durationMs !== 'number' || output.durationMs < 0) {
+        issues.push({ path: 'durationMs', message: 'expected a non-negative number' });
+    }
+    if (typeof output.modelTurns !== 'number' || output.modelTurns < 0) {
+        issues.push({ path: 'modelTurns', message: 'expected a non-negative number' });
+    }
+    if (!Array.isArray(output.trace)) {
+        issues.push({ path: 'trace', message: 'expected an array' });
+    }
+    const diagnosisResult = assertDiagnosticShape(output.diagnosis);
+    for (const issue of diagnosisResult.issues) {
+        issues.push({ path: `diagnosis.${issue.path}`, message: issue.message });
+    }
+    const replayEval = output.eval;
+    if (!isRecord(replayEval) || replayEval.ok !== true) {
+        issues.push({ path: 'eval.ok', message: 'expected embedded replay eval to pass' });
+    }
+    validatePromptPackageProvenance(output, issues);
+    const secretIssue = findSecretLikeString(output);
+    if (secretIssue) {
+        issues.push(secretIssue);
+    }
+    return { name: 'diagnostic-replay-artifact-shape', ok: issues.length === 0, issues };
+}
+export function assertQueryReplayArtifactShape(output) {
+    const result = assertRequiredPaths(output, [
+        'schemaVersion',
+        'capabilityId',
+        'createdAt',
+        'durationMs',
+        'provider.id',
+        'provider.model',
+        'fixture.id',
+        'fixture.path',
+        'answer',
+        'trace',
+        'eval.name',
+        'eval.ok',
+        'modelTurns',
+    ]);
+    const issues = [...result.issues];
+    if (!isRecord(output)) {
+        return {
+            name: 'query-replay-artifact-shape',
+            ok: false,
+            issues: [{ path: '', message: 'artifact must be an object' }, ...issues],
+        };
+    }
+    if (output.schemaVersion !== 1) {
+        issues.push({ path: 'schemaVersion', message: 'expected schemaVersion 1' });
+    }
+    if (output.capabilityId !== 'query-agent') {
+        issues.push({ path: 'capabilityId', message: 'expected query-agent' });
+    }
+    if (typeof output.createdAt !== 'string' || Number.isNaN(Date.parse(output.createdAt))) {
+        issues.push({ path: 'createdAt', message: 'expected an ISO timestamp string' });
+    }
+    if (typeof output.durationMs !== 'number' || output.durationMs < 0) {
+        issues.push({ path: 'durationMs', message: 'expected a non-negative number' });
+    }
+    if (typeof output.modelTurns !== 'number' || output.modelTurns < 0) {
+        issues.push({ path: 'modelTurns', message: 'expected a non-negative number' });
+    }
+    if (!Array.isArray(output.trace)) {
+        issues.push({ path: 'trace', message: 'expected an array' });
+    }
+    const answerResult = assertQueryAnswerShape(output.answer);
+    for (const issue of answerResult.issues) {
+        issues.push({ path: `answer.${issue.path}`, message: issue.message });
+    }
+    const replayEval = output.eval;
+    if (!isRecord(replayEval) || replayEval.ok !== true) {
+        issues.push({ path: 'eval.ok', message: 'expected embedded replay eval to pass' });
+    }
+    validatePromptPackageProvenance(output, issues);
+    const secretIssue = findSecretLikeString(output);
+    if (secretIssue) {
+        issues.push(secretIssue);
+    }
+    return { name: 'query-replay-artifact-shape', ok: issues.length === 0, issues };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function validatePromptPackageProvenance(output, issues) {
+    if (output.promptPackage === undefined)
+        return;
+    if (!isRecord(output.promptPackage)) {
+        issues.push({ path: 'promptPackage', message: 'expected an object' });
+        return;
+    }
+    for (const path of ['id', 'version', 'capabilityId', 'templateHash', 'renderedHash']) {
+        if (typeof output.promptPackage[path] !== 'string' || output.promptPackage[path].trim().length === 0) {
+            issues.push({ path: `promptPackage.${path}`, message: 'expected a non-empty string' });
+        }
+    }
+    for (const path of ['templateChars', 'renderedChars']) {
+        if (typeof output.promptPackage[path] !== 'number' || output.promptPackage[path] <= 0) {
+            issues.push({ path: `promptPackage.${path}`, message: 'expected a positive number' });
+        }
+    }
+}
+function findSecretLikeString(value, path = '') {
+    if (typeof value === 'string') {
+        if (/sk-[A-Za-z0-9_-]{10,}/.test(value) || /OPENAI_API_KEY\s*=/.test(value)) {
+            return { path, message: 'artifact contains a secret-like string' };
+        }
+        return null;
+    }
+    if (Array.isArray(value)) {
+        for (let index = 0; index < value.length; index += 1) {
+            const issue = findSecretLikeString(value[index], path ? `${path}.${index}` : String(index));
+            if (issue)
+                return issue;
+        }
+        return null;
+    }
+    if (isRecord(value)) {
+        for (const [key, child] of Object.entries(value)) {
+            const issue = findSecretLikeString(child, path ? `${path}.${key}` : key);
+            if (issue)
+                return issue;
+        }
+    }
+    return null;
+}

package/node_modules/@aptkit/evals/dist/src/detection-scorer.d.ts

@@ -0,0 +1,25 @@
+import type { StructuralIssue } from './structural-diff.js';
+export type DetectionLike = {
+    category?: string;
+    metric?: string;
+    scope?: readonly string[];
+    severity?: string;
+};
+export type DetectionExpectations = {
+    minCount?: number;
+    maxCount?: number;
+    requiredCategories?: readonly string[];
+    requiredMetrics?: readonly string[];
+    requiredScopes?: readonly string[];
+    requiredSeverities?: readonly string[];
+};
+export type DetectionScoreResult = {
+    ok: boolean;
+    score: number;
+    matched: string[];
+    missed: string[];
+    unexpected: string[];
+    issues: StructuralIssue[];
+};
+/** Scores detection-like outputs against expected categories, metrics, scopes, severities, and counts. */
+export declare function scoreDetections(detections: readonly DetectionLike[], expectations?: DetectionExpectations): DetectionScoreResult;

package/node_modules/@aptkit/evals/dist/src/detection-scorer.js

@@ -0,0 +1,72 @@
+/** Scores detection-like outputs against expected categories, metrics, scopes, severities, and counts. */
+export function scoreDetections(detections, expectations = {}) {
+    const required = [
+        ...(expectations.requiredCategories ?? []).map((value) => ({ kind: 'category', value })),
+        ...(expectations.requiredMetrics ?? []).map((value) => ({ kind: 'metric', value })),
+        ...(expectations.requiredScopes ?? []).map((value) => ({ kind: 'scope', value })),
+        ...(expectations.requiredSeverities ?? []).map((value) => ({ kind: 'severity', value })),
+    ];
+    const matched = [];
+    const missed = [];
+    const issues = [];
+    const minCount = expectations.minCount ?? 0;
+    if (detections.length < minCount) {
+        issues.push({ path: 'expectations.minCount', message: `expected at least ${minCount} detections, got ${detections.length}` });
+    }
+    if (expectations.maxCount !== undefined && detections.length > expectations.maxCount) {
+        issues.push({ path: 'expectations.maxCount', message: `expected at most ${expectations.maxCount} detections, got ${detections.length}` });
+    }
+    for (const requirement of required) {
+        const label = `${requirement.kind}:${requirement.value}`;
+        if (matchesRequirement(detections, requirement.kind, requirement.value)) {
+            matched.push(label);
+        }
+        else {
+            missed.push(label);
+            issues.push({
+                path: expectationPath(requirement.kind),
+                message: `expected ${requirement.kind}=${requirement.value}`,
+            });
+        }
+    }
+    const expectedCategories = new Set(expectations.requiredCategories ?? []);
+    const unexpected = detections
+        .map((detection) => detection.category)
+        .filter((category) => typeof category === 'string' && category.length > 0)
+        .filter((category) => expectedCategories.size > 0 && !expectedCategories.has(category))
+        .map((category) => `category:${category}`);
+    const requirementCount = required.length + (minCount > 0 ? 1 : 0) + (expectations.maxCount !== undefined ? 1 : 0);
+    const failedCount = missed.length + issues.filter((issue) => issue.path === 'expectations.minCount' || issue.path === 'expectations.maxCount').length;
+    const score = requirementCount === 0 ? 1 : Math.max(0, (requirementCount - failedCount) / requirementCount);
+    return {
+        ok: issues.length === 0,
+        score,
+        matched,
+        missed,
+        unexpected: [...new Set(unexpected)],
+        issues,
+    };
+}
+function matchesRequirement(detections, kind, value) {
+    return detections.some((detection) => {
+        if (kind === 'category')
+            return detection.category === value;
+        if (kind === 'metric')
+            return detection.metric === value;
+        if (kind === 'scope')
+            return detection.scope?.includes(value) ?? false;
+        if (kind === 'severity')
+            return detection.severity === value;
+        return false;
+    });
+}
+function capitalize(value) {
+    return `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+}
+function expectationPath(kind) {
+    if (kind === 'category')
+        return 'expectations.requiredCategories';
+    if (kind === 'severity')
+        return 'expectations.requiredSeverities';
+    return `expectations.required${capitalize(kind)}s`;
+}

package/node_modules/@aptkit/evals/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './assertions.js';
+export * from './detection-scorer.js';
+export * from './structural-diff.js';

package/node_modules/@aptkit/evals/dist/src/index.js

@@ -0,0 +1,3 @@
+export * from './assertions.js';
+export * from './detection-scorer.js';
+export * from './structural-diff.js';

package/node_modules/@aptkit/evals/dist/src/replay-runner.d.ts

@@ -0,0 +1,29 @@
+import { type EvalAssertionResult } from './assertions.js';
+export type ReplayArtifactEvalSummary = {
+    path: string;
+    ok: boolean;
+    issues: EvalAssertionResult['issues'];
+    capabilityId: string;
+    provider: unknown;
+    fixture: string | null;
+    recommendationCount: number | null;
+    anomalyCount: number | null;
+    diagnosisPresent: boolean | null;
+    answerPresent: boolean | null;
+};
+export type ReplayArtifactEvalReport = {
+    ok: boolean;
+    checked: number;
+    failed: number;
+    results: ReplayArtifactEvalSummary[];
+    message?: string;
+};
+export type EvaluateReplayArtifactFilesOptions = {
+    cwd?: string;
+};
+/** Lists replay artifact JSON files in deterministic filename order. */
+export declare function listReplayArtifacts(dir: string): Promise<string[]>;
+/** Evaluates one parsed replay artifact and returns the CLI/Studio summary fields. */
+export declare function evaluateReplayArtifact(artifact: unknown, path: string): ReplayArtifactEvalSummary;
+/** Reads and evaluates replay artifact files, preserving the aggregate CLI report shape. */
+export declare function evaluateReplayArtifactFiles(paths: readonly string[], options?: EvaluateReplayArtifactFilesOptions): Promise<ReplayArtifactEvalReport>;