@shivaedev/quality 0.0.0 → 0.1.0

package/dist/rules/max-lines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"max-lines.d.ts","sourceRoot":"","sources":["../../src/rules/max-lines.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,QAAQ;;;;EAUnB,CAAC"}

package/dist/rules/max-lines.js

@@ -0,0 +1,26 @@
+import { Effect, Schema } from "effect";
+import ignore from "ignore";
+import { defineRule } from "../rule.js";
+const DEFAULT_TEST_FILES = ["*.test.*", "*.spec.*", "test/", "tests/", "__tests__/"];
+const DECLARATION = /\.d\.[cm]?ts$/;
+const Limit = Schema.Int.check(Schema.isGreaterThan(0));
+const MaxLinesOptions = Schema.Struct({
+    source: Limit.pipe(Schema.withDecodingDefaultKey(Effect.succeed(150))),
+    test: Limit.pipe(Schema.withDecodingDefaultKey(Effect.succeed(300))),
+    testFiles: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed(DEFAULT_TEST_FILES))),
+});
+const oversized = (file, limit) => file.lines.length <= limit
+    ? []
+    : [{ file: file.path, measure: file.lines.length, message: `${file.lines.length} lines exceeds the ${limit}-line limit.` }];
+export const maxLines = defineRule({
+    id: "structure/max-lines",
+    description: "Keep each module to one job. Split a long file along its responsibilities; never golf it under the limit.",
+    options: Schema.toStandardSchemaV1(MaxLinesOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
+    check: ({ options, sources }) => {
+        const tests = ignore().add([...options.testFiles]);
+        return sources
+            .filter((file) => !DECLARATION.test(file.path))
+            .flatMap((file) => oversized(file, tests.ignores(file.path) ? options.test : options.source));
+    },
+});
+//# sourceMappingURL=max-lines.js.map

package/dist/rules/max-lines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"max-lines.js","sourceRoot":"","sources":["../../src/rules/max-lines.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,MAAM,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,UAAU,EAAiC,MAAM,YAAY,CAAC;AAEvE,MAAM,kBAAkB,GAA0B,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC;AAC5G,MAAM,WAAW,GAAG,eAAe,CAAC;AAEpC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;AAExD,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,CAAC;IACrC,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,sBAAsB,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;IACtE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,sBAAsB,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;IACpE,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,sBAAsB,CAAC,MAAM,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC;CAC9G,CAAC,CAAC;AAEH,MAAM,SAAS,GAAG,CAAC,IAAgB,EAAE,KAAa,EAA0B,EAAE,CAC7E,IAAI,CAAC,KAAK,CAAC,MAAM,IAAI,KAAK;IACzB,CAAC,CAAC,EAAE;IACJ,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,sBAAsB,KAAK,cAAc,EAAE,CAAC,CAAC;AAE9H,MAAM,CAAC,MAAM,QAAQ,GAAG,UAAU,CAAC;IAClC,EAAE,EAAE,qBAAqB;IACzB,WAAW,EAAE,2GAA2G;IACxH,OAAO,EAAE,MAAM,CAAC,kBAAkB,CAAC,eAAe,EAAE,EAAE,YAAY,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,EAAE,CAAC;IACnH,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE;QAC/B,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;QACnD,OAAO,OAAO;aACZ,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAC9C,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IAChG,CAAC;CACD,CAAC,CAAC"}

package/dist/standard-schema.d.ts

@@ -0,0 +1,25 @@
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly "~standard": {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => StandardResult<Output> | Promise<StandardResult<Output>>;
+        readonly types?: {
+            readonly input: Input;
+            readonly output: Output;
+        } | undefined;
+    };
+}
+export type StandardResult<Output> = {
+    readonly value: Output;
+    readonly issues?: undefined;
+} | {
+    readonly issues: ReadonlyArray<StandardIssue>;
+};
+export interface StandardIssue {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | {
+        readonly key: PropertyKey;
+    }> | undefined;
+}
+export declare const describeIssue: (issue: StandardIssue) => string;
+//# sourceMappingURL=standard-schema.d.ts.map

