@shivaedev/quality 0.23.0 → 0.25.0

package/src/baseline/update.ts

@@ -13,8 +13,8 @@ export interface Pruned {
 	readonly removed: number;
 }
 
-const record = (violations: readonly Violation[]): readonly BaselineEntry[] =>
-	[...groupBy(violations, (violation) => keyOf(violation.rule, violation.file)).values()].flatMap((group) => {
+function record(violations: readonly Violation[]): readonly BaselineEntry[] {
+	return [...groupBy(violations, (violation) => keyOf(violation.rule, violation.file)).values()].flatMap((group) => {
 		const first = group[0];
 		if (first === undefined) {
 			return [];
@@ -22,21 +22,22 @@ const record = (violations: readonly Violation[]): readonly BaselineEntry[] =>
 		const count = countOf(group);
 		return count > 0 ? [{ count, file: first.file, rule: first.rule }] : [];
 	});
+}
 
-const refusal = (id: string, index: RuleIndex): readonly string[] => {
+function 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.`];
 	}
-	return level === "error" ? [] : [`${id}: the rule is ${level}. Set it to error before baselining it.`];
-};
+	return [];
+}
 
-export const adopt = (
+export function adopt(
 	existing: readonly BaselineEntry[] | undefined,
 	rules: readonly string[],
 	violations: readonly Violation[],
 	index: RuleIndex,
-): Adoption => {
+): 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."] };
 	}
@@ -44,38 +45,41 @@ export const adopt = (
 	if (reasons.length > 0) {
 		return { _tag: "Refused", reasons };
 	}
-	const named = (rule: string): boolean => rules.some((name) => covers(name, rule));
+	function named(rule: string): boolean {
+		return 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 adopted = violations.filter((violation) => 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 files?: ReadonlySet<string> | undefined;
 	readonly moves: ReadonlyMap<string, string>;
 }
 
-const inScope = (entry: BaselineEntry, scope: Scope): boolean =>
-	scope.files === undefined || scope.files.has(entry.file) || scope.moves.has(entry.file);
+function inScope(entry: BaselineEntry, scope: Scope): boolean {
+	return scope.files === undefined || scope.files.has(entry.file) || scope.moves.has(entry.file);
+}
 
-const destination = (
+function destination(
 	before: BaselineEntry,
 	current: ReadonlyMap<string, BaselineEntry>,
 	moves: ReadonlyMap<string, string>,
 	taken: ReadonlySet<string>,
-) => {
+) {
 	const to = moves.get(before.file);
 	const key = to === undefined ? undefined : keyOf(before.rule, to);
 	return key === undefined || taken.has(key) ? undefined : current.get(key);
-};
+}
 
-export const prune = (
+export function prune(
 	existing: readonly BaselineEntry[],
 	violations: readonly Violation[],
 	index: RuleIndex,
 	scope: Scope = { moves: new Map() },
-): Pruned => {
+): Pruned {
 	const current = new Map(record(violations).map((entry) => [keyOf(entry.rule, entry.file), entry]));
 	const taken = new Set(existing.map((entry) => keyOf(entry.rule, entry.file)));
 	let moved = 0;
@@ -85,7 +89,7 @@ export const prune = (
 		}
 		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") {
+		if (now === undefined || level === undefined) {
 			return [];
 		}
 		moved += Number(now.file !== before.file);
@@ -97,4 +101,4 @@ export const prune = (
 		moved,
 		removed: existing.length - kept.length,
 	};
-};
+}

package/src/cli/args.ts

@@ -1,10 +1,9 @@
 import { parseArgs } from "node:util";
 import { Result } from "effect";
-import type { WarningDetail } from "#report/render.ts";
 import { ADOPT_REMOVED, USAGE as COMMAND_USAGE } from "./messages.ts";
 
 export type Command =
-	| { readonly _tag: "Lint"; readonly config: string | undefined; readonly warnings: WarningDetail }
+	| { readonly _tag: "Lint"; readonly config: string | undefined }
 	| { readonly _tag: "ExceptionsMigrate"; readonly config: string | undefined; readonly from: string | undefined }
 	| { readonly _tag: "Fix"; readonly config: string | undefined }
 	| { readonly _tag: "BaselineWrite"; readonly config: string | undefined; readonly rules: readonly string[] }
@@ -28,10 +27,11 @@ const OPTIONS = {
 	help: { short: "h", type: "boolean" },
 	rule: { multiple: true, type: "string" },
 	staged: { type: "boolean" },
-	warnings: { type: "string" },
 } as const;
 
-const usage = (problem: string): Parsed => ({ _tag: "Usage", problem });
+function usage(problem: string): Parsed {
+	return { _tag: "Usage", problem };
+}
 
 const SUBCOMMANDS: Readonly<Record<string, string>> = {
 	baseline: "baseline takes write, prune, tighten or migrate.",
@@ -39,13 +39,15 @@ const SUBCOMMANDS: Readonly<Record<string, string>> = {
 	hooks: "hooks takes install, uninstall or pre-commit.",
 };
 
-const parsed = (command: Command): Parsed => ({ _tag: "Parsed", command });
+function parsed(command: Command): Parsed {
+	return { _tag: "Parsed", command };
+}
 
 type Values = ReturnType<typeof parseArgs<{ options: typeof OPTIONS; allowPositionals: true }>>["values"];
 
 type Option = Exclude<keyof Values, "config" | "help">;
 
-const COMMAND_OPTIONS: readonly Option[] = ["against", "force", "from", "rule", "staged", "warnings"];
+const COMMAND_OPTIONS: readonly Option[] = ["against", "force", "from", "rule", "staged"];
 
 const ACCEPTS: Readonly<Record<string, readonly Option[]>> = {
 	"baseline migrate": ["from"],
@@ -57,27 +59,24 @@ const ACCEPTS: Readonly<Record<string, readonly Option[]>> = {
 	"hooks install": ["force"],
 	"hooks pre-commit": [],
 	"hooks uninstall": [],
-	lint: ["warnings"],
+	lint: [],
 };
 
-const misplaced = (name: string, values: Values): string | undefined => {
+function misplaced(name: string, values: Values): string | undefined {
 	const option = COMMAND_OPTIONS.find((key) => values[key] !== undefined && !(ACCEPTS[name] ?? []).includes(key));
 	const owners = Object.keys(ACCEPTS).filter((owner) => option !== undefined && (ACCEPTS[owner] ?? []).includes(option));
 	return option === undefined ? undefined : `--${option} applies only to ${owners.join(" and ")}.`;
-};
+}
 
-const ref = (against: string | undefined, command: Command): Parsed =>
-	against?.startsWith("-") === true ? usage(`--against takes a git ref, not "${against}".`) : parsed(command);
+function ref(against: string | undefined, command: Command): Parsed {
+	return against?.startsWith("-") === true ? usage(`--against takes a git ref, not "${against}".`) : parsed(command);
+}
 
-const commandFor = (name: string, values: Values): Parsed => {
+function commandFor(name: string, values: Values): Parsed {
 	const config = values.config;
 	switch (name) {
-		case "lint": {
-			const warnings = values.warnings ?? "summary";
-			return warnings === "summary" || warnings === "all"
-				? parsed({ _tag: "Lint", config, warnings })
-				: usage(`--warnings takes summary or all, not "${warnings}".`);
-		}
+		case "lint":
+			return parsed({ _tag: "Lint", config });
 		case "exceptions migrate":
 			return parsed({ _tag: "ExceptionsMigrate", config, from: values.from });
 		case "fix":
@@ -97,9 +96,9 @@ const commandFor = (name: string, values: Values): Parsed => {
 		default:
 			return parsed({ _tag: "BaselineMigrate", config, from: values.from });
 	}
-};
+}
 
-export const parseCommand = (args: readonly string[]): Parsed => {
+export function 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 }),
@@ -122,4 +121,4 @@ export const parseCommand = (args: readonly string[]): Parsed => {
 	}
 	const problem = misplaced(name, values);
 	return problem === undefined ? commandFor(name, values) : usage(problem);
-};
+}

package/src/cli/baseline.ts

@@ -9,57 +9,58 @@ import { SetupFailure } from "#failure.ts";
 import { writeText } from "#inventory/filesystem.ts";
 import { plural } from "#report/plural.ts";
 
-const save = (session: Session, entries: readonly BaselineEntry[]): Effect.Effect<void, SetupFailure, FileSystem.FileSystem> =>
-	Effect.mapError(
+function save(session: Session, entries: readonly BaselineEntry[]): Effect.Effect<void, SetupFailure, FileSystem.FileSystem> {
+	return 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).kept;
+function unregistered(session: Session) {
+	return applyRegistry(session.violations, session.registry, session.config).kept;
+}
 
-export const writeBaseline = (
+export const writeBaseline = Effect.fn("Cli.writeBaseline")(function* (
 	cwd: string,
 	config: string | undefined,
 	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);
-		if (adoption._tag === "Refused") {
-			return yield* new SetupFailure({ message: `baseline write refused:\n${adoption.reasons.map((reason) => `  - ${reason}`).join("\n")}` });
-		}
-		if (adoption.added === 0 && adoption.replaced === 0) {
-			return yield* Console.log(`quality: no error-level violations to record; ${session.config.baseline} is unchanged.`);
-		}
-		yield* save(session, adoption.entries);
-		const replaced = adoption.replaced > 0 ? `, replacing ${plural(adoption.replaced, "entry", "entries")}` : "";
-		yield* Console.log(`quality: recorded ${plural(adoption.added, "entry", "entries")} in ${session.config.baseline}${replaced}.`);
-	});
+): Effect.fn.Return<void, SetupFailure, FileSystem.FileSystem> {
+	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);
+	if (adoption._tag === "Refused") {
+		return yield* new SetupFailure({ message: `baseline write refused:\n${adoption.reasons.map((reason) => `  - ${reason}`).join("\n")}` });
+	}
+	if (adoption.added === 0 && adoption.replaced === 0) {
+		return yield* Console.log(`quality: no error-level violations to record; ${session.config.baseline} is unchanged.`);
+	}
+	yield* save(session, adoption.entries);
+	const replaced = adoption.replaced > 0 ? `, replacing ${plural(adoption.replaced, "entry", "entries")}` : "";
+	yield* Console.log(`quality: recorded ${plural(adoption.added, "entry", "entries")} in ${session.config.baseline}${replaced}.`);
+});
 
-const changes = (pruned: Pruned): string => {
+function changes(pruned: Pruned): string {
 	const parts = [
 		`removed ${plural(pruned.removed, "entry", "entries")}`,
 		`lowered ${plural(pruned.lowered, "entry", "entries")}`,
 		...(pruned.moved > 0 ? [`carried ${plural(pruned.moved, "entry", "entries")} to moved files`] : []),
 	];
 	return `${parts.slice(0, -1).join(", ")} and ${parts.at(-1)}`;
-};
+}
 
-export const shrinkBaseline = <TRequirements>(
+export const shrinkBaseline = Effect.fn("Cli.shrinkBaseline")(function* <TRequirements>(
 	cwd: string,
 	config: string | undefined,
 	scopeOf: (session: Session) => Effect.Effect<Scope, SetupFailure, TRequirements>,
-): Effect.Effect<void, SetupFailure, FileSystem.FileSystem | TRequirements> =>
-	Effect.gen(function* () {
-		const session = yield* openSession(cwd, config);
-		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, yield* scopeOf(session));
-		if (pruned.removed === 0 && pruned.lowered === 0 && pruned.moved === 0) {
-			return yield* Console.log(`quality: ${session.config.baseline} is current.`);
-		}
-		yield* save(session, pruned.entries);
-		yield* Console.log(`quality: ${changes(pruned)} in ${session.config.baseline}.`);
-	});
+): Effect.fn.Return<void, SetupFailure, FileSystem.FileSystem | TRequirements> {
+	const session = yield* openSession(cwd, config);
+	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, yield* scopeOf(session));
+	if (pruned.removed === 0 && pruned.lowered === 0 && pruned.moved === 0) {
+		return yield* Console.log(`quality: ${session.config.baseline} is current.`);
+	}
+	yield* save(session, pruned.entries);
+	yield* Console.log(`quality: ${changes(pruned)} in ${session.config.baseline}.`);
+});

package/src/cli/fix.ts

@@ -4,7 +4,7 @@ import { biomeReport, type Report } from "#biome/report.ts";
 import { loadConfig } from "#config/load.ts";
 import type { ExceptionDeclaration } from "#exceptions/declaration.ts";
 import { SetupFailure } from "#failure.ts";
-import { posix } from "#inventory/ignore-scope.ts";
+import { posix } from "#inventory/ignoreScope.ts";
 import { walk } from "#inventory/walk.ts";
 import { sortManifests } from "#manifests/sorted.ts";
 import { plural } from "#report/plural.ts";
@@ -62,24 +62,22 @@ function biomePasses(root: string, exceptions: readonly ExceptionDeclaration[]):
 	];
 }
 
-function round<TFailure, TRequirements>(
+const round = Effect.fn("Cli.round")(function* <TFailure, TRequirements>(
 	passes: readonly Pass<TFailure, TRequirements>[],
 	index: number,
 	afterEachPass: Effect.Effect<void, TFailure, TRequirements>,
-): Effect.Effect<number, TFailure, TRequirements> {
-	return Effect.gen(function* () {
-		let total = 0;
-		const parts: string[] = [];
-		for (const pass of passes) {
-			const changed = yield* pass.run;
-			total += changed;
-			parts.push(`${plural(changed, "file")} ${pass.label}`);
-			yield* afterEachPass;
-		}
-		yield* Console.log(`quality: Biome round ${index} rewrote ${parts.join(" and ")}.`);
-		return total;
-	});
-}
+): Effect.fn.Return<number, TFailure, TRequirements> {
+	let total = 0;
+	const parts: string[] = [];
+	for (const pass of passes) {
+		const changed = yield* pass.run;
+		total += changed;
+		parts.push(`${plural(changed, "file")} ${pass.label}`);
+		yield* afterEachPass;
+	}
+	yield* Console.log(`quality: Biome round ${index} rewrote ${parts.join(" and ")}.`);
+	return total;
+});
 
 function changedBetween(before: ReadonlyMap<string, string>, after: ReadonlyMap<string, string>): readonly string[] {
 	return [...new Set([...before.keys(), ...after.keys()])].filter((path) => before.get(path) !== after.get(path));
@@ -100,36 +98,35 @@ function unsettled(changed: ReadonlySet<string>): SetupFailure {
 	});
 }
 
-export function settle<TFailure, TRequirements>({
+export const settle = Effect.fn("Cli.settle")(function* <TFailure, TRequirements>({
 	passes,
 	snapshot,
-}: Settling<TFailure, TRequirements>): Effect.Effect<void, TFailure | SetupFailure, TRequirements> {
-	return Effect.gen(function* () {
-		for (let index = 1; index < MAX_FIX_ROUNDS; index += 1) {
-			if ((yield* round(passes, index, Effect.void)) === 0) {
-				return;
-			}
-		}
-		const changed = new Set<string>();
-		let previous = yield* snapshot;
-		const record = Effect.map(snapshot, (current) => {
-			for (const path of changedBetween(previous, current)) {
-				changed.add(path);
-			}
-			previous = current;
-		});
-		if ((yield* round(passes, MAX_FIX_ROUNDS, record)) === 0) {
+}: Settling<TFailure, TRequirements>): Effect.fn.Return<void, TFailure | SetupFailure, TRequirements> {
+	for (let index = 1; index < MAX_FIX_ROUNDS; index += 1) {
+		if ((yield* round(passes, index, Effect.void)) === 0) {
 			return;
 		}
-		return yield* unsettled(changed);
+	}
+	const changed = new Set<string>();
+	let previous = yield* snapshot;
+	const record = Effect.map(snapshot, (current) => {
+		for (const path of changedBetween(previous, current)) {
+			changed.add(path);
+		}
+		previous = current;
 	});
-}
+	if ((yield* round(passes, MAX_FIX_ROUNDS, record)) === 0) {
+		return;
+	}
+	return yield* unsettled(changed);
+});
 
-export function fix(cwd: string, config: string | undefined): Effect.Effect<void, SetupFailure, FileSystem.FileSystem> {
-	return Effect.gen(function* () {
-		const { root, exceptions } = 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")}.`);
-		yield* settle({ passes: biomePasses(root, exceptions), snapshot: snapshotOf(root) });
-	});
-}
+export const fix = Effect.fn("Cli.fix")(function* (
+	cwd: string,
+	config: string | undefined,
+): Effect.fn.Return<void, SetupFailure, FileSystem.FileSystem> {
+	const { root, exceptions } = 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")}.`);
+	yield* settle({ passes: biomePasses(root, exceptions), snapshot: snapshotOf(root) });
+});

