@shivaedev/quality 0.23.0 → 0.25.0

package/src/git/base.ts

@@ -9,54 +9,62 @@ export interface Base {
 
 const FALLBACK_BRANCHES = ["origin/main", "origin/master"];
 
-const fail = (message: string) => Effect.fail(new SetupFailure({ message }));
+function fail(message: string) {
+	return Effect.fail(new SetupFailure({ message }));
+}
 
-const isCommit = (root: string, ref: string): Effect.Effect<boolean, SetupFailure, Git> =>
-	Effect.map(git(root, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]), (result) => result.code === 0);
+function isCommit(root: string, ref: string): Effect.Effect<boolean, SetupFailure, Git> {
+	return Effect.map(git(root, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]), (result) => result.code === 0);
+}
 
-const defaultBranch = (root: string): Effect.Effect<string, SetupFailure, Git> =>
-	Effect.gen(function* () {
-		const head = yield* git(root, ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"]);
-		if (head.code === 0) {
-			return head.stdout.trim();
-		}
-		for (const candidate of FALLBACK_BRANCHES) {
-			if (yield* isCommit(root, candidate)) {
-				return candidate;
-			}
+const defaultBranch = Effect.fn("Git.defaultBranch")(function* (root: string): Effect.fn.Return<string, SetupFailure, Git> {
+	const head = yield* git(root, ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"]);
+	if (head.code === 0) {
+		return head.stdout.trim();
+	}
+	for (const candidate of FALLBACK_BRANCHES) {
+		if (yield* isCommit(root, candidate)) {
+			return candidate;
 		}
-		return yield* fail(
-			"cannot find the default branch: origin/HEAD, origin/main and origin/master are missing. Pass --against <ref>, or run `git remote set-head origin --auto`.",
-		);
-	});
+	}
+	return yield* fail(
+		"cannot find the default branch: origin/HEAD, origin/main and origin/master are missing. Pass --against <ref>, or run `git remote set-head origin --auto`.",
+	);
+});
 
-const isShallow = (root: string): Effect.Effect<boolean, SetupFailure, Git> =>
-	Effect.map(git(root, ["rev-parse", "--is-shallow-repository"]), (result) => result.stdout.trim() === "true");
+function isShallow(root: string): Effect.Effect<boolean, SetupFailure, Git> {
+	return Effect.map(git(root, ["rev-parse", "--is-shallow-repository"]), (result) => result.stdout.trim() === "true");
+}
 
-const mergeBase = (root: string, ref: string): Effect.Effect<string | undefined, SetupFailure, Git> =>
-	Effect.map(git(root, ["merge-base", "HEAD", ref]), (result) => (result.code === 0 ? result.stdout.trim() : undefined));
+function mergeBase(root: string, ref: string): Effect.Effect<string | undefined, SetupFailure, Git> {
+	return Effect.map(git(root, ["merge-base", "HEAD", ref]), (result) => (result.code === 0 ? result.stdout.trim() : undefined));
+}
 
-const missingMergeBase = (root: string, ref: string): Effect.Effect<never, SetupFailure, Git> =>
-	Effect.flatMap(isShallow(root), (shallow) =>
+function missingMergeBase(root: string, ref: string): Effect.Effect<never, SetupFailure, Git> {
+	return Effect.flatMap(isShallow(root), (shallow) =>
 		fail(
 			shallow
 				? `the clone is shallow and does not reach the merge base of HEAD and ${ref}. Fetch the history first: \`git fetch --unshallow\`.`
 				: `HEAD and ${ref} share no history.`,
 		),
 	);
+}
 
-const reachMergeBase = (root: string, ref: string): Effect.Effect<string, SetupFailure, Git> =>
-	Effect.flatMap(mergeBase(root, ref), (found) => (found === undefined ? missingMergeBase(root, ref) : Effect.succeed(found)));
+function reachMergeBase(root: string, ref: string): Effect.Effect<string, SetupFailure, Git> {
+	return Effect.flatMap(mergeBase(root, ref), (found) => (found === undefined ? missingMergeBase(root, ref) : Effect.succeed(found)));
+}
 
-export const resolveBase = (root: string, against: string | undefined): Effect.Effect<Base, SetupFailure, Git> =>
-	Effect.gen(function* () {
-		const inside = yield* git(root, ["rev-parse", "--is-inside-work-tree"]);
-		if (inside.code !== 0 || inside.stdout.trim() !== "true") {
-			return yield* fail(`${root} is not in a git work tree; moves are followed through git history.`);
-		}
-		const ref = against ?? (yield* defaultBranch(root));
-		if (!(yield* isCommit(root, ref))) {
-			return yield* fail(`${ref} names no commit in this clone. Fetch it first, or pass another --against <ref>.`);
-		}
-		return { commit: yield* reachMergeBase(root, ref), ref };
-	});
+export const resolveBase = Effect.fn("Git.resolveBase")(function* (
+	root: string,
+	against: string | undefined,
+): Effect.fn.Return<Base, SetupFailure, Git> {
+	const inside = yield* git(root, ["rev-parse", "--is-inside-work-tree"]);
+	if (inside.code !== 0 || inside.stdout.trim() !== "true") {
+		return yield* fail(`${root} is not in a git work tree; moves are followed through git history.`);
+	}
+	const ref = against ?? (yield* defaultBranch(root));
+	if (!(yield* isCommit(root, ref))) {
+		return yield* fail(`${ref} names no commit in this clone. Fetch it first, or pass another --against <ref>.`);
+	}
+	return { commit: yield* reachMergeBase(root, ref), ref };
+});

package/src/git/command.ts

@@ -10,8 +10,8 @@ export interface GitResult {
 
 export type Git = ChildProcessSpawner.ChildProcessSpawner;
 
-export const git = (cwd: string, args: readonly string[]): Effect.Effect<GitResult, SetupFailure, Git> =>
-	Effect.scoped(
+export function git(cwd: string, args: readonly string[]): Effect.Effect<GitResult, SetupFailure, Git> {
+	return Effect.scoped(
 		Effect.gen(function* () {
 			const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
 			const child = yield* spawner.spawn(ChildProcess.make("git", [...args], { cwd, stdin: "ignore" }));
@@ -22,10 +22,12 @@ export const git = (cwd: string, args: readonly string[]): Effect.Effect<GitResu
 			return { code: Number(code), stderr, stdout };
 		}),
 	).pipe(Effect.mapError((error) => new SetupFailure({ message: `cannot run git: ${error.message}` })));
+}
 
-export const gitOrFail = (cwd: string, args: readonly string[]): Effect.Effect<string, SetupFailure, Git> =>
-	Effect.flatMap(git(cwd, args), (result) =>
+export function gitOrFail(cwd: string, args: readonly string[]): Effect.Effect<string, SetupFailure, Git> {
+	return Effect.flatMap(git(cwd, args), (result) =>
 		result.code === 0
 			? Effect.succeed(result.stdout)
 			: Effect.fail(new SetupFailure({ message: `git ${args[0]} failed: ${result.stderr.trim() || `exit code ${result.code}`}` })),
 	);
+}

package/src/git/history.ts

@@ -7,7 +7,7 @@ export interface Changes {
 	readonly moves: ReadonlyMap<string, string>;
 }
 
-const parse = (output: string): Changes => {
+function parse(output: string): Changes {
 	const fields = output.split("\0");
 	const files = new Set<string>();
 	const moves = new Map<string, string>();
@@ -24,11 +24,12 @@ const parse = (output: string): Changes => {
 		index += paths.length + 1;
 	}
 	return { files, moves };
-};
+}
 
 // Paths are relative to the root, and only tracked files count: a move is seen once both of its sides are staged.
-export const changesSince = (root: string, revision: readonly string[]): Effect.Effect<Changes, SetupFailure, Git> =>
-	Effect.map(
+export function changesSince(root: string, revision: readonly string[]): Effect.Effect<Changes, SetupFailure, Git> {
+	return Effect.map(
 		gitOrFail(root, ["diff", "--no-color", "--no-ext-diff", "--find-renames", "--name-status", "-z", "--relative", ...revision, "--"]),
 		parse,
 	);
+}

package/src/hooks/preCommit.ts

@@ -48,7 +48,7 @@ const runScript = Effect.fnUntraced(
 export const preCommitHook = Effect.fn("Hooks.preCommitHook")(function* (cwd: string, path: string | undefined) {
 	const config = yield* loadConfig(cwd, path);
 	const { manager, scripts } = yield* commitScripts(config.root);
-	const linted = yield* lint(cwd, path, "summary").pipe(
+	const linted = yield* lint(cwd, path).pipe(
 		Effect.as(true),
 		Effect.catchTag("GateFailed", () => Effect.succeed(false)),
 	);

package/src/imports/generated.ts

@@ -1,7 +1,7 @@
 import { execFile } from "node:child_process";
 import { posix } from "node:path";
 import { promisify } from "node:util";
-import { emptyScope, type IgnoreScope, verdictFor, withIgnoreFile } from "#inventory/ignore-scope.ts";
+import { emptyScope, type IgnoreScope, verdictFor, withIgnoreFile } from "#inventory/ignoreScope.ts";
 import type { RuleInputs } from "#rule.ts";
 import type { ImportGraph, UnresolvedImport } from "./graph.ts";
 

package/src/imports/resolve.ts

@@ -2,7 +2,7 @@ import { realpathSync } from "node:fs";
 import { isBuiltin } from "node:module";
 import { dirname, join, relative } from "node:path";
 import ts from "typescript";
-import { posix } from "#inventory/ignore-scope.ts";
+import { posix } from "#inventory/ignoreScope.ts";
 import type { Ambient } from "./ambient.ts";
 import type { ImportRequest } from "./extract.ts";
 import type { Project } from "./projects.ts";

package/src/imports/workspace.ts

@@ -4,7 +4,7 @@ import { Effect } from "effect";
 import { manifestsIn } from "#manifests/sorted.ts";
 import type { RuleInputs } from "#rule.ts";
 import { globMatcher } from "./glob.ts";
-import { pnpmWorkspacePatterns } from "./pnpm-workspace.ts";
+import { pnpmWorkspacePatterns } from "./pnpmWorkspacePatterns.ts";
 
 export interface WorkspacePackage {
 	readonly directory: string;

package/src/inventory/collect.ts

@@ -3,7 +3,7 @@ import { Effect, FileSystem } from "effect";
 import ignore from "ignore";
 import type { SourceFile } from "#rule.ts";
 import { FilesystemFailure, orWhenAbsent, readRequiredText } from "./filesystem.ts";
-import { posix } from "./ignore-scope.ts";
+import { posix } from "./ignoreScope.ts";
 import { scopeAbove, walk } from "./walk.ts";
 
 export interface InventoryScope {
@@ -19,42 +19,47 @@ export interface Inventory {
 
 const READ_CONCURRENCY = 16;
 
-export const linesOf = (text: string): readonly string[] => {
+export function linesOf(text: string): readonly string[] {
 	const lines = text.split("\n");
 	return lines.at(-1) === "" ? lines.slice(0, -1) : lines;
-};
+}
 
-const zoneFiles = (root: string, zone: string): Effect.Effect<readonly string[], FilesystemFailure, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		const path = join(root, zone);
-		if (posix(relative(root, path)).startsWith("..")) {
-			return yield* new FilesystemFailure({ message: `source "${zone}" lies outside the repository at ${root}`, path });
-		}
-		const info = yield* orWhenAbsent<FileSystem.File.Info | undefined>(path, fs.stat(path), undefined);
-		if (info === undefined) {
-			return yield* new FilesystemFailure({ message: `source "${zone}" does not exist in ${root}`, path });
-		}
-		return info.type === "Directory" ? yield* walk(path, yield* scopeAbove(root, path)) : [path];
-	});
+const zoneFiles = Effect.fn("Inventory.zoneFiles")(function* (
+	root: string,
+	zone: string,
+): Effect.fn.Return<readonly string[], FilesystemFailure, FileSystem.FileSystem> {
+	const fs = yield* FileSystem.FileSystem;
+	const path = join(root, zone);
+	if (posix(relative(root, path)).startsWith("..")) {
+		return yield* new FilesystemFailure({ message: `source "${zone}" lies outside the repository at ${root}`, path });
+	}
+	const info = yield* orWhenAbsent<FileSystem.File.Info | undefined>(path, fs.stat(path), undefined);
+	if (info === undefined) {
+		return yield* new FilesystemFailure({ message: `source "${zone}" does not exist in ${root}`, path });
+	}
+	return info.type === "Directory" ? yield* walk(path, yield* scopeAbove(root, path)) : [path];
+});
 
-const readSource = (root: string, path: string): Effect.Effect<SourceFile, FilesystemFailure, FileSystem.FileSystem> =>
-	Effect.map(readRequiredText(join(root, path)), (text) => ({ lines: linesOf(text), path, text }));
+function readSource(root: string, path: string): Effect.Effect<SourceFile, FilesystemFailure, FileSystem.FileSystem> {
+	return Effect.map(readRequiredText(join(root, path)), (text) => ({ lines: linesOf(text), path, text }));
+}
 
-export const collectInventory = (root: string, scope: InventoryScope): Effect.Effect<Inventory, FilesystemFailure, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		const excluded = ignore().add([...scope.exclude]);
-		const zones = yield* Effect.forEach(scope.sources, (zone) => zoneFiles(root, zone), { concurrency: READ_CONCURRENCY });
-		const relativePaths = zones.flat().map((absolute) => posix(relative(root, absolute)));
-		const files = [...new Set(relativePaths)]
-			.filter((path) => !excluded.ignores(path))
-			.sort((left, right) => {
-				if (left === right) {
-					return 0;
-				}
-				return left < right ? -1 : 1;
-			});
-		const sourcePaths = files.filter((path) => scope.extensions.some((extension) => path.endsWith(extension)));
-		const sources = yield* Effect.forEach(sourcePaths, (path) => readSource(root, path), { concurrency: READ_CONCURRENCY });
-		return { files, sources };
-	});
+export const collectInventory = Effect.fn("Inventory.collectInventory")(function* (
+	root: string,
+	scope: InventoryScope,
+): Effect.fn.Return<Inventory, FilesystemFailure, FileSystem.FileSystem> {
+	const excluded = ignore().add([...scope.exclude]);
+	const zones = yield* Effect.forEach(scope.sources, (zone) => zoneFiles(root, zone), { concurrency: READ_CONCURRENCY });
+	const relativePaths = zones.flat().map((absolute) => posix(relative(root, absolute)));
+	const files = [...new Set(relativePaths)]
+		.filter((path) => !excluded.ignores(path))
+		.sort((left, right) => {
+			if (left === right) {
+				return 0;
+			}
+			return left < right ? -1 : 1;
+		});
+	const sourcePaths = files.filter((path) => scope.extensions.some((extension) => path.endsWith(extension)));
+	const sources = yield* Effect.forEach(sourcePaths, (path) => readSource(root, path), { concurrency: READ_CONCURRENCY });
+	return { files, sources };
+});

package/src/inventory/filesystem.ts

@@ -10,38 +10,46 @@ export class FilesystemFailure extends Data.TaggedError("FilesystemFailure")<{
 }> {}
 
 // Effect maps ENOTDIR and EISDIR to BadResource; the original errno remains on the cause.
-const errnoOf = (error: PlatformError): string => {
+function errnoOf(error: PlatformError): string {
 	const cause: unknown = error.reason.cause;
 	return typeof cause === "object" && cause !== null && "code" in cause && typeof cause.code === "string" ? cause.code : "";
-};
+}
 
-const failure = (path: string, error: PlatformError): FilesystemFailure =>
-	new FilesystemFailure({ message: `cannot read ${path}: ${error.message}`, path });
+function failure(path: string, error: PlatformError): FilesystemFailure {
+	return new FilesystemFailure({ message: `cannot read ${path}: ${error.message}`, path });
+}
 
-export const orWhenAbsent = <Value>(
+export function orWhenAbsent<TValue>(
 	path: string,
-	action: Effect.Effect<Value, PlatformError, FileSystem.FileSystem>,
-	whenAbsent: Value,
-): Effect.Effect<Value, FilesystemFailure, FileSystem.FileSystem> =>
-	Effect.catchTag(action, "PlatformError", (error) => (ABSENT.has(errnoOf(error)) ? Effect.succeed(whenAbsent) : Effect.fail(failure(path, error))));
-
-export const readOptionalText = (path: string): Effect.Effect<string | undefined, FilesystemFailure, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		return yield* orWhenAbsent<string | undefined>(path, fs.readFileString(path), undefined);
-	});
-
-export const readRequiredText = (path: string): Effect.Effect<string, FilesystemFailure, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		return yield* Effect.mapError(fs.readFileString(path), (error) =>
-			ABSENT.has(errnoOf(error)) ? new FilesystemFailure({ message: `required input is missing: ${path}`, path }) : failure(path, error),
-		);
-	});
-
-export const writeText = (path: string, text: string): Effect.Effect<void, FilesystemFailure, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		const written = Effect.andThen(fs.makeDirectory(dirname(path), { recursive: true }), fs.writeFileString(path, text));
-		return yield* Effect.mapError(written, (error) => new FilesystemFailure({ message: `cannot write ${path}: ${error.message}`, path }));
-	});
+	action: Effect.Effect<TValue, PlatformError, FileSystem.FileSystem>,
+	whenAbsent: TValue,
+): Effect.Effect<TValue, FilesystemFailure, FileSystem.FileSystem> {
+	return Effect.catchTag(action, "PlatformError", (error) =>
+		ABSENT.has(errnoOf(error)) ? Effect.succeed(whenAbsent) : Effect.fail(failure(path, error)),
+	);
+}
+
+export const readOptionalText = Effect.fn("Inventory.readOptionalText")(function* (
+	path: string,
+): Effect.fn.Return<string | undefined, FilesystemFailure, FileSystem.FileSystem> {
+	const fs = yield* FileSystem.FileSystem;
+	return yield* orWhenAbsent<string | undefined>(path, fs.readFileString(path), undefined);
+});
+
+export const readRequiredText = Effect.fn("Inventory.readRequiredText")(function* (
+	path: string,
+): Effect.fn.Return<string, FilesystemFailure, FileSystem.FileSystem> {
+	const fs = yield* FileSystem.FileSystem;
+	return yield* Effect.mapError(fs.readFileString(path), (error) =>
+		ABSENT.has(errnoOf(error)) ? new FilesystemFailure({ message: `required input is missing: ${path}`, path }) : failure(path, error),
+	);
+});
+
+export const writeText = Effect.fn("Inventory.writeText")(function* (
+	path: string,
+	text: string,
+): Effect.fn.Return<void, FilesystemFailure, FileSystem.FileSystem> {
+	const fs = yield* FileSystem.FileSystem;
+	const written = Effect.andThen(fs.makeDirectory(dirname(path), { recursive: true }), fs.writeFileString(path, text));
+	return yield* Effect.mapError(written, (error) => new FilesystemFailure({ message: `cannot write ${path}: ${error.message}`, path }));
+});

package/src/inventory/{ignore-scope.ts → ignoreScope.ts}

@@ -15,17 +15,23 @@ export interface IgnoreScope {
 
 export const emptyScope: IgnoreScope = { boundary: undefined, matchers: [] };
 
-export const posix = (path: string): string => path.replaceAll("\\", "/");
+export function posix(path: string): string {
+	return path.replaceAll("\\", "/");
+}
 
-export const withIgnoreFile = (scope: IgnoreScope, base: string, contents: string): IgnoreScope => ({
-	boundary: scope.boundary,
-	matchers: [...scope.matchers, { base, rules: ignore().add(contents) }],
-});
+export function withIgnoreFile(scope: IgnoreScope, base: string, contents: string): IgnoreScope {
+	return {
+		boundary: scope.boundary,
+		matchers: [...scope.matchers, { base, rules: ignore().add(contents) }],
+	};
+}
 
 // Re-including a directory resets directory rules below that boundary; filename rules still apply.
-export const insideKept = (scope: IgnoreScope, directory: string): IgnoreScope => ({ boundary: directory, matchers: scope.matchers });
+export function insideKept(scope: IgnoreScope, directory: string): IgnoreScope {
+	return { boundary: directory, matchers: scope.matchers };
+}
 
-const matcherVerdict = (matcher: IgnoreMatcher, boundary: string | undefined, path: string, directory: boolean): Verdict => {
+function matcherVerdict(matcher: IgnoreMatcher, boundary: string | undefined, path: string, directory: boolean): Verdict {
 	const anchor = boundary !== undefined && boundary.length > matcher.base.length ? boundary : matcher.base;
 	const rel = posix(relative(anchor, path));
 	if (rel === "" || rel.startsWith("..")) {
@@ -37,7 +43,11 @@ const matcherVerdict = (matcher: IgnoreMatcher, boundary: string | undefined, pa
 		return "ignored";
 	}
 	return result.unignored ? "kept" : "unknown";
-};
+}
 
-export const verdictFor = (scope: IgnoreScope, path: string, directory: boolean): Verdict =>
-	scope.matchers.map((matcher) => matcherVerdict(matcher, scope.boundary, path, directory)).findLast((verdict) => verdict !== "unknown") ?? "unknown";
+export function verdictFor(scope: IgnoreScope, path: string, directory: boolean): Verdict {
+	return (
+		scope.matchers.map((matcher) => matcherVerdict(matcher, scope.boundary, path, directory)).findLast((verdict) => verdict !== "unknown")
+		?? "unknown"
+	);
+}

package/src/inventory/walk.ts

@@ -1,7 +1,7 @@
 import { dirname, join, relative, sep } from "node:path";
 import { Effect, FileSystem } from "effect";
 import { FilesystemFailure, orWhenAbsent, readOptionalText } from "./filesystem.ts";
-import { emptyScope, type IgnoreScope, insideKept, verdictFor, withIgnoreFile } from "./ignore-scope.ts";
+import { emptyScope, type IgnoreScope, insideKept, verdictFor, withIgnoreFile } from "./ignoreScope.ts";
 import { trackedPaths } from "./trackedPaths.ts";
 
 const SKIPPED = new Set([".git", "node_modules"]);

package/src/manifests/sorted.ts

@@ -2,7 +2,7 @@ import { basename, join, relative } from "node:path";
 import { Effect, FileSystem } from "effect";
 import { sortPackageJson } from "sort-package-json";
 import { FilesystemFailure } from "#inventory/filesystem.ts";
-import { posix } from "#inventory/ignore-scope.ts";
+import { posix } from "#inventory/ignoreScope.ts";
 import { walk } from "#inventory/walk.ts";
 
 export type Sorting = { readonly _tag: "Invalid" } | { readonly _tag: "Sorted" } | { readonly _tag: "Unsorted"; readonly sorted: string };
@@ -26,21 +26,21 @@ export function sortingOf(text: string): Sorting {
 	return sorted === text ? { _tag: "Sorted" } : { _tag: "Unsorted", sorted };
 }
 
-export function sortManifests(root: string): Effect.Effect<number, FilesystemFailure, FileSystem.FileSystem> {
-	return Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		const manifests = yield* manifestsIn(root);
-		const written = yield* Effect.forEach(manifests, (path) =>
-			Effect.gen(function* () {
-				const absolute = join(root, path);
-				const sorting = sortingOf(yield* fs.readFileString(absolute));
-				if (sorting._tag !== "Unsorted") {
-					return false;
-				}
-				yield* fs.writeFileString(absolute, sorting.sorted);
-				return true;
-			}).pipe(Effect.mapError((error) => new FilesystemFailure({ message: `cannot sort ${path}: ${error.message}`, path }))),
-		);
-		return written.filter(Boolean).length;
-	});
-}
+export const sortManifests = Effect.fn("Manifests.sortManifests")(function* (
+	root: string,
+): Effect.fn.Return<number, FilesystemFailure, FileSystem.FileSystem> {
+	const fs = yield* FileSystem.FileSystem;
+	const manifests = yield* manifestsIn(root);
+	const written = yield* Effect.forEach(manifests, (path) =>
+		Effect.gen(function* () {
+			const absolute = join(root, path);
+			const sorting = sortingOf(yield* fs.readFileString(absolute));
+			if (sorting._tag !== "Unsorted") {
+				return false;
+			}
+			yield* fs.writeFileString(absolute, sorting.sorted);
+			return true;
+		}).pipe(Effect.mapError((error) => new FilesystemFailure({ message: `cannot sort ${path}: ${error.message}`, path }))),
+	);
+	return written.filter(Boolean).length;
+});

package/src/report/plural.ts

@@ -1 +1,3 @@
-export const plural = (count: number, singular: string, many = `${singular}s`): string => `${count} ${count === 1 ? singular : many}`;
+export function plural(count: number, singular: string, many = `${singular}s`): string {
+	return `${count} ${count === 1 ? singular : many}`;
+}

package/src/report/render.ts

@@ -4,30 +4,28 @@ import { groupBy, keyOf, type Violation } from "#engine/violation.ts";
 import { plural } from "./plural.ts";
 import { staleSections } from "./stale.ts";
 
-export type WarningDetail = "summary" | "all";
-
 export interface ReportContext {
 	readonly baseline: string;
 	readonly checked: number;
 	readonly descriptions: ReadonlyMap<string, string>;
 	readonly registry: string;
-	readonly warnings: WarningDetail;
 }
 
-const LISTED_FILES = 5;
-
-const locate = (violation: Violation): string => (violation.line === undefined ? violation.file : `${violation.file}:${violation.line}`);
+function locate(violation: Violation): string {
+	return violation.line === undefined ? violation.file : `${violation.file}:${violation.line}`;
+}
 
-const regressionNote = (regression: Regression): string =>
-	`  ${regression.entry.file} is over its baseline: ${regression.count} against ${regression.entry.count} baselined.`;
+function regressionNote(regression: Regression): string {
+	return `  ${regression.entry.file} is over its baseline: ${regression.count} against ${regression.entry.count} baselined.`;
+}
 
-const heading = (label: string, rule: string, violations: readonly Violation[], context: ReportContext): readonly string[] => {
+function heading(rule: string, violations: readonly Violation[], context: ReportContext): readonly string[] {
 	const description = context.descriptions.get(rule);
-	return [`${label} ${rule} (${violations.length})`, ...(description === undefined ? [] : [`  ${description}`])];
-};
+	return [`error ${rule} (${violations.length})`, ...(description === undefined ? [] : [`  ${description}`])];
+}
 
-const detailed = (violations: readonly Violation[], regressions: ReadonlyMap<string, Regression>): readonly string[] =>
-	[...groupBy(violations, (violation) => violation.file).values()].flatMap((inFile) => {
+function detailed(violations: readonly Violation[], regressions: ReadonlyMap<string, Regression>): readonly string[] {
+	return [...groupBy(violations, (violation) => violation.file).values()].flatMap((inFile) => {
 		const first = inFile[0];
 		const regression = first === undefined ? undefined : regressions.get(keyOf(first.rule, first.file));
 		return [
@@ -35,43 +33,32 @@ const detailed = (violations: readonly Violation[], regressions: ReadonlyMap<str
 			...(regression === undefined ? [] : [regressionNote(regression)]),
 		];
 	});
+}
 
-const summarized = (violations: readonly Violation[]): readonly string[] => {
-	const files = [...groupBy(violations, (violation) => violation.file).entries()].sort(([, left], [, right]) => right.length - left.length);
-	const listed = files.slice(0, LISTED_FILES).map(([file, inFile]) => `${file} (${inFile.length})`);
-	const rest = files.length - listed.length;
-	return [`  ${listed.join(", ")}${rest > 0 ? `, and ${plural(rest, "more file", "more files")}` : ""}. --warnings all lists each one.`];
-};
-
-const ruleSections = (
-	label: string,
-	violations: readonly Violation[],
-	context: ReportContext,
-	body: (inRule: readonly Violation[]) => readonly string[],
-): readonly string[] =>
-	[...groupBy(violations, (violation) => violation.rule).entries()].map(([rule, inRule]) =>
-		[...heading(label, rule, inRule, context), ...body(inRule)].join("\n"),
+function ruleSections(violations: readonly Violation[], context: ReportContext, regressions: ReadonlyMap<string, Regression>): readonly string[] {
+	return [...groupBy(violations, (violation) => violation.rule).entries()].map(([rule, inRule]) =>
+		[...heading(rule, inRule, context), ...detailed(inRule, regressions)].join("\n"),
 	);
+}
 
-const failures = (outcome: Outcome): string => {
+function failures(outcome: Outcome): string {
 	const stale = outcome.staleBaseline.length + outcome.staleRegistry.length;
 	return [
 		...(outcome.errors.length > 0 ? [plural(outcome.errors.length, "error")] : []),
 		...(stale > 0 ? [plural(stale, "stale entry", "stale entries")] : []),
 	].join(" and ");
-};
+}
 
-const summary = (outcome: Outcome, context: ReportContext): string => {
+function summary(outcome: Outcome, context: ReportContext): string {
 	const verdict = passes(outcome) ? "quality: passed" : `quality: failed with ${failures(outcome)}`;
-	const warnings = outcome.warnings.length > 0 ? `; ${plural(outcome.warnings.length, "warning")} from rules still at warn` : "";
 	const hidden = [
 		...(outcome.baselined > 0 ? [`${outcome.baselined} baselined`] : []),
 		...(outcome.registered > 0 ? [`${outcome.registered} registered`] : []),
 	];
 	const suppressed =
 		hidden.length === 0 ? "" : `; ${hidden.join(" and ")} ${outcome.baselined + outcome.registered === 1 ? "violation" : "violations"} not shown`;
-	return `${verdict}${warnings}. ${plural(context.checked, "source file")} checked${suppressed}.`;
-};
+	return `${verdict}. ${plural(context.checked, "source file")} checked${suppressed}.`;
+}
 
 function rerecord(outcome: Outcome): readonly string[] {
 	const rules = [...new Set(outcome.errors.map((violation) => violation.rule))].sort((left, right) => left.localeCompare(right));
@@ -84,14 +71,12 @@ function rerecord(outcome: Outcome): readonly string[] {
 	];
 }
 
-export const render = (outcome: Outcome, context: ReportContext): string => {
+export function render(outcome: Outcome, context: ReportContext): string {
 	const regressions = new Map(outcome.regressions.map((regression) => [keyOf(regression.entry.rule, regression.entry.file), regression]));
-	const warningBody = context.warnings === "all" ? (inRule: readonly Violation[]) => detailed(inRule, regressions) : summarized;
 	return [
-		...ruleSections("error", outcome.errors, context, (inRule) => detailed(inRule, regressions)),
-		...ruleSections("warn", outcome.warnings, context, warningBody),
+		...ruleSections(outcome.errors, context, regressions),
 		...staleSections(outcome, context),
 		summary(outcome, context),
 		...rerecord(outcome),
 	].join("\n\n");
-};
+}