@shivaedev/quality 0.26.0 → 0.27.1

package/src/hooks/status.ts

@@ -0,0 +1,50 @@
+import { constants } from "node:fs";
+import { access, realpath } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { Console, Effect } from "effect";
+import { GateFailed, SetupFailure } from "#failure.ts";
+import { git, gitOrFail } from "#git/command.ts";
+import { readOptionalText } from "#inventory/filesystem.ts";
+import { type HookLocation, hookLocation } from "./location.ts";
+import { isHookShim } from "./shim.ts";
+
+function executable(file: string) {
+	return Effect.promise(async () => {
+		try {
+			await access(file, constants.X_OK);
+			return await realpath(file);
+		} catch {
+			return undefined;
+		}
+	});
+}
+
+export const globalHookStatus = Effect.fn("Hooks.globalHookStatus")(function* (location: HookLocation) {
+	const global = yield* git(location.toplevel, ["config", "--global", "--includes", "--type=path", "--get", "core.hooksPath"]);
+	if (global.code !== 0 && global.code !== 1) {
+		return yield* new SetupFailure({ message: `cannot read global core.hooksPath: ${global.stderr.trim()}` });
+	}
+	const path = global.stdout.trim();
+	const hook = resolve(location.toplevel, path, "pre-commit");
+	const target = path === "" ? undefined : yield* executable(hook);
+	const own = yield* executable(location.file);
+	yield* Console.log(
+		target !== undefined && target !== own
+			? `quality: chaining global pre-commit hook at ${hook}.`
+			: "quality: no executable global pre-commit hook to chain.",
+	);
+});
+
+export const hookStatus = Effect.fn("Hooks.hookStatus")(function* (cwd: string) {
+	const location = yield* hookLocation(cwd);
+	const path = (yield* gitOrFail(cwd, ["rev-parse", "--path-format=absolute", "--git-path", "hooks/pre-commit"])).trim();
+	const text = yield* readOptionalText(path).pipe(Effect.mapError((error) => new SetupFailure({ message: error.message })));
+	if (text === undefined || !isHookShim(text) || (yield* executable(path)) === undefined) {
+		yield* Console.error(
+			`quality: the effective hooks path ${dirname(path)} does not run Quality's pre-commit hook.\nhelp: run \`quality hooks install\` to check commits.`,
+		);
+		return yield* new GateFailed();
+	}
+	yield* Console.log(`quality: git runs Quality's pre-commit hook at ${path}.`);
+	yield* globalHookStatus(location);
+});

package/src/hooks/uninstall.ts

@@ -1,5 +1,7 @@
+import { dirname } from "node:path";
 import { Console, Effect, FileSystem } from "effect";
 import { SetupFailure } from "#failure.ts";
+import { git, gitOrFail } from "#git/command.ts";
 import { readOptionalText } from "#inventory/filesystem.ts";
 import { hookLocation } from "./location.ts";
 import { isHookShim } from "./shim.ts";
@@ -15,5 +17,9 @@ export const uninstallHook = Effect.fn("Hooks.uninstallHook")(function* (cwd: st
 		return yield* Console.error(`quality: kept ${file}: it is not quality's pre-commit hook.`);
 	}
 	yield* Effect.mapError(fs.remove(file), (error) => new SetupFailure({ message: `cannot remove ${file}: ${error.message}` }));
+	const local = yield* git(cwd, ["config", "--local", "--get", "core.hooksPath"]);
+	if (local.stdout.trim() === dirname(file)) {
+		yield* gitOrFail(cwd, ["config", "--local", "--unset-all", "core.hooksPath"]);
+	}
 	yield* Console.log(`quality: removed the pre-commit hook at ${file}.`);
 });

package/src/inventory/collect.ts

@@ -4,6 +4,7 @@ import ignore from "ignore";
 import type { SourceFile } from "#rule.ts";
 import { FilesystemFailure, orWhenAbsent, readRequiredText } from "./filesystem.ts";
 import { posix } from "./ignoreScope.ts";
+import { shadcnFolders } from "./shadcnFolders.ts";
 import { scopeAbove, walk } from "./walk.ts";
 
 export interface InventoryScope {
@@ -49,10 +50,12 @@ export const collectInventory = Effect.fn("Inventory.collectInventory")(function
 	scope: InventoryScope,
 ): Effect.fn.Return<Inventory, FilesystemFailure, FileSystem.FileSystem> {
 	const excluded = ignore().add([...scope.exclude]);
+	const toolOwned = yield* shadcnFolders(root);
 	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))