package/src/cli/lint.ts

@@ -3,27 +3,23 @@ import { Console, Effect, type FileSystem } from "effect";
 import { evaluate, passes } from "#engine/evaluate.ts";
 import { openSession } from "#engine/session.ts";
 import { GateFailed, type SetupFailure } from "#failure.ts";
-import { render, type WarningDetail } from "#report/render.ts";
+import { render } from "#report/render.ts";
 
-export const lint = (
+export const lint = Effect.fn("Cli.lint")(function* (
 	cwd: string,
 	config: string | undefined,
-	warnings: WarningDetail,
-): 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);
-		yield* Console.log(
-			render(outcome, {
-				baseline: session.config.baseline,
-				checked: session.inventory.sources.length,
-				descriptions: new Map(session.config.active.map((rule) => [rule.id, rule.description])),
-				registry:
-					session.config.exceptions.length === 0 ? session.config.registry : `${relative(session.config.root, session.config.file)} exceptions`,
-				warnings,
-			}),
-		);
-		if (!passes(outcome)) {
-			return yield* new GateFailed();
-		}
-	});
+): Effect.fn.Return<void, SetupFailure | GateFailed, FileSystem.FileSystem> {
+	const session = yield* openSession(cwd, config);
+	const outcome = evaluate(session.violations, session.registry, session.baseline.entries, session.config);
+	yield* Console.log(
+		render(outcome, {
+			baseline: session.config.baseline,
+			checked: session.inventory.sources.length,
+			descriptions: new Map(session.config.active.map((rule) => [rule.id, rule.description])),
+			registry: session.config.exceptions.length === 0 ? session.config.registry : `${relative(session.config.root, session.config.file)} exceptions`,
+		}),
+	);
+	if (!passes(outcome)) {
+		return yield* new GateFailed();
+	}
+});

