@shivaedev/quality 0.2.0 → 0.3.0

package/src/baseline/format.ts

@@ -1,53 +1,56 @@
 import { Schema } from "effect";
 import { type Decoded, decodeWith } from "../decoded.ts";
+import { keyOf } from "../engine/violation.ts";
 
-const Entry = Schema.Struct({
+const Line = Schema.Struct({
+	path: Schema.NonEmptyString,
+	rule: Schema.NonEmptyString,
 	count: Schema.Int.check(Schema.isGreaterThan(0)),
-	measure: Schema.optionalKey(Schema.Finite),
 });
 
-const BaselineFile = Schema.Record(Schema.String, Schema.Record(Schema.String, Entry));
-
-const standard = Schema.toStandardSchemaV1(Schema.fromJsonString(BaselineFile), { parseOptions: { errors: "all", onExcessProperty: "error" } });
+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 measure?: number | undefined;
 }
 
-type Stored = typeof Entry.Type;
-
 const codepoints = (left: string, right: string): number => (left < right ? -1 : Number(left > right));
 
-export const byRuleAndFile = (left: BaselineEntry, right: BaselineEntry): number =>
-	codepoints(left.rule, right.rule) || codepoints(left.file, right.file);
+export const byPathAndRule = (left: BaselineEntry, right: BaselineEntry): number =>
+	codepoints(left.file, right.file) || codepoints(left.rule, right.rule);
+
+export const linesOf = (raw: string | undefined): ReadonlyArray<{ readonly line: number; readonly text: string }> =>
+	(raw ?? "")
+		.split("\n")
+		.map((text, index) => ({ line: index + 1, text }))
+		.filter((row) => row.text.trim() !== "");
 
 export const decodeBaseline = async (raw: string | undefined): Promise<Decoded<ReadonlyArray<BaselineEntry>>> => {
-	if (raw === undefined) {
-		return { _tag: "Valid", value: [] };
-	}
-	const decoded = await decodeWith(standard, raw);
-	if (decoded._tag === "Invalid") {
-		return decoded;
+	const issues: string[] = [];
+	const entries: BaselineEntry[] = [];
+	const seen = new Set<string>();
+	for (const { line, text } of linesOf(raw)) {
+		const decoded = await decodeWith(standard, text);
+		if (decoded._tag === "Invalid") {
+			issues.push(...decoded.issues.map((issue) => `line ${line}: ${issue}`));
+			continue;
+		}
+		const { path, ...stored } = decoded.value;
+		if (seen.has(keyOf(stored.rule, path))) {
+			issues.push(`line ${line}: repeats the entry for ${stored.rule} in ${path}`);
+		}
+		seen.add(keyOf(stored.rule, path));
+		entries.push({ ...stored, file: path });
 	}
-	const entries = Object.entries(decoded.value).flatMap(([rule, files]) =>
-		Object.entries(files).map(([file, stored]) => ({ ...stored, file, rule })),
-	);
-	return { _tag: "Valid", value: entries };
+	return issues.length === 0 ? { _tag: "Valid", value: entries } : { _tag: "Invalid", issues };
 };
 
-const stored = (entry: BaselineEntry): Stored =>
-	entry.measure === undefined ? { count: entry.count } : { count: entry.count, measure: entry.measure };
-
-export const encodeBaseline = (entries: ReadonlyArray<BaselineEntry>, indent: string): string => {
-	const rules: Record<string, Record<string, Stored>> = {};
-	for (const entry of [...entries].sort(byRuleAndFile)) {
-		rules[entry.rule] = { ...rules[entry.rule], [entry.file]: stored(entry) };
-	}
-	return `${JSON.stringify(rules, null, indent)}\n`;
-};
+export const encodeEntry = (entry: BaselineEntry): string => JSON.stringify({ path: entry.file, rule: entry.rule, count: entry.count });
 
-/** Keeps the indentation of the file being rewritten, so the repository formatter leaves it alone. */
-export const indentOf = (raw: string | undefined): string => /^([ \t]+)\S/m.exec(raw ?? "")?.[1] ?? "\t";
+export const encodeBaseline = (entries: ReadonlyArray<BaselineEntry>): string =>
+	[...entries]
+		.sort(byPathAndRule)
+		.map((entry) => `${encodeEntry(entry)}\n`)
+		.join("");

package/src/baseline/guard.ts

@@ -0,0 +1,47 @@
+import { groupBy, keyOf } from "../engine/violation.ts";
+import type { BaselineEntry } from "./format.ts";
+
+export type GuardProblem =
+	| { readonly _tag: "Added"; readonly entry: BaselineEntry }
+	| { readonly _tag: "Raised"; readonly entry: BaselineEntry; readonly base: BaselineEntry }
+	| { readonly _tag: "Unadopted"; readonly rule: string; readonly entries: number }
+	| { readonly _tag: "NothingAdopted"; readonly rule: string };
+
+export interface GuardResult {
+	readonly problems: ReadonlyArray<GuardProblem>;
+	readonly moved: number;
+	readonly adopted: ReadonlyArray<string>;
+}
+
+export const guardBaseline = (
+	base: ReadonlyArray<BaselineEntry>,
+	working: ReadonlyArray<BaselineEntry>,
+	renames: ReadonlyMap<string, string>,
+	adopt: ReadonlyArray<string>,
+): GuardResult => {
+	const before = new Map(base.map((entry) => [keyOf(entry.rule, entry.file), entry]));
+	const covered = new Set(base.map((entry) => entry.rule));
+	const byRule = groupBy(working, (entry) => entry.rule);
+	const problems: GuardProblem[] = [];
+	let moved = 0;
+	for (const entry of working.filter((candidate) => covered.has(candidate.rule))) {
+		const exact = before.get(keyOf(entry.rule, entry.file));
+		const origin = renames.get(entry.file);
+		const matched = exact ?? (origin === undefined ? undefined : before.get(keyOf(entry.rule, origin)));
+		if (matched === undefined) {
+			problems.push({ _tag: "Added", entry });
+		} else if (entry.count > matched.count) {
+			problems.push({ _tag: "Raised", base: matched, entry });
+		} else if (exact === undefined) {
+			moved += 1;
+		}
+	}
+	const fresh = [...byRule.entries()].filter(([rule]) => !covered.has(rule));
+	for (const [rule, entries] of fresh.filter(([rule]) => !adopt.includes(rule))) {
+		problems.push({ _tag: "Unadopted", entries: entries.length, rule });
+	}
+	for (const rule of adopt.filter((candidate) => !byRule.has(candidate))) {
+		problems.push({ _tag: "NothingAdopted", rule });
+	}
+	return { adopted: fresh.map(([rule]) => rule).filter((rule) => adopt.includes(rule)), moved, problems };
+};

package/src/baseline/legacy.ts

@@ -0,0 +1,46 @@
+import { Schema } from "effect";
+import { type Decoded, decodeWith } from "../decoded.ts";
+import { groupBy, keyOf, type Violation } from "../engine/violation.ts";
+import { countOf } from "./compare.ts";
+import type { BaselineEntry } from "./format.ts";
+
+export const LEGACY_BASELINE = "quality/baseline.json";
+
+const Entry = Schema.Struct({
+	count: Schema.Int.check(Schema.isGreaterThan(0)),
+	measure: Schema.optionalKey(Schema.Finite),
+});
+
+const LegacyFile = Schema.Record(Schema.String, Schema.Record(Schema.String, Entry));
+
+const standard = Schema.toStandardSchemaV1(Schema.fromJsonString(LegacyFile), { parseOptions: { errors: "all", onExcessProperty: "error" } });
+
+export interface LegacyEntry extends BaselineEntry {
+	readonly measure?: number | undefined;
+}
+
+export const decodeLegacyBaseline = async (raw: string): Promise<Decoded<ReadonlyArray<LegacyEntry>>> => {
+	const decoded = await decodeWith(standard, raw);
+	if (decoded._tag === "Invalid") {
+		return decoded;
+	}
+	const entries = Object.entries(decoded.value).flatMap(([rule, files]) =>
+		Object.entries(files).map(([file, stored]) => ({ ...stored, file, rule })),
+	);
+	return { _tag: "Valid", value: entries };
+};
+
+export const measured = (legacy: ReadonlyArray<LegacyEntry>): boolean => legacy.some((entry) => entry.measure !== undefined);
+
+export const convertLegacy = (legacy: ReadonlyArray<LegacyEntry>, violations: ReadonlyArray<Violation>): ReadonlyArray<BaselineEntry> => {
+	const current = groupBy(violations, (violation) => keyOf(violation.rule, violation.file));
+	return legacy.flatMap(({ count, file, measure, rule }) => {
+		if (measure === undefined) {
+			return [{ count, file, rule }];
+		}
+		const group = current.get(keyOf(rule, file)) ?? [];
+		const threshold = group.find((violation) => violation.threshold !== undefined)?.threshold;
+		const converted = threshold === undefined ? countOf(group) : Math.ceil(measure - threshold);
+		return converted > 0 ? [{ count: converted, file, rule }] : [];
+	});
+};

package/src/baseline/rewrite.ts

@@ -0,0 +1,24 @@
+import { keyOf } from "../engine/violation.ts";
+import { type BaselineEntry, byPathAndRule, encodeEntry, linesOf } from "./format.ts";
+
+interface Row {
+	readonly entry: BaselineEntry;
+	readonly text: string;
+}
+
+// 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 => {
+	const wanted = new Map(after.map((entry) => [keyOf(entry.rule, entry.file), entry]));
+	const lines = linesOf(raw);
+	const rows: Row[] = before.flatMap((old, index) => {
+		const entry = wanted.get(keyOf(old.rule, old.file));
+		const line = lines[index];
+		wanted.delete(keyOf(old.rule, old.file));
+		return entry === undefined ? [] : [{ entry, text: line !== undefined && old.count === entry.count ? line.text : encodeEntry(entry) }];
+	});
+	for (const entry of [...wanted.values()].sort(byPathAndRule)) {
+		const at = rows.findIndex((row) => byPathAndRule(row.entry, entry) > 0);
+		rows.splice(at === -1 ? rows.length : at, 0, { entry, text: encodeEntry(entry) });
+	}
+	return rows.map((row) => `${row.text}\n`).join("");
+};

package/src/baseline/update.ts

@@ -1,14 +1,15 @@
 import type { Level } from "../config.ts";
 import { groupBy, keyOf, type Violation } from "../engine/violation.ts";
-import { tallyOf } from "./compare.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 _tag: "Adopted"; readonly entries: ReadonlyArray<BaselineEntry>; readonly added: number; readonly replaced: number };
 
 export interface Pruned {
 	readonly entries: ReadonlyArray<BaselineEntry>;
+	readonly moved: number;
 	readonly removed: number;
 	readonly lowered: number;
 }
@@ -19,27 +20,18 @@ const record = (violations: ReadonlyArray<Violation>): ReadonlyArray<BaselineEnt
 		if (first === undefined) {
 			return [];
 		}
-		const tally = tallyOf(group);
-		return [
-			tally.measure === undefined ? { count: tally.count, file: first.file, rule: first.rule } : { ...tally, file: first.file, rule: first.rule },
-		];
+		const count = countOf(group);
+		return count > 0 ? [{ count, file: first.file, rule: first.rule }] : [];
 	});
 
