@shivaedev/quality 0.3.1 → 0.5.0

package/src/baseline/compare.ts

@@ -1,10 +1,9 @@
-import type { Level } from "../config.ts";
-import { groupBy, keyOf, unusedEntryProblem, type Violation } from "../engine/violation.ts";
+import { groupBy, keyOf, levelOf, type RuleIndex, unusedEntryProblem, type Violation } from "../engine/violation.ts";
 import type { BaselineEntry } from "./format.ts";
 
 export interface Regression {
-	readonly entry: BaselineEntry;
 	readonly count: number;
+	readonly entry: BaselineEntry;
 }
 
 export interface StaleBaselineEntry {
@@ -13,20 +12,16 @@ export interface StaleBaselineEntry {
 }
 
 export interface BaselineCheck {
-	readonly kept: ReadonlyArray<Violation>;
-	readonly regressions: ReadonlyArray<Regression>;
-	readonly stale: ReadonlyArray<StaleBaselineEntry>;
-	readonly loose: ReadonlyArray<StaleBaselineEntry>;
 	readonly baselined: number;
+	readonly kept: readonly Violation[];
+	readonly loose: readonly StaleBaselineEntry[];
+	readonly regressions: readonly Regression[];
+	readonly stale: readonly StaleBaselineEntry[];
 }
 
-export const countOf = (violations: ReadonlyArray<Violation>): number => violations.reduce((total, violation) => total + (violation.count ?? 1), 0);
+export const countOf = (violations: readonly Violation[]): number => violations.reduce((total, violation) => total + (violation.count ?? 1), 0);
 
-export const applyBaseline = (
-	violations: ReadonlyArray<Violation>,
-	entries: ReadonlyArray<BaselineEntry>,
-	levels: ReadonlyMap<string, Level>,
-): BaselineCheck => {
+export const applyBaseline = (violations: readonly Violation[], entries: readonly BaselineEntry[], rules: RuleIndex): BaselineCheck => {
 	const groups = groupBy(violations, (violation) => keyOf(violation.rule, violation.file));
 	const covered = new Set<string>();
 	const regressions: Regression[] = [];
@@ -35,10 +30,10 @@ export const applyBaseline = (
 	for (const entry of entries) {
 		const group = groups.get(keyOf(entry.rule, entry.file)) ?? [];
 		if (group.length === 0) {
-			const level = levels.get(entry.rule);
+			const level = levelOf(rules, entry.rule);
 			(level === undefined || level === "off" ? stale : loose).push({
 				entry,
-				problem: unusedEntryProblem(levels, entry.rule, "has no violations left"),
+				problem: unusedEntryProblem(rules, entry.rule, "has no violations left"),
 			});
 			continue;
 		}

package/src/baseline/format.ts

@@ -3,17 +3,17 @@ import { type Decoded, decodeWith } from "../decoded.ts";
 import { keyOf } from "../engine/violation.ts";
 
 const Line = Schema.Struct({
+	count: Schema.Int.check(Schema.isGreaterThan(0)),
 	path: Schema.NonEmptyString,
 	rule: Schema.NonEmptyString,
-	count: Schema.Int.check(Schema.isGreaterThan(0)),
 });
 
 const standard = Schema.toStandardSchemaV1(Schema.fromJsonString(Line), { parseOptions: { errors: "all", onExcessProperty: "error" } });
 
 export interface BaselineEntry {
-	readonly rule: string;
-	readonly file: string;
 	readonly count: number;
+	readonly file: string;
+	readonly rule: string;
 }
 
 const codepoints = (left: string, right: string): number => (left < right ? -1 : Number(left > right));
@@ -27,7 +27,7 @@ export const linesOf = (raw: string | undefined): ReadonlyArray<{ readonly line:
 		.map((text, index) => ({ line: index + 1, text }))
 		.filter((row) => row.text.trim() !== "");
 
-export const decodeBaseline = async (raw: string | undefined): Promise<Decoded<ReadonlyArray<BaselineEntry>>> => {
+export const decodeBaseline = async (raw: string | undefined): Promise<Decoded<readonly BaselineEntry[]>> => {
 	const issues: string[] = [];
 	const entries: BaselineEntry[] = [];
 	const seen = new Set<string>();
@@ -47,9 +47,11 @@ export const decodeBaseline = async (raw: string | undefined): Promise<Decoded<R
 	return issues.length === 0 ? { _tag: "Valid", value: entries } : { _tag: "Invalid", issues };
 };
 
-export const encodeEntry = (entry: BaselineEntry): string => JSON.stringify({ path: entry.file, rule: entry.rule, count: entry.count });
+const LINE_KEYS = ["path", "rule", "count"];
+
+export const encodeEntry = (entry: BaselineEntry): string => JSON.stringify({ count: entry.count, path: entry.file, rule: entry.rule }, LINE_KEYS);
 
-export const encodeBaseline = (entries: ReadonlyArray<BaselineEntry>): string =>
+export const encodeBaseline = (entries: readonly BaselineEntry[]): string =>
 	[...entries]
 		.sort(byPathAndRule)
 		.map((entry) => `${encodeEntry(entry)}\n`)

package/src/baseline/guard.ts

@@ -1,4 +1,4 @@
-import { groupBy, keyOf } from "../engine/violation.ts";
+import { covers, groupBy, keyOf } from "../engine/violation.ts";
 import type { BaselineEntry } from "./format.ts";
 
 export type GuardProblem =
@@ -8,16 +8,16 @@ export type GuardProblem =
 	| { readonly _tag: "NothingAdopted"; readonly rule: string };
 
 export interface GuardResult {
-	readonly problems: ReadonlyArray<GuardProblem>;
+	readonly adopted: readonly string[];
 	readonly moved: number;
-	readonly adopted: ReadonlyArray<string>;
+	readonly problems: readonly GuardProblem[];
 }
 
 export const guardBaseline = (
-	base: ReadonlyArray<BaselineEntry>,
-	working: ReadonlyArray<BaselineEntry>,
+	base: readonly BaselineEntry[],
+	working: readonly BaselineEntry[],
 	renames: ReadonlyMap<string, string>,
-	adopt: ReadonlyArray<string>,
+	adopt: readonly string[],
 ): GuardResult => {
 	const before = new Map(base.map((entry) => [keyOf(entry.rule, entry.file), entry]));
 	const covered = new Set(base.map((entry) => entry.rule));
@@ -36,12 +36,13 @@ export const guardBaseline = (
 			moved += 1;
 		}
 	}
+	const adopted = (rule: string): boolean => adopt.some((name) => covers(name, rule));
 	const fresh = [...byRule.entries()].filter(([rule]) => !covered.has(rule));
-	for (const [rule, entries] of fresh.filter(([rule]) => !adopt.includes(rule))) {
+	for (const [rule, entries] of fresh.filter(([rule]) => !adopted(rule))) {
 		problems.push({ _tag: "Unadopted", entries: entries.length, rule });
 	}
-	for (const rule of adopt.filter((candidate) => !byRule.has(candidate))) {
-		problems.push({ _tag: "NothingAdopted", rule });
+	for (const name of adopt.filter((candidate) => ![...byRule.keys()].some((rule) => covers(candidate, rule)))) {
+		problems.push({ _tag: "NothingAdopted", rule: name });
 	}
-	return { adopted: fresh.map(([rule]) => rule).filter((rule) => adopt.includes(rule)), moved, problems };
+	return { adopted: fresh.map(([rule]) => rule).filter(adopted), moved, problems };
 };

package/src/baseline/legacy.ts

@@ -19,7 +19,7 @@ export interface LegacyEntry extends BaselineEntry {
 	readonly measure?: number | undefined;
 }
 
-export const decodeLegacyBaseline = async (raw: string): Promise<Decoded<ReadonlyArray<LegacyEntry>>> => {
+export const decodeLegacyBaseline = async (raw: string): Promise<Decoded<readonly LegacyEntry[]>> => {
 	const decoded = await decodeWith(standard, raw);
 	if (decoded._tag === "Invalid") {
 		return decoded;
@@ -30,9 +30,9 @@ export const decodeLegacyBaseline = async (raw: string): Promise<Decoded<Readonl
 	return { _tag: "Valid", value: entries };
 };
 
-export const measured = (legacy: ReadonlyArray<LegacyEntry>): boolean => legacy.some((entry) => entry.measure !== undefined);
+export const measured = (legacy: readonly LegacyEntry[]): boolean => legacy.some((entry) => entry.measure !== undefined);
 
-export const convertLegacy = (legacy: ReadonlyArray<LegacyEntry>, violations: ReadonlyArray<Violation>): ReadonlyArray<BaselineEntry> => {
+export const convertLegacy = (legacy: readonly LegacyEntry[], violations: readonly Violation[]): readonly BaselineEntry[] => {
 	const current = groupBy(violations, (violation) => keyOf(violation.rule, violation.file));
 	return legacy.flatMap(({ count, file, measure, rule }) => {
 		if (measure === undefined) {

package/src/baseline/rewrite.ts

@@ -7,7 +7,7 @@ interface Row {
 }
 
 // An untouched entry keeps its exact line and a new one goes before the first line that sorts after it, so two branches conflict only on the same or neighbouring entries.
-export const rewriteBaseline = (raw: string | undefined, before: ReadonlyArray<BaselineEntry>, after: ReadonlyArray<BaselineEntry>): string => {
+export const rewriteBaseline = (raw: string | undefined, before: readonly BaselineEntry[], after: readonly BaselineEntry[]): string => {
 	const wanted = new Map(after.map((entry) => [keyOf(entry.rule, entry.file), entry]));
 	const lines = linesOf(raw);
 	const rows: Row[] = before.flatMap((old, index) => {

package/src/baseline/update.ts

@@ -1,20 +1,19 @@
-import type { Level } from "../config.ts";
-import { groupBy, keyOf, type Violation } from "../engine/violation.ts";
+import { covers, groupBy, keyOf, levelOf, type RuleIndex, type Violation } from "../engine/violation.ts";
 import { countOf } from "./compare.ts";
 import type { BaselineEntry } from "./format.ts";
 
 export type Adoption =
-	| { readonly _tag: "Refused"; readonly reasons: ReadonlyArray<string> }
-	| { readonly _tag: "Adopted"; readonly entries: ReadonlyArray<BaselineEntry>; readonly added: number; readonly replaced: number };
+	| { readonly _tag: "Refused"; readonly reasons: readonly string[] }
+	| { readonly _tag: "Adopted"; readonly entries: readonly BaselineEntry[]; readonly added: number; readonly replaced: number };
 
 export interface Pruned {
-	readonly entries: ReadonlyArray<BaselineEntry>;
+	readonly entries: readonly BaselineEntry[];
+	readonly lowered: number;
 	readonly moved: number;
 	readonly removed: number;
-	readonly lowered: number;
 }
 
-const record = (violations: ReadonlyArray<Violation>): ReadonlyArray<BaselineEntry> =>
+const record = (violations: readonly Violation[]): readonly BaselineEntry[] =>
 	[...groupBy(violations, (violation) => keyOf(violation.rule, violation.file)).values()].flatMap((group) => {
 		const first = group[0];
 		if (first === undefined) {
@@ -24,8 +23,8 @@ const record = (violations: ReadonlyArray<Violation>): ReadonlyArray<BaselineEnt
 		return count > 0 ? [{ count, file: first.file, rule: first.rule }] : [];
 	});
 
-const refusal = (id: string, levels: ReadonlyMap<string, Level>): ReadonlyArray<string> => {
-	const level = levels.get(id);
+const refusal = (id: string, index: RuleIndex): readonly string[] => {
+	const level = levelOf(index, id);
 	if (level === undefined) {
 		return [`${id}: no built-in or local rule has this id.`];
 	}
@@ -33,27 +32,28 @@ const refusal = (id: string, levels: ReadonlyMap<string, Level>): ReadonlyArray<
 };
 
 export const adopt = (
-	existing: ReadonlyArray<BaselineEntry> | undefined,
-	rules: ReadonlyArray<string>,
-	violations: ReadonlyArray<Violation>,
-	levels: ReadonlyMap<string, Level>,
+	existing: readonly BaselineEntry[] | undefined,
+	rules: readonly string[],
+	violations: readonly Violation[],
+	index: RuleIndex,
 ): Adoption => {
 	if (existing !== undefined && rules.length === 0) {
 		return { _tag: "Refused", reasons: ["a baseline exists. Record a rule with --rule <id>, or drop fixed debt with prune."] };
 	}
-	const reasons = rules.flatMap((id) => refusal(id, levels));
+	const reasons = rules.flatMap((id) => refusal(id, index));
 	if (reasons.length > 0) {
 		return { _tag: "Refused", reasons };
 	}
-	const kept = (existing ?? []).filter((entry) => !rules.includes(entry.rule));
-	const adopted = violations.filter((violation) => violation.level === "error" && (rules.length === 0 || rules.includes(violation.rule)));
+	const named = (rule: string): boolean => rules.some((name) => covers(name, rule));
+	const kept = (existing ?? []).filter((entry) => !named(entry.rule));
+	const adopted = violations.filter((violation) => violation.level === "error" && (rules.length === 0 || named(violation.rule)));
 	const added = record(adopted);
 	return { _tag: "Adopted", added: added.length, entries: [...kept, ...added], replaced: (existing ?? []).length - kept.length };
 };
 
 export interface Scope {
-	readonly moves: ReadonlyMap<string, string>;
 	readonly files?: ReadonlySet<string> | undefined;
+	readonly moves: ReadonlyMap<string, string>;
 }
 
 const inScope = (entry: BaselineEntry, scope: Scope): boolean =>
@@ -71,9 +71,9 @@ const destination = (
 };
 
 export const prune = (
-	existing: ReadonlyArray<BaselineEntry>,
-	violations: ReadonlyArray<Violation>,
-	levels: ReadonlyMap<string, Level>,
+	existing: readonly BaselineEntry[],
+	violations: readonly Violation[],
+	index: RuleIndex,
 	scope: Scope = { moves: new Map() },
 ): Pruned => {
 	const current = new Map(record(violations).map((entry) => [keyOf(entry.rule, entry.file), entry]));
@@ -83,7 +83,7 @@ export const prune = (
 		if (!inScope(before, scope)) {
 			return [{ after: before, before }];
 		}
-		const level = levels.get(before.rule);
+		const level = levelOf(index, before.rule);
 		const now = current.get(keyOf(before.rule, before.file)) ?? destination(before, current, scope.moves, taken);
 		if (now === undefined || level === undefined || level === "off") {
 			return [];

package/src/biome/report.ts

@@ -0,0 +1,35 @@
+import { Schema } from "effect";
+import { type BiomeRun, runBiome } from "./run.ts";
+
+const Position = Schema.Struct({ line: Schema.Int });
+
+const Diagnostic = Schema.Struct({
+	category: Schema.optionalKey(Schema.String),
+	location: Schema.Struct({ path: Schema.optionalKey(Schema.String), start: Schema.optionalKey(Position) }),
+	message: Schema.String,
+	severity: Schema.String,
+});
+
+export type Diagnostic = typeof Diagnostic.Type;
+
+const Report = Schema.Struct({
+	diagnostics: Schema.Array(Diagnostic),
+	summary: Schema.Struct({ changed: Schema.Int }),
+});
+
+export type Report = typeof Report.Type;
+
+const decodeReport = Schema.decodeUnknownOption(Schema.fromJsonString(Report));
+
+const failure = (args: readonly string[], run: BiomeRun): Error =>
+	new Error(`biome ${args.join(" ")} exited ${run.code} without a report:\n${[run.stdout, run.stderr].join("\n").trim()}`);
+
+export async function biomeReport(root: string, args: readonly string[]): Promise<Report> {
+	const command = [...args, "--reporter=json", "--max-diagnostics=none", "."];
+	const run = await runBiome(root, command);
+	const report = decodeReport(run.stdout.trim());
+	if (report._tag === "None") {
+		throw failure(command, run);
+	}
+	return report.value;
+}

package/src/biome/run.ts

@@ -0,0 +1,23 @@
+import { execFile } from "node:child_process";
+import { createRequire } from "node:module";
+import process from "node:process";
+
+export interface BiomeRun {
+	readonly code: number;
+	readonly stderr: string;
+	readonly stdout: string;
+}
+
+const BIN = createRequire(import.meta.url).resolve("@biomejs/biome/bin/biome");
+
+export function runBiome(root: string, args: readonly string[]): Promise<BiomeRun> {
+	return new Promise((resolve, reject) => {
+		execFile(process.execPath, [BIN, ...args, "--colors=off"], { cwd: root, maxBuffer: 2 ** 30 }, (error, stdout, stderr) => {
+			if (error !== null && typeof error.code !== "number") {
+				reject(error);
+				return;
+			}
+			resolve({ code: error === null ? 0 : Number(error.code), stderr, stdout });
+		});
+	});
+}

package/src/cli/args.ts

@@ -4,7 +4,8 @@ import type { WarningDetail } from "../report/render.ts";
 
 export type Command =
 	| { readonly _tag: "Lint"; readonly config: string | undefined; readonly warnings: WarningDetail }
-	| { readonly _tag: "BaselineWrite"; readonly config: string | undefined; readonly rules: ReadonlyArray<string> }
+	| { readonly _tag: "Fix"; readonly config: string | undefined }
+	| { readonly _tag: "BaselineWrite"; readonly config: string | undefined; readonly rules: readonly string[] }
 	| { readonly _tag: "BaselinePrune"; readonly config: string | undefined; readonly against: string | undefined }
 	| { readonly _tag: "BaselineCheck"; readonly config: string | undefined; readonly against: string | undefined }
 	| { readonly _tag: "BaselineTighten"; readonly config: string | undefined; readonly staged: boolean }
@@ -15,6 +16,7 @@ export type Parsed = { readonly _tag: "Parsed"; readonly command: Command } | {
 
 export const USAGE = `Usage:
   quality lint [--config <file>] [--warnings summary|all]
+  quality fix [--config <file>]
   quality baseline write [--config <file>] [--rule <id>]...
   quality baseline prune [--config <file>] [--against <ref>]
   quality baseline tighten [--config <file>] [--staged]
@@ -23,6 +25,7 @@ export const USAGE = `Usage:
 
 lint              Run every rule. Exits 1 on an error-level violation, a file over its baseline, a stale registry entry
                   or a baseline entry for a rule that is off or unknown.
+fix               Apply Biome's safe fixes, assist actions and formatting.
 baseline write    Record current error-level violations. Creates the baseline, or records the named rules again, replacing their entries.
 baseline prune    Drop fixed debt, lower entries to what is left and carry entries to files git saw move. Never adds or raises an entry.
 baseline tighten  Prune only the entries of files changed since HEAD, or with --staged, in the index.
@@ -51,15 +54,16 @@ type Values = ReturnType<typeof parseArgs<{ options: typeof OPTIONS; allowPositi
 
 type Option = Exclude<keyof Values, "config" | "help">;
 
-const COMMAND_OPTIONS: ReadonlyArray<Option> = ["against", "from", "rule", "staged", "warnings"];
+const COMMAND_OPTIONS: readonly Option[] = ["against", "from", "rule", "staged", "warnings"];
 
-const ACCEPTS: Readonly<Record<string, ReadonlyArray<Option>>> = {
-	lint: ["warnings"],
-	"baseline write": ["rule"],
-	"baseline prune": ["against"],
-	"baseline tighten": ["staged"],
+const ACCEPTS: Readonly<Record<string, readonly Option[]>> = {
 	"baseline check": ["against"],
 	"baseline migrate": ["from"],
+	"baseline prune": ["against"],
+	"baseline tighten": ["staged"],
+	"baseline write": ["rule"],
+	fix: [],
+	lint: ["warnings"],
 };
 
 const misplaced = (name: string, values: Values): string | undefined => {
@@ -80,6 +84,8 @@ const commandFor = (name: string, values: Values): Parsed => {
 				? parsed({ _tag: "Lint", config, warnings })
 				: usage(`--warnings takes summary or all, not "${warnings}".`);
 		}
+		case "fix":
+			return parsed({ _tag: "Fix", config });
 		case "baseline write":
 			return parsed({ _tag: "BaselineWrite", config, rules: values.rule ?? [] });
 		case "baseline prune":
@@ -93,7 +99,7 @@ const commandFor = (name: string, values: Values): Parsed => {
 	}
 };
 
-export const parseCommand = (args: ReadonlyArray<string>): Parsed => {
+export const parseCommand = (args: readonly string[]): Parsed => {
 	const result = Result.try({
 		catch: (error) => (error instanceof Error ? error.message : String(error)),
 		try: () => parseArgs({ allowPositionals: true, args: [...args], options: OPTIONS, strict: true }),

package/src/cli/baseline.ts

@@ -9,24 +9,23 @@ import { SetupFailure } from "../failure.ts";
 import { writeText } from "../inventory/filesystem.ts";
 import { plural } from "../report/plural.ts";
 
-const save = (session: Session, entries: ReadonlyArray<BaselineEntry>): Effect.Effect<void, SetupFailure, FileSystem.FileSystem> =>
+const save = (session: Session, entries: readonly BaselineEntry[]): Effect.Effect<void, SetupFailure, FileSystem.FileSystem> =>
 	Effect.mapError(
 		writeText(join(session.config.root, session.config.baseline), rewriteBaseline(session.baseline.raw, session.baseline.entries, entries)),
 		(failure) => new SetupFailure({ message: failure.message }),
 	);
 
-const unregistered = (session: Session) =>
-	applyRegistry(session.violations, session.registry, session.config.levels, session.config.unregistrable).kept;
+const unregistered = (session: Session) => applyRegistry(session.violations, session.registry, session.config).kept;
 
 export const writeBaseline = (
 	cwd: string,
 	config: string | undefined,
-	rules: ReadonlyArray<string>,
+	rules: readonly string[],
 ): Effect.Effect<void, SetupFailure, FileSystem.FileSystem> =>
 	Effect.gen(function* () {
 		const session = yield* openSession(cwd, config);
 		const existing = session.baseline.raw === undefined ? undefined : session.baseline.entries;
-		const adoption = adopt(existing, rules, unregistered(session), session.config.levels);
+		const adoption = adopt(existing, rules, unregistered(session), session.config);
 		if (adoption._tag === "Refused") {
 			return yield* new SetupFailure({ message: `baseline write refused:\n${adoption.reasons.map((reason) => `  - ${reason}`).join("\n")}` });
 		}
@@ -57,7 +56,7 @@ export const shrinkBaseline = <Requirements>(
 		if (session.baseline.raw === undefined) {
 			return yield* Console.log(`quality: no baseline at ${session.config.baseline}; nothing to lower.`);
 		}
-		const pruned = prune(session.baseline.entries, unregistered(session), session.config.levels, yield* scopeOf(session));
+		const pruned = prune(session.baseline.entries, unregistered(session), session.config, yield* scopeOf(session));
 		if (pruned.removed === 0 && pruned.lowered === 0 && pruned.moved === 0) {
 			return yield* Console.log(`quality: ${session.config.baseline} is current.`);
 		}

package/src/cli/check.ts

@@ -17,7 +17,7 @@ const baseEntries = (
 	config: ResolvedConfig,
 	base: Base,
 	path: string,
-): Effect.Effect<ReadonlyArray<BaselineEntry>, SetupFailure, FileSystem.FileSystem | Git> =>
+): Effect.Effect<readonly BaselineEntry[], SetupFailure, FileSystem.FileSystem | Git> =>
 	Effect.gen(function* () {
 		const raw = yield* readAt(config.root, base.commit, path);
 		if (raw !== undefined) {

package/src/cli/fix.ts

@@ -0,0 +1,19 @@
+import { Console, Effect, type FileSystem } from "effect";
+import { biomeReport } from "../biome/report.ts";
+import { loadConfig } from "../config/load.ts";
+import { SetupFailure } from "../failure.ts";
+import { sortManifests } from "../manifests/sorted.ts";
+import { plural } from "../report/plural.ts";
+
+export function fix(cwd: string, config: string | undefined): Effect.Effect<void, SetupFailure, FileSystem.FileSystem> {
+	return Effect.gen(function* () {
+		const { root } = yield* loadConfig(cwd, config);
+		const sorted = yield* Effect.mapError(sortManifests(root), (failure) => new SetupFailure({ message: failure.message }));
+		yield* Console.log(`quality: sort-package-json rewrote ${plural(sorted, "manifest")}.`);
+		const report = yield* Effect.tryPromise({
+			catch: (cause) => new SetupFailure({ message: cause instanceof Error ? cause.message : String(cause) }),
+			try: () => biomeReport(root, ["check", "--write"]),
+		});
+		yield* Console.log(`quality: Biome rewrote ${plural(report.summary.changed, "file")}.`);
+	});
+}

package/src/cli/lint.ts

@@ -11,7 +11,7 @@ export const lint = (
 ): Effect.Effect<void, SetupFailure | GateFailed, FileSystem.FileSystem> =>
 	Effect.gen(function* () {
 		const session = yield* openSession(cwd, config);
-		const outcome = evaluate(session.violations, session.registry, session.baseline.entries, session.config.levels, session.config.unregistrable);
+		const outcome = evaluate(session.violations, session.registry, session.baseline.entries, session.config);
 		yield* Console.log(
 			render(outcome, {
 				baseline: session.config.baseline,

package/src/cli/run-main.ts

@@ -1,3 +1,4 @@
+import process from "node:process";
 import * as NodeChildProcessSpawner from "@effect/platform-node/NodeChildProcessSpawner";
 import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
 import * as NodePath from "@effect/platform-node/NodePath";
@@ -20,11 +21,15 @@ const explain = (cause: Cause.Cause<unknown>): Effect.Effect<void> => {
 const exitCodeOf = (error: unknown): number =>
 	typeof error === "object" && error !== null && Runtime.errorExitCode in error ? Runtime.getErrorExitCode(error) : COULD_NOT_RUN;
 
-const teardown: Runtime.Teardown = (exit, onExit) => {
+const exitCode = (exit: Exit.Exit<unknown, unknown>): number => {
 	if (Exit.isSuccess(exit)) {
-		return onExit(0);
+		return 0;
 	}
-	return onExit(Cause.hasInterruptsOnly(exit.cause) ? INTERRUPTED : exitCodeOf(Cause.squash(exit.cause)));
+	return Cause.hasInterruptsOnly(exit.cause) ? INTERRUPTED : exitCodeOf(Cause.squash(exit.cause));
+};
+
+const teardown: Runtime.Teardown = (exit, onExit) => {
+	process.stdout.write("", () => process.stderr.write("", () => onExit(exitCode(exit))));
 };
 
 const services = NodeChildProcessSpawner.layer.pipe(Layer.provideMerge(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer)));

package/src/cli.ts

@@ -4,6 +4,7 @@ import { Console, Effect } from "effect";
 import { parseCommand, USAGE } from "./cli/args.ts";
 import { writeBaseline } from "./cli/baseline.ts";
 import { checkBaseline } from "./cli/check.ts";
+import { fix } from "./cli/fix.ts";
 import { lint } from "./cli/lint.ts";
 import { migrateBaseline } from "./cli/migrate.ts";
 import { runMain } from "./cli/run-main.ts";
@@ -22,6 +23,8 @@ const program = Effect.gen(function* () {
 			return yield* Console.log(USAGE);
 		case "Lint":
 			return yield* lint(process.cwd(), command.config, command.warnings);
+		case "Fix":
+			return yield* fix(process.cwd(), command.config);
 		case "BaselineWrite":
 			return yield* writeBaseline(process.cwd(), command.config, command.rules);
 		case "BaselinePrune":

package/src/config/decode.ts

@@ -3,14 +3,14 @@ import { type Decoded, decodeWith } from "../decoded.ts";
 import type { Rule } from "../rule.ts";
 
 const isRule = (value: unknown): value is Rule =>
-	typeof value === "object" &&
-	value !== null &&
-	"id" in value &&
-	typeof value.id === "string" &&
-	"description" in value &&
-	typeof value.description === "string" &&
-	"configure" in value &&
-	typeof value.configure === "function";
+	typeof value === "object"
+	&& value !== null
+	&& "id" in value
+	&& typeof value.id === "string"
+	&& "description" in value
+	&& typeof value.description === "string"
+	&& "configure" in value
+	&& typeof value.configure === "function";
 
 const Level = Schema.Literals(["error", "warn", "off"]);
 
@@ -19,14 +19,14 @@ const Setting = Schema.Union([Level, Schema.Struct({ level: Schema.optionalKey(L
 const LocalRule = Schema.declare(isRule, { expected: "a rule made with defineRule" });
 
 const ConfigInput = Schema.Struct({
-	sources: Schema.optionalKey(Schema.Array(Schema.String)),
+	adopt: Schema.optionalKey(Schema.Array(Schema.String)),
+	baseline: Schema.optionalKey(Schema.String),
 	exclude: Schema.optionalKey(Schema.Array(Schema.String)),
 	extensions: Schema.optionalKey(Schema.Array(Schema.String)),
-	registry: Schema.optionalKey(Schema.String),
-	baseline: Schema.optionalKey(Schema.String),
-	adopt: Schema.optionalKey(Schema.Array(Schema.String)),
 	local: Schema.optionalKey(Schema.Array(LocalRule)),
+	registry: Schema.optionalKey(Schema.String),
 	rules: Schema.optionalKey(Schema.Record(Schema.String, Setting)),
+	sources: Schema.optionalKey(Schema.Array(Schema.String)),
 });
 
 export type ConfigInput = typeof ConfigInput.Type;

package/src/config/load.ts

@@ -11,11 +11,11 @@ import { type ResolvedRules, resolveRules } from "./resolve.ts";
 const DEFAULT_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 
 export interface ResolvedConfig extends ResolvedRules, InventoryScope {
-	readonly root: string;
+	readonly adopt: readonly string[];
+	readonly baseline: string;
 	readonly file: string;
 	readonly registry: string;
-	readonly baseline: string;
-	readonly adopt: ReadonlyArray<string>;
+	readonly root: string;
 }
 
 const messageOf = (cause: unknown): string => (cause instanceof Error ? cause.message : String(cause));
@@ -23,8 +23,8 @@ const messageOf = (cause: unknown): string => (cause instanceof Error ? cause.me
 const importDefault = (file: string): Effect.Effect<unknown, SetupFailure> =>
 	Effect.flatMap(
 		Effect.tryPromise({
-			try: async (): Promise<unknown> => import(pathToFileURL(file).href),
 			catch: (cause) => new SetupFailure({ message: `cannot load ${file}: ${messageOf(cause)}` }),
+			try: async (): Promise<unknown> => import(pathToFileURL(file).href),
 		}),
 		(loaded) =>
 			typeof loaded === "object" && loaded !== null && "default" in loaded