@sanity/ailf 2.0.2 → 2.2.0

package/dist/scripts/compare.d.ts

@@ -1,22 +0,0 @@
-/**
- * compare.ts
- *
- * CLI for structured comparison between two evaluation runs.
- *
- * Usage:
- *   pnpm compare                                # compare current vs latest baseline
- *   pnpm compare --baseline <path>              # compare current vs specific file
- *   pnpm compare --baseline <path> --experiment <path>  # compare two specific files
- *   pnpm compare --threshold 5                  # custom noise threshold
- *   pnpm compare --output /tmp/comparison.json  # write JSON report to file
- *   pnpm compare --format json                  # output raw JSON (default: table)
- *
- * Reads: results/latest/score-summary.json (as experiment, unless --experiment)
- * Reads: results/baselines/<latest>.json (as baseline, unless --baseline)
- */
-import { type ComparisonReport } from "../pipeline/types.js";
-/**
- * Generate a markdown comparison section suitable for PR comments.
- */
-export declare function formatComparisonMarkdown(report: ComparisonReport): string;
-export declare function formatComparisonTable(report: ComparisonReport): string;

package/dist/scripts/compare.js

@@ -1,334 +0,0 @@
-/**
- * compare.ts
- *
- * CLI for structured comparison between two evaluation runs.
- *
- * Usage:
- *   pnpm compare                                # compare current vs latest baseline
- *   pnpm compare --baseline <path>              # compare current vs specific file
- *   pnpm compare --baseline <path> --experiment <path>  # compare two specific files
- *   pnpm compare --threshold 5                  # custom noise threshold
- *   pnpm compare --output /tmp/comparison.json  # write JSON report to file
- *   pnpm compare --format json                  # output raw JSON (default: table)
- *
- * Reads: results/latest/score-summary.json (as experiment, unless --experiment)
- * Reads: results/baselines/<latest>.json (as baseline, unless --baseline)
- */
-import { existsSync, readFileSync, readdirSync, writeFileSync } from "fs";
-import { dirname, join, resolve } from "path";
-import { fileURLToPath } from "url";
-import { compare } from "../pipeline/compare.js";
-import { DEFAULT_NOISE_THRESHOLD, } from "../pipeline/types.js";
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(__dirname, "..", "..");
-const BASELINES_DIR = join(ROOT, "results", "baselines");
-const SCORE_SUMMARY_PATH = join(ROOT, "results", "latest", "score-summary.json");
-// ---------------------------------------------------------------------------
-// CLI argument parsing
-// ---------------------------------------------------------------------------
-const args = process.argv.slice(2);
-function getFlag(name) {
-    return args.includes(`--${name}`);
-}
-function getOption(name) {
-    const idx = args.indexOf(`--${name}`);
-    return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : undefined;
-}
-const baselinePath = getOption("baseline");
-const experimentPath = getOption("experiment");
-const thresholdStr = getOption("threshold");
-const threshold = thresholdStr
-    ? parseFloat(thresholdStr)
-    : DEFAULT_NOISE_THRESHOLD;
-const outputPath = getOption("output");
-const format = getOption("format") ?? "table";
-const showHelp = getFlag("help") || getFlag("h");
-if (showHelp) {
-    console.log(`
-Usage: pnpm compare [options]
-
-Compare two evaluation score summaries and produce structured deltas.
-
-Options:
-  --baseline <path>     Baseline score-summary.json (default: latest baseline)
-  --experiment <path>   Experiment score-summary.json (default: results/latest/score-summary.json)
-  --threshold <n>       Noise threshold for unchanged classification (default: ${DEFAULT_NOISE_THRESHOLD})
-  --output <path>       Write JSON report to file
-  --format <fmt>        Output format: table (default) or json
-  --help, -h            Show this help
-
-Examples:
-  pnpm compare                           # current scores vs latest baseline
-  pnpm compare --threshold 5             # wider noise band
-  pnpm compare --format json             # machine-readable output
-  pnpm compare --baseline results/baselines/20260310_02_43_44.json
-  pnpm compare --baseline before.json --experiment after.json
-`);
-    process.exit(0);
-}
-// ---------------------------------------------------------------------------
-// File loading helpers
-// ---------------------------------------------------------------------------
-/**
- * Generate a markdown comparison section suitable for PR comments.
- */
-export function formatComparisonMarkdown(report) {
-    const lines = [];
-    const overall = report.deltas.overall;
-    const overallIcon = changeIcon(overall > report.noiseThreshold
-        ? "improved"
-        : overall < -report.noiseThreshold
-            ? "regressed"
-            : "unchanged");
-    lines.push("### 📊 Score Comparison");
-    lines.push("");
-    lines.push(`**Overall: ${Math.round(report.baseline.overall.avgScore)} → ${Math.round(report.experiment.overall.avgScore)}** (${overallIcon} ${deltaStr(overall)})`);
-    lines.push("");
-    // Per-area table
-    lines.push("| Feature | Baseline | Current | Delta | Task | Code | Docs |");
-    lines.push("|---------|----------|---------|-------|------|------|------|");
-    for (const a of report.areas) {
-        const icon = changeIcon(a.change);
-        lines.push(`| ${a.area} | ${a.baseline} | ${a.experiment} | ${icon} ${deltaStr(a.delta)} | ${deltaStr(a.dimensions.taskCompletion.delta)} | ${deltaStr(a.dimensions.codeCorrectness.delta)} | ${deltaStr(a.dimensions.docCoverage.delta)} |`);
-    }
-    lines.push("");
-    // Summary
-    const parts = [];
-    if (report.improved.length > 0) {
-        parts.push(`📈 ${report.improved.length} improved`);
-    }
-    if (report.regressed.length > 0) {
-        parts.push(`📉 ${report.regressed.length} regressed`);
-    }
-    if (report.unchanged.length > 0) {
-        parts.push(`➡️ ${report.unchanged.length} unchanged`);
-    }
-    if (parts.length > 0) {
-        lines.push(parts.join(" · "));
-        lines.push("");
-    }
-    // Dimension averages in collapsible
-    lines.push("<details>");
-    lines.push("<summary>Dimension averages</summary>");
-    lines.push("");
-    const dim = report.deltas.perDimension;
-    lines.push("| Dimension | Delta |");
-    lines.push("|-----------|-------|");
-    lines.push(`| Task Completion | ${deltaStr(dim.taskCompletion)} |`);
-    lines.push(`| Code Correctness | ${deltaStr(dim.codeCorrectness)} |`);
-    lines.push(`| Doc Coverage | ${deltaStr(dim.docCoverage)} |`);
-    lines.push(`| Doc Lift | ${deltaStr(report.deltas.docLift)} |`);
-    if (report.deltas.cost !== undefined) {
-        const costStr = report.deltas.cost > 0
-            ? `+$${report.deltas.cost.toFixed(4)}`
-            : `-$${Math.abs(report.deltas.cost).toFixed(4)}`;
-        lines.push(`| Cost | ${costStr} |`);
-    }
-    lines.push("");
-    lines.push("</details>");
-    lines.push("");
-    return lines.join("\n");
-}
-export function formatComparisonTable(report) {
-    const lines = [];
-    lines.push("=".repeat(80));
-    lines.push("                    COMPARISON REPORT");
-    lines.push("=".repeat(80));
-    lines.push("");
-    // Overall summary
-    const overall = report.deltas.overall;
-    const overallIcon = changeIcon(overall > report.noiseThreshold
-        ? "improved"
-        : overall < -report.noiseThreshold
-            ? "regressed"
-            : "unchanged");
-    lines.push(`  Overall: ${Math.round(report.baseline.overall.avgScore)} → ${Math.round(report.experiment.overall.avgScore)} (${overallIcon} ${deltaStr(overall)})`);
-    lines.push("");
-    // Per-dimension averages
-    const dim = report.deltas.perDimension;
-    lines.push("  Dimension averages:");
-    lines.push(`    Task Completion:  ${deltaStr(dim.taskCompletion)}`);
-    lines.push(`    Code Correctness: ${deltaStr(dim.codeCorrectness)}`);
-    lines.push(`    Doc Coverage:     ${deltaStr(dim.docCoverage)}`);
-    lines.push(`    Doc Lift:         ${deltaStr(report.deltas.docLift)}`);
-    if (report.deltas.cost !== undefined) {
-        lines.push(`    Cost:             ${report.deltas.cost > 0 ? "+" : ""}$${report.deltas.cost.toFixed(4)}`);
-    }
-    lines.push("");
-    // Per-area table
-    lines.push("-".repeat(80));
-    lines.push("PER-AREA BREAKDOWN");
-    lines.push("-".repeat(80));
-    lines.push("");
-    const h = "| Feature Area        | Baseline | Experiment | Delta | Task | Code | Docs |";
-    const sep = "|---------------------|----------|------------|-------|------|------|------|";
-    lines.push(h);
-    lines.push(sep);
-    for (const a of report.areas) {
-        const icon = changeIcon(a.change);
-        lines.push(`| ${icon} ${a.area.padEnd(17)} | ${String(a.baseline).padStart(8)} | ${String(a.experiment).padStart(10)} | ${deltaStr(a.delta).padStart(5)} | ${deltaStr(a.dimensions.taskCompletion.delta).padStart(4)} | ${deltaStr(a.dimensions.codeCorrectness.delta).padStart(4)} | ${deltaStr(a.dimensions.docCoverage.delta).padStart(4)} |`);
-    }
-    lines.push("");
-    // Classification summary
-    if (report.improved.length > 0) {
-        lines.push(`  📈 Improved:   ${report.improved.join(", ")}`);
-    }
-    if (report.regressed.length > 0) {
-        lines.push(`  📉 Regressed:  ${report.regressed.join(", ")}`);
-    }
-    if (report.unchanged.length > 0) {
-        lines.push(`  ➡️  Unchanged:  ${report.unchanged.join(", ")}`);
-    }
-    lines.push("");
-    // Mismatched areas
-    if (report.mismatched.onlyInBaseline.length > 0 ||
-        report.mismatched.onlyInExperiment.length > 0) {
-        lines.push("  ⚠️  Area mismatches:");
-        if (report.mismatched.onlyInBaseline.length > 0) {
-            lines.push(`    Only in baseline:   ${report.mismatched.onlyInBaseline.join(", ")}`);
-        }
-        if (report.mismatched.onlyInExperiment.length > 0) {
-            lines.push(`    Only in experiment: ${report.mismatched.onlyInExperiment.join(", ")}`);
-        }
-        lines.push("");
-    }
-    const isEmpirical = "noiseThresholdEmpirical" in report &&
-        report.noiseThresholdEmpirical === true;
-    const thresholdSource = isEmpirical
-        ? "empirical, from grader consistency data"
-        : "default";
-    lines.push(`  Noise threshold: ±${report.noiseThreshold}${Number.isInteger(report.noiseThreshold) ? "" : ` (${report.noiseThreshold.toFixed(1)})`} (${thresholdSource})`);
-    lines.push("");
-    // Ceiling decomposition deltas (when areas have ceiling data)
-    const hasCeilingData = report.areas.some((a) => a.ceilingDelta !== undefined);
-    if (hasCeilingData) {
-        lines.push("-".repeat(80));
-        lines.push("CEILING DECOMPOSITION DELTAS");
-        lines.push("-".repeat(80));
-        lines.push("");
-        const cH = "| Feature Area        | Ceiling Δ | Floor Δ | Doc Lift Δ |";
-        const cSep = "|---------------------|-----------|---------|------------|";
-        lines.push(cH);
-        lines.push(cSep);
-        for (const a of report.areas) {
-            lines.push(`| ${a.area.padEnd(19)} | ` +
-                `${deltaStr(a.ceilingDelta).padStart(9)} | ` +
-                `${deltaStr(a.floorDelta).padStart(7)} | ` +
-                `${deltaStr(a.docLiftDelta).padStart(10)} |`);
-        }
-        lines.push("");
-    }
-    return lines.join("\n");
-}
-// ---------------------------------------------------------------------------
-// Formatting
-// ---------------------------------------------------------------------------
-function changeIcon(change) {
-    switch (change) {
-        case "improved":
-            return "📈";
-        case "regressed":
-            return "📉";
-        default:
-            return "➡️";
-    }
-}
-function deltaStr(d) {
-    if (d > 0)
-        return `+${Math.round(d)}`;
-    if (d < 0)
-        return `${Math.round(d)}`;
-    return "0";
-}
-function findLatestBaseline() {
-    if (!existsSync(BASELINES_DIR))
-        return null;
-    const files = readdirSync(BASELINES_DIR)
-        .filter((f) => f.endsWith(".json"))
-        .sort()
-        .reverse();
-    return files.length > 0 ? join(BASELINES_DIR, files[0]) : null;
-}
-function loadSummary(path) {
-    if (!existsSync(path)) {
-        console.error(`❌ File not found: ${path}`);
-        process.exit(1);
-    }
-    const raw = readFileSync(path, "utf-8");
-    return JSON.parse(raw);
-}
-// ---------------------------------------------------------------------------
-// Main
-// ---------------------------------------------------------------------------
-function main() {
-    // Resolve experiment path
-    const expPath = experimentPath ?? SCORE_SUMMARY_PATH;
-    const experiment = loadSummary(expPath);
-    // Resolve baseline path
-    let basePath;
-    if (baselinePath) {
-        basePath = resolve(baselinePath);
-    }
-    else {
-        const latest = findLatestBaseline();
-        if (!latest) {
-            console.error("❌ No baselines found. Run 'pnpm baseline:save' first, or use --baseline <path>.");
-            process.exit(1);
-        }
-        basePath = latest;
-    }
-    const baseline = loadSummary(basePath);
-    // Try to load grader consistency data for empirical thresholds
-    const consistencyPath = join(ROOT, "results", "latest", "grader-consistency.json");
-    let graderConsistency;
-    if (existsSync(consistencyPath) && !thresholdStr) {
-        try {
-            const consistencyRaw = JSON.parse(readFileSync(consistencyPath, "utf-8"));
-            if (consistencyRaw.recommendedThreshold && consistencyRaw.perDimension) {
-                graderConsistency =
-                    consistencyRaw;
-                console.log(`  📊 Using empirical noise threshold: ±${graderConsistency.recommendedThreshold.toFixed(1)} (from grader consistency data)`);
-            }
-        }
-        catch {
-            // Non-fatal — fall back to default threshold
-        }
-    }
-    console.log(`  Baseline:   ${basePath}`);
-    console.log(`  Experiment: ${expPath}`);
-    if (!graderConsistency) {
-        console.log(`  Threshold:  ±${threshold} (default — run --grader-replications for empirical threshold)`);
-    }
-    console.log("");
-    const report = compare(baseline, experiment, {
-        graderConsistency,
-        noiseThreshold: threshold,
-    });
-    if (format === "json") {
-        const json = JSON.stringify(report, null, 2);
-        if (outputPath) {
-            writeFileSync(outputPath, json);
-            console.log(`  ✅ Comparison report written to ${outputPath}`);
-        }
-        else {
-            console.log(json);
-        }
-    }
-    else {
-        const table = formatComparisonTable(report);
-        console.log(table);
-        if (outputPath) {
-            const json = JSON.stringify(report, null, 2);
-            writeFileSync(outputPath, json);
-            console.log(`  ✅ Comparison report also written to ${outputPath}`);
-        }
-    }
-    // Write comparison report to results/latest for other steps to consume
-    const latestComparisonPath = join(ROOT, "results", "latest", "comparison-report.json");
-    writeFileSync(latestComparisonPath, JSON.stringify(report, null, 2));
-}
-// Only run when invoked directly
-if (process.argv[1]?.endsWith("compare.ts") ||
-    process.argv[1]?.endsWith("compare.js")) {
-    main();
-}