package/dist/standard-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-schema.d.ts","sourceRoot":"","sources":["../src/standard-schema.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,gBAAgB,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;IAChE,QAAQ,CAAC,WAAW,EAAE;QACrB,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;QACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,cAAc,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC;QAChG,QAAQ,CAAC,KAAK,CAAC,EAAE;YAAE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;YAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;SAAE,GAAG,SAAS,CAAC;KAChF,CAAC;CACF;AAED,MAAM,MAAM,cAAc,CAAC,MAAM,IAAI;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,CAAA;CAAE,CAAC;AAEjJ,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,WAAW,GAAG;QAAE,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAA;KAAE,CAAC,GAAG,SAAS,CAAC;CACvF;AAID,eAAO,MAAM,aAAa,GAAI,OAAO,aAAa,KAAG,MAC0E,CAAC"}

package/dist/standard-schema.js

@@ -0,0 +1,3 @@
+const segment = (part) => String(typeof part === "object" ? part.key : part);
+export const describeIssue = (issue) => issue.path === undefined || issue.path.length === 0 ? issue.message : `${issue.path.map(segment).join(".")}: ${issue.message}`;
+//# sourceMappingURL=standard-schema.js.map

package/dist/standard-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-schema.js","sourceRoot":"","sources":["../src/standard-schema.ts"],"names":[],"mappings":"AAkBA,MAAM,OAAO,GAAG,CAAC,IAAiD,EAAU,EAAE,CAAC,MAAM,CAAC,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAElI,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAoB,EAAU,EAAE,CAC7D,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC"}

package/package.json

@@ -1,14 +1,63 @@
 {
   "name": "@shivaedev/quality",
-  "version": "0.0.0",
-  "description": "Name reservation. The first release is published from https://github.com/ShivaeDev/platform.",
+  "version": "0.1.0",
+  "description": "Repository quality gate with typed rules, a shrink-only baseline and a registry of reasoned exceptions",
+  "type": "module",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShivaeDev/platform.git",
     "directory": "packages/quality"
   },
+  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/quality#readme",
+  "bugs": {
+    "url": "https://github.com/ShivaeDev/platform/issues"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "sideEffects": false,
+  "bin": {
+    "quality": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "source": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@effect/platform-node": "4.0.0-rc.112",
+    "effect": "4.0.0-rc.112",
+    "ignore": "7.0.6"
+  },
+  "devDependencies": {
+    "@effect/vitest": "4.0.0-rc.112",
+    "@types/node": "24.10.1",
+    "@typescript/native": "npm:typescript@7.0.2",
+    "typescript": "npm:@typescript/typescript6@6.0.2",
+    "vitest": "4.1.9"
+  },
+  "scripts": {
+    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc6 --project tsconfig.build.json",
+    "check": "biome check .",
+    "test": "vitest run",
+    "test:package": "node scripts/test-package.mjs",
+    "typecheck": "tsc --noEmit",
+    "typecheck:compat": "tsc6 --noEmit",
+    "ready": "pnpm check && pnpm typecheck && pnpm typecheck:compat && pnpm test && pnpm build && pnpm test:package"
   }
-}
+}

package/src/baseline/compare.ts