+		.filter((path) => !toolOwned.some((folder) => path.startsWith(`${folder}/`)))
 		.sort((left, right) => {
 			if (left === right) {
 				return 0;

package/src/inventory/shadcnAlias.ts

@@ -0,0 +1,88 @@
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import ts from "typescript";
+
+const PROBE = "__quality_shadcn__.tsx";
+
+function capture(pattern: string, alias: string): string | undefined {
+	const star = pattern.indexOf("*");
+	if (star === -1) {
+		return pattern === alias ? "" : undefined;
+	}
+	const prefix = pattern.slice(0, star);
+	const suffix = pattern.slice(star + 1);
+	return alias.startsWith(prefix) && alias.endsWith(suffix)
+		? alias.slice(prefix.length, suffix.length === 0 ? undefined : -suffix.length)
+		: undefined;
+}
+
+function pathTarget(alias: string, options: ts.CompilerOptions, directory: string): string | undefined {
+	const pathsBase = Reflect.get(options, "pathsBasePath");
+	const base = options.baseUrl ?? (typeof pathsBase === "string" ? pathsBase : directory);
+	const patterns = Object.entries(options.paths ?? {}).toSorted(([left], [right]) => right.indexOf("*") - left.indexOf("*"));
+	const exact = options.paths?.[alias]?.[0];
+	if (exact !== undefined) {
+		return resolve(base, exact);
+	}
+	for (const [pattern, targets] of patterns) {
+		const captured = capture(pattern, alias);
+		const target = targets[0];
+		if (captured !== undefined && target !== undefined) {
+			return resolve(base, target.replace("*", captured));
+		}
+	}
+	return undefined;
+}
+
+export function shadcnAlias(directory: string, alias: string): string {
+	if (alias.startsWith(".") || isAbsolute(alias)) {
+		return resolve(directory, alias);
+	}
+	const config = ts.findConfigFile(directory, ts.sys.fileExists);
+	const parsed =
+		config === undefined
+			? undefined
+			: ts.getParsedCommandLineOfConfigFile(
+					config,
+					{},
+					{
+						...ts.sys,
+						onUnRecoverableConfigFileDiagnostic: () => undefined,
+					},
+				);
+	if (parsed?.errors.length) {
+		throw new Error(
+			ts.formatDiagnostics(parsed.errors, {
+				getCanonicalFileName: (file) => file,
+				getCurrentDirectory: () => directory,
+				getNewLine: () => "\n",
+			}),
+		);
+	}
+	const options = parsed?.options ?? {};
+	const target = pathTarget(alias, options, config === undefined ? directory : dirname(config));
+	if (target !== undefined) {
+		return target;
+	}
+	if (!alias.startsWith("#")) {
+		throw new Error(`Cannot resolve shadcn UI alias "${alias}" from ${directory}. Check tsconfig paths.`);
+	}
+	// A synthetic child lets TypeScript resolve directory aliases through package imports without requiring a stock component to exist.
+	const resolved = ts.resolveModuleName(
+		`${alias}/${PROBE}`,
+		join(directory, "components.tsx"),
+		{
+			...options,
+			customConditions: ["source", ...(options.customConditions ?? [])],
+			moduleResolution: ts.ModuleResolutionKind.Bundler,
+		},
+		{
+			...ts.sys,
+			directoryExists: () => true,
+			fileExists: (file) => file.endsWith(`/${PROBE}`) || ts.sys.fileExists(file),
+		},
+	).resolvedModule;
+	if (resolved === undefined) {
+		throw new Error(`Cannot resolve shadcn UI alias "${alias}" from ${directory}. Check tsconfig paths or package imports.`);
+	}
+	return dirname(resolved.resolvedFileName);
+}

package/src/inventory/shadcnFolders.ts

@@ -0,0 +1,30 @@
+import { basename, dirname, relative } from "node:path";
+import { Effect, type FileSystem, Schema } from "effect";
+import { FilesystemFailure, readRequiredText } from "./filesystem.ts";
+import { posix } from "./ignoreScope.ts";
+import { shadcnAlias } from "./shadcnAlias.ts";
+import { walk } from "./walk.ts";
+
+const Components = Schema.fromJsonString(Schema.Struct({ aliases: Schema.Struct({ ui: Schema.NonEmptyString }) }));
+
+export const shadcnFolders = Effect.fn("Inventory.shadcnFolders")(function* (
+	root: string,
+): Effect.fn.Return<readonly string[], FilesystemFailure, FileSystem.FileSystem> {
+	const paths = (yield* walk(root)).filter((path) => basename(path) === "components.json");
+	return yield* Effect.forEach(paths, (path) =>
+		Effect.gen(function* () {
+			const text = yield* readRequiredText(path);
+			return yield* Effect.try({
+				catch: (cause) => new FilesystemFailure({ message: `cannot resolve ${path}: ${String(cause)}`, path }),
+				try: () => {
+					const { aliases } = Schema.decodeUnknownSync(Components)(text);
+					const folder = posix(relative(root, shadcnAlias(dirname(path), aliases.ui)));
+					if (folder === "" || folder === ".." || folder.startsWith("../")) {
+						throw new Error("the shadcn UI folder must be inside the repository and cannot be its root");
+					}
+					return folder;
+				},
+			});
+		}),
+	);
+});

package/src/naming/migrationFile.ts

@@ -0,0 +1,9 @@
+import { posix } from "node:path";
+
+export const MIGRATIONS_DIRECTORY = "src/server/migrations";
+export const MIGRATION_FILE_PATTERN = /^[0-9]{4}_[a-z][a-z0-9]*(?:_[a-z0-9]+)*\.ts$/u;
+
+export function isMigrationFile(path: string): boolean {
+	const directory = posix.dirname(path);
+	return (directory === MIGRATIONS_DIRECTORY || directory.endsWith(`/${MIGRATIONS_DIRECTORY}`)) && MIGRATION_FILE_PATTERN.test(posix.basename(path));
+}

package/src/rules/files/folderNames.ts

@@ -5,15 +5,13 @@ 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[] = ["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))),
+	toolOwned: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
 });
 
 function foldersIn(files: readonly string[]): readonly string[] {

package/src/rules/files/namedAfterExport.ts

@@ -3,6 +3,7 @@ import { Effect, Schema } from "effect";
 import ignore from "ignore";
 import { exportFits } from "#naming/exportFits.ts";
 import { mainExport } from "#naming/mainExport.ts";
+import { isMigrationFile } from "#naming/migrationFile.ts";
 import { ownExports } from "#naming/ownExports.ts";
 import { type PackageLayout, packageLayout } from "#naming/packageLayout.ts";
 import { CAMEL, KEBAB, sameWord, wordsOf } from "#naming/words.ts";
@@ -86,7 +87,9 @@ 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));
+		return sources
+			.filter((file) => !(TEST.test(file.path) || isMigrationFile(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.",

package/src/rules/files/otherNames.ts

@@ -5,7 +5,7 @@ import { CAMEL, KEBAB } from "#naming/words.ts";
 import { defineRule, type Finding } from "#rule.ts";
 import { stylesheetImporters } from "./stylesheetImporters.ts";
 
-const DEFAULT_TOOL_OWNED: readonly string[] = [".*", "package.json", "tsconfig*.json", "biome.json", "biome.jsonc", "*.config.*", "migrations/"];
+const DEFAULT_TOOL_OWNED: readonly string[] = [".*", "package.json", "tsconfig*.json", "biome.json", "biome.jsonc", "*.config.*"];
 
 const CONVENTIONAL: ReadonlySet<string> = new Set(["AGENTS", "CHANGELOG", "CLAUDE", "CONTRIBUTING", "LICENSE", "README", "SECURITY", "SKILL"]);
 

package/src/testProjects.ts

@@ -1,5 +1,6 @@
+import { fileURLToPath } from "node:url";
 import { Config, ConfigProvider, Effect } from "effect";
-import { defaultExclude, type TestUserConfig } from "vitest/config";
+import { coverageConfigDefaults, defaultExclude, type TestUserConfig } from "vitest/config";
 import type { Environment } from "#naming/testName.ts";
 
 const EXTENSION = "?(c|m)[jt]s?(x)";
@@ -14,13 +15,36 @@ function excluding(...patterns: readonly string[]): string[] {
 	return [...defaultExclude, named("typecheck"), TYPECHECK_ALONE, ...patterns];
 }
 
-export function testProjects(): TestUserConfig {
+export interface TestProjectsOptions {
+	readonly coverage?: boolean | NonNullable<TestUserConfig["coverage"]>;
+}
+
+export function testProjects({ coverage = false }: TestProjectsOptions = {}): TestUserConfig {
 	const ci = Effect.runSync(Config.String("CI").pipe(Config.withDefault("")).parse(ConfigProvider.fromEnv()));
 	return {
+		...(coverage === false
+			? {}
+			: {
+					coverage: {
+						enabled: true,
+						exclude: [...coverageConfigDefaults.exclude, "**/*.d.ts", "**/*.test.*", "**/*.spec.*", "**/test-support/**"],
+						include: ["src/**/*.{ts,tsx}"],
+						provider: "v8",
+						...(coverage === true ? {} : coverage),
+					},
+				}),
 		project: ["unit", "dom"],
 		projects: [
 			{ extends: true, test: { environment: "node", exclude: excluding(named("dom"), named("slow")), include: [named()], name: "unit" } },
-			{ extends: true, test: { environment: "happy-dom", exclude: excluding(named("slow")), include: [named("dom")], name: "dom" } },
+			{
+				extends: true,
+				test: {
+					environment: fileURLToPath(import.meta.resolve("#domEnvironment.config.ts")),
+					exclude: excluding(named("slow")),
+					include: [named("dom")],
+					name: "dom",
+				},
+			},
 			{ extends: true, test: { environment: "node", exclude: excluding(), include: [named("slow")], name: "slow" } },
 		],
 		silent: ci ? false : "passed-only",