@shivaedev/quality 0.7.2 → 0.8.0

package/src/naming/packageLayout.ts

@@ -0,0 +1,75 @@
+import { posix } from "node:path";
+import type { RuleInputs } from "#rule.ts";
+
+export interface PackageLayout {
+	readonly foldersOf: (path: string) => readonly string[];
+	readonly names: ReadonlyMap<string, string>;
+	readonly scripts: ReadonlySet<string>;
+}
+
+const MANIFEST = "package.json";
+
+const SOURCE_FOLDER = "src";
+
+const RUNNABLE = /\.[cm]?[jt]sx?$/u;
+
+const BUILT = /^dist\/(?<entry>.+)\.[cm]?js$/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 texts(value: unknown): readonly string[] {
+	if (typeof value === "string") {
+		return [value];
+	}
+	return typeof value === "object" && value !== null ? Object.values(value).filter((entry): entry is string => typeof entry === "string") : [];
+}
+
+function sourcesOf(target: string): readonly string[] {
+	const built = BUILT.exec(target)?.groups?.entry;
+	return built === undefined ? [target] : [target, `src/${built}.ts`, `src/${built}.tsx`];
+}
+
+function packageOf(path: string, roots: readonly string[]): string {
+	return roots.find((root) => root === "" || path.startsWith(`${root}/`)) ?? "";
+}
+
+function runBy(directory: string, manifest: unknown): readonly string[] {
+	const commands = texts(field(manifest, "scripts")).flatMap((command) => command.split(/\s+/u).filter((token) => RUNNABLE.test(token)));
+	const bins = texts(field(manifest, "bin")).flatMap(sourcesOf);
+	return [...commands, ...bins].map((target) => posix.join(directory, target));
+}
+
+export async function packageLayout({ files, readText }: Pick<RuleInputs, "files" | "readText">): Promise<PackageLayout> {
+	const directories = ["", ...files.filter((path) => posix.basename(path) === MANIFEST).map((path) => posix.dirname(path))];
+	const manifests = await Promise.all(
+		[...new Set(directories)].map(async (directory) => ({
+			directory: directory === "." ? "" : directory,
+			manifest: parsed(await readText(directory === "" ? MANIFEST : `${directory}/${MANIFEST}`)),
+		})),
+	);
+	const present = manifests.filter((entry) => entry.manifest !== undefined);
+	const roots = present.map((entry) => entry.directory).toSorted((left, right) => right.length - left.length);
+	const names = new Map(present.flatMap(({ directory, manifest }) => texts(field(manifest, "name")).map((name) => [directory, name] as const)));
+	return {
+		foldersOf: (path) => {
+			const root = packageOf(path, roots);
+			const folders = posix.dirname(root === "" ? path : path.slice(root.length + 1)).split("/");
+			return folders.filter((folder, index) => folder !== "." && !(index === 0 && folder === SOURCE_FOLDER));
+		},
+		names,
+		scripts: new Set(present.flatMap(({ directory, manifest }) => runBy(directory, manifest))),
+	};
+}

package/src/naming/testName.ts

@@ -0,0 +1,25 @@
+import { posix } from "node:path";
+
+export const ENVIRONMENTS = ["dom", "slow", "typecheck"] as const;
+
+export type Environment = (typeof ENVIRONMENTS)[number];
+
+export interface TestName {
+	readonly extension: string;
+	readonly folder: string;
+	readonly kind: "spec" | "test";
+	readonly modifiers: readonly string[];
+	readonly stem: string;
+}
+
+const TEST_FILE = /^(?<base>.+)\.(?<kind>test|spec)(?<extension>\.[cm]?[jt]sx?)$/u;
+
+export function testName(path: string): TestName | undefined {
+	const groups = TEST_FILE.exec(posix.basename(path))?.groups;
+	const kind = groups?.kind;
+	if (groups?.base === undefined || groups.extension === undefined || (kind !== "test" && kind !== "spec")) {
+		return undefined;
+	}
+	const [stem = "", ...modifiers] = groups.base.split(".");
+	return { extension: groups.extension, folder: posix.dirname(path), kind, modifiers, stem };
+}