package/dist/scripts/coverage-audit.d.ts

@@ -1,44 +0,0 @@
-/**
- * coverage-audit.ts
- *
- * CLI script that cross-references the product feature registry
- * (config/features.yaml) against actual task files (tasks/*.yaml)
- * to produce a documentation coverage audit.
- *
- * Phase 3c of the Scenario Matrix implementation.
- *
- * Usage:
- *   pnpm coverage-audit              # console report
- *   pnpm coverage-audit --format md  # markdown output
- *   pnpm coverage-audit --json       # JSON output
- *
- * @see docs/exec-plans/completed/scenario-matrix-implementation/phase-3-gap-analysis.md
- */
-import type { CoverageAuditReport, ProductFeature } from "../pipeline/types.js";
-/**
- * Count unique document slugs referenced across all tasks.
- */
-export declare function countReferencedDocs(rootDir: string): {
-    slugs: string[];
-    total: number;
-};
-/**
- * Count actual tasks per area from task YAML files.
- */
-export declare function countTasksByArea(rootDir: string): Record<string, number>;
-/**
- * Format coverage audit for console output.
- */
-export declare function formatCoverageConsole(report: CoverageAuditReport): string;
-/**
- * Format coverage audit as markdown.
- */
-export declare function formatCoverageMarkdown(report: CoverageAuditReport): string;
-/**
- * Load and validate the feature registry from config/features.yaml.
- */
-export declare function loadFeatureRegistry(rootDir: string): null | ProductFeature[];
-/**
- * Run the coverage audit and produce a structured report.
- */
-export declare function runCoverageAudit(rootDir: string): CoverageAuditReport | null;

