miniread 1.0.0

package/dist/cli.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import { Command, InvalidArgumentError } from "@commander-js/extra-typings";
+import packageJson from "../package.json" with { type: "json" };
+import { getTransformsToRun, getTransformSummaries } from "./cli/config.js";
+import { runTransforms, transformStdin } from "./cli/runner.js";
+const parseListFormat = (value) => {
+    if (value === "text" || value === "tsv" || value === "json")
+        return value;
+    throw new InvalidArgumentError(`invalid value '${value}' (expected: text, tsv, json)`);
+};
+const parsePositiveInt = (value) => {
+    const parsed = Number.parseInt(value);
+    if (!Number.isFinite(parsed) || parsed < 1) {
+        throw new InvalidArgumentError("must be a positive integer");
+    }
+    return parsed;
+};
+const program = new Command()
+    .name(packageJson.name)
+    .description(packageJson.description)
+    .version(packageJson.version)
+    .showHelpAfterError("(add --help for additional information)")
+    .showSuggestionAfterError()
+    .option("-v, --verbose", "Enable verbose output")
+    .option("-i, --input <path>", "Input file or directory (default: stdin)")
+    .option("-o, --output <path>", "Output directory (required when using --input)")
+    .option("-t, --transforms <list>", "Comma-separated list of transforms to run (or preset: recommended, all, none)")
+    .option("--list-transforms", "List available transforms")
+    .option("--format <format>", "Output format for --list-transforms: text, tsv, json", parseListFormat, "text")
+    .option("--dry-run", "Show what would be changed without writing files")
+    .option("-w, --workers <n>", "Number of parallel workers", parsePositiveInt, 4)
+    .option("-f, --overwrite", "Overwrite existing files in output directory");
+program.addHelpText("after", `
+Examples:
+  # Read from stdin, write to stdout (filter mode)
+  cat bundle.min.js | miniread > bundle.js
+
+  # Process a directory into an output directory
+  miniread --input ./minified --output ./readable
+
+  # Use the recommended preset explicitly
+  miniread --input ./minified --output ./readable --transforms recommended
+
+  # Run all transforms (including non-recommended ones)
+  miniread --input ./minified --output ./readable --transforms all
+
+  # List available transforms (one per line)
+  miniread --list-transforms
+
+  # Pipeline example: find frequent identifiers after transforming
+  cat bundle.min.js | miniread | grep -oE '[A-Za-z_][A-Za-z0-9_]+' | sort | uniq -c | sort -rn | head -20
+`);
+// Package managers often pass a standalone `--` to separate script args.
+// Commander treats `--` as "end of options", which would cause flags like
+// `--help` to be parsed as positional arguments. Strip it for robustness.
+program.parse(process.argv.filter((argument) => argument !== "--"));
+const options = program.opts();
+if (options.listTransforms) {
+    const summaries = getTransformSummaries();
+    if (options.format === "json") {
+        process.stdout.write(JSON.stringify(summaries, undefined, 2) + "\n");
+    }
+    else if (options.format === "tsv") {
+        process.stdout.write("ID\tDESCRIPTION\tSCOPE\tPARALLELIZABLE\n");
+        for (const summary of summaries) {
+            process.stdout.write(`${summary.id}\t${summary.description}\t${summary.scope}\t${summary.parallelizable}\n`);
+        }
+    }
+    else {
+        for (const summary of summaries) {
+            process.stdout.write(`${summary.id}\n`);
+        }
+    }
+}
+else if (options.input) {
+    if (!options.output) {
+        program.error("--output is required when using --input");
+        process.exit(1);
+    }
+    const transformsResult = getTransformsToRun(options.transforms);
+    if (!transformsResult.ok) {
+        program.error(transformsResult.error);
+        process.exit(1);
+    }
+    const result = await runTransforms({
+        input: options.input,
+        output: options.output,
+        transforms: transformsResult.transforms,
+        dryRun: options.dryRun ?? false,
+        workers: options.workers,
+        overwrite: options.overwrite ?? false,
+        verbose: options.verbose ?? false,
+    });
+    if (result.errors.length > 0) {
+        console.error("Errors:");
+        for (const error of result.errors) {
+            console.error(`- ${error}`);
+        }
+        console.error(`Try '${packageJson.name} --help' for details.`);
+        process.exit(1);
+    }
+}
+else {
+    if (options.output) {
+        program.error("--output cannot be used without --input");
+    }
+    const transformsResult = getTransformsToRun(options.transforms);
+    if (!transformsResult.ok) {
+        program.error(transformsResult.error);
+        process.exit(1);
+    }
+    const result = await transformStdin({
+        transforms: transformsResult.transforms,
+        verbose: options.verbose ?? false,
+    });
+    if (!result.ok) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+    }
+    process.stdout.write(result.output);
+}

