@shivaedev/quality 0.4.0 → 0.5.0

package/src/imports/projects.ts

@@ -0,0 +1,106 @@
+import { dirname, join, relative } from "node:path";
+import ts from "typescript";
+
+export interface Project {
+	readonly cache: ts.ModuleResolutionCache;
+	readonly files: ReadonlySet<string>;
+	readonly options: ts.CompilerOptions;
+	readonly typesCache: ts.ModuleResolutionCache;
+	readonly typesOptions: ts.CompilerOptions;
+}
+
+interface ParsedProject {
+	readonly files: ReadonlySet<string>;
+	readonly key: string;
+	readonly options: ts.CompilerOptions;
+	readonly references: readonly string[];
+}
+
+const CONFIG = "tsconfig.json";
+
+const SOURCE_CONDITION = "source";
+
+const quietHost: ts.ParseConfigFileHost = { ...ts.sys, onUnRecoverableConfigFileDiagnostic: () => undefined };
+
+function resolutionOptions(options: ts.CompilerOptions, declarations: boolean): ts.CompilerOptions {
+	return {
+		...options,
+		allowArbitraryExtensions: declarations,
+		allowImportingTsExtensions: true,
+		allowJs: true,
+		customConditions: [...new Set([SOURCE_CONDITION, ...(options.customConditions ?? [])])],
+		module: ts.ModuleKind.ESNext,
+		moduleResolution: ts.ModuleResolutionKind.Bundler,
+		noDtsResolution: !declarations,
+		resolveJsonModule: true,
+		resolvePackageJsonExports: true,
+		resolvePackageJsonImports: true,
+	};
+}
+
+function projectOf(root: string, parsed: ParsedProject | undefined): Project {
+	const runtime = resolutionOptions(parsed?.options ?? {}, false);
+	const types = resolutionOptions(parsed?.options ?? {}, true);
+	return {
+		cache: ts.createModuleResolutionCache(root, (file) => file, runtime),
+		files: parsed?.files ?? new Set(),
+		options: runtime,
+		typesCache: ts.createModuleResolutionCache(root, (file) => file, types),
+		typesOptions: types,
+	};
+}
+
+function parse(path: string): ParsedProject {
+	const parsed = ts.getParsedCommandLineOfConfigFile(path, {}, quietHost);
+	return {
+		files: new Set(parsed?.fileNames ?? []),
+		key: path,
+		options: parsed?.options ?? {},
+		references: (parsed?.projectReferences ?? []).map((reference) => ts.resolveProjectReferencePath(reference)),
+	};
+}
+
+function nearestConfig(root: string, file: string): string | undefined {
+	for (let directory = dirname(file); !relative(root, directory).startsWith(".."); directory = dirname(directory)) {
+		const candidate = join(directory, CONFIG);
+		if (ts.sys.fileExists(candidate)) {
+			return candidate;
+		}
+		if (directory === root) {
+			return undefined;
+		}
+	}
+	return undefined;
+}
+
+function memo<Value>(compute: (key: string) => Value): (key: string) => Value {
+	const known = new Map<string, Value>();
+	return (key) => {
+		const value = known.get(key) ?? compute(key);
+		known.set(key, value);
+		return value;
+	};
+}
+
+// A file resolves with the options of the project that includes it: the nearest tsconfig.json, or a project it references.
+export function projectsFor(root: string): (file: string) => Project {
+	const parsedAt = memo(parse);
+	function withReferences(path: string, seen: Set<string>): readonly ParsedProject[] {
+		if (seen.has(path)) {
+			return [];
+		}
+		seen.add(path);
+		const project = parsedAt(path);
+		return [project, ...project.references.flatMap((reference) => withReferences(reference, seen))];
+	}
+	const familyAt = memo((config) => withReferences(config, new Set()));
+	const projects = new Map<string, Project>();
+	return (file) => {
+		const config = nearestConfig(root, file);
+		const owner = config === undefined ? undefined : (familyAt(config).find((candidate) => candidate.files.has(file)) ?? parsedAt(config));
+		const key = owner?.key ?? "";
+		const project = projects.get(key) ?? projectOf(root, owner);
+		projects.set(key, project);
+		return project;
+	};
+}

package/src/imports/resolve.ts

