miniread 1.0.0 → 1.1.0

package/README.md

@@ -74,10 +74,10 @@ The `miniread-evaluate` CLI compares transform configurations by measuring diff
 pnpm run miniread-evaluate -- --help
 
 # Compare baseline none vs a transform
-pnpm run miniread-evaluate -- --compare v1.0:v1.1 --baseline none --test add-prefix
+pnpm run miniread-evaluate -- --compare v1.0:v1.1 --baseline none --test rename-destructured-aliases
 
 # Pipeline example: sort by reduction ratio (best first)
-pnpm run miniread-evaluate -- --compare v1.0:v1.1 --compare v2.0:v2.1 --baseline none --test add-prefix \
+pnpm run miniread-evaluate -- --compare v1.0:v1.1 --compare v2.0:v2.1 --baseline none --test rename-destructured-aliases \
   | tail -n +2 | sort -k5,5nr | head -10
 ```
 

package/dist/scripts/evaluate/check-expected-evaluations.d.ts

@@ -0,0 +1,17 @@
+import type { SnapshotIssue } from "./check-snapshots.js";
+type MissingManifestEntry = {
+    transformId: string;
+    path: string;
+};
+type CheckExpectedEvaluationsResult = {
+    transformIds: string[];
+    missingManifestEntries: MissingManifestEntry[];
+    snapshotIssues: SnapshotIssue[];
+    allPresent: boolean;
+};
+type CheckExpectedEvaluationsOptions = {
+    manifestPath: string;
+    testCasesDirectory: string;
+};
+export declare const checkExpectedEvaluations: (options: CheckExpectedEvaluationsOptions) => Promise<CheckExpectedEvaluationsResult>;
+export {};

package/dist/scripts/evaluate/check-expected-evaluations.js

@@ -0,0 +1,35 @@
+import * as fs from "node:fs/promises";
+import { allTransformIds } from "../../transforms/transform-registry.js";
+import { transformRegistry } from "../../transforms/transform-registry.js";
+import { parseTransformManifest } from "./parse-transform-manifest.js";
+import { checkAllSnapshots } from "./check-snapshots.js";
+export const checkExpectedEvaluations = async (options) => {
+    const { manifestPath, testCasesDirectory } = options;
+    const transformIds = allTransformIds.toSorted();
+    const missingManifestEntries = [];
+    // Check manifest entries
+    const manifestContent = await fs.readFile(manifestPath, "utf8");
+    const manifest = parseTransformManifest(manifestContent);
+    const manifestIds = new Set(manifest.transforms.map((t) => t.id));
+    for (const transformId of transformIds) {
+        if (!manifestIds.has(transformId)) {
+            missingManifestEntries.push({
+                transformId,
+                path: manifestPath,
+            });
+        }
+    }
+    // Check test-cases matrix with smart snapshot detection
+    const snapshotIssues = await checkAllSnapshots({
+        testCasesDirectory,
+        transformIds,
+        transformRegistry,
+    });
+    const allPresent = missingManifestEntries.length === 0 && snapshotIssues.length === 0;
+    return {
+        transformIds,
+        missingManifestEntries,
+        snapshotIssues,
+        allPresent,
+    };
+};

package/dist/scripts/evaluate/check-snapshots.d.ts

@@ -0,0 +1,14 @@
+import type { Transform } from "../../core/types.js";
+export type SnapshotIssue = {
+    transformId: string;
+    testCase: string;
+    snapshotPath: string;
+    issue: "missing-required" | "unnecessary" | "outdated";
+};
+type CheckAllSnapshotsOptions = {
+    testCasesDirectory: string;
+    transformIds: string[];
+    transformRegistry: Record<string, Transform>;
+};
+export declare const checkAllSnapshots: (options: CheckAllSnapshotsOptions) => Promise<SnapshotIssue[]>;
+export {};

package/dist/scripts/evaluate/check-snapshots.js

@@ -0,0 +1,111 @@
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import * as prettier from "prettier";
+import { transformContent } from "./transform-content.js";
+const formatCode = async (code) => {
+    return prettier.format(code, { parser: "babel" });
+};
+const fileExists = async (filePath) => {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const checkSnapshot = async (options) => {
+    const { basePath, baseContent, formattedBase, snapshotPath, transformId, testCaseName, transform, } = options;
+    const snapshotExists = await fileExists(snapshotPath);
+    if (snapshotExists) {
+        const snapshotContent = await fs.readFile(snapshotPath, "utf8");
+        const formattedSnapshot = await formatCode(snapshotContent);
+        // Check if snapshot is unnecessary (formatted snapshot equals formatted base)
+        if (formattedSnapshot === formattedBase) {
+            return {
+                transformId,
+                testCase: testCaseName,
+                snapshotPath,
+                issue: "unnecessary",
+            };
+        }
+        if (transform) {
+            // Check if snapshot is outdated (formatted snapshot differs from current transform output)
+            const result = await transformContent({
+                content: baseContent,
+                filePath: basePath,
+                transform,
+            });
+            if (result.ok) {
+                const formattedOutput = await formatCode(result.output);
+                if (formattedOutput !== formattedSnapshot) {
+                    return {
+                        transformId,
+                        testCase: testCaseName,
+                        snapshotPath,
+                        issue: "outdated",
+                    };
+                }
+            }
+        }
+    }
+    else if (transform) {
+        // Check if snapshot is required (formatted transform output differs from formatted base)
+        const result = await transformContent({
+            content: baseContent,
+            filePath: basePath,
+            transform,
+        });
+        if (result.ok) {
+            const formattedOutput = await formatCode(result.output);
+            if (formattedOutput !== formattedBase) {
+                return {
+                    transformId,
+                    testCase: testCaseName,
+                    snapshotPath,
+                    issue: "missing-required",
+                };
+            }
+        }
+    }
+    return undefined;
+};
+const getTestCaseNames = async (testCasesDirectory) => {
+    const entries = await fs.readdir(testCasesDirectory, { withFileTypes: true });
+    const testCaseNames = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const basePath = path.join(testCasesDirectory, entry.name, "base.js");
+        if (await fileExists(basePath)) {
+            testCaseNames.push(entry.name);
+        }
+    }
+    return testCaseNames.toSorted();
+};
+export const checkAllSnapshots = async (options) => {
+    const { testCasesDirectory, transformIds, transformRegistry } = options;
+    const snapshotIssues = [];
+    const testCaseNames = await getTestCaseNames(testCasesDirectory);
+    for (const testCaseName of testCaseNames) {
+        const basePath = path.join(testCasesDirectory, testCaseName, "base.js");
+        const baseContent = await fs.readFile(basePath, "utf8");
+        const formattedBase = await formatCode(baseContent);
+        for (const transformId of transformIds) {
+            const snapshotPath = path.join(testCasesDirectory, testCaseName, `${transformId}.js`);
+            const issue = await checkSnapshot({
+                basePath,
+                baseContent,
+                formattedBase,
+                snapshotPath,
+                transformId,
+                testCaseName,
+                transform: transformRegistry[transformId],
+            });
+            if (issue) {
+                snapshotIssues.push(issue);
+            }
+        }
+    }
+    return snapshotIssues;
+};

package/dist/scripts/evaluate/clone-metrics-report.d.ts

@@ -0,0 +1,2 @@
+import type { EvaluationReport } from "./evaluation-report.js";
+export declare const cloneMetricsReport: (report: EvaluationReport) => EvaluationReport;

package/dist/scripts/evaluate/clone-metrics-report.js

@@ -0,0 +1,6 @@
+export const cloneMetricsReport = (report) => ({
+    ...report,
+    results: report.results.map((result) => ({
+        ...result,
+    })),
+});

package/dist/scripts/evaluate/create-evaluate-command.js

@@ -1,4 +1,5 @@
 import { Command, InvalidArgumentError } from "@commander-js/extra-typings";
+import { evaluateHelpText } from "./evaluate-help-text.js";
 const parseOutputFormat = (value) => {
     if (value === "tsv" || value === "json")
         return value;
@@ -21,27 +22,11 @@ export const createEvaluateCommand = (options) => {
         .option("--write-metrics", "Write metrics JSON to the evaluation directory")
         .option("--metrics-file <path>", "Write metrics JSON to a specific path")
         .option("--write-patches", "Write baseline/test diff patches to the evaluation directory")
-        .option("-u, --update-manifest", "Update transform-manifest.json based on results")
+        .option("-u, --update-manifest", "Update transform-manifest.json metrics (does not add new entries or edit notes)")
         .option("--manifest-file <path>", "Path to transform-manifest.json", "transform-manifest.json")
         .option("-f, --overwrite", "Overwrite existing metrics/patch files")
-        .option("--no-format-code", "Skip formatting temp directories with Prettier before diffing");
-    program.addHelpText("after", `
-Dependencies:
-  - diff (override: MINIREAD_EVALUATE_DIFF_PATH)
-  - pnpm + prettier (used unless --no-format-code; overrides: MINIREAD_EVALUATE_PNPM_PATH, MINIREAD_EVALUATE_PRETTIER_PATH)
-
-Examples:
-  # Compare baseline none vs a transform
-  miniread-evaluate --compare v1.0:v1.1 --baseline none --test add-prefix
-
-  # Multiple pairs, output JSON and inspect with jq
-  miniread-evaluate --compare v1.0:v1.1 --compare v2.0:v2.1 --baseline none --test add-prefix --format json | jq '.results[] | {pair, reductionRatio}'
-
-  # Pipeline example: sort by reduction ratio (best first)
-  miniread-evaluate --compare v1.0:v1.1 --compare v2.0:v2.1 --baseline none --test add-prefix | tail -n +2 | sort -k5,5nr | head -10
-
-  # Write patches + metrics (refuses to overwrite unless -f/--overwrite)
-  miniread-evaluate --compare v1.0:v1.1 --baseline none --test add-prefix --write-patches --write-metrics
-`);
+        .option("--no-format-code", "Skip formatting temp directories with Prettier before diffing")
+        .option("--check", "Check that all expected evaluation metrics files exist (does not run evaluations)");
+    program.addHelpText("after", evaluateHelpText);
     return program;
 };

package/dist/scripts/evaluate/evaluate-help-text.d.ts

@@ -0,0 +1 @@
+export declare const evaluateHelpText = "\nDependencies:\n  - diff (override: MINIREAD_EVALUATE_DIFF_PATH)\n  - pnpm + prettier (used unless --no-format-code; overrides: MINIREAD_EVALUATE_PNPM_PATH, MINIREAD_EVALUATE_PRETTIER_PATH)\n\nExamples:\n  # Compare baseline none vs a transform\n  miniread-evaluate --compare v1.0:v1.1 --baseline none --test rename-destructured-aliases\n\n  # Multiple pairs, output JSON and inspect with jq\n  miniread-evaluate --compare v1.0:v1.1 --compare v2.0:v2.1 --baseline none --test rename-destructured-aliases --format json | jq '.results[] | {pair, reductionRatio}'\n\n  # Pipeline example: sort by reduction ratio (best first)\n  miniread-evaluate --compare v1.0:v1.1 --compare v2.0:v2.1 --baseline none --test rename-destructured-aliases | tail -n +2 | sort -k5,5nr | head -10\n\n  # Write patches + metrics (refuses to overwrite unless -f/--overwrite)\n  miniread-evaluate --compare v1.0:v1.1 --baseline none --test rename-destructured-aliases --write-patches --write-metrics\n\n  # Check that all expected evaluation metrics files exist\n  miniread-evaluate --check\n";

package/dist/scripts/evaluate/evaluate-help-text.js

@@ -0,0 +1,21 @@
+export const evaluateHelpText = `
+Dependencies:
+  - diff (override: MINIREAD_EVALUATE_DIFF_PATH)
+  - pnpm + prettier (used unless --no-format-code; overrides: MINIREAD_EVALUATE_PNPM_PATH, MINIREAD_EVALUATE_PRETTIER_PATH)
+
+Examples:
+  # Compare baseline none vs a transform
+  miniread-evaluate --compare v1.0:v1.1 --baseline none --test rename-destructured-aliases
+
+  # Multiple pairs, output JSON and inspect with jq
+  miniread-evaluate --compare v1.0:v1.1 --compare v2.0:v2.1 --baseline none --test rename-destructured-aliases --format json | jq '.results[] | {pair, reductionRatio}'
+
+  # Pipeline example: sort by reduction ratio (best first)
+  miniread-evaluate --compare v1.0:v1.1 --compare v2.0:v2.1 --baseline none --test rename-destructured-aliases | tail -n +2 | sort -k5,5nr | head -10
+
+  # Write patches + metrics (refuses to overwrite unless -f/--overwrite)
+  miniread-evaluate --compare v1.0:v1.1 --baseline none --test rename-destructured-aliases --write-patches --write-metrics
+
+  # Check that all expected evaluation metrics files exist
+  miniread-evaluate --check
+`;

package/dist/scripts/evaluate/pair-evaluator.d.ts

@@ -5,6 +5,7 @@ type EvaluatePairOptions = {
     testTransforms: string[];
     sourcesDirectory: string;
     rootDirectory: string;
+    evaluationDirectory: string;
     nodePath: string;
     minireadCliPath: string;
     diffPath: string;

package/dist/scripts/evaluate/pair-evaluator.js

@@ -3,11 +3,12 @@ import path from "node:path";
 import envPaths from "env-paths";
 import { computeDirectoryDiff } from "./diff-utilities.js";
 import { calculateReductionRatio, formatDiffStats } from "./metrics.js";
+import { getRelativePatchPath } from "./relative-patch-path.js";
 import { formatDirectoryWithPrettier } from "./shell-utilities.js";
 import { runPairTransformations } from "./run-pair-transformations.js";
 const appPaths = envPaths("miniread");
 export const evaluatePair = async (options) => {
-    const { pair, baselineTransforms, testTransforms, sourcesDirectory, rootDirectory, nodePath, minireadCliPath, diffPath, pnpmPath, prettierPath, formatCode, baselinePatchPath, testPatchPath, overwrite, verbose, log, } = options;
+    const { pair, baselineTransforms, testTransforms, sourcesDirectory, rootDirectory, evaluationDirectory, nodePath, minireadCliPath, diffPath, pnpmPath, prettierPath, formatCode, baselinePatchPath, testPatchPath, overwrite, verbose, log, } = options;
     if (verbose) {
         log(`Evaluating: ${pair.from} -> ${pair.to}`);
     }
@@ -86,6 +87,16 @@ export const evaluatePair = async (options) => {
         const status = reductionRatio >= 0 ? "GOOD" : "BAD";
         if (verbose)
             log(`Reduction ratio: ${percentReduction}% (${status})`);
+        const reportBaselinePatchPath = getRelativePatchPath({
+            rootDirectory,
+            evaluationDirectory,
+            patchPath: baselinePatchPath,
+        });
+        const reportTestPatchPath = getRelativePatchPath({
+            rootDirectory,
+            evaluationDirectory,
+            patchPath: testPatchPath,
+        });
         return {
             timestamp: new Date().toISOString(),
             pair,
@@ -94,8 +105,8 @@ export const evaluatePair = async (options) => {
             baselineDiff,
             testDiff,
             reductionRatio,
-            baselinePatchPath,
-            testPatchPath,
+            baselinePatchPath: reportBaselinePatchPath,
+            testPatchPath: reportTestPatchPath,
         };
     }
     finally {

package/dist/scripts/evaluate/parse-evaluate-cli-options.d.ts

@@ -15,9 +15,11 @@ export type EvaluateCliRawOptions = {
     manifestFile: string;
     overwrite?: boolean;
     formatCode: boolean;
+    check?: boolean;
 };
 export type EvaluateCliOptions = {
     verbose: boolean;
+    checkMode: boolean;
     pairs: ComparisonPair[];
     baselineTransforms: string[];
     testTransforms: string[];

package/dist/scripts/evaluate/parse-evaluate-cli-options.js

@@ -53,7 +53,8 @@ const parseComparePair = (value) => {
 };
 export const parseEvaluateCliOptions = (options) => {
     const { cwd, rawOptions } = options;
-    if (rawOptions.compare.length === 0) {
+    const checkMode = rawOptions.check ?? false;
+    if (!checkMode && rawOptions.compare.length === 0) {
         throw new Error("at least one --compare flag is required");
     }
     const pairs = [];
@@ -78,6 +79,7 @@ export const parseEvaluateCliOptions = (options) => {
         : path.join(evaluationDirectory, `metrics-${baselineSlug}-vs-${testSlug}.json`);
     return {
         verbose,
+        checkMode,
         pairs,
         baselineTransforms,
         testTransforms,

package/dist/scripts/evaluate/parse-transform-manifest.d.ts

@@ -2,11 +2,11 @@ import type { Transform } from "../../core/types.js";
 type TransformManifestEntry = {
     id: string;
     description: string;
-    iteration: number;
     scope: Transform["scope"];
     parallelizable: boolean;
     diffReductionImpact: number;
     enabledByDefault: boolean;
+    evaluatedAt?: string;
     notes?: string;
     supersededBy?: string;
 };

package/dist/scripts/evaluate/parse-transform-manifest.js

@@ -3,11 +3,11 @@ const TransformManifestEntrySchema = z
     .object({
     id: z.string().min(1),
     description: z.string(),
-    iteration: z.number().int().nonnegative(),
     scope: z.union([z.literal("file"), z.literal("project")]),
     parallelizable: z.boolean(),
     diffReductionImpact: z.number(),
     enabledByDefault: z.boolean(),
+    evaluatedAt: z.iso.datetime().optional(),
     notes: z.string().optional(),
     supersededBy: z.string().min(1).optional(),
 })

package/dist/scripts/evaluate/relative-patch-path.d.ts

@@ -0,0 +1,7 @@
+type RelativePatchPathOptions = {
+    rootDirectory: string;
+    evaluationDirectory: string;
+    patchPath: string | undefined;
+};
+export declare const getRelativePatchPath: (options: RelativePatchPathOptions) => string | undefined;
+export {};

package/dist/scripts/evaluate/relative-patch-path.js

@@ -0,0 +1,22 @@
+import path from "node:path";
+export const getRelativePatchPath = (options) => {
+    const { rootDirectory, evaluationDirectory, patchPath } = options;
+    if (!patchPath)
+        return;
+    const relativePath = path.relative(rootDirectory, patchPath);
+    if (relativePath === "" || relativePath === ".")
+        return;
+    // Avoid leaking paths outside the repo when evaluation output is elsewhere.
+    if (!path.isAbsolute(relativePath) &&
+        relativePath !== ".." &&
+        !relativePath.startsWith(`..${path.sep}`)) {
+        return relativePath;
+    }
+    const evaluationRelativePath = path.relative(evaluationDirectory, patchPath);
+    if (!path.isAbsolute(evaluationRelativePath) &&
+        evaluationRelativePath !== ".." &&
+        !evaluationRelativePath.startsWith(`..${path.sep}`)) {
+        return evaluationRelativePath;
+    }
+    return path.basename(patchPath);
+};

package/dist/scripts/evaluate/run-check-mode.d.ts

@@ -0,0 +1,8 @@
+import type { OutputFormat } from "./create-evaluate-command.js";
+type RunCheckModeOptions = {
+    manifestPath: string;
+    rootDirectory: string;
+    format: OutputFormat;
+};
+export declare const runCheckMode: (options: RunCheckModeOptions) => Promise<number>;
+export {};

package/dist/scripts/evaluate/run-check-mode.js

@@ -0,0 +1,116 @@
+import path from "node:path";
+import { checkExpectedEvaluations } from "./check-expected-evaluations.js";
+export const runCheckMode = async (options) => {
+    const { manifestPath, rootDirectory, format } = options;
+    const checkResult = await checkExpectedEvaluations({
+        manifestPath,
+        testCasesDirectory: path.join(rootDirectory, "test-cases"),
+    });
+    if (format === "json") {
+        console.log(JSON.stringify(checkResult, undefined, 2));
+    }
+    else {
+        const allIssues = [
+            ...checkResult.missingManifestEntries.map((item) => ({
+                type: "manifest",
+                transformId: item.transformId,
+                testCase: "",
+                path: item.path,
+            })),
+            ...checkResult.snapshotIssues.map((item) => ({
+                type: item.issue,
+                transformId: item.transformId,
+                testCase: item.testCase,
+                path: item.snapshotPath,
+            })),
+        ];
+        if (allIssues.length > 0) {
+            console.log("type\ttransform_id\ttest_case\tpath");
+            for (const item of allIssues) {
+                console.log(`${item.type}\t${item.transformId}\t${item.testCase}\t${item.path}`);
+            }
+        }
+    }
+    let exitCode = 0;
+    if (checkResult.missingManifestEntries.length > 0) {
+        console.error(`\n[MISSING MANIFEST ENTRIES] ${checkResult.missingManifestEntries.length} transform(s) not in transform-manifest.json:`);
+        for (const item of checkResult.missingManifestEntries) {
+            console.error(`  - ${item.transformId}`);
+        }
+        console.error(`\n  To fix: Add entries manually to transform-manifest.json, or run evaluation with --update-manifest`);
+        exitCode = 1;
+    }
+    const missingSnapshots = checkResult.snapshotIssues.filter((issue) => issue.issue === "missing-required");
+    const unnecessarySnapshots = checkResult.snapshotIssues.filter((issue) => issue.issue === "unnecessary");
+    const outdatedSnapshots = checkResult.snapshotIssues.filter((issue) => issue.issue === "outdated");
+    if (missingSnapshots.length > 0) {
+        console.error(`\n[MISSING SNAPSHOTS] ${missingSnapshots.length} snapshot(s) required but missing:`);
+        const byTransform = new Map();
+        for (const item of missingSnapshots) {
+            const testCases = byTransform.get(item.transformId);
+            if (testCases) {
+                testCases.push(item.testCase);
+            }
+            else {
+                byTransform.set(item.transformId, [item.testCase]);
+            }
+        }
+        for (const [transformId, testCases] of byTransform) {
+            console.error(`  - ${transformId}: ${testCases.join(", ")}`);
+        }
+        console.error(`\n  To fix: Generate snapshots for each transform:`);
+        console.error(`    for testcase in test-cases/*/; do`);
+        console.error(`      cat "\${testcase}base.js" | pnpm -s run miniread -- --transforms <transform-id> \\`);
+        console.error(`        | pnpm exec prettier --stdin-filepath test.js --parser babel \\`);
+        console.error(`        > "\${testcase}<transform-id>.js"`);
+        console.error(`    done`);
+        exitCode = 1;
+    }
+    if (unnecessarySnapshots.length > 0) {
+        console.error(`\n[UNNECESSARY SNAPSHOTS] ${unnecessarySnapshots.length} snapshot(s) identical to base.js (should be removed):`);
+        const byTransform = new Map();
+        for (const item of unnecessarySnapshots) {
+            const testCases = byTransform.get(item.transformId);
+            if (testCases) {
+                testCases.push(item.testCase);
+            }
+            else {
+                byTransform.set(item.transformId, [item.testCase]);
+            }
+        }
+        for (const [transformId, testCases] of byTransform) {
+            console.error(`  - ${transformId}: ${testCases.join(", ")}`);
+        }
+        console.error(`\n  To fix: Remove unnecessary snapshots:`);
+        for (const item of unnecessarySnapshots) {
+            console.error(`    rm "${item.snapshotPath}"`);
+        }
+        exitCode = 1;
+    }
+    if (outdatedSnapshots.length > 0) {
+        console.error(`\n[OUTDATED SNAPSHOTS] ${outdatedSnapshots.length} snapshot(s) don't match current transform output:`);
+        const byTransform = new Map();
+        for (const item of outdatedSnapshots) {
+            const testCases = byTransform.get(item.transformId);
+            if (testCases) {
+                testCases.push(item.testCase);
+            }
+            else {
+                byTransform.set(item.transformId, [item.testCase]);
+            }
+        }
+        for (const [transformId, testCases] of byTransform) {
+            console.error(`  - ${transformId}: ${testCases.join(", ")}`);
+        }
+        console.error(`\n  To fix: Regenerate outdated snapshots:`);
+        for (const item of outdatedSnapshots) {
+            const testCaseDirectory = path.dirname(item.snapshotPath);
+            console.error(`    cat "${testCaseDirectory}/base.js" | pnpm -s run miniread -- --transforms ${item.transformId} | pnpm exec prettier --stdin-filepath test.js --parser babel > "${item.snapshotPath}"`);
+        }
+        exitCode = 1;
+    }
+    if (exitCode === 0) {
+        console.error(`\nAll checks passed: ${checkResult.transformIds.length} transforms verified.`);
+    }
+    return exitCode;
+};

package/dist/scripts/evaluate/run-evaluate-cli.js

@@ -1,12 +1,13 @@
 import * as fs from "node:fs/promises";
 import packageJson from "../../../package.json" with { type: "json" };
-import { transformRegistry } from "../../transforms/transform-registry.js";
 import { createEvaluateCommand } from "./create-evaluate-command.js";
 import { parseEvaluateCliOptions, } from "./parse-evaluate-cli-options.js";
 import { resolveEvaluateDependencies } from "./resolve-evaluate-dependencies.js";
+import { runCheckMode } from "./run-check-mode.js";
 import { runEvaluations } from "./run-evaluations.js";
 import { writeEvaluationStdout } from "./write-evaluation-stdout.js";
 import { updateTransformManifestFromEvaluation } from "./transform-manifest.js";
+import { cloneMetricsReport } from "./clone-metrics-report.js";
 import { writeJsonFileAtomic } from "./write-text-file-atomic.js";
 export const runEvaluateCli = async (argv) => {
     const program = createEvaluateCommand({ version: packageJson.version });
@@ -32,6 +33,13 @@ export const runEvaluateCli = async (argv) => {
             return;
         console.error(message);
     };
+    if (parsedOptions.checkMode) {
+        return runCheckMode({
+            manifestPath: parsedOptions.manifestPath,
+            rootDirectory: process.cwd(),
+            format: parsedOptions.format,
+        });
+    }
     let dependencies;
     try {
         dependencies = resolveEvaluateDependencies({
@@ -78,7 +86,8 @@ export const runEvaluateCli = async (argv) => {
     });
     if (parsedOptions.shouldWriteMetrics) {
         try {
-            await writeJsonFileAtomic(parsedOptions.metricsPath, report, {
+            const sanitizedReport = cloneMetricsReport(report);
+            await writeJsonFileAtomic(parsedOptions.metricsPath, sanitizedReport, {
                 overwrite: parsedOptions.overwrite,
             });
             log(`Wrote ${parsedOptions.metricsPath}`);
@@ -100,7 +109,6 @@ export const runEvaluateCli = async (argv) => {
                 baselineTransforms: parsedOptions.baselineTransforms,
                 testTransforms: parsedOptions.testTransforms,
                 reductionRatios: results.map((r) => r.reductionRatio),
-                transformRegistry,
             });
             console.error(updateResult.message);
         }

package/dist/scripts/evaluate/run-evaluations.js

@@ -23,6 +23,7 @@ export const runEvaluations = async (options) => {
                 testTransforms,
                 sourcesDirectory,
                 rootDirectory,
+                evaluationDirectory,
                 nodePath: process.execPath,
                 minireadCliPath: process.env.MINIREAD_EVALUATE_MINIREAD_PATH ?? "bin/miniread",
                 diffPath: dependencies.diffPath,

package/dist/scripts/evaluate/transform-content.d.ts

@@ -0,0 +1,14 @@
+import type { Transform } from "../../core/types.js";
+type TransformContentResult = {
+    ok: true;
+    output: string;
+} | {
+    ok: false;
+    error: string;
+};
+export declare const transformContent: (options: {
+    content: string;
+    filePath: string;
+    transform: Transform;
+}) => Promise<TransformContentResult>;
+export {};

package/dist/scripts/evaluate/transform-content.js

@@ -0,0 +1,31 @@
+import { buildProjectGraph } from "../../core/project-graph.js";
+import { generateCode } from "../../cli/generate-code.js";
+export const transformContent = async (options) => {
+    const { content, filePath, transform } = options;
+    const projectGraph = buildProjectGraph([{ path: filePath, content }]);
+    const file = projectGraph.files.get(filePath);
+    if (!file) {
+        return { ok: false, error: "Failed to parse input" };
+    }
+    try {
+        await transform.transform({
+            projectGraph,
+            currentFile: undefined,
+            options: {},
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            ok: false,
+            error: `Transform '${transform.id}' failed: ${message}`,
+        };
+    }
+    const generated = generateCode(file.ast);
+    const output = generated === ""
+        ? ""
+        : generated.endsWith("\n")
+            ? generated
+            : `${generated}\n`;
+    return { ok: true, output };
+};

package/dist/scripts/evaluate/transform-manifest.d.ts

@@ -1,10 +1,8 @@
-import type { Transform } from "../../core/types.js";
 type UpdateTransformManifestOptions = {
     manifestPath: string;
     baselineTransforms: string[];
     testTransforms: string[];
     reductionRatios: number[];
-    transformRegistry: Record<string, Transform>;
 };
 export declare const updateTransformManifestFromEvaluation: (options: UpdateTransformManifestOptions) => Promise<{
     updated: boolean;