package/dist/core/paths.d.ts

@@ -0,0 +1,8 @@
+export type AppPaths = {
+    data: string;
+    config: string;
+    cache: string;
+    log: string;
+    temp: string;
+};
+export declare const appPaths: AppPaths;

package/dist/core/paths.js

@@ -0,0 +1,9 @@
+import envPaths from "env-paths";
+const paths = envPaths("miniread");
+export const appPaths = {
+    data: paths.data,
+    config: paths.config,
+    cache: paths.cache,
+    log: paths.log,
+    temp: paths.temp,
+};

package/dist/core/project-graph.d.ts

@@ -0,0 +1,6 @@
+import type { ProjectGraph } from "./types.js";
+export type ParsedFile = {
+    path: string;
+    content: string;
+};
+export declare const buildProjectGraph: (files: ParsedFile[]) => ProjectGraph;

package/dist/core/project-graph.js

@@ -0,0 +1,40 @@
+import { parse } from "@babel/parser";
+const getPlugins = (filePath) => {
+    const plugins = [];
+    if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) {
+        plugins.push("typescript");
+    }
+    if (filePath.endsWith(".jsx") || filePath.endsWith(".tsx")) {
+        plugins.push("jsx");
+    }
+    return plugins;
+};
+export const buildProjectGraph = (files) => {
+    const fileMap = new Map();
+    for (const file of files) {
+        try {
+            const ast = parse(file.content, {
+                sourceType: "unambiguous",
+                plugins: getPlugins(file.path),
+                sourceFilename: file.path,
+            });
+            fileMap.set(file.path, {
+                path: file.path,
+                content: file.content,
+                ast,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`  Warning: Parse error in ${file.path}: ${message}`);
+        }
+    }
+    return {
+        files: fileMap,
+        // Stubbed for future implementation
+        symbols: new Map(),
+        references: new Map(),
+        exports: new Map(),
+        imports: new Map(),
+    };
+};

package/dist/core/types.d.ts

@@ -0,0 +1,30 @@
+import type { File } from "@babel/types";
+export type SourceFileInfo = {
+    path: string;
+    content: string;
+    ast: File;
+};
+export type ProjectGraph = {
+    files: Map<string, SourceFileInfo>;
+    symbols: Map<string, unknown>;
+    references: Map<string, unknown>;
+    exports: Map<string, unknown>;
+    imports: Map<string, unknown>;
+};
+export type TransformContext = {
+    projectGraph: ProjectGraph;
+    currentFile: SourceFileInfo | undefined;
+    options: Record<string, unknown>;
+};
+export type TransformStats = {
+    nodesVisited: number;
+    transformationsApplied: number;
+};
+export type TransformScope = "file" | "project";
+export type Transform = {
+    id: string;
+    description: string;
+    scope: TransformScope;
+    parallelizable: boolean;
+    transform: (context: TransformContext) => Promise<TransformStats>;
+};

package/dist/core/types.js

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

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export type { Transform, TransformContext, TransformScope, ProjectGraph, SourceFileInfo, TransformStats, } from "./core/types.js";
+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 { runTransforms } from "./cli/runner.js";
+export type { RunnerOptions, RunnerResult } from "./cli/runner.js";

package/dist/index.js

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

package/dist/scripts/evaluate/create-evaluate-command.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "@commander-js/extra-typings";
+export type OutputFormat = "tsv" | "json";
+export declare const createEvaluateCommand: (options: {
+    version: string;
+}) => Command;

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

@@ -0,0 +1,47 @@
+import { Command, InvalidArgumentError } from "@commander-js/extra-typings";
+const parseOutputFormat = (value) => {
+    if (value === "tsv" || value === "json")
+        return value;
+    throw new InvalidArgumentError(`invalid value '${value}' (expected: tsv, json)`);
+};
+export const createEvaluateCommand = (options) => {
+    const program = new Command()
+        .name("miniread-evaluate")
+        .description("Compare miniread transform configurations by measuring diff reduction across version pairs.")
+        .version(options.version)
+        .showHelpAfterError("(add --help for additional information)")
+        .showSuggestionAfterError()
+        .option("-v, --verbose", "Enable verbose output")
+        .option("-c, --compare <from:to>", "Version pair to compare (repeatable)", (value, previous) => [...previous, value], [])
+        .option("-b, --baseline <transforms>", "Comma-separated baseline transforms (or preset: recommended, all, none)", "none")
+        .option("-t, --test <transforms>", "Comma-separated test transforms (or preset: recommended, all, none)", "none")
+        .option("--sources <path>", "Sources directory", "sources")
+        .option("--evaluation-dir <path>", "Output directory for patches/metrics", "evaluation")
+        .option("--format <format>", "Output format: tsv, json", parseOutputFormat, "tsv")
+        .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("--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
+`);
+    return program;
+};

package/dist/scripts/evaluate/diff-utilities.d.ts

@@ -0,0 +1,17 @@
+export type DiffStats = {
+    totalLines: number;
+    sizeBytes: number;
+    addedLines: number;
+    removedLines: number;
+    changedHunks: number;
+};
+export declare const createTransformSlug: (transforms: string[]) => string;
+type ComputeDirectoryDiffOptions = {
+    diffPath: string;
+    directoryA: string;
+    directoryB: string;
+    outputPath: string | undefined;
+    overwrite: boolean;
+};
+export declare const computeDirectoryDiff: (options: ComputeDirectoryDiffOptions) => Promise<DiffStats>;
+export {};

package/dist/scripts/evaluate/diff-utilities.js

@@ -0,0 +1,114 @@
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import path from "node:path";
+import readline from "node:readline";
+export const createTransformSlug = (transforms) => {
+    return transforms.length > 0 ? transforms.join("-") : "none";
+};
+const isErrnoException = (error) => {
+    return error instanceof Error;
+};
+export const computeDirectoryDiff = async (options) => {
+    const { diffPath, directoryA, directoryB, outputPath, overwrite } = options;
+    if (outputPath) {
+        await fsPromises.mkdir(path.dirname(outputPath), { recursive: true });
+    }
+    const diffProcess = spawn(diffPath, ["-ru", directoryA, directoryB], {
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    const stderrChunks = [];
+    diffProcess.stderr.setEncoding("utf8");
+    diffProcess.stderr.on("data", (chunk) => {
+        if (stderrChunks.join("").length > 200_000)
+            return;
+        stderrChunks.push(chunk);
+    });
+    const outputStream = outputPath
+        ? fs.createWriteStream(outputPath, { flags: overwrite ? "w" : "wx" })
+        : undefined;
+    let outputStreamError;
+    if (outputStream) {
+        outputStream.on("error", (error) => {
+            outputStreamError = error;
+            diffProcess.kill();
+            outputStream.destroy();
+        });
+    }
+    let totalLines = 0;
+    let sizeBytes = 0;
+    let addedLines = 0;
+    let removedLines = 0;
+    let changedHunks = 0;
+    const rl = readline.createInterface({
+        input: diffProcess.stdout,
+        crlfDelay: Number.POSITIVE_INFINITY,
+    });
+    try {
+        for await (const line of rl) {
+            const normalizedLine = line.replaceAll(/[\t ]+$/gu, "");
+            const outputLine = `${normalizedLine}\n`;
+            totalLines += 1;
+            sizeBytes += Buffer.byteLength(outputLine, "utf8");
+            if (normalizedLine.startsWith("+") && !normalizedLine.startsWith("+++")) {
+                addedLines += 1;
+            }
+            else if (normalizedLine.startsWith("-") &&
+                !normalizedLine.startsWith("---")) {
+                removedLines += 1;
+            }
+            else if (normalizedLine.startsWith("@@")) {
+                changedHunks += 1;
+            }
+            if (!outputStream)
+                continue;
+            if (outputStreamError)
+                throw outputStreamError;
+            if (outputStream.write(outputLine))
+                continue;
+            await once(outputStream, "drain");
+        }
+    }
+    finally {
+        rl.close();
+    }
+    if (outputStreamError) {
+        if (outputPath && isErrnoException(outputStreamError)) {
+            if (outputStreamError.code !== "EEXIST")
+                throw outputStreamError;
+            throw new Error(`Refusing to overwrite existing diff output file: ${outputPath}. Re-run with --overwrite to replace.`);
+        }
+        throw outputStreamError;
+    }
+    const exitCode = await new Promise((resolve, reject) => {
+        diffProcess.on("error", reject);
+        diffProcess.on("close", (code) => {
+            resolve(code);
+        });
+    });
+    if (outputStream) {
+        await new Promise((resolve, reject) => {
+            outputStream.on("error", reject);
+            outputStream.end(() => {
+                resolve();
+            });
+        });
+    }
+    // diff exits:
+    // - 0: no differences
+    // - 1: differences found (expected)
+    // - 2: error
+    if (exitCode !== 0 && exitCode !== 1) {
+        const stderr = stderrChunks.join("").trim();
+        const stderrSuffix = stderr ? `\n\nstderr:\n${stderr}` : "";
+        throw new Error(`Failed to run diff (exit code ${exitCode}).${stderrSuffix}`);
+    }
+    return {
+        totalLines,
+        sizeBytes,
+        addedLines,
+        removedLines,
+        changedHunks,
+    };
+};

package/dist/scripts/evaluate/evaluation-report.d.ts

@@ -0,0 +1,22 @@
+import type { ComparisonPair, EvaluationResult } from "./evaluation-types.js";
+export type EvaluationError = {
+    pair: ComparisonPair;
+    error: string;
+};
+export type EvaluationOutcome = {
+    ok: true;
+    pair: ComparisonPair;
+    result: EvaluationResult;
+} | {
+    ok: false;
+    pair: ComparisonPair;
+    error: string;
+};
+export type EvaluationReport = {
+    version: string;
+    baselineTransforms: string[];
+    testTransforms: string[];
+    pairs: ComparisonPair[];
+    results: EvaluationResult[];
+    errors: EvaluationError[];
+};

package/dist/scripts/evaluate/evaluation-report.js

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

package/dist/scripts/evaluate/evaluation-types.d.ts

@@ -0,0 +1,16 @@
+import type { DiffStats } from "./diff-utilities.js";
+export type ComparisonPair = {
+    from: string;
+    to: string;
+};
+export type EvaluationResult = {
+    timestamp: string;
+    pair: ComparisonPair;
+    baselineTransforms: string[];
+    testTransforms: string[];
+    baselineDiff: DiffStats;
+    testDiff: DiffStats;
+    reductionRatio: number;
+    baselinePatchPath?: string;
+    testPatchPath?: string;
+};

package/dist/scripts/evaluate/evaluation-types.js

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

package/dist/scripts/evaluate/metrics.d.ts

@@ -0,0 +1,3 @@
+import type { DiffStats } from "./diff-utilities.js";
+export declare const calculateReductionRatio: (baselineDiff: DiffStats, testDiff: DiffStats) => number;
+export declare const formatDiffStats: (diff: DiffStats) => string;

package/dist/scripts/evaluate/metrics.js

@@ -0,0 +1,11 @@
+export const calculateReductionRatio = (baselineDiff, testDiff) => {
+    const baselineChangedLines = baselineDiff.addedLines + baselineDiff.removedLines;
+    const testChangedLines = testDiff.addedLines + testDiff.removedLines;
+    return baselineChangedLines === 0
+        ? 0
+        : 1 - testChangedLines / baselineChangedLines;
+};
+export const formatDiffStats = (diff) => {
+    const changedLines = diff.addedLines + diff.removedLines;
+    return `${changedLines.toLocaleString()} changed lines (${diff.changedHunks.toLocaleString()} hunks)`;
+};

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

@@ -0,0 +1,21 @@
+import type { ComparisonPair, EvaluationResult } from "./evaluation-types.js";
+type EvaluatePairOptions = {
+    pair: ComparisonPair;
+    baselineTransforms: string[];
+    testTransforms: string[];
+    sourcesDirectory: string;
+    rootDirectory: string;
+    nodePath: string;
+    minireadCliPath: string;
+    diffPath: string;
+    pnpmPath: string | undefined;
+    prettierPath: string | undefined;
+    formatCode: boolean;
+    baselinePatchPath: string | undefined;
+    testPatchPath: string | undefined;
+    overwrite: boolean;
+    verbose: boolean;
+    log: (message: string) => void;
+};
+export declare const evaluatePair: (options: EvaluatePairOptions) => Promise<EvaluationResult>;
+export {};

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

@@ -0,0 +1,104 @@
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import envPaths from "env-paths";
+import { computeDirectoryDiff } from "./diff-utilities.js";
+import { calculateReductionRatio, formatDiffStats } from "./metrics.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;
+    if (verbose) {
+        log(`Evaluating: ${pair.from} -> ${pair.to}`);
+    }
+    const runId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const temporaryDirectory = path.join(appPaths.temp, `miniread-evaluate-${runId}`);
+    await fs.mkdir(temporaryDirectory, { recursive: true });
+    try {
+        if (verbose) {
+            log(`Running miniread with baseline [${baselineTransforms.join(", ") || "none"}] and test [${testTransforms.join(", ") || "none"}]...`);
+        }
+        const { baselineOutputFrom, baselineOutputTo, testOutputFrom, testOutputTo, } = await runPairTransformations({
+            pair,
+            baselineTransforms,
+            testTransforms,
+            sourcesDirectory,
+            temporaryDirectory,
+            rootDirectory,
+            nodePath,
+            minireadCliPath,
+            verbose,
+        });
+        if (formatCode) {
+            if (verbose)
+                log("Formatting output with Prettier...");
+            await Promise.all([
+                formatDirectoryWithPrettier({
+                    directory: baselineOutputFrom,
+                    rootDirectory,
+                    pnpmPath,
+                    prettierPath,
+                }),
+                formatDirectoryWithPrettier({
+                    directory: baselineOutputTo,
+                    rootDirectory,
+                    pnpmPath,
+                    prettierPath,
+                }),
+                formatDirectoryWithPrettier({
+                    directory: testOutputFrom,
+                    rootDirectory,
+                    pnpmPath,
+                    prettierPath,
+                }),
+                formatDirectoryWithPrettier({
+                    directory: testOutputTo,
+                    rootDirectory,
+                    pnpmPath,
+                    prettierPath,
+                }),
+            ]);
+        }
+        if (verbose)
+            log("Computing diffs...");
+        const [baselineDiff, testDiff] = await Promise.all([
+            computeDirectoryDiff({
+                diffPath,
+                directoryA: baselineOutputFrom,
+                directoryB: baselineOutputTo,
+                outputPath: baselinePatchPath,
+                overwrite,
+            }),
+            computeDirectoryDiff({
+                diffPath,
+                directoryA: testOutputFrom,
+                directoryB: testOutputTo,
+                outputPath: testPatchPath,
+                overwrite,
+            }),
+        ]);
+        if (verbose) {
+            log(`Baseline: ${formatDiffStats(baselineDiff)}`);
+            log(`Test: ${formatDiffStats(testDiff)}`);
+        }
+        const reductionRatio = calculateReductionRatio(baselineDiff, testDiff);
+        const percentReduction = (reductionRatio * 100).toFixed(2);
+        const status = reductionRatio >= 0 ? "GOOD" : "BAD";
+        if (verbose)
+            log(`Reduction ratio: ${percentReduction}% (${status})`);
+        return {
+            timestamp: new Date().toISOString(),
+            pair,
+            baselineTransforms,
+            testTransforms,
+            baselineDiff,
+            testDiff,
+            reductionRatio,
+            baselinePatchPath,
+            testPatchPath,
+        };
+    }
+    finally {
+        await fs.rm(temporaryDirectory, { recursive: true, force: true });
+    }
+};

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

@@ -0,0 +1,40 @@
+import type { ComparisonPair } from "./evaluation-types.js";
+import type { OutputFormat } from "./create-evaluate-command.js";
+export type EvaluateCliRawOptions = {
+    verbose?: boolean;
+    compare: string[];
+    baseline?: string;
+    test?: string;
+    sources: string;
+    evaluationDir: string;
+    format: OutputFormat;
+    writeMetrics?: boolean;
+    metricsFile?: string;
+    writePatches?: boolean;
+    updateManifest?: boolean;
+    manifestFile: string;
+    overwrite?: boolean;
+    formatCode: boolean;
+};
+export type EvaluateCliOptions = {
+    verbose: boolean;
+    pairs: ComparisonPair[];
+    baselineTransforms: string[];
+    testTransforms: string[];
+    sourcesDirectory: string;
+    evaluationDirectory: string;
+    format: OutputFormat;
+    shouldWriteMetrics: boolean;
+    shouldWritePatches: boolean;
+    shouldUpdateManifest: boolean;
+    metricsPath: string;
+    manifestPath: string;
+    overwrite: boolean;
+    formatCode: boolean;
+    baselineSlug: string;
+    testSlug: string;
+};
+export declare const parseEvaluateCliOptions: (options: {
+    cwd: string;
+    rawOptions: EvaluateCliRawOptions;
+}) => EvaluateCliOptions;