-const refusal = (id: string, levels: ReadonlyMap<string, Level>, existing: ReadonlyArray<BaselineEntry>): ReadonlyArray<string> => {
+const refusal = (id: string, levels: ReadonlyMap<string, Level>): ReadonlyArray<string> => {
 	const level = levels.get(id);
 	if (level === undefined) {
 		return [`${id}: no built-in or local rule has this id.`];
 	}
-	if (level !== "error") {
-		return [`${id}: the rule is ${level}. Set it to error before baselining it.`];
-	}
-	return existing.some((entry) => entry.rule === id) ? [`${id}: already baselined. Its entries only shrink; fix new violations instead.`] : [];
+	return level === "error" ? [] : [`${id}: the rule is ${level}. Set it to error before baselining it.`];
 };
 
-/**
- * Records the error-level violations of rules being adopted. Without a baseline every rule is adopted at once; afterwards a
- * rule is adopted by name, once, so a baseline never grows for a rule it already covers.
- */
 export const adopt = (
 	existing: ReadonlyArray<BaselineEntry> | undefined,
 	rules: ReadonlyArray<string>,
@@ -47,37 +39,62 @@ export const adopt = (
 	levels: ReadonlyMap<string, Level>,
 ): Adoption => {
 	if (existing !== undefined && rules.length === 0) {
-		return { _tag: "Refused", reasons: ["a baseline exists and only shrinks. Adopt a new rule with --rule <id>, or drop fixed debt with prune."] };
+		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, existing ?? []));
+	const reasons = rules.flatMap((id) => refusal(id, levels));
 	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 added = record(adopted);
-	return { _tag: "Adopted", added: added.length, entries: [...(existing ?? []), ...added] };
+	return { _tag: "Adopted", added: added.length, entries: [...kept, ...added], replaced: (existing ?? []).length - kept.length };
 };
 
-const shrunk = (entry: BaselineEntry, current: BaselineEntry): BaselineEntry => {
-	const count = Math.min(entry.count, current.count);
-	return entry.measure === undefined || current.measure === undefined
-		? { count, file: entry.file, rule: entry.rule }
-		: { count, file: entry.file, measure: Math.min(entry.measure, current.measure), rule: entry.rule };
-};
+export interface Scope {
+	readonly moves: ReadonlyMap<string, string>;
+	readonly files?: ReadonlySet<string> | undefined;
+}
 
-const unchanged = (left: BaselineEntry, right: BaselineEntry): boolean => left.count === right.count && left.measure === right.measure;
+const inScope = (entry: BaselineEntry, scope: Scope): boolean =>
+	scope.files === undefined || scope.files.has(entry.file) || scope.moves.has(entry.file);
+
+const 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);
+};
 