package/src/naming/words.ts

@@ -0,0 +1,28 @@
+const WORD = /[A-Z]?[a-z0-9]+|[A-Z]+(?![a-z])/gu;
+
+export const KEBAB = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+
+export const CAMEL = /^[a-z][a-zA-Z0-9]*$/u;
+
+export const PASCAL = /^[A-Z][a-zA-Z0-9]*$/u;
+
+const UPPER_START = /^[A-Z]/u;
+
+export function wordsOf(name: string): readonly string[] {
+	return [...name.matchAll(WORD)].map((match) => match[0].toLowerCase());
+}
+
+export function singular(word: string): string {
+	if (word.endsWith("ies") && word.length > 3) {
+		return `${word.slice(0, -3)}y`;
+	}
+	return word.endsWith("s") && !word.endsWith("ss") && word.length > 1 ? word.slice(0, -1) : word;
+}
+
+export function sameWord(left: string, right: string): boolean {
+	return singular(left) === singular(right);
+}
+
+export function isUpper(text: string): boolean {
+	return UPPER_START.test(text);
+}

package/src/report/render.ts

@@ -1,6 +1,6 @@
-import type { Regression } from "../baseline/compare.ts";
-import { type Outcome, passes } from "../engine/evaluate.ts";
-import { groupBy, keyOf, type Violation } from "../engine/violation.ts";
+import type { Regression } from "#baseline/compare.ts";
+import { type Outcome, passes } from "#engine/evaluate.ts";
+import { groupBy, keyOf, type Violation } from "#engine/violation.ts";
 import { plural } from "./plural.ts";
 import { staleSections } from "./stale.ts";
 

package/src/report/stale.ts

@@ -1,6 +1,6 @@
-import type { StaleBaselineEntry } from "../baseline/compare.ts";
-import type { Outcome } from "../engine/evaluate.ts";
-import type { StaleRegistryEntry } from "../exceptions/registry.ts";
+import type { StaleBaselineEntry } from "#baseline/compare.ts";
+import type { Outcome } from "#engine/evaluate.ts";
+import type { StaleRegistryEntry } from "#exceptions/registry.ts";
 import { plural } from "./plural.ts";
 
 interface StaleFiles {

package/src/rules/biome.ts

@@ -1,6 +1,6 @@
-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";
+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 "#rules/suppressions/biome/json.ts";
 
 export const PRESET = "@shivaedev/quality/biome";
 

package/src/rules/built-in.ts

@@ -1,20 +1,25 @@
+import { maxPerFile } from "#rules/comments/max-per-file.ts";
+import { noBanner } from "#rules/comments/no-banner.ts";
+import { noEnvironmentPragma } from "#rules/comments/no-environment-pragma.ts";
+import { noJsdoc } from "#rules/comments/no-jsdoc.ts";
+import { noLineReference } from "#rules/comments/no-line-reference.ts";
+import { noPrReference } from "#rules/comments/no-pr-reference.ts";
+import { noTodo } from "#rules/comments/no-todo.ts";
+import { folderNames } from "#rules/files/folderNames.ts";
+import { namedAfterExport } from "#rules/files/namedAfterExport.ts";
+import { otherNames } from "#rules/files/otherNames.ts";
+import { importsAliased } from "#rules/imports/aliased.ts";
+import { importCycles } from "#rules/imports/cycles.ts";
+import { importFences } from "#rules/imports/fences.ts";
+import { importsResolvable } from "#rules/imports/resolvable.ts";
+import { biomeOverrides } from "#rules/suppressions/biome-overrides.ts";
+import { noDoubleCast } from "#rules/suppressions/no-double-cast.ts";
+import { noInline } from "#rules/suppressions/no-inline.ts";
+import { testsColocated } from "#rules/test-names/colocated.ts";
+import { testsFollow } from "#rules/test-names/follow.ts";
 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 { importsAliased } from "./imports/aliased.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";
-import { noInline } from "./suppressions/no-inline.ts";
 
 export const builtInRules = [
 	maxLines,
@@ -34,4 +39,9 @@ export const builtInRules = [
 	importsResolvable,
 	importsAliased,
 	manifestsSorted,
+	namedAfterExport,
+	folderNames,
+	otherNames,
+	testsFollow,
+	testsColocated,
 ] as const;

package/src/rules/comments/kinds.ts

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect";
-import { SUPPRESSIONS } from "../suppressions/directives.ts";
+import { SUPPRESSIONS } from "#rules/suppressions/directives.ts";
 import type { SourceComment } from "./scan.ts";
 
 export const Pragmas = Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed<readonly string[]>([])));