@@ -0,0 +1,115 @@
+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 type { Ambient } from "./ambient.ts";
+import type { ImportRequest } from "./extract.ts";
+import type { Project } from "./projects.ts";
+
+export type Endpoint =
+	| { readonly kind: "file"; readonly path: string }
+	| { readonly kind: "external"; readonly package: string; readonly specifier: string };
+
+const NODE_PREFIX = "node:";
+
+const NODE_MODULES = "/node_modules/";
+
+const ASSET_DECLARATION = /\.d(?<extension>\.[^./]+)\.ts$/u;
+
+const DECLARATION = /\.d\.[cm]?ts$/u;
+
+const QUERY = /\?.*$/u;
+
+export function builtinName(specifier: string): string | undefined {
+	if (!isBuiltin(specifier)) {
+		return undefined;
+	}
+	return specifier.startsWith(NODE_PREFIX) ? specifier : `${NODE_PREFIX}${specifier}`;
+}
+
+const TYPES_SCOPE = "@types";
+
+const TYPES_SCOPE_SEPARATOR = "__";
+
+function typedName(name: string): string {
+	return name.includes(TYPES_SCOPE_SEPARATOR) ? `@${name.replace(TYPES_SCOPE_SEPARATOR, "/")}` : name;
+}
+
+function nameAt(path: string): string {
+	const [first = "", second] = path.split("/");
+	if (second === undefined || !first.startsWith("@")) {
+		return first;
+	}
+	return first === TYPES_SCOPE ? typedName(second) : `${first}/${second}`;
+}
+
+// The example checker and the graph name a package through this one function, so a fence example and a real import cannot disagree.
+export function packageNameOf(specifier: string): string {
+	return builtinName(specifier) ?? nameAt(specifier);
+}
+
+function assetOf(declaration: string): string {
+	return declaration.replace(ASSET_DECLARATION, "$<extension>");
+}
+
+// TypeScript resolves an import of a stylesheet or an image once the asset has a declaration beside it, so this host lets every asset have one.
+const assetHost: ts.ModuleResolutionHost = {
+	...ts.sys,
+	fileExists: (path) => ts.sys.fileExists(path) || (ASSET_DECLARATION.test(path) && ts.sys.fileExists(assetOf(path))),
+};
+
+export function isDeclarationFile(path: string): boolean {
+	return DECLARATION.test(path) || ASSET_DECLARATION.test(path);
+}
+
+function fitting(resolved: string, type: boolean): string | undefined {
+	if (ASSET_DECLARATION.test(resolved) && ts.sys.fileExists(assetOf(resolved))) {
+		return assetOf(resolved);
+	}
+	return type || !isDeclarationFile(resolved) ? resolved : undefined;
+}
+
+function located(request: ImportRequest, from: string, project: Project): string | undefined {
+	const specifier = request.specifier.replace(QUERY, "");
+	if (request.kind === "type-reference") {
+		return ts.resolveTypeReferenceDirective(specifier, from, project.typesOptions, ts.sys).resolvedTypeReferenceDirective?.resolvedFileName;
+	}
+	if (request.kind === "path-reference") {
+		const path = join(dirname(from), specifier);
+		return ts.sys.fileExists(path) ? path : undefined;
+	}
+	return (
+		ts.resolveModuleName(specifier, from, project.options, ts.sys, project.cache).resolvedModule?.resolvedFileName
+		?? ts.resolveModuleName(specifier, from, project.typesOptions, assetHost, project.typesCache).resolvedModule?.resolvedFileName
+	);
+}
+
+function resolvedPath(request: ImportRequest, from: string, project: Project): string | undefined {
+	const path = located(request, from, project);
+	return path === undefined ? undefined : fitting(path, request.type);
+}
+
+function endpointAt(root: string, specifier: string, path: string): Endpoint {
+	const real = posix(realpathSync(path));
+	const installed = real.lastIndexOf(NODE_MODULES);
+	if (installed !== -1) {
+		return { kind: "external", package: nameAt(real.slice(installed + NODE_MODULES.length)), specifier };
+	}
+	const inRoot = posix(relative(root, real));
+	return inRoot.startsWith("../") ? { kind: "external", package: packageNameOf(specifier), specifier } : { kind: "file", path: inRoot };
+}
+
+export function resolveImport(root: string, ambient: Ambient, request: ImportRequest, from: string, project: Project): Endpoint | undefined {
+	const builtin = builtinName(request.specifier);
+	if (builtin !== undefined) {
+		return { kind: "external", package: builtin, specifier: builtin };
+	}
+	const path = resolvedPath(request, from, project);
+	if (path !== undefined) {
+		return endpointAt(root, request.specifier, path);
+	}
+	return ambient(request.specifier, project.files)
+		? { kind: "external", package: packageNameOf(request.specifier), specifier: request.specifier }
+		: undefined;
+}