@@ -0,0 +1,81 @@
+import type { Level } from "../config.ts";
+import { groupBy, keyOf, unusedEntryProblem, type Violation } from "../engine/violation.ts";
+import type { BaselineEntry } from "./format.ts";
+
+export interface Tally {
+	readonly count: number;
+	readonly measure: number | undefined;
+}
+
+export interface Regression {
+	readonly entry: BaselineEntry;
+	readonly tally: Tally;
+}
+
+export interface StaleBaselineEntry {
+	readonly entry: BaselineEntry;
+	readonly problem: string;
+}
+
+export interface BaselineCheck {
+	readonly kept: ReadonlyArray<Violation>;
+	readonly regressions: ReadonlyArray<Regression>;
+	readonly stale: ReadonlyArray<StaleBaselineEntry>;
+	readonly baselined: number;
+}
+
+type Verdict = { readonly _tag: "Covered"; readonly loose: boolean } | { readonly _tag: "Regressed" };
+
+const measures = (violations: ReadonlyArray<Violation>): ReadonlyArray<number> =>
+	violations.flatMap((violation) => (violation.measure === undefined ? [] : [violation.measure]));
+
+export const tallyOf = (violations: ReadonlyArray<Violation>): Tally => {
+	const found = measures(violations);
+	return { count: violations.length, measure: found.length === 0 ? undefined : Math.max(...found) };
+};
+
+const measureTrend = (entry: BaselineEntry, tally: Tally): number =>
+	entry.measure === undefined || tally.measure === undefined ? 0 : Math.sign(tally.measure - entry.measure);
+
+const verdictOf = (entry: BaselineEntry, tally: Tally): Verdict => {
+	const trend = measureTrend(entry, tally);
+	if (tally.count > entry.count || trend > 0) {
+		return { _tag: "Regressed" };
+	}
+	return { _tag: "Covered", loose: tally.count < entry.count || trend < 0 };
+};
+
+export const describeTally = (tally: Tally): string =>
+	`${tally.count} violation${tally.count === 1 ? "" : "s"}${tally.measure === undefined ? "" : ` measuring ${tally.measure}`}`;
+
+export const describeEntry = (entry: BaselineEntry): string => describeTally({ count: entry.count, measure: entry.measure });
+
+export const applyBaseline = (
+	violations: ReadonlyArray<Violation>,
+	entries: ReadonlyArray<BaselineEntry>,
+	levels: ReadonlyMap<string, Level>,
+): BaselineCheck => {
+	const groups = groupBy(violations, (violation) => keyOf(violation.rule, violation.file));
+	const covered = new Set<string>();
+	const regressions: Regression[] = [];
+	const stale: StaleBaselineEntry[] = [];
+	for (const entry of entries) {
+		const group = groups.get(keyOf(entry.rule, entry.file)) ?? [];
+		if (group.length === 0) {
+			stale.push({ entry, problem: unusedEntryProblem(levels, entry.rule, "has no violations left") });
+			continue;
+		}
+		const tally = tallyOf(group);
+		const verdict = verdictOf(entry, tally);
+		if (verdict._tag === "Regressed") {
+			regressions.push({ entry, tally });
+			continue;
+		}
+		covered.add(keyOf(entry.rule, entry.file));
+		if (verdict.loose) {
+			stale.push({ entry, problem: `allows more than is left: ${describeTally(tally)} against ${describeEntry(entry)} baselined` });
+		}
+	}
+	const kept = violations.filter((violation) => !covered.has(keyOf(violation.rule, violation.file)));
+	return { baselined: violations.length - kept.length, kept, regressions, stale };
+};

package/src/baseline/format.ts