-/** Drops fixed debt and lowers entries to what is left. It never adds an entry or raises one. */
-export const prune = (existing: ReadonlyArray<BaselineEntry>, violations: ReadonlyArray<Violation>, levels: ReadonlyMap<string, Level>): Pruned => {
+export const prune = (
+	existing: ReadonlyArray<BaselineEntry>,
+	violations: ReadonlyArray<Violation>,
+	levels: ReadonlyMap<string, Level>,
+	scope: Scope = { moves: new Map() },
+): 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;
 	const kept = existing.flatMap((before) => {
-		const now = current.get(keyOf(before.rule, before.file));
+		if (!inScope(before, scope)) {
+			return [{ after: before, before }];
+		}
 		const level = levels.get(before.rule);
-		return now === undefined || level === undefined || level === "off" ? [] : [{ after: shrunk(before, now), before }];
+		const now = current.get(keyOf(before.rule, before.file)) ?? destination(before, current, scope.moves, taken);
+		if (now === undefined || level === undefined || level === "off") {
+			return [];
+		}
+		moved += Number(now.file !== before.file);
+		return [{ after: { count: Math.min(before.count, now.count), file: now.file, rule: before.rule }, before }];
 	});
 	return {
 		entries: kept.map(({ after }) => after),
-		lowered: kept.filter(({ after, before }) => !unchanged(before, after)).length,
+		lowered: kept.filter(({ after, before }) => after.count !== before.count).length,
+		moved,
 		removed: existing.length - kept.length,
 	};
 };