package/src/imports/workspace.ts

@@ -0,0 +1,76 @@
+import { posix } from "node:path";
+import type { RuleInputs } from "../rule.ts";
+import { globMatcher } from "./glob.ts";
+import { pnpmWorkspacePatterns } from "./pnpm-workspace.ts";
+
+export interface WorkspacePackage {
+	readonly directory: string;
+	readonly name: string;
+}
+
+type Reader = Pick<RuleInputs, "files" | "readText">;
+
+const MANIFEST = "package.json";
+
+const PNPM_WORKSPACE = "pnpm-workspace.yaml";
+
+const NEGATION = "!";
+
+const LEADING_DOT = /^\.\//u;
+
+const TRAILING_SLASHES = /\/+$/u;
+
+function parsed(text: string | undefined): unknown {
+	if (text === undefined) {
+		return undefined;
+	}
+	try {
+		return JSON.parse(text);
+	} catch {
+		return undefined;
+	}
+}
+
+function field(value: unknown, key: string): unknown {
+	return typeof value === "object" && value !== null && key in value ? Reflect.get(value, key) : undefined;
+}
+
+function strings(value: unknown): readonly string[] {
+	return Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === "string") : [];
+}
+
+function npmPatterns(text: string | undefined): readonly string[] {
+	const workspaces = field(parsed(text), "workspaces");
+	return Array.isArray(workspaces) ? strings(workspaces) : strings(field(workspaces, "packages"));
+}
+
+function normalized(pattern: string): string {
+	return pattern.replace(LEADING_DOT, "").replace(TRAILING_SLASHES, "");
+}
+
+async function memberOf(inputs: Reader): Promise<(directory: string) => boolean> {
+	const pnpm = await inputs.readText(PNPM_WORKSPACE);
+	const patterns = [...(pnpm === undefined ? [] : pnpmWorkspacePatterns(pnpm)), ...npmPatterns(await inputs.readText(MANIFEST))];
+	const included = patterns.filter((pattern) => !pattern.startsWith(NEGATION)).map((pattern) => globMatcher(normalized(pattern)));
+	const excluded = patterns
+		.filter((pattern) => pattern.startsWith(NEGATION))
+		.map((pattern) => globMatcher(normalized(pattern.slice(NEGATION.length))));
+	return (directory) => included.some((matches) => matches(directory)) && !excluded.some((matches) => matches(directory));
+}
+
+export async function workspacePackages(inputs: Reader): Promise<readonly WorkspacePackage[]> {
+	const member = await memberOf(inputs);
+	const directories = inputs.files
+		.filter((file) => posix.basename(file) === MANIFEST && file !== MANIFEST)
+		.map((manifest) => posix.dirname(manifest))
+		.filter(member);
+	const named = await Promise.all(
+		directories.map(async (directory) => ({ directory, name: field(parsed(await inputs.readText(posix.join(directory, MANIFEST))), "name") })),
+	);
+	return named.flatMap(({ directory, name }) => (typeof name === "string" ? [{ directory, name }] : []));
+}
+
+export function packageOf(packages: readonly WorkspacePackage[], path: string): WorkspacePackage | undefined {
+	const owners = packages.filter((candidate) => path.startsWith(`${candidate.directory}/`));
+	return owners.toSorted((left, right) => right.directory.length - left.directory.length)[0];
+}

package/src/index.ts

@@ -1,5 +1,8 @@
 export type { BuiltInRules, Level, QualityConfig, RuleSetting, RuleSettings } from "./config.ts";
 export { defineConfig } from "./config.ts";
+export { fence } from "./imports/fences/dsl.ts";
+export type { Chain, ExampleStep, Examples, External, Fence, Target } from "./imports/fences/model.ts";
+export { anyOf, anything, external, files, folders, modules, packages, scopes, workspace } from "./imports/fences/selectors.ts";
 export type { Configured, Finding, Findings, Rule, RuleContext, RuleInputs, SourceFile } from "./rule.ts";
 export { defineRule } from "./rule.ts";
 export type { StandardIssue, StandardResult, StandardSchemaV1 } from "./standard-schema.ts";

package/src/inventory/collect.ts