package/src/cli/messages.ts

@@ -1,5 +1,5 @@
 export const USAGE = `Usage:
-  quality lint [--config <file>] [--warnings summary|all]
+  quality lint [--config <file>]
   quality fix [--config <file>]
   quality exceptions migrate [--config <file>] [--from <registry>]
   quality baseline write [--config <file>] [--rule <id>]...
@@ -11,7 +11,7 @@ export const USAGE = `Usage:
   quality hooks pre-commit [--config <file>]
 
 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.
+                  or a baseline entry for an unknown rule.
 fix               Sort every package.json, apply Biome's lint fixes, unsafe ones included, its assist actions and formatting, then format again.
 exceptions migrate Move legacy registry entries and Biome declarations into quality.config.ts exceptions and remove matching root overrides.
 baseline write    Record current error-level violations. Creates the baseline, or records the named rules again, replacing their entries.

package/src/cli/migrate.ts

@@ -4,33 +4,32 @@ import { encodeBaseline } from "#baseline/format.ts";
 import { convertLegacy, decodeLegacyBaseline, LEGACY_BASELINE } from "#baseline/legacy.ts";
 import { loadConfig } from "#config/load.ts";
 import { validOrFail } from "#decoded.ts";
-import { readInput } from "#engine/baseline-file.ts";
+import { readInput } from "#engine/baselineFile.ts";
 import { scan } from "#engine/session.ts";
 import { SetupFailure } from "#failure.ts";
 import { writeText } from "#inventory/filesystem.ts";
 import { plural } from "#report/plural.ts";
 
