miniread 1.102.0 → 1.102.1

package/dist/cli/config.d.ts

@@ -1,10 +1,5 @@
 import type { Transform } from "../core/types.js";
-type TransformSummary = {
-    id: string;
-    description: string;
-    scope: Transform["scope"];
-    parallelizable: boolean;
-};
+import { type TransformSummary } from "../transforms/transform-catalog.js";
 export declare const getTransformSummaries: () => TransformSummary[];
 type GetTransformsResult = {
     ok: true;

package/dist/cli/config.js

@@ -1,85 +1,37 @@
-import { transformPresets } from "../transforms/transform-presets.js";
-import { allTransformIds, transformRegistry, } from "../transforms/transform-registry.js";
+import { expandTransformSelectors, listTransformSummaries, resolveTransformsByIds, } from "../transforms/transform-catalog.js";
 export const getTransformSummaries = () => {
-    const summaries = [];
-    for (const id of allTransformIds) {
-        const transform = transformRegistry[id];
-        if (!transform)
-            continue;
-        summaries.push({
-            id,
-            description: transform.description,
-            scope: transform.scope,
-            parallelizable: transform.parallelizable,
-        });
-    }
-    return summaries;
-};
-const getTransformsForPreset = (preset) => {
-    if (preset === "recommended" || preset === "default") {
-        return [...transformPresets.recommended];
-    }
-    if (preset === "all") {
-        return [...allTransformIds];
-    }
-    return;
+    return listTransformSummaries();
 };
 export const getTransformsToRun = (transformList) => {
     // undefined = run recommended transforms (default behavior)
     if (transformList === undefined) {
-        const requestedIds = getTransformsForPreset("recommended");
-        if (!requestedIds || requestedIds.length === 0) {
+        const requestedIds = expandTransformSelectors({
+            value: transformList,
+            defaultPreset: "recommended",
+        });
+        if (requestedIds.length === 0) {
             return { ok: false, error: "No recommended transforms are configured." };
         }
-        const transforms = [];
-        for (const id of requestedIds) {
-            const transform = transformRegistry[id];
-            if (!transform)
-                return { ok: false, error: `Unknown transform: ${id}` };
-            transforms.push(transform);
+        const resolveResult = resolveTransformsByIds(requestedIds);
+        if (!resolveResult.ok) {
+            const unknownTransformId = resolveResult.unknownTransformIds[0];
+            if (!unknownTransformId) {
+                return { ok: false, error: "Unknown transform: <missing-id>" };
+            }
+            return { ok: false, error: `Unknown transform: ${unknownTransformId}` };
         }
-        return { ok: true, transforms };
-    }
-    // Empty string = run no transforms (explicit empty list)
-    if (transformList === "" || transformList === "none") {
-        return { ok: true, transforms: [] };
-    }
-    // Parse comma-separated list
-    const requestedIds = transformList.split(",").map((id) => id.trim());
-    const expandedIds = [];
-    const unknownIds = [];
-    for (const id of requestedIds) {
-        if (!id || id === "none")
-            continue;
-        const presetTransforms = getTransformsForPreset(id);
-        if (presetTransforms) {
-            expandedIds.push(...presetTransforms);
-            continue;
-        }
-        expandedIds.push(id);
-    }
-    const uniqueIds = [];
-    const seen = new Set();
-    for (const id of expandedIds) {
-        if (seen.has(id))
-            continue;
-        seen.add(id);
-        uniqueIds.push(id);
-    }
-    const transforms = [];
-    for (const id of uniqueIds) {
-        const transform = transformRegistry[id];
-        if (!transform) {
-            unknownIds.push(id);
-            continue;
-        }
-        transforms.push(transform);
-    }
-    if (unknownIds.length > 0) {
+        return { ok: true, transforms: resolveResult.transforms };
+    }
+    const requestedIds = expandTransformSelectors({
+        value: transformList,
+        defaultPreset: "none",
+    });
+    const resolveResult = resolveTransformsByIds(requestedIds);
+    if (!resolveResult.ok) {
         return {
             ok: false,
-            error: `Unknown transform(s): ${unknownIds.join(", ")}. Use --list-transforms to see available transforms.`,
+            error: `Unknown transform(s): ${resolveResult.unknownTransformIds.join(", ")}. Use --list-transforms to see available transforms.`,
         };
     }
-    return { ok: true, transforms };
+    return { ok: true, transforms: resolveResult.transforms };
 };

package/dist/index.d.ts

@@ -2,6 +2,6 @@ export type { Transform, TransformContext, TransformScope, ProjectGraph, SourceF
 export { appPaths } from "./core/paths.js";
 export type { AppPaths } from "./core/paths.js";
 export { buildProjectGraph } from "./core/project-graph.js";
-export { allTransformIds, transformRegistry, } from "./transforms/transform-registry.js";
+export { allTransformIds, transformRegistry, } from "./transforms/transform-catalog.js";
 export { runTransforms } from "./cli/runner.js";
 export type { RunnerOptions, RunnerResult } from "./cli/runner.js";

package/dist/index.js

@@ -2,6 +2,6 @@
 export { appPaths } from "./core/paths.js";
 export { buildProjectGraph } from "./core/project-graph.js";
 // Transform registry
-export { allTransformIds, transformRegistry, } from "./transforms/transform-registry.js";
+export { allTransformIds, transformRegistry, } from "./transforms/transform-catalog.js";
 // Runner (for programmatic use)
 export { runTransforms } from "./cli/runner.js";

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

@@ -1,16 +1,10 @@
 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 = {
-    transformsDirectory: string;
     testCasesDirectory: string;
 };
 export declare const checkExpectedEvaluations: (options: CheckExpectedEvaluationsOptions) => Promise<CheckExpectedEvaluationsResult>;

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

@@ -1,37 +1,16 @@
-import * as fs from "node:fs/promises";
-import path from "node:path";
-import { allTransformIds } from "../../transforms/transform-registry.js";
-import { transformRegistry } from "../../transforms/transform-registry.js";
-import { transformPresets } from "../../transforms/transform-presets.js";
+import { allTransformIds } from "../../transforms/transform-catalog.js";
 import { checkAllSnapshots } from "./check-snapshots.js";
 export const checkExpectedEvaluations = async (options) => {
-    const { transformsDirectory, testCasesDirectory } = options;
-    const transformIds = allTransformIds.toSorted();
-    const missingManifestEntries = [];
-    // Check that each transform has a manifest.json file
-    for (const transformId of transformIds) {
-        const manifestPath = path.join(transformsDirectory, transformId, "manifest.json");
-        try {
-            await fs.access(manifestPath);
-        }
-        catch {
-            missingManifestEntries.push({
-                transformId,
-                path: manifestPath,
-            });
-        }
-    }
+    const { testCasesDirectory } = options;
+    const transformIds = [...allTransformIds];
     // Check test-cases matrix with smart snapshot detection
     const snapshotIssues = await checkAllSnapshots({
         testCasesDirectory,
         transformIds,
-        transformRegistry,
-        recommendedTransformIds: transformPresets.recommended,
     });
-    const allPresent = missingManifestEntries.length === 0 && snapshotIssues.length === 0;
+    const allPresent = snapshotIssues.length === 0;
     return {
         transformIds,
-        missingManifestEntries,
         snapshotIssues,
         allPresent,
     };

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

@@ -1,4 +1,3 @@
-import type { Transform } from "../../core/types.js";
 export type SnapshotIssue = {
     transformId: string;
     testCase: string;
@@ -8,8 +7,6 @@ export type SnapshotIssue = {
 type CheckAllSnapshotsOptions = {
     testCasesDirectory: string;
     transformIds: string[];
-    transformRegistry: Record<string, Transform>;
-    recommendedTransformIds: string[];
 };
 export declare const checkAllSnapshots: (options: CheckAllSnapshotsOptions) => Promise<SnapshotIssue[]>;
 export {};

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

@@ -2,6 +2,7 @@ import * as fs from "node:fs/promises";
 import path from "node:path";
 import * as prettier from "prettier";
 import { normalizeCode } from "../../core/normalize-code.js";
+import { getRecommendedTransforms, getTransformById, } from "../../transforms/transform-catalog.js";
 import { transformContent } from "./transform-content.js";
 import { checkRecommendedSnapshot } from "./check-recommended-snapshot.js";
 const formatCode = async (code) => {
@@ -86,13 +87,10 @@ const getTestCaseNames = async (testCasesDirectory) => {
     return testCaseNames.toSorted();
 };
 export const checkAllSnapshots = async (options) => {
-    const { testCasesDirectory, transformIds, transformRegistry, recommendedTransformIds, } = options;
+    const { testCasesDirectory, transformIds } = options;
     const snapshotIssues = [];
     const testCaseNames = await getTestCaseNames(testCasesDirectory);
-    // Get the recommended transforms in order
-    const recommendedTransforms = recommendedTransformIds
-        .map((id) => transformRegistry[id])
-        .filter((t) => t !== undefined);
+    const recommendedTransforms = getRecommendedTransforms();
     for (const testCaseName of testCaseNames) {
         const basePath = path.join(testCasesDirectory, testCaseName, "base.js");
         const baseContent = await fs.readFile(basePath, "utf8");
@@ -107,7 +105,7 @@ export const checkAllSnapshots = async (options) => {
                 snapshotPath,
                 transformId,
                 testCaseName,
-                transform: transformRegistry[transformId],
+                transform: getTransformById(transformId),
             });
             if (issue) {
                 snapshotIssues.push(issue);

package/dist/scripts/evaluate/create-output-slug.d.ts

@@ -1,7 +1,5 @@
 type CreateOutputSlugOptions = {
     transforms: string[];
-    recommendedTransforms: readonly string[];
-    allTransformIds: readonly string[];
 };
 export declare const createOutputSlug: (options: CreateOutputSlugOptions) => string;
 export {};

package/dist/scripts/evaluate/create-output-slug.js

@@ -1,26 +1,8 @@
 import crypto from "node:crypto";
+import { getTransformSelectionSlugSource } from "../../transforms/transform-catalog.js";
 import { sanitizeFileComponent } from "./sanitize.js";
-const isSameOrderedList = (a, b) => {
-    if (a.length !== b.length)
-        return false;
-    for (const [index, value] of a.entries()) {
-        const other = b[index];
-        if (other === undefined)
-            return false;
-        if (value !== other)
-            return false;
-    }
-    return true;
-};
 const createRawTransformSlug = (options) => {
-    const { transforms, recommendedTransforms, allTransformIds } = options;
-    if (transforms.length === 0)
-        return "none";
-    if (isSameOrderedList(transforms, recommendedTransforms))
-        return "recommended";
-    if (isSameOrderedList(transforms, allTransformIds))
-        return "all";
-    return transforms.join("-");
+    return getTransformSelectionSlugSource(options.transforms);
 };
 export const createOutputSlug = (options) => {
     const sanitized = sanitizeFileComponent(createRawTransformSlug(options));

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

@@ -1,36 +1,11 @@
 import path from "node:path";
-import { transformPresets } from "../../transforms/transform-presets.js";
-import { allTransformIds } from "../../transforms/transform-registry.js";
+import { expandTransformSelectors } from "../../transforms/transform-catalog.js";
 import { createOutputSlug } from "./create-output-slug.js";
 const parseTransformList = (value) => {
-    if (!value || value === "none")
-        return [];
-    const ids = value
-        .split(",")
-        .map((id) => id.trim())
-        .filter(Boolean)
-        .filter((id) => id !== "none");
-    const expandedIds = [];
-    for (const id of ids) {
-        if (id === "recommended" || id === "default") {
-            expandedIds.push(...transformPresets.recommended);
-            continue;
-        }
-        if (id === "all") {
-            expandedIds.push(...allTransformIds);
-            continue;
-        }
-        expandedIds.push(id);
-    }
-    const uniqueIds = [];
-    const seen = new Set();
-    for (const id of expandedIds) {
-        if (seen.has(id))
-            continue;
-        seen.add(id);
-        uniqueIds.push(id);
-    }
-    return uniqueIds;
+    return expandTransformSelectors({
+        value,
+        defaultPreset: "none",
+    });
 };
 const containsPathSeparator = (value) => {
     return value.includes("/") || value.includes("\\");
@@ -65,16 +40,8 @@ export const parseEvaluateCliOptions = (options) => {
     const verbose = rawOptions.verbose ?? false;
     const overwrite = rawOptions.overwrite ?? false;
     const formatCode = rawOptions.formatCode;
-    const baselineSlug = createOutputSlug({
-        transforms: baselineTransforms,
-        recommendedTransforms: transformPresets.recommended,
-        allTransformIds,
-    });
-    const testSlug = createOutputSlug({
-        transforms: testTransforms,
-        recommendedTransforms: transformPresets.recommended,
-        allTransformIds,
-    });
+    const baselineSlug = createOutputSlug({ transforms: baselineTransforms });
+    const testSlug = createOutputSlug({ transforms: testTransforms });
     const sourcesDirectory = path.resolve(cwd, rawOptions.sources);
     const evaluationDirectory = path.resolve(cwd, rawOptions.evaluationDir);
     const transformsDirectory = path.resolve(cwd, "src/transforms-by-id");

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

@@ -1,6 +1,5 @@
 import type { OutputFormat } from "./create-evaluate-command.js";
 type RunCheckModeOptions = {
-    transformsDirectory: string;
     rootDirectory: string;
     format: OutputFormat;
 };

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

@@ -1,29 +1,20 @@
 import path from "node:path";
 import { checkExpectedEvaluations } from "./check-expected-evaluations.js";
 export const runCheckMode = async (options) => {
-    const { transformsDirectory, rootDirectory, format } = options;
+    const { rootDirectory, format } = options;
     const checkResult = await checkExpectedEvaluations({
-        transformsDirectory,
         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,
-            })),
-        ];
+        const allIssues = 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) {
@@ -32,27 +23,6 @@ export const runCheckMode = async (options) => {
         }
     }
     let exitCode = 0;
-    if (checkResult.missingManifestEntries.length > 0) {
-        console.error(`\n[MISSING MANIFEST FILES] ${checkResult.missingManifestEntries.length} transform(s) missing manifest.json:`);
-        for (const item of checkResult.missingManifestEntries) {
-            console.error(`  - ${item.transformId}`);
-        }
-        console.error(`\n  To fix: Create a manifest.json file in each transform directory with the following structure:`);
-        console.error(`    {`);
-        console.error(`      "recommended": true,`);
-        console.error(`      "notes": "Description of the transform's impact",`);
-        console.error(`      "evaluations": {`);
-        console.error(`        "source-v1.0.0:source-v1.0.1": {`);
-        console.error(`          "diffSizePercent": 100,`);
-        console.error(`          "evaluatedAt": "2026-01-25T00:00:00.000Z",`);
-        console.error(`          "changedLines": 0,`);
-        console.error(`          "durationSeconds": 0,`);
-        console.error(`          "stableNames": 0`);
-        console.error(`        }`);
-        console.error(`      }`);
-        console.error(`    }`);
-        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");

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

@@ -1,6 +1,5 @@
 import * as fs from "node:fs/promises";
 import packageJson from "../../../package.json" with { type: "json" };
-import { transformPresets } from "../../transforms/transform-presets.js";
 import { createEvaluateCommand } from "./create-evaluate-command.js";
 import { parseEvaluateCliOptions, } from "./parse-evaluate-cli-options.js";
 import { resolveEvaluateDependencies } from "./resolve-evaluate-dependencies.js";
@@ -36,7 +35,6 @@ export const runEvaluateCli = async (argv) => {
     };
     if (parsedOptions.checkMode) {
         return runCheckMode({
-            transformsDirectory: parsedOptions.transformsDirectory,
             rootDirectory: process.cwd(),
             format: parsedOptions.format,
         });
@@ -111,7 +109,6 @@ export const runEvaluateCli = async (argv) => {
                 baselineTransforms: parsedOptions.baselineTransforms,
                 testTransforms: parsedOptions.testTransforms,
                 diffSizeRatios: results.map((r) => r.diffSizeRatio),
-                recommendedTransformIds: transformPresets.recommended,
                 transformChangedLines: results.map((r) => r.transformChangedLines),
                 evaluatedPairs: results.map((r) => r.pair),
                 durationSeconds: results.map((r) => r.durationSeconds),

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

@@ -9,7 +9,6 @@ type UpdateTransformManifestOptions = {
     testTransforms: string[];
     /** Diff size ratios (test/baseline) per evaluation pair. */
     diffSizeRatios: number[];
-    recommendedTransformIds: string[];
     /** Changed lines per evaluation pair (added + removed). */
     transformChangedLines?: (number | undefined)[];
     /** Source pairs used in the evaluation. */

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

@@ -1,9 +1,9 @@
-import * as fs from "node:fs/promises";
 import path from "node:path";
 import { buildEvaluationStats } from "./build-evaluation-stats.js";
 import { haveSameIds, normalizeTransformIds, uniqueIds, } from "./transform-id-set.js";
 import { writeJsonFileAtomic } from "./write-text-file-atomic.js";
 import presetStats from "../../transforms/preset-stats.json" with { type: "json" };
+import { getTransformCatalogEntry, recommendedTransformIds, } from "../../transforms/transform-catalog.js";
 const average = (values) => {
     if (values.length === 0)
         return 0;
@@ -13,20 +13,8 @@ const average = (values) => {
     }
     return total / values.length;
 };
-const loadManifest = async (manifestPath) => {
-    try {
-        const content = await fs.readFile(manifestPath, "utf8");
-        return JSON.parse(content);
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-            return undefined;
-        }
-        throw error;
-    }
-};
 export const updateTransformManifestFromEvaluation = async (options) => {
-    const { transformsDirectory, presetStatsPath, baselineTransforms, testTransforms, diffSizeRatios, recommendedTransformIds, transformChangedLines, evaluatedPairs, durationSeconds, stableNames, } = options;
+    const { transformsDirectory, presetStatsPath, baselineTransforms, testTransforms, diffSizeRatios, transformChangedLines, evaluatedPairs, durationSeconds, stableNames, } = options;
     const baselineIds = normalizeTransformIds(baselineTransforms);
     const testIds = normalizeTransformIds(testTransforms);
     const isBaselineNone = baselineIds.length === 0 ||
@@ -38,8 +26,8 @@ export const updateTransformManifestFromEvaluation = async (options) => {
         const transformId = testIds[0];
         if (transformId) {
             const manifestPath = path.join(transformsDirectory, transformId, "manifest.json");
-            const manifest = await loadManifest(manifestPath);
-            if (manifest) {
+            const catalogEntry = getTransformCatalogEntry(transformId);
+            if (catalogEntry) {
                 const newEvaluations = buildEvaluationStats({
                     evaluatedPairs,
                     diffSizeRatios,
@@ -48,14 +36,16 @@ export const updateTransformManifestFromEvaluation = async (options) => {
                     stableNames,
                 });
                 const mergedEvaluations = {
-                    ...manifest.evaluations,
+                    ...catalogEntry.manifest.evaluations,
                     ...newEvaluations,
                 };
-                const evaluationsChanged = JSON.stringify(manifest.evaluations) !==
+                const evaluationsChanged = JSON.stringify(catalogEntry.manifest.evaluations) !==
                     JSON.stringify(mergedEvaluations);
                 if (evaluationsChanged) {
-                    manifest.evaluations = mergedEvaluations;
-                    await writeJsonFileAtomic(manifestPath, manifest, {
+                    await writeJsonFileAtomic(manifestPath, {
+                        ...catalogEntry.manifest,
+                        evaluations: mergedEvaluations,
+                    }, {
                         overwrite: true,
                     });
                     messages.push(`Updated ${transformId}/manifest.json`);
@@ -63,7 +53,7 @@ export const updateTransformManifestFromEvaluation = async (options) => {
                 }
             }
             else {
-                messages.push(`Skipping update for ${transformId}: manifest.json not found at ${manifestPath}`);
+                messages.push(`Skipping update for ${transformId}: transform ID is not in the registry.`);
             }
         }
     }

package/dist/scripts/snapshot/run-testcase-transform.js

@@ -2,24 +2,22 @@ import { createRequire } from "node:module";
 import * as fs from "node:fs/promises";
 import { buildProjectGraph } from "../../core/project-graph.js";
 import { getDefaultTransformOptions } from "../../core/default-transform-options.js";
-import { transformPresets } from "../../transforms/transform-presets.js";
-import { transformRegistry } from "../../transforms/transform-registry.js";
+import { expandTransformSelectors, resolveTransformsByIds, } from "../../transforms/transform-catalog.js";
 import { formatCode } from "./format-code.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const generate = require("@babel/generator").default;
 const runTransform = async (inputPath, transformId) => {
     const content = await fs.readFile(inputPath, "utf8");
-    const transformIds = transformId === "recommended"
-        ? transformPresets.recommended
-        : [transformId];
-    const transforms = transformIds.map((id) => {
-        const transform = transformRegistry[id];
-        if (!transform) {
-            throw new Error(`Unknown transform: ${id}. Run 'miniread --list-transforms' to see available transforms.`);
-        }
-        return transform;
+    const transformIds = expandTransformSelectors({
+        value: transformId,
+        defaultPreset: "none",
     });
+    const resolveResult = resolveTransformsByIds(transformIds);
+    if (!resolveResult.ok) {
+        throw new Error(`Unknown transform: ${resolveResult.unknownTransformIds.join(", ")}. Run 'miniread --list-transforms' to see available transforms.`);
+    }
+    const transforms = resolveResult.transforms;
     const projectGraph = buildProjectGraph([{ path: inputPath, content }]);
     const options = getDefaultTransformOptions();
     for (const transform of transforms) {

package/dist/transforms/_generated/catalog.d.ts

@@ -0,0 +1,7 @@
+import type { Transform } from "../../core/types.js";
+export type GeneratedTransformCatalogEntry = {
+    id: string;
+    transform: Transform;
+    manifest: unknown;
+};
+export declare const generatedTransformCatalog: GeneratedTransformCatalogEntry[];