package/src/cli/args.ts

@@ -5,7 +5,10 @@ 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: "BaselinePrune"; readonly config: string | undefined }
+	| { 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 }
+	| { readonly _tag: "BaselineMigrate"; readonly config: string | undefined; readonly from: string | undefined }
 	| { readonly _tag: "Help" };
 
 export type Parsed = { readonly _tag: "Parsed"; readonly command: Command } | { readonly _tag: "Usage"; readonly problem: string };
@@ -13,19 +16,30 @@ export type Parsed = { readonly _tag: "Parsed"; readonly command: Command } | {
 export const USAGE = `Usage:
   quality lint [--config <file>] [--warnings summary|all]
   quality baseline write [--config <file>] [--rule <id>]...
-  quality baseline prune [--config <file>]
+  quality baseline prune [--config <file>] [--against <ref>]
+  quality baseline tighten [--config <file>] [--staged]
+  quality baseline check [--config <file>] [--against <ref>]
+  quality baseline migrate [--config <file>] [--from <file>]
 
-lint            Run every rule. Exits 1 on an error-level violation, a baseline regression or a stale entry.
-baseline write  Record current error-level violations. Creates the baseline, or adopts named rules into an existing one.
-baseline prune  Drop fixed debt and lower entries to what is left. Never adds or raises an entry.
+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.
+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.
+baseline check    Compare the baseline with its version at the merge base. Exits 1 when it gained an entry or a higher count.
+baseline migrate  Move a baseline from the earlier JSON format (--from, quality/baseline.json by default) to the configured file.
 
 --config <file>  Config file; its directory is the repository root. Defaults to ./quality.config.ts.
+--against <ref>  The branch the work merges into. Defaults to origin/HEAD, then origin/main, then origin/master.
 Exit codes: 0 passed, 1 failed the gate, 2 could not run.`;
 
 const OPTIONS = {
+	against: { type: "string" },
 	config: { type: "string" },
+	from: { type: "string" },
 	help: { short: "h", type: "boolean" },
 	rule: { multiple: true, type: "string" },
+	staged: { type: "boolean" },
 	warnings: { type: "string" },
 } as const;
 
@@ -35,27 +49,48 @@ const parsed = (command: Command): Parsed => ({ _tag: "Parsed", command });
 
 type Values = ReturnType<typeof parseArgs<{ options: typeof OPTIONS; allowPositionals: true }>>["values"];
 
-const lint = (values: Values): Parsed => {
-	if (values.rule !== undefined) {
-		return usage("--rule applies only to baseline write.");
-	}
-	const warnings = values.warnings ?? "summary";
-	return warnings === "summary" || warnings === "all"
-		? parsed({ _tag: "Lint", config: values.config, warnings })
-		: usage(`--warnings takes summary or all, not "${warnings}".`);
+type Option = Exclude<keyof Values, "config" | "help">;
+
+const COMMAND_OPTIONS: ReadonlyArray<Option> = ["against", "from", "rule", "staged", "warnings"];
+
+const ACCEPTS: Readonly<Record<string, ReadonlyArray<Option>>> = {
+	lint: ["warnings"],
+	"baseline write": ["rule"],
+	"baseline prune": ["against"],
+	"baseline tighten": ["staged"],
+	"baseline check": ["against"],
+	"baseline migrate": ["from"],
 };
 
-const baseline = (action: string | undefined, values: Values): Parsed => {
-	if (values.warnings !== undefined) {
-		return usage("--warnings applies only to lint.");
-	}
-	if (action === "write") {
-		return parsed({ _tag: "BaselineWrite", config: values.config, rules: values.rule ?? [] });
-	}
-	if (action === "prune" && values.rule === undefined) {
-		return parsed({ _tag: "BaselinePrune", config: values.config });
+const 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);
+
+const 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 "baseline write":
+			return parsed({ _tag: "BaselineWrite", config, rules: values.rule ?? [] });
+		case "baseline prune":
+			return ref(values.against, { _tag: "BaselinePrune", against: values.against, config });
+		case "baseline check":
+			return ref(values.against, { _tag: "BaselineCheck", against: values.against, config });
+		case "baseline tighten":
+			return parsed({ _tag: "BaselineTighten", config, staged: values.staged === true });
+		default:
+			return parsed({ _tag: "BaselineMigrate", config, from: values.from });
 	}
-	return usage(action === "prune" ? "--rule applies only to baseline write." : "baseline takes write or prune.");
 };
 
 export const parseCommand = (args: ReadonlyArray<string>): Parsed => {
@@ -67,15 +102,14 @@ export const parseCommand = (args: ReadonlyArray<string>): Parsed => {
 		return usage(result.failure);
 	}
 	const { positionals, values } = result.success;
-	const [command = "lint", action, ...extra] = positionals;
+	const [command = "lint", ...rest] = positionals;
 	if (values.help === true || command === "help") {
 		return parsed({ _tag: "Help" });
 	}
-	if (command === "lint" && action === undefined) {
-		return lint(values);
-	}
-	if (command === "baseline" && extra.length === 0) {
-		return baseline(action, values);
+	const name = [command, ...rest].join(" ");
+	if (ACCEPTS[name] === undefined) {
+		return usage(command === "baseline" && rest.length < 2 ? "baseline takes write, prune, tighten, check or migrate." : `unknown command: ${name}`);
 	}
-	return usage(`unknown command: ${positionals.join(" ")}`);
+	const problem = misplaced(name, values);
+	return problem === undefined ? commandFor(name, values) : usage(problem);
 };

package/src/cli/baseline.ts

@@ -1,7 +1,8 @@
 import { join } from "node:path";
 import { Console, Effect, type FileSystem } from "effect";
-import { type BaselineEntry, encodeBaseline, indentOf } from "../baseline/format.ts";
-import { adopt, prune } from "../baseline/update.ts";
+import type { BaselineEntry } from "../baseline/format.ts";
+import { rewriteBaseline } from "../baseline/rewrite.ts";
+import { adopt, type Pruned, prune, type Scope } from "../baseline/update.ts";
 import { openSession, type Session } from "../engine/session.ts";
 import { applyRegistry } from "../exceptions/registry.ts";
 import { SetupFailure } from "../failure.ts";
@@ -10,11 +11,12 @@ import { plural } from "../report/plural.ts";
 
 const save = (session: Session, entries: ReadonlyArray<BaselineEntry>): Effect.Effect<void, SetupFailure, FileSystem.FileSystem> =>
 	Effect.mapError(
-		writeText(join(session.config.root, session.config.baseline), encodeBaseline(entries, indentOf(session.baseline.raw))),
+		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).kept;
+const unregistered = (session: Session) =>
+	applyRegistry(session.violations, session.registry, session.config.levels, session.config.unregistrable).kept;
 
 export const writeBaseline = (
 	cwd: string,
@@ -28,25 +30,37 @@ export const writeBaseline = (
 		if (adoption._tag === "Refused") {
 			return yield* new SetupFailure({ message: `baseline write refused:\n${adoption.reasons.map((reason) => `  - ${reason}`).join("\n")}` });
 		}
-		if (adoption.added === 0) {
+		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);
-		yield* Console.log(`quality: recorded ${plural(adoption.added, "entry", "entries")} in ${session.config.baseline}.`);
+		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}.`);
 	});
 
-export const pruneBaseline = (cwd: string, config: string | undefined): Effect.Effect<void, SetupFailure, FileSystem.FileSystem> =>
+const 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 = <Requirements>(
+	cwd: string,
+	config: string | undefined,
+	scopeOf: (session: Session) => Effect.Effect<Scope, SetupFailure, Requirements>,
+): Effect.Effect<void, SetupFailure, FileSystem.FileSystem | Requirements> =>
 	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 prune.`);
+			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);
-		if (pruned.removed === 0 && pruned.lowered === 0) {
+		const pruned = prune(session.baseline.entries, unregistered(session), session.config.levels, 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: removed ${plural(pruned.removed, "entry", "entries")} and lowered ${plural(pruned.lowered, "entry", "entries")} in ${session.config.baseline}.`,
-		);
+		yield* Console.log(`quality: ${changes(pruned)} in ${session.config.baseline}.`);
 	});

package/src/cli/check.ts

@@ -0,0 +1,51 @@
+import { relative } from "node:path";
+import { Console, Effect, type FileSystem } from "effect";
+import { type BaselineEntry, decodeBaseline } from "../baseline/format.ts";
+import { guardBaseline } from "../baseline/guard.ts";
+import { convertLegacy, decodeLegacyBaseline, LEGACY_BASELINE, measured } from "../baseline/legacy.ts";
+import { loadConfig, type ResolvedConfig } from "../config/load.ts";
+import { validOrFail } from "../decoded.ts";
+import { readBaseline } from "../engine/baseline-file.ts";
+import { scan } from "../engine/session.ts";
+import { GateFailed, type SetupFailure } from "../failure.ts";
+import { type Base, resolveBase } from "../git/base.ts";
+import type { Git } from "../git/command.ts";
+import { changesSince, readAt } from "../git/history.ts";
+import { renderGuard } from "../report/guard.ts";
+
+const baseEntries = (
+	config: ResolvedConfig,
+	base: Base,
+	path: string,
+): Effect.Effect<ReadonlyArray<BaselineEntry>, SetupFailure, FileSystem.FileSystem | Git> =>
+	Effect.gen(function* () {
+		const raw = yield* readAt(config.root, base.commit, path);
+		if (raw !== undefined) {
+			return yield* validOrFail(`${path} at ${base.ref}`, yield* Effect.promise(() => decodeBaseline(raw)));
+		}
+		const legacyRaw = yield* readAt(config.root, base.commit, LEGACY_BASELINE);
+		if (legacyRaw === undefined) {
+			return [];
+		}
+		const legacy = yield* validOrFail(`${LEGACY_BASELINE} at ${base.ref}`, yield* Effect.promise(() => decodeLegacyBaseline(legacyRaw)));
+		return measured(legacy) ? convertLegacy(legacy, (yield* scan(config)).violations) : legacy;
+	});
+
+export const checkBaseline = (
+	cwd: string,
+	configPath: string | undefined,
+	against: string | undefined,
+): Effect.Effect<void, SetupFailure | GateFailed, FileSystem.FileSystem | Git> =>
+	Effect.gen(function* () {
+		const config = yield* loadConfig(cwd, configPath);
+		const working = yield* readBaseline(config);
+		const base = yield* resolveBase(config.root, against);
+		const { moves } = yield* changesSince(config.root, [base.commit]);
+		const renames = new Map([...moves].map(([from, to]) => [to, from]));
+		const before = yield* baseEntries(config, base, renames.get(config.baseline) ?? config.baseline);
+		const result = guardBaseline(before, working.entries, renames, config.adopt);
+		yield* Console.log(renderGuard(result, { base, baseline: config.baseline, config: relative(config.root, config.file) }));
+		if (result.problems.length > 0) {
+			return yield* new GateFailed();
+		}
+	});

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);
+		const outcome = evaluate(session.violations, session.registry, session.baseline.entries, session.config.levels, session.config.unregistrable);
 		yield* Console.log(
 			render(outcome, {
 				baseline: session.config.baseline,

package/src/cli/migrate.ts

@@ -0,0 +1,36 @@
+import { join } from "node:path";
+import { Console, Effect, FileSystem } from "effect";
+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 { 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 = (
+	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}.`);
+	});