-export const migrateBaseline = (
+export const migrateBaseline = Effect.fn("Cli.migrateBaseline")(function* (
 	cwd: string,
 	configPath: string | undefined,
 	from: string | undefined,
-): Effect.Effect<void, SetupFailure, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		const config = yield* loadConfig(cwd, configPath);
-		const source = from ?? LEGACY_BASELINE;
-		if (source === config.baseline || (yield* readInput(config.root, config.baseline)) !== undefined) {
-			return yield* new SetupFailure({ message: `${config.baseline} already exists. Migrate into a baseline file that does not exist yet.` });
-		}
-		const raw = yield* readInput(config.root, source);
-		if (raw === undefined) {
-			return yield* new SetupFailure({ message: `no baseline at ${source} to migrate. Name it with --from <file>.` });
-		}
-		const legacy = yield* validOrFail(source, yield* Effect.promise(() => decodeLegacyBaseline(raw)));
-		const entries = convertLegacy(legacy, (yield* scan(config)).violations);
-		const fs = yield* FileSystem.FileSystem;
-		const written = Effect.andThen(writeText(join(config.root, config.baseline), encodeBaseline(entries)), fs.remove(join(config.root, source)));
-		yield* Effect.mapError(written, (failure) => new SetupFailure({ message: failure.message }));
-		const fixed = legacy.length - entries.length;
-		const dropped = fixed > 0 ? `, dropping ${plural(fixed, "fixed entry", "fixed entries")}` : "";
-		yield* Console.log(`quality: moved ${plural(entries.length, "entry", "entries")} from ${source} to ${config.baseline}${dropped}.`);
-	});
+): Effect.fn.Return<void, SetupFailure, FileSystem.FileSystem> {
+	const config = yield* loadConfig(cwd, configPath);
+	const source = from ?? LEGACY_BASELINE;
+	if (source === config.baseline || (yield* readInput(config.root, config.baseline)) !== undefined) {
+		return yield* new SetupFailure({ message: `${config.baseline} already exists. Migrate into a baseline file that does not exist yet.` });
+	}
+	const raw = yield* readInput(config.root, source);
+	if (raw === undefined) {
+		return yield* new SetupFailure({ message: `no baseline at ${source} to migrate. Name it with --from <file>.` });
+	}
+	const legacy = yield* validOrFail(source, yield* Effect.promise(() => decodeLegacyBaseline(raw)));
+	const entries = convertLegacy(legacy, (yield* scan(config)).violations);
+	const fs = yield* FileSystem.FileSystem;
+	const written = Effect.andThen(writeText(join(config.root, config.baseline), encodeBaseline(entries)), fs.remove(join(config.root, source)));
+	yield* Effect.mapError(written, (failure) => new SetupFailure({ message: failure.message }));
+	const fixed = legacy.length - entries.length;
+	const dropped = fixed > 0 ? `, dropping ${plural(fixed, "fixed entry", "fixed entries")}` : "";
+	yield* Console.log(`quality: moved ${plural(entries.length, "entry", "entries")} from ${source} to ${config.baseline}${dropped}.`);
+});