package/src/rules/comments/max-per-file.ts

@@ -1,6 +1,6 @@
 import { Effect, Schema } from "effect";
-import { plural } from "../../report/plural.ts";
-import { defineRule, type Finding, type SourceFile } from "../../rule.ts";
+import { plural } from "#report/plural.ts";
+import { defineRule, type Finding, type SourceFile } from "#rule.ts";
 import { isDirective, isPragma, Pragmas } from "./kinds.ts";
 import { commentsOf, type SourceComment } from "./scan.ts";
 

package/src/rules/comments/no-jsdoc.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { defineRule } from "../../rule.ts";
+import { defineRule } from "#rule.ts";
 import { isDirective, isJsdoc, isPragma, Pragmas } from "./kinds.ts";
 import { commentsOf } from "./scan.ts";
 

package/src/rules/comments/pattern-rule.ts

@@ -1,4 +1,4 @@
-import { defineRule, type Finding, type Rule } from "../../rule.ts";
+import { defineRule, type Finding, type Rule } from "#rule.ts";
 import { isDirective, textOf } from "./kinds.ts";
 import { commentsOf, type SourceComment } from "./scan.ts";
 

package/src/rules/comments/scan.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
-import type { SourceFile } from "../../rule.ts";
-import { parse } from "../syntax.ts";
+import type { SourceFile } from "#rule.ts";
+import { parse } from "#rules/syntax.ts";
 
 export interface SourceComment {
 	readonly body: readonly string[];

package/src/rules/files/folderNames.ts

@@ -0,0 +1,92 @@
+import { posix } from "node:path";
+import { Effect, Schema } from "effect";
+import ignore, { type Ignore } from "ignore";
+import { packageLayout } from "#naming/packageLayout.ts";
+import { KEBAB, PASCAL } from "#naming/words.ts";
+import { defineRule, type Finding } from "#rule.ts";
+
+const DEFAULT_TOOL_OWNED: readonly string[] = ["generated/", "migrations/"];
+
+const SNAKE = /^[a-z0-9]+(?:_[a-z0-9]+)*$/u;
+
+const CODE = /\.[cm]?[jt]sx?$/u;
+
+const FolderNamesOptions = Schema.Struct({
+	content: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+	toolOwned: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed(DEFAULT_TOOL_OWNED))),
+});
+
+function foldersIn(files: readonly string[]): readonly string[] {
+	const folders = new Set<string>();
+	for (const file of files) {
+		for (let folder = posix.dirname(file); folder !== "."; folder = posix.dirname(folder)) {
+			folders.add(folder);
+		}
+	}
+	return [...folders].sort();
+}
+
+function stemsIn(files: readonly string[]): ReadonlySet<string> {
+	return new Set(files.filter((file) => CODE.test(file)).map((file) => `${posix.dirname(file)}/${posix.basename(file).replace(CODE, "")}`));
+}
+
+function isModule(folder: string, stems: ReadonlySet<string>): boolean {
+	const name = posix.basename(folder);
+	return stems.has(`${folder}/${name}`) || stems.has(`${posix.dirname(folder)}/${name}`);
+}
+
+function packageMessage(name: string, packageName: string): string | undefined {
+	const expected = packageName.replace(/^@[^/]+\//u, "");
+	return name === expected ? undefined : `The folder of the package ${packageName} is named "${expected}", in kebab-case after the package name.`;
+}
+
+function groupMessage(name: string): string | undefined {
+	if (PASCAL.test(name)) {
+		return `"${name}" is PascalCase but holds no ${name}.ts or ${name}.tsx. A PascalCase folder is a module named after its main file: add that file, or name the folder in kebab-case.`;
+	}
+	return KEBAB.test(name.replace(/^\./u, ""))
+		? undefined
+		: `"${name}" groups files, so it is named in kebab-case, such as test-support/. A folder named after a file beside or inside it is a module and takes that file's name.`;
+}
+
+interface Context {
+	readonly content: Ignore;
+	readonly names: ReadonlyMap<string, string>;
+	readonly stems: ReadonlySet<string>;
+	readonly toolOwned: Ignore;
+}
+
+function messageFor(folder: string, context: Context): string | undefined {
+	const name = posix.basename(folder);
+	if (context.toolOwned.ignores(`${folder}/`) || isModule(folder, context.stems)) {
+		return undefined;
+	}
+	const packageName = context.names.get(folder);
+	if (packageName !== undefined) {
+		return packageMessage(name, packageName);
+	}
+	if (context.content.ignores(`${folder}/`)) {
+		return SNAKE.test(name) ? undefined : `"${name}" holds content, so it is named in snake_case, such as forest_path/.`;
+	}
+	return groupMessage(name);
+}
+
+export const folderNames = defineRule({
+	check: async ({ files, options, readText }) => {
+		const layout = await packageLayout({ files, readText });
+		const context: Context = {
+			content: ignore().add([...options.content]),
+			names: layout.names,
+			stems: stemsIn(files),
+			toolOwned: ignore().add([...options.toolOwned]),
+		};
+		return foldersIn(files).flatMap((folder): readonly Finding[] => {
+			const message = messageFor(folder, context);
+			return message === undefined ? [] : [{ file: folder, message }];
+		});
+	},
+	description:
+		"A package folder is named after its package, a module folder after its main file, a content folder in snake_case and every other folder in kebab-case.",
+	id: "files/folder-names",
+	options: Schema.toStandardSchemaV1(FolderNamesOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
+});

package/src/rules/files/namedAfterExport.ts

@@ -0,0 +1,87 @@
+import { posix } from "node:path";
+import { Effect, Schema } from "effect";
+import ignore from "ignore";
+import { exportFits } from "#naming/exportFits.ts";
+import { mainExport } from "#naming/mainExport.ts";
+import { ownExports } from "#naming/ownExports.ts";
+import { type PackageLayout, packageLayout } from "#naming/packageLayout.ts";
+import { CAMEL, KEBAB, sameWord, wordsOf } from "#naming/words.ts";
+import { defineRule, type Finding, type SourceFile } from "#rule.ts";
+import { parse } from "#rules/syntax.ts";
+
+const DEFAULT_TOOL_OWNED: readonly string[] = ["*.config.*", "*.d.ts", "*.d.mts", "*.d.cts"];
+
+const TEST = /\.(?:test|spec)\.[cm]?[jt]sx?$/u;
+
+const SHEBANG = "#!";
+
+const SHAPES =
+	"The file name and the names of its folders spell the export, in any order, and the file's first letter follows the export's case: listItems in items/ is items/list.ts, ItemPanel is ItemPanel.tsx or item/Panel.tsx.";
+
+const NamedAfterExportOptions = Schema.Struct({
+	toolOwned: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed(DEFAULT_TOOL_OWNED))),
+});
+
+function stemOf(path: string): string {
+	return posix.basename(path).replace(/\.[^.]+$/u, "");
+}
+
+function repeated(stem: string, folders: readonly string[]): string | undefined {
+	if (folders.at(-1) === stem) {
+		return undefined;
+	}
+	const words = wordsOf(stem);
+	return folders.find((folder) => wordsOf(folder).some((word) => words.some((own) => sameWord(own, word))));
+}
+
+function nameFinding(file: SourceFile, stem: string, folders: readonly string[]): string | undefined {
+	const source = parse(file);
+	const exports = source === undefined ? [] : ownExports(source);
+	const [only] = exports;
+	if (only === undefined) {
+		return CAMEL.test(stem)
+			? undefined
+			: `"${stem}" exports nothing, so it is named in camelCase, such as setupTests.ts. A file that a package.json script or bin runs is kebab-case.`;
+	}
+	if (exports.length === 1 && only.constant) {
+		return `"${stem}" exports only the constant ${only.name}. Constants live in a topic file with related constants, such as limits.ts holding MAX_ITEMS and MAX_DEPTH.`;
+	}
+	if (exports.some((entry) => exportFits(entry.name, stem, folders))) {
+		return undefined;
+	}
+	const main = mainExport(exports);
+	if (main !== undefined) {
+		return `"${stem}" does not name its export ${main.name}. ${SHAPES} Rename the file or the export.`;
+	}
+	return CAMEL.test(stem)
+		? undefined
+		: `"${stem}" exports several things, so it is a topic file named in camelCase, such as limits.ts. Or split it so each file has one main export. ${SHAPES}`;
+}
+
+function findingsOf(file: SourceFile, layout: PackageLayout): readonly Finding[] {
+	const stem = stemOf(file.path);
+	const folders = layout.foldersOf(file.path);
+	if (layout.scripts.has(file.path) || file.text.startsWith(SHEBANG)) {
+		return KEBAB.test(stem)
+			? []
+			: [{ file: file.path, message: `"${stem}" is run as a script, so it is named in kebab-case, such as build-docs.ts.` }];
+	}
+	const folder = repeated(stem, folders);
+	const messages = [
+		nameFinding(file, stem, folders),
+		folder === undefined ? undefined : `"${stem}" repeats its folder "${folder}". The folder is the prefix: items/listItems.ts is items/list.ts.`,
+	];
+	return messages.flatMap((message) => (message === undefined ? [] : [{ file: file.path, message }]));
+}
+
+export const namedAfterExport = defineRule({
+	check: async ({ files, options, readText, sources }) => {
+		const layout = await packageLayout({ files, readText });
+		const toolOwned = ignore().add([...options.toolOwned]);
+		return sources.filter((file) => !(TEST.test(file.path) || toolOwned.ignores(file.path))).flatMap((file) => findingsOf(file, layout));
+	},
+	description:
+		"A file is named after its main export, with its folders as the prefix; a file of several exports is a camelCase topic file, and a script is kebab-case. Rename the file or the export; nothing renames them for you.",
+	id: "files/named-after-export",
+	options: Schema.toStandardSchemaV1(NamedAfterExportOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
+});

package/src/rules/files/otherNames.ts

@@ -0,0 +1,118 @@
+import { posix } from "node:path";
+import { Effect, Schema } from "effect";
+import ignore, { type Ignore } from "ignore";
+import { CAMEL, KEBAB } from "#naming/words.ts";
+import { defineRule, type Finding, type SourceFile } from "#rule.ts";
+
+const DEFAULT_TOOL_OWNED: readonly string[] = [
+	".*",
+	"package.json",
+	"tsconfig*.json",
+	"biome.json",
+	"biome.jsonc",
+	"*.config.*",
+	"migrations/",
+	"generated/",
+];
+
+const CONVENTIONAL: ReadonlySet<string> = new Set(["AGENTS", "CHANGELOG", "CLAUDE", "CONTRIBUTING", "LICENSE", "README", "SECURITY", "SKILL"]);
+
+const KEBAB_KINDS: ReadonlySet<string> = new Set([
+	"avif",
+	"gif",
+	"grit",
+	"ico",
+	"jpeg",
+	"jpg",
+	"json",
+	"jsonc",
+	"md",
+	"mdx",
+	"otf",
+	"png",
+	"svg",
+	"ttf",
+	"webp",
+	"woff",
+	"woff2",
+]);
+
+const STYLESHEETS: ReadonlySet<string> = new Set(["css", "scss"]);
+
+const DOTTED_KEBAB = /^[a-z0-9]+(?:-[a-z0-9]+)*(?:\.[a-z0-9]+(?:-[a-z0-9]+)*)*$/u;
+
+const SNAKE = /^[a-z0-9]+(?:_[a-z0-9]+)*$/u;
+
+const STYLESHEET_IMPORT = /["'](?<stylesheet>\.{1,2}\/[^"'\n]+\.s?css)["']/gu;
+
+const CODE = /\.[cm]?[jt]sx?$/u;
+
+const OtherNamesOptions = Schema.Struct({
+	content: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+	toolOwned: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed(DEFAULT_TOOL_OWNED))),
+});
+
+function importers(sources: readonly SourceFile[]): ReadonlyMap<string, readonly string[]> {
+	const found = new Map<string, string[]>();
+	for (const source of sources) {
+		for (const match of source.text.matchAll(STYLESHEET_IMPORT)) {
+			const target = posix.normalize(posix.join(posix.dirname(source.path), match.groups?.stylesheet ?? ""));
+			found.set(target, [...new Set([...(found.get(target) ?? []), source.path])]);
+		}
+	}
+	return found;
+}
+
+function stylesheetMessage(path: string, stem: string, importedBy: readonly string[]): string | undefined {
+	const [only] = importedBy;
+	if (importedBy.length === 1 && only !== undefined) {
+		const owner = posix.basename(only).replace(CODE, "");
+		return stem === owner ? undefined : `"${stem}" is styling for ${posix.basename(only)} alone, so it is named ${owner}${posix.extname(path)}.`;
+	}
+	return KEBAB.test(stem) ? undefined : `"${stem}" is a shared stylesheet, so it is named in kebab-case, such as form-controls.css.`;
+}
+
+interface Context {
+	readonly content: Ignore;
+	readonly stylesheets: ReadonlyMap<string, readonly string[]>;
+	readonly toolOwned: Ignore;
+}
+
+function messageFor(path: string, context: Context): string | undefined {
+	const name = posix.basename(path);
+	const kind = posix.extname(name).slice(1);
+	const stem = name.slice(0, name.length - kind.length - 1);
+	if (kind === "" || context.toolOwned.ignores(path) || CONVENTIONAL.has(stem)) {
+		return undefined;
+	}
+	if (context.content.ignores(path)) {
+		return SNAKE.test(stem) ? undefined : `"${name}" is content, so it is named in snake_case, such as forest_path.json.`;
+	}
+	if (STYLESHEETS.has(kind)) {
+		return stylesheetMessage(path, stem, context.stylesheets.get(path) ?? []);
+	}
+	if (kind === "prisma") {
+		return CAMEL.test(stem) ? undefined : `"${name}" is a Prisma schema, so it is named in camelCase, such as schema.prisma.`;
+	}
+	return KEBAB_KINDS.has(kind) && !DOTTED_KEBAB.test(stem)
+		? `"${name}" is named in kebab-case, such as release-notes.md. Only conventional names such as README.md and CHANGELOG.md are upper case.`
+		: undefined;
+}
+
+export const otherNames = defineRule({
+	check: ({ files, options, sources }) => {
+		const context: Context = {
+			content: ignore().add([...options.content]),
+			stylesheets: importers(sources),
+			toolOwned: ignore().add([...options.toolOwned]),
+		};
+		return files.flatMap((path): readonly Finding[] => {
+			const message = messageFor(path, context);
+			return message === undefined ? [] : [{ file: path, message }];
+		});
+	},
+	description:
+		"Documents, data, assets and GritQL files are kebab-case, a stylesheet that one component imports is named after it, a Prisma schema is camelCase and content is snake_case.",
+	id: "files/other-names",
+	options: Schema.toStandardSchemaV1(OtherNamesOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
+});

package/src/rules/imports/aliased.ts

@@ -1,5 +1,5 @@
-import { type Departure, departures } from "../../imports/departures.ts";
-import { defineRule } from "../../rule.ts";
+import { type Departure, departures } from "#imports/departures.ts";
+import { defineRule } from "#rule.ts";
 
 function messageOf({ installed, specifier, workspace }: Departure): string {
 	const leaves = `"${specifier}" leaves its folder.`;

package/src/rules/imports/cycles.ts

@@ -1,7 +1,7 @@
-import { cyclicComponents } from "../../imports/components.ts";
-import { type ImportEdge, importGraph } from "../../imports/graph.ts";
-import { shortestPath } from "../../imports/paths.ts";
-import { defineRule, type Finding } from "../../rule.ts";
+import { cyclicComponents } from "#imports/components.ts";
+import { type ImportEdge, importGraph } from "#imports/graph.ts";
+import { shortestPath } from "#imports/paths.ts";
+import { defineRule, type Finding } from "#rule.ts";
 
 type RuntimeEdge = ImportEdge & { readonly to: { readonly kind: "file"; readonly path: string } };
 

package/src/rules/imports/fences.ts

@@ -1,8 +1,8 @@
 import { Effect, Schema } from "effect";
-import type { Fence } from "../../imports/fences/model.ts";
-import { compilePolicy } from "../../imports/fences/policy.ts";
-import { importGraph } from "../../imports/graph.ts";
-import { defineRule } from "../../rule.ts";
+import type { Fence } from "#imports/fences/model.ts";
+import { compilePolicy } from "#imports/fences/policy.ts";
+import { importGraph } from "#imports/graph.ts";
+import { defineRule } from "#rule.ts";
 
 function isFence(value: unknown): value is Fence {
 	return typeof value === "object" && value !== null && "_tag" in value && value._tag === "Fence";

package/src/rules/imports/resolvable.ts

@@ -1,7 +1,7 @@
 import { Effect, Schema } from "effect";
-import { withoutGenerated } from "../../imports/generated.ts";
-import { importGraph } from "../../imports/graph.ts";
-import { defineRule } from "../../rule.ts";
+import { withoutGenerated } from "#imports/generated.ts";
+import { importGraph } from "#imports/graph.ts";
+import { defineRule } from "#rule.ts";
 
 const ResolvableOptions = Schema.Struct({
 	generated: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),

package/src/rules/manifests-sorted.ts

@@ -1,7 +1,7 @@
 import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
 import { Effect } from "effect";
-import { manifestsIn, sortingOf } from "../manifests/sorted.ts";
-import { defineRule, type Finding } from "../rule.ts";
+import { manifestsIn, sortingOf } from "#manifests/sorted.ts";
+import { defineRule, type Finding } from "#rule.ts";
 
 const MESSAGES = {
 	Invalid: "Is not valid JSON.",

package/src/rules/max-lines.ts

@@ -1,6 +1,6 @@
 import { Effect, Schema } from "effect";
 import ignore from "ignore";
-import { defineRule, type Finding, type SourceFile } from "../rule.ts";
+import { defineRule, type Finding, type SourceFile } from "#rule.ts";
 
 const DEFAULT_TEST_FILES: readonly string[] = ["*.test.*", "*.spec.*", "test/", "tests/", "__tests__/"];
 const DECLARATION = /\.d\.[cm]?ts$/u;

package/src/rules/suppressions/biome/configs.ts

@@ -1,5 +1,5 @@
 import { posix } from "node:path";
-import type { Finding, RuleInputs } from "../../../rule.ts";
+import type { Finding, RuleInputs } from "#rule.ts";
 import { type Declaration, decodeShipped, PRESET_DECLARATIONS } from "./declarations.ts";
 import { itemsOf, type Json, member, type Parsed, parseJsonc, textOf } from "./json.ts";
 import { resolvePackage } from "./resolve.ts";

package/src/rules/suppressions/biome/declarations.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { type Decoded, decodeWith } from "../../../decoded.ts";
+import { type Decoded, decodeWith } from "#decoded.ts";
 
 export const Declaration = Schema.Struct({
 	includes: Schema.NonEmptyArray(Schema.NonEmptyString),

package/src/rules/suppressions/biome/resolve.ts

@@ -1,7 +1,7 @@
 import { posix } from "node:path";
 import { Schema } from "effect";
-import { decodeWith } from "../../../decoded.ts";
-import type { RuleInputs } from "../../../rule.ts";
+import { decodeWith } from "#decoded.ts";
+import type { RuleInputs } from "#rule.ts";
 
 const Manifest = Schema.Struct({
 	exports: Schema.optionalKey(Schema.Unknown),