package/dist/scripts/coverage-audit.js

@@ -1,209 +0,0 @@
-/**
- * coverage-audit.ts
- *
- * CLI script that cross-references the product feature registry
- * (config/features.yaml) against actual task files (tasks/*.yaml)
- * to produce a documentation coverage audit.
- *
- * Phase 3c of the Scenario Matrix implementation.
- *
- * Usage:
- *   pnpm coverage-audit              # console report
- *   pnpm coverage-audit --format md  # markdown output
- *   pnpm coverage-audit --json       # JSON output
- *
- * @see docs/exec-plans/completed/scenario-matrix-implementation/phase-3-gap-analysis.md
- */
-import { existsSync, readFileSync } from "fs";
-import { dirname, join, resolve } from "path";
-import { fileURLToPath } from "url";
-import { load } from "js-yaml";
-import { FeatureRegistrySchema } from "../pipeline/schemas.js";
-import { resolveMappings } from "../pipeline/resolve-mappings.js";
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(__dirname, "..", "..");
-// ---------------------------------------------------------------------------
-// Core logic (exported for testing)
-// ---------------------------------------------------------------------------
-/**
- * Count unique document slugs referenced across all tasks.
- */
-export function countReferencedDocs(rootDir) {
-    const mappings = resolveMappings(rootDir);
-    const allSlugs = new Set();
-    for (const config of Object.values(mappings.feature_areas)) {
-        for (const task of config.tasks) {
-            for (const doc of task.canonical_docs) {
-                allSlugs.add(doc.slug);
-            }
-        }
-    }
-    const slugs = [...allSlugs].sort();
-    return { slugs, total: slugs.length };
-}
-/**
- * Count actual tasks per area from task YAML files.
- */
-export function countTasksByArea(rootDir) {
-    const mappings = resolveMappings(rootDir);
-    const counts = {};
-    for (const [area, config] of Object.entries(mappings.feature_areas)) {
-        counts[area] = config.tasks.length;
-    }
-    return counts;
-}
-/**
- * Format coverage audit for console output.
- */
-export function formatCoverageConsole(report) {
-    const lines = [];
-    lines.push("═══════════════════════════════════════════════════════════════");
-    lines.push(" DOCUMENTATION COVERAGE AUDIT");
-    lines.push("═══════════════════════════════════════════════════════════════");
-    lines.push("");
-    lines.push(`Coverage: ${report.covered.length}/${report.totalFeatures} features (${report.coveragePercent}%)`);
-    lines.push("");
-    // Covered features
-    if (report.covered.length > 0) {
-        lines.push("COVERED FEATURES:");
-        for (const f of report.covered) {
-            const taskLabel = f.actualTaskCount === 1 ? "1 task" : `${f.actualTaskCount} tasks`;
-            const sections = f.sections.join(", ");
-            lines.push(`  ✅ ${f.id.padEnd(20)} ${taskLabel.padEnd(10)} ${f.priority.padEnd(10)} ${sections}`);
-        }
-        lines.push("");
-    }
-    // Uncovered features
-    if (report.uncovered.length > 0) {
-        lines.push("UNCOVERED FEATURES (by priority):");
-        for (const f of report.uncovered) {
-            const sections = f.sections.join(", ");
-            lines.push(`  ❌ ${f.id.padEnd(20)} ${f.priority.padEnd(10)} ${sections}`);
-        }
-        lines.push("");
-    }
-    return lines.join("\n");
-}
-/**
- * Format coverage audit as markdown.
- */
-export function formatCoverageMarkdown(report) {
-    const lines = [];
-    lines.push("### 📊 Documentation Coverage Audit");
-    lines.push("");
-    lines.push(`**Coverage: ${report.covered.length}/${report.totalFeatures} features (${report.coveragePercent}%)**`);
-    lines.push("");
-    if (report.covered.length > 0) {
-        lines.push("#### Covered Features");
-        lines.push("");
-        lines.push("| Feature | Tasks | Priority | Sections |");
-        lines.push("|---------|-------|----------|----------|");
-        for (const f of report.covered) {
-            lines.push(`| ✅ ${f.name} | ${f.actualTaskCount} | ${f.priority} | ${f.sections.join(", ")} |`);
-        }
-        lines.push("");
-    }
-    if (report.uncovered.length > 0) {
-        lines.push("#### Uncovered Features");
-        lines.push("");
-        lines.push("| Feature | Priority | Sections |");
-        lines.push("|---------|----------|----------|");
-        for (const f of report.uncovered) {
-            lines.push(`| ❌ ${f.name} | ${f.priority} | ${f.sections.join(", ")} |`);
-        }
-        lines.push("");
-    }
-    return lines.join("\n");
-}
-// ---------------------------------------------------------------------------
-// Formatting
-// ---------------------------------------------------------------------------
-/**
- * Load and validate the feature registry from config/features.yaml.
- */
-export function loadFeatureRegistry(rootDir) {
-    const filePath = join(rootDir, "config", "features.yaml");
-    if (!existsSync(filePath)) {
-        return null;
-    }
-    const raw = readFileSync(filePath, "utf-8");
-    const parsed = load(raw);
-    const result = FeatureRegistrySchema.safeParse(parsed);
-    if (!result.success) {
-        console.error("❌ config/features.yaml validation failed:");
-        for (const issue of result.error.issues) {
-            console.error(`  ${issue.path.join(".")}: ${issue.message}`);
-        }
-        return null;
-    }
-    return result.data.features;
-}
-/**
- * Run the coverage audit and produce a structured report.
- */
-export function runCoverageAudit(rootDir) {
-    const features = loadFeatureRegistry(rootDir);
-    if (!features)
-        return null;
-    const taskCounts = countTasksByArea(rootDir);
-    const totalFeatures = features.length;
-    const covered = [];
-    const uncovered = [];
-    for (const feature of features) {
-        if (feature.status === "covered" && feature.area) {
-            const actualTaskCount = taskCounts[feature.area] ?? 0;
-            covered.push({ ...feature, actualTaskCount });
-        }
-        else if (feature.status === "uncovered" || feature.status === "planned") {
-            uncovered.push(feature);
-        }
-    }
-    // Sort uncovered by priority
-    const priorityOrder = { critical: 0, high: 1, low: 3, medium: 2 };
-    uncovered.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
-    const coveredCount = covered.length;
-    const coveragePercent = totalFeatures > 0 ? (coveredCount / totalFeatures) * 100 : 0;
-    return {
-        coveragePercent: Math.round(coveragePercent * 10) / 10,
-        covered,
-        generatedAt: new Date().toISOString(),
-        totalFeatures,
-        uncovered,
-    };
-}
-// ---------------------------------------------------------------------------
-// CLI entry point
-// ---------------------------------------------------------------------------
-function main() {
-    const args = process.argv.slice(2);
-    const formatArg = args.includes("--format")
-        ? args[args.indexOf("--format") + 1]
-        : undefined;
-    const jsonOutput = args.includes("--json");
-    const report = runCoverageAudit(ROOT);
-    if (!report) {
-        console.error("❌ Coverage audit failed. Ensure config/features.yaml exists and is valid.");
-        process.exit(1);
-    }
-    if (jsonOutput) {
-        console.log(JSON.stringify(report, null, 2));
-    }
-    else if (formatArg === "md" || formatArg === "markdown") {
-        console.log(formatCoverageMarkdown(report));
-    }
-    else {
-        console.log(formatCoverageConsole(report));
-    }
-    // Also print document utilization stats
-    if (!jsonOutput && formatArg !== "md") {
-        const docStats = countReferencedDocs(ROOT);
-        console.log("DOCUMENT UTILIZATION:");
-        console.log(`  ${docStats.total} unique document slugs referenced across evaluation tasks`);
-        console.log("");
-    }
-}
-// Only run when invoked directly
-if (process.argv[1]?.endsWith("coverage-audit.ts") ||
-    process.argv[1]?.endsWith("coverage-audit.js")) {
-    main();
-}

package/dist/scripts/debug-eval.d.ts

@@ -1,19 +0,0 @@
-/**
- * debug-eval.ts
- *
- * Thin wrapper around `promptfoo eval` that reads DEBUG_EVAL_* environment
- * variables and forwards them as native promptfoo filter flags.
- *
- * Environment variables:
- *   DEBUG_EVAL=1              — required to enable debug mode
- *   DEBUG_EVAL_PATTERN=<re>   — --filter-pattern (regex on test description)
- *   DEBUG_EVAL_N=<number>     — --filter-first-n (default: 2 when no other filters set)
- *   DEBUG_EVAL_SAMPLE=<number> — --filter-sample (random N tests)
- *
- * Usage:
- *   tsx src/scripts/debug-eval.ts --config promptfooconfig.yaml
- *   tsx src/scripts/debug-eval.ts --config promptfooconfig.agentic.yaml --no-cache
- *
- * All extra argv are forwarded to promptfoo eval unchanged.
- */
-export {};