package/src/cli/migrateExceptions.ts

@@ -2,7 +2,7 @@ import { join } from "node:path";
 import { Console, Effect, FileSystem } from "effect";
 import { loadConfig } from "#config/load.ts";
 import { validOrFail } from "#decoded.ts";
-import { readInput } from "#engine/baseline-file.ts";
+import { readInput } from "#engine/baselineFile.ts";
 import { decodeExceptions, type ExceptionDeclaration } from "#exceptions/declaration.ts";
 import { migrateBiome } from "#exceptions/migrateBiome.ts";
 import { migrateConfig } from "#exceptions/migrateConfig.ts";

package/src/cli/program.ts

@@ -27,7 +27,7 @@ export const program = Effect.fn("Cli.program")(function* (args: readonly string
 		case "Help":
 			return yield* Console.log(USAGE);
 		case "Lint":
-			return yield* lint(cwd, command.config, command.warnings);
+			return yield* lint(cwd, command.config);
 		case "Fix":
 			return yield* fix(cwd, command.config);
 		case "BaselineWrite":

package/src/cli/{run-main.ts → runMain.ts}

@@ -30,9 +30,9 @@ export function exitCode(exit: Exit.Exit<unknown, unknown>): number {
 	return Cause.hasInterruptsOnly(exit.cause) ? INTERRUPTED : exitCodeOf(Cause.squash(exit.cause));
 }
 
-const teardown: Runtime.Teardown = (exit, onExit) => {
+function teardown(exit: Parameters<Runtime.Teardown>[0], onExit: Parameters<Runtime.Teardown>[1]): void {
 	process.stdout.write("", () => process.stderr.write("", () => onExit(exitCode(exit))));
-};
+}
 
 function isClosedPipe(error: unknown): boolean {
 	return error instanceof Error && "code" in error && error.code === "EPIPE";

package/src/cli/shrink.ts

@@ -6,8 +6,8 @@ import type { Git } from "#git/command.ts";
 import { changesSince } from "#git/history.ts";
 import { shrinkBaseline } from "./baseline.ts";
 
-const followedMoves = (root: string, against: string | undefined): Effect.Effect<Scope, SetupFailure, Git> =>
-	resolveBase(root, against).pipe(
+function followedMoves(root: string, against: string | undefined): Effect.Effect<Scope, SetupFailure, Git> {
+	return resolveBase(root, against).pipe(
 		Effect.flatMap((base) => changesSince(root, [base.commit])),
 		Effect.map((changes): Scope => ({ moves: changes.moves })),
 		Effect.catchIf(
@@ -15,17 +15,20 @@ const followedMoves = (root: string, against: string | undefined): Effect.Effect
 			(failure) => Effect.as(Console.error(`quality: moved files are not followed: ${failure.message}`), { moves: new Map() }),
 		),
 	);
+}
 
-export const pruneBaseline = (
+export function pruneBaseline(
 	cwd: string,
 	config: string | undefined,
 	against: string | undefined,
-): Effect.Effect<void, SetupFailure, FileSystem.FileSystem | Git> =>
-	shrinkBaseline(cwd, config, (session) => followedMoves(session.config.root, against));
+): Effect.Effect<void, SetupFailure, FileSystem.FileSystem | Git> {
+	return shrinkBaseline(cwd, config, (session) => followedMoves(session.config.root, against));
+}
 
-export const tightenBaseline = (
+export function tightenBaseline(
 	cwd: string,
 	config: string | undefined,
 	staged: boolean,
-): Effect.Effect<void, SetupFailure, FileSystem.FileSystem | Git> =>
-	shrinkBaseline(cwd, config, (session) => changesSince(session.config.root, staged ? ["--cached"] : ["HEAD"]));
+): Effect.Effect<void, SetupFailure, FileSystem.FileSystem | Git> {
+	return shrinkBaseline(cwd, config, (session) => changesSince(session.config.root, staged ? ["--cached"] : ["HEAD"]));
+}

package/src/cli.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import process from "node:process";
 import { program } from "#cli/program.ts";
-import { runMain } from "#cli/run-main.ts";
+import { runMain } from "#cli/runMain.ts";
 
 runMain(program(process.argv.slice(2), { cwd: process.cwd(), launch: { options: process.execArgv, script: process.argv[1] ?? "" } }));