@@ -7,19 +7,19 @@ import { posix } from "./ignore-scope.ts";
 import { scopeAbove, walk } from "./walk.ts";
 
 export interface InventoryScope {
-	readonly sources: ReadonlyArray<string>;
-	readonly exclude: ReadonlyArray<string>;
-	readonly extensions: ReadonlyArray<string>;
+	readonly exclude: readonly string[];
+	readonly extensions: readonly string[];
+	readonly sources: readonly string[];
 }
 
 export interface Inventory {
-	readonly files: ReadonlyArray<string>;
-	readonly sources: ReadonlyArray<SourceFile>;
+	readonly files: readonly string[];
+	readonly sources: readonly SourceFile[];
 }
 
 const READ_CONCURRENCY = 16;
 
-export const linesOf = (text: string): ReadonlyArray<string> => {
+export const linesOf = (text: string): readonly string[] => {
 	const lines = text.split("\n");
 	return lines.at(-1) === "" ? lines.slice(0, -1) : lines;
 };

package/src/manifests/sorted.ts

@@ -0,0 +1,46 @@
+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 { walk } from "../inventory/walk.ts";
+
+export type Sorting = { readonly _tag: "Invalid" } | { readonly _tag: "Sorted" } | { readonly _tag: "Unsorted"; readonly sorted: string };
+
+export function manifestsIn(root: string): Effect.Effect<readonly string[], FilesystemFailure, FileSystem.FileSystem> {
+	return Effect.map(walk(root), (paths) =>
+		paths
+			.filter((path) => basename(path) === "package.json")
+			.map((path) => posix(relative(root, path)))
+			.sort(),
+	);
+}
+
+export function sortingOf(text: string): Sorting {
+	try {
+		JSON.parse(text);
+	} catch {
+		return { _tag: "Invalid" };
+	}
+	const sorted = sortPackageJson(text);
+	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;
+	});
+}

package/src/report/guard.ts