@@ -0,0 +1,53 @@
+import { Schema } from "effect";
+import { type Decoded, decodeWith } from "../decoded.ts";
+
+const Entry = Schema.Struct({
+	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" } });
+
+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 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 entries = Object.entries(decoded.value).flatMap(([rule, files]) =>
+		Object.entries(files).map(([file, stored]) => ({ ...stored, file, rule })),
+	);
+	return { _tag: "Valid", value: entries };
+};
+
+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`;
+};
+
+/** 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";

package/src/baseline/update.ts

@@ -0,0 +1,83 @@
+import type { Level } from "../config.ts";
+import { groupBy, keyOf, type Violation } from "../engine/violation.ts";
+import { tallyOf } 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 };
+
+export interface Pruned {
+	readonly entries: ReadonlyArray<BaselineEntry>;
+	readonly removed: number;
+	readonly lowered: number;
+}
+
+const record = (violations: ReadonlyArray<Violation>): ReadonlyArray<BaselineEntry> =>
+	[...groupBy(violations, (violation) => keyOf(violation.rule, violation.file)).values()].flatMap((group) => {
+		const first = group[0];
+		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 refusal = (id: string, levels: ReadonlyMap<string, Level>, existing: ReadonlyArray<BaselineEntry>): 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.`] : [];
+};
+
+/**
+ * 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>,
+	violations: ReadonlyArray<Violation>,
+	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."] };
+	}
+	const reasons = rules.flatMap((id) => refusal(id, levels, existing ?? []));
+	if (reasons.length > 0) {
+		return { _tag: "Refused", reasons };
+	}
+	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] };
+};
+
+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 };
+};
+
+const unchanged = (left: BaselineEntry, right: BaselineEntry): boolean => left.count === right.count && left.measure === right.measure;
+
+/** 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 => {
+	const current = new Map(record(violations).map((entry) => [keyOf(entry.rule, entry.file), entry]));
+	const kept = existing.flatMap((before) => {
+		const now = current.get(keyOf(before.rule, before.file));
+		const level = levels.get(before.rule);
+		return now === undefined || level === undefined || level === "off" ? [] : [{ after: shrunk(before, now), before }];
+	});
+	return {
+		entries: kept.map(({ after }) => after),
+		lowered: kept.filter(({ after, before }) => !unchanged(before, after)).length,
+		removed: existing.length - kept.length,
+	};
+};

package/src/cli/args.ts

@@ -0,0 +1,81 @@
+import { parseArgs } from "node:util";
+import { Result } from "effect";
+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: "Help" };
+
+export type Parsed = { readonly _tag: "Parsed"; readonly command: Command } | { readonly _tag: "Usage"; readonly problem: string };
+
+export const USAGE = `Usage:
+  quality lint [--config <file>] [--warnings summary|all]
+  quality baseline write [--config <file>] [--rule <id>]...
+  quality baseline prune [--config <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.
+
+--config <file>  Config file; its directory is the repository root. Defaults to ./quality.config.ts.
+Exit codes: 0 passed, 1 failed the gate, 2 could not run.`;
+
+const OPTIONS = {
+	config: { type: "string" },
+	help: { short: "h", type: "boolean" },
+	rule: { multiple: true, type: "string" },
+	warnings: { type: "string" },
+} as const;
+
+const usage = (problem: string): Parsed => ({ _tag: "Usage", problem });
+
+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}".`);
+};
+
+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 });
+	}
+	return usage(action === "prune" ? "--rule applies only to baseline write." : "baseline takes write or prune.");
+};
+
+export const parseCommand = (args: ReadonlyArray<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 }),
+	});
+	if (Result.isFailure(result)) {
+		return usage(result.failure);
+	}
+	const { positionals, values } = result.success;
+	const [command = "lint", action, ...extra] = 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);
+	}
+	return usage(`unknown command: ${positionals.join(" ")}`);
+};

package/src/cli/baseline.ts

@@ -0,0 +1,52 @@
+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 { openSession, type Session } from "../engine/session.ts";
+import { applyRegistry } from "../exceptions/registry.ts";
+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> =>
+	Effect.mapError(
+		writeText(join(session.config.root, session.config.baseline), encodeBaseline(entries, indentOf(session.baseline.raw))),
+		(failure) => new SetupFailure({ message: failure.message }),
+	);
+
+const unregistered = (session: Session) => applyRegistry(session.violations, session.registry, session.config.levels).kept;
+
+export const writeBaseline = (
+	cwd: string,
+	config: string | undefined,
+	rules: ReadonlyArray<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);
+		if (adoption._tag === "Refused") {
+			return yield* new SetupFailure({ message: `baseline write refused:\n${adoption.reasons.map((reason) => `  - ${reason}`).join("\n")}` });
+		}
+		if (adoption.added === 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}.`);
+	});
+
+export const pruneBaseline = (cwd: string, config: string | undefined): Effect.Effect<void, SetupFailure, FileSystem.FileSystem> =>
+	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.`);
+		}
+		const pruned = prune(session.baseline.entries, unregistered(session), session.config.levels);
+		if (pruned.removed === 0 && pruned.lowered === 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}.`,
+		);
+	});

package/src/cli/lint.ts

@@ -0,0 +1,27 @@
+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";
+
+export const lint = (
+	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.levels);
+		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.registry,
+				warnings,
+			}),
+		);
+		if (!passes(outcome)) {
+			return yield* new GateFailed();
+		}
+	});

package/src/cli/run-main.ts

@@ -0,0 +1,29 @@
+import { NodeFileSystem, NodeRuntime } from "@effect/platform-node";
+import { Cause, Console, Effect, Exit, type FileSystem, Runtime } from "effect";
+import { SetupFailure } from "../failure.ts";
+
+const INTERRUPTED = 130;
+const COULD_NOT_RUN = 2;
+
+const explain = (cause: Cause.Cause<unknown>): Effect.Effect<void> => {
+	const error = Cause.squash(cause);
+	if (error instanceof SetupFailure) {
+		return Console.error(`quality: ${error.message}`);
+	}
+	return Runtime.getErrorReported(error) ? Console.error(`quality: internal error\n${Cause.pretty(cause)}`) : 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) => {
+	if (Exit.isSuccess(exit)) {
+		return onExit(0);
+	}
+	return onExit(Cause.hasInterruptsOnly(exit.cause) ? INTERRUPTED : exitCodeOf(Cause.squash(exit.cause)));
+};
+
+export const runMain = <Value, Error>(program: Effect.Effect<Value, Error, FileSystem.FileSystem>): void => {
+	const explained = Effect.tapCause(program, (cause) => (Cause.hasInterruptsOnly(cause) ? Effect.void : explain(cause)));
+	NodeRuntime.runMain(Effect.provide(explained, NodeFileSystem.layer), { disableErrorReporting: true, teardown });
+};

package/src/cli.ts

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { Console, Effect } from "effect";
+import { parseCommand, USAGE } from "./cli/args.ts";
+import { pruneBaseline, writeBaseline } from "./cli/baseline.ts";
+import { lint } from "./cli/lint.ts";
+import { runMain } from "./cli/run-main.ts";
+import { SetupFailure } from "./failure.ts";
+
+const parsed = parseCommand(process.argv.slice(2));
+
+const program = Effect.gen(function* () {
+	if (parsed._tag === "Usage") {
+		return yield* new SetupFailure({ message: `${parsed.problem}\n\n${USAGE}` });
+	}
+	const command = parsed.command;
+	switch (command._tag) {
+		case "Help":
+			return yield* Console.log(USAGE);
+		case "Lint":
+			return yield* lint(process.cwd(), command.config, command.warnings);
+		case "BaselineWrite":
+			return yield* writeBaseline(process.cwd(), command.config, command.rules);
+		case "BaselinePrune":
+			return yield* pruneBaseline(process.cwd(), command.config);
+	}
+});
+
+runMain(program);

package/src/config/decode.ts

@@ -0,0 +1,35 @@
+import { Schema } from "effect";
+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";
+
+const Level = Schema.Literals(["error", "warn", "off"]);
+
+const Setting = Schema.Union([Level, Schema.Struct({ level: Schema.optionalKey(Level), options: Schema.optionalKey(Schema.Unknown) })]);
+
+const LocalRule = Schema.declare(isRule, { expected: "a rule made with defineRule" });
+
+const ConfigInput = Schema.Struct({
+	sources: Schema.optionalKey(Schema.Array(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),
+	local: Schema.optionalKey(Schema.Array(LocalRule)),
+	rules: Schema.optionalKey(Schema.Record(Schema.String, Setting)),
+});
+
+export type ConfigInput = typeof ConfigInput.Type;
+
+const standard = Schema.toStandardSchemaV1(ConfigInput, { parseOptions: { errors: "all", onExcessProperty: "error" } });
+
+export const decodeConfig = (value: unknown): Promise<Decoded<ConfigInput>> => decodeWith(standard, value);