@@ -3,9 +3,9 @@ import type { Base } from "../git/base.ts";
 import { plural } from "./plural.ts";
 
 export interface GuardContext {
+	readonly base: Base;
 	readonly baseline: string;
 	readonly config: string;
-	readonly base: Base;
 }
 
 const problemLine = (problem: GuardProblem, context: GuardContext): string => {
@@ -38,7 +38,7 @@ export const renderGuard = (result: GuardResult, context: GuardContext): string
 	return [
 		[
 			`error ${context.baseline} grew against ${against(context.base)}`,
-			`  The baseline only shrinks. Fix new violations instead of baselining them; a rule enters the baseline for the first time only while \`adopt\` names it.`,
+			"  The baseline only shrinks. Fix new violations instead of baselining them; a rule enters the baseline for the first time only while `adopt` names it.",
 			...result.problems.map((problem) => `  ${problemLine(problem, context)}`),
 		].join("\n"),
 		`quality: baseline check failed with ${plural(result.problems.length, "problem")}.`,

package/src/report/render.ts

@@ -7,10 +7,10 @@ import { staleSections } from "./stale.ts";
 export type WarningDetail = "summary" | "all";
 
 export interface ReportContext {
-	readonly descriptions: ReadonlyMap<string, string>;
-	readonly registry: string;
 	readonly baseline: string;
 	readonly checked: number;
+	readonly descriptions: ReadonlyMap<string, string>;
+	readonly registry: string;
 	readonly warnings: WarningDetail;
 }
 
@@ -21,12 +21,12 @@ const locate = (violation: Violation): string => (violation.line === undefined ?
 const regressionNote = (regression: Regression): string =>
 	`  ${regression.entry.file} is over its baseline: ${regression.count} against ${regression.entry.count} baselined.`;
 
-const heading = (label: string, rule: string, violations: ReadonlyArray<Violation>, context: ReportContext): ReadonlyArray<string> => {
+const heading = (label: string, rule: string, violations: readonly Violation[], context: ReportContext): readonly string[] => {
 	const description = context.descriptions.get(rule);
 	return [`${label} ${rule} (${violations.length})`, ...(description === undefined ? [] : [`  ${description}`])];
 };
 
-const detailed = (violations: ReadonlyArray<Violation>, regressions: ReadonlyMap<string, Regression>): ReadonlyArray<string> =>
+const detailed = (violations: readonly Violation[], regressions: ReadonlyMap<string, Regression>): readonly string[] =>
 	[...groupBy(violations, (violation) => violation.file).values()].flatMap((inFile) => {
 		const first = inFile[0];
 		const regression = first === undefined ? undefined : regressions.get(keyOf(first.rule, first.file));
@@ -36,7 +36,7 @@ const detailed = (violations: ReadonlyArray<Violation>, regressions: ReadonlyMap
 		];
 	});
 
-const summarized = (violations: ReadonlyArray<Violation>): ReadonlyArray<string> => {
+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;
@@ -45,10 +45,10 @@ const summarized = (violations: ReadonlyArray<Violation>): ReadonlyArray<string>
 
 const ruleSections = (
 	label: string,
-	violations: ReadonlyArray<Violation>,
+	violations: readonly Violation[],
 	context: ReportContext,
-	body: (inRule: ReadonlyArray<Violation>) => ReadonlyArray<string>,
-): ReadonlyArray<string> =>
+	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"),
 	);
@@ -75,7 +75,7 @@ const summary = (outcome: Outcome, context: ReportContext): string => {
 
 export const 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: ReadonlyArray<Violation>) => detailed(inRule, regressions) : summarized;
+	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),

package/src/report/stale.ts

@@ -4,11 +4,11 @@ import type { StaleRegistryEntry } from "../exceptions/registry.ts";
 import { plural } from "./plural.ts";
 
 interface StaleFiles {
-	readonly registry: string;
 	readonly baseline: string;
+	readonly registry: string;
 }
 
-const section = (label: string, file: string, guidance: string, lines: ReadonlyArray<string>): ReadonlyArray<string> =>
+const section = (label: string, file: string, guidance: string, lines: readonly string[]): readonly string[] =>
 	lines.length === 0 ? [] : [[`${label} ${file}: ${plural(lines.length, "stale entry", "stale entries")}`, `  ${guidance}`, ...lines].join("\n")];
 
 const baselineLine = ({ entry, problem }: StaleBaselineEntry): string => `  ${entry.rule} ${entry.file} ${problem}.`;
@@ -16,7 +16,7 @@ const baselineLine = ({ entry, problem }: StaleBaselineEntry): string => `  ${en
 const registryLine = ({ entry, problem }: StaleRegistryEntry): string =>
 	`  ${entry.rule} ${entry.file}${entry.subject === undefined ? "" : ` (${entry.subject})`} ${problem}.`;
 
-export const staleSections = (outcome: Outcome, files: StaleFiles): ReadonlyArray<string> => [
+export const staleSections = (outcome: Outcome, files: StaleFiles): readonly string[] => [
 	...section(
 		"error",
 		files.baseline,

package/src/rule.ts

@@ -1,27 +1,27 @@
 import { describeIssue, type StandardSchemaV1 } from "./standard-schema.ts";
 
 export interface Finding {
+	readonly count?: number | undefined;
 	readonly file: string;
 	readonly line?: number | undefined;
 	readonly message: string;
 	readonly subject?: string | undefined;
-	readonly count?: number | undefined;
 	readonly threshold?: number | undefined;
 }
 
-export type Findings = ReadonlyArray<Finding>;
+export type Findings = readonly Finding[];
 
 export interface SourceFile {
+	readonly lines: readonly string[];
 	readonly path: string;
 	readonly text: string;
-	readonly lines: ReadonlyArray<string>;
 }
 
 export interface RuleInputs {
-	readonly root: string;
-	readonly files: ReadonlyArray<string>;
-	readonly sources: ReadonlyArray<SourceFile>;
+	readonly files: readonly string[];
 	readonly readText: (path: string) => Promise<string | undefined>;
+	readonly root: string;
+	readonly sources: readonly SourceFile[];
 }
 
 export interface RuleContext<Options> extends RuleInputs {
@@ -29,22 +29,23 @@ export interface RuleContext<Options> extends RuleInputs {
 }
 
 export type Configured =
-	| { readonly _tag: "Invalid"; readonly issues: ReadonlyArray<string> }
+	| { readonly _tag: "Invalid"; readonly issues: readonly string[] }
 	| { readonly _tag: "Ready"; readonly check: (inputs: RuleInputs) => Promise<Findings> };
 
 export interface Rule<Id extends string = string, Input = unknown> {
-	readonly id: Id;
-	readonly description: string;
-	readonly registrable?: boolean;
 	// Method syntax keeps rules with different options in one list; configure validates its input at runtime.
 	configure(options: Input | undefined): Promise<Configured>;
+	readonly description: string;
+	readonly family?: boolean;
+	readonly id: Id;
+	readonly registrable?: boolean;
 }
 
 interface RuleDefinition<Id extends string, Options> {
-	readonly id: Id;
+	readonly check: (context: RuleContext<Options>) => Findings | PromiseLike<Findings>;
 	readonly description: string;
+	readonly id: Id;
 	readonly registrable?: false;
-	readonly check: (context: RuleContext<Options>) => Findings | PromiseLike<Findings>;
 }
 
 interface RuleDefinitionWithOptions<Id extends string, Input, Options> extends RuleDefinition<Id, Options> {

package/src/rules/biome.ts

@@ -0,0 +1,47 @@
+import { biomeReport, type Diagnostic } from "../biome/report.ts";
+import { defineRule, type Finding, type Rule, type RuleInputs } from "../rule.ts";
+import { itemsOf, member, parseJsonc, textOf } from "./suppressions/biome/json.ts";
+
+export const PRESET = "@shivaedev/quality/biome";
+
+const ROOT_CONFIGS: readonly string[] = ["biome.json", "biome.jsonc"];
+
+const FAILING: ReadonlySet<string> = new Set(["error", "fatal"]);
+
+function messageOf(diagnostic: Diagnostic): string {
+	return diagnostic.category === "format" && diagnostic.message.startsWith("Formatter would have printed")
+		? "Is not formatted. Run `quality fix`."
+		: diagnostic.message;
+}
+
+function findingOf(diagnostic: Diagnostic): Finding {
+	const line = diagnostic.location.start?.line ?? 0;
+	return {
+		file: diagnostic.location.path ?? ".",
+		line: line > 0 ? line : undefined,
+		message: messageOf(diagnostic),
+		subject: diagnostic.category ?? "internal",
+	};
+}
+
+async function presetFinding(readText: RuleInputs["readText"]): Promise<readonly Finding[]> {
+	const texts = await Promise.all(ROOT_CONFIGS.map(async (path) => ({ path, text: await readText(path) })));
+	const found = texts.find((candidate) => candidate.text !== undefined);
+	const parsed = found?.text === undefined ? undefined : parseJsonc(found.path, found.text);
+	const extended = parsed?._tag === "Parsed" ? itemsOf(member(parsed.json, "extends")).map(textOf) : [];
+	return extended.includes(PRESET)
+		? []
+		: [{ file: found?.path ?? "biome.json", message: `Extend "${PRESET}" from the root Biome config.`, subject: "preset" }];
+}
+
+const bridge = defineRule({
+	check: async ({ readText, root }) => {
+		const [preset, report] = await Promise.all([presetFinding(readText), biomeReport(root, ["check"])]);
+		return [...preset, ...report.diagnostics.filter((diagnostic) => FAILING.has(diagnostic.severity)).map(findingOf)];
+	},
+	description: "Biome's lint, format and assist findings under the shared preset. `quality fix` applies the safe fixes and the formatting.",
+	id: "biome",
+	registrable: false,
+});
+
+export const biome: Rule<"biome", undefined> = { ...bridge, family: true };

package/src/rules/built-in.ts

@@ -1,9 +1,15 @@
+import { biome } from "./biome.ts";
 import { maxPerFile } from "./comments/max-per-file.ts";
 import { noBanner } from "./comments/no-banner.ts";
+import { noEnvironmentPragma } from "./comments/no-environment-pragma.ts";
 import { noJsdoc } from "./comments/no-jsdoc.ts";
 import { noLineReference } from "./comments/no-line-reference.ts";
 import { noPrReference } from "./comments/no-pr-reference.ts";
 import { noTodo } from "./comments/no-todo.ts";
+import { importCycles } from "./imports/cycles.ts";
+import { importFences } from "./imports/fences.ts";
+import { importsResolvable } from "./imports/resolvable.ts";
+import { manifestsSorted } from "./manifests-sorted.ts";
 import { maxLines } from "./max-lines.ts";
 import { biomeOverrides } from "./suppressions/biome-overrides.ts";
 import { noDoubleCast } from "./suppressions/no-double-cast.ts";
@@ -16,8 +22,14 @@ export const builtInRules = [
 	noPrReference,
 	noBanner,
 	noTodo,
+	noEnvironmentPragma,
 	maxPerFile,
 	noInline,
 	noDoubleCast,
 	biomeOverrides,
+	biome,
+	importCycles,
+	importFences,
+	importsResolvable,
+	manifestsSorted,
 ] as const;