@shivaedev/quality 0.18.0 → 0.20.0

package/src/biome/report.ts

@@ -1,11 +1,14 @@
+import { relative, sep } from "node:path";
 import { Schema } from "effect";
+import { ignoredTrackedPaths } from "#inventory/trackedPaths.ts";
+import { recognizeDiagnostics } from "./recognizeDiagnostics.ts";
 import { type BiomeRun, runBiome } from "./run.ts";
 
-const Position = Schema.Struct({ line: Schema.Int });
+const Position = Schema.Struct({ column: Schema.optionalKey(Schema.Int), line: Schema.Int });
 
 const Diagnostic = Schema.Struct({
 	category: Schema.optionalKey(Schema.String),
-	location: Schema.Struct({ path: Schema.optionalKey(Schema.String), start: Schema.optionalKey(Position) }),
+	location: Schema.Struct({ end: Schema.optionalKey(Position), path: Schema.optionalKey(Schema.String), start: Schema.optionalKey(Position) }),
 	message: Schema.String,
 	severity: Schema.String,
 });
@@ -21,11 +24,12 @@ export type Report = typeof Report.Type;
 
 const decodeReport = Schema.decodeUnknownOption(Schema.fromJsonString(Report));
 
-const failure = (args: readonly string[], run: BiomeRun): Error =>
-	new Error(`biome ${args.join(" ")} exited ${run.code} without a report:\n${[run.stdout, run.stderr].join("\n").trim()}`);
+function failure(args: readonly string[], run: BiomeRun): Error {
+	return new Error(`biome ${args.join(" ")} exited ${run.code} without a report:\n${[run.stdout, run.stderr].join("\n").trim()}`);
+}
 
-export async function biomeReport(root: string, args: readonly string[]): Promise<Report> {
-	const command = [...args, "--reporter=json", "--max-diagnostics=none", "."];
+async function reportFor(root: string, args: readonly string[], paths: readonly string[]): Promise<Report> {
+	const command = [...args, "--reporter=json", "--max-diagnostics=none", ...paths];
 	const run = await runBiome(root, command);
 	const report = decodeReport(run.stdout.trim());
 	if (report._tag === "None") {
@@ -33,3 +37,17 @@ export async function biomeReport(root: string, args: readonly string[]): Promis
 	}
 	return report.value;
 }
+
+export async function biomeReport(root: string, args: readonly string[]): Promise<Report> {
+	const [report, tracked] = await Promise.all([reportFor(root, args, ["."]), ignoredTrackedPaths(root)]);
+	const paths = tracked
+		.map((path) => relative(root, path))
+		.filter((path) => !path.split(sep).some((part) => part === ".git" || part === "node_modules"));
+	const extra = paths.length === 0 ? undefined : await reportFor(root, [...args, "--vcs-enabled=false"], paths);
+	const diagnostics = [...report.diagnostics, ...(extra?.diagnostics ?? [])];
+	const unique = [...new Map(diagnostics.map((diagnostic) => [JSON.stringify(diagnostic), diagnostic])).values()];
+	return {
+		diagnostics: recognizeDiagnostics(root, unique),
+		summary: { changed: report.summary.changed + (extra?.summary.changed ?? 0) },
+	};
+}

package/src/biome/syntax.ts

@@ -0,0 +1,36 @@
+import { readFileSync } from "node:fs";
+import ts from "typescript";
+
+export interface Syntax {
+	readonly checker: ts.TypeChecker;
+	readonly source: ts.SourceFile;
+}
+
+export function syntaxOf(path: string): Syntax {
+	const source = ts.createSourceFile(path, readFileSync(path, "utf8"), ts.ScriptTarget.Latest, true);
+	const options: ts.CompilerOptions = { allowJs: true, noLib: true, noResolve: true };
+	const host = ts.createCompilerHost(options);
+	host.getSourceFile = (file) => (file === path ? source : undefined);
+	const program = ts.createProgram([path], options, host);
+	return { checker: program.getTypeChecker(), source };
+}
+
+export function offsetOf(source: ts.SourceFile, position: { readonly line: number; readonly column?: number }): number | undefined {
+	const start = source.getLineStarts()[position.line - 1];
+	if (start === undefined || position.column === undefined || position.column < 1) {
+		return undefined;
+	}
+	const line = source.text.slice(start, source.getLineStarts()[position.line] ?? source.text.length);
+	const characters = [...line];
+	return position.column <= characters.length + 1 ? start + characters.slice(0, position.column - 1).join("").length : undefined;
+}
+
+export function nodeAt(source: ts.SourceFile, start: number, end: number): ts.Node | undefined {
+	function visit(node: ts.Node): ts.Node | undefined {
+		if (node.getStart(source) > start || node.end < end) {
+			return undefined;
+		}
+		return ts.forEachChild(node, visit) ?? (node.getStart(source) === start && node.end === end ? node : undefined);
+	}
+	return visit(source);
+}

package/src/cli/args.ts

@@ -37,9 +37,9 @@ baseline migrate  Move a baseline from the earlier JSON format (--from, quality/
 hooks install     Install the git pre-commit hook, shared by every worktree, that runs hooks pre-commit. Keeps a hook that is not quality's
                   unless --force replaces it.
 hooks uninstall   Remove quality's pre-commit hook. Keeps a hook that is not quality's.
-hooks pre-commit  What the hook runs: baseline tighten for staged files when preCommit.tighten is set, lint, then each preCommit.run command.
+hooks pre-commit  What the hook runs: lint, then package.json scripts typecheck and quality:commit when present.
 
---config <file>  Config file; its directory is the repository root. Defaults to ./quality.config.ts.
+--config <file>  Config file; its directory is the repository root. Without this option, uses ./quality.config.ts when present, otherwise defaults.
 --against <ref>  The branch the work merges into, whose merge base prune follows moves from. Defaults to origin/HEAD, then origin/main, then origin/master.
 Exit codes: 0 passed, 1 failed the gate, 2 could not run.`;
 

package/src/cli/baseline.ts

@@ -46,11 +46,11 @@ const changes = (pruned: Pruned): string => {
 	return `${parts.slice(0, -1).join(", ")} and ${parts.at(-1)}`;
 };
 
-export const shrinkBaseline = <Requirements>(
+export const shrinkBaseline = <TRequirements>(
 	cwd: string,
 	config: string | undefined,
-	scopeOf: (session: Session) => Effect.Effect<Scope, SetupFailure, Requirements>,
-): Effect.Effect<void, SetupFailure, FileSystem.FileSystem | Requirements> =>
+	scopeOf: (session: Session) => Effect.Effect<Scope, SetupFailure, TRequirements>,
+): Effect.Effect<void, SetupFailure, FileSystem.FileSystem | TRequirements> =>
 	Effect.gen(function* () {
 		const session = yield* openSession(cwd, config);
 		if (session.baseline.raw === undefined) {

package/src/cli/fix.ts

@@ -33,21 +33,21 @@ export function snapshotOf(root: string): Effect.Effect<ReadonlyMap<string, stri
 	}).pipe(Effect.mapError((failure) => new SetupFailure({ message: failure.message })));
 }
 
-export interface Pass<Failure, Requirements> {
+export interface Pass<TFailure, TRequirements> {
 	readonly label: string;
-	readonly run: Effect.Effect<number, Failure, Requirements>;
+	readonly run: Effect.Effect<number, TFailure, TRequirements>;
 }
 
-export interface Settling<Failure, Requirements> {
-	readonly passes: ReadonlyArray<Pass<Failure, Requirements>>;
-	readonly snapshot: Effect.Effect<ReadonlyMap<string, string>, Failure, Requirements>;
+export interface Settling<TFailure, TRequirements> {
+	readonly passes: readonly Pass<TFailure, TRequirements>[];
+	readonly snapshot: Effect.Effect<ReadonlyMap<string, string>, TFailure, TRequirements>;
 }
 
 function changedBy(root: string, args: readonly string[]): Effect.Effect<number, SetupFailure> {
 	return Effect.map(biome(root, args), (report) => report.summary.changed);
 }
 
-function biomePasses(root: string): ReadonlyArray<Pass<SetupFailure, never>> {
+function biomePasses(root: string): readonly Pass<SetupFailure, never>[] {
 	return [
 		{
 			label: "with fixes",
@@ -57,11 +57,11 @@ function biomePasses(root: string): ReadonlyArray<Pass<SetupFailure, never>> {
 	];
 }
 
-function round<Failure, Requirements>(
-	passes: ReadonlyArray<Pass<Failure, Requirements>>,
+function round<TFailure, TRequirements>(
+	passes: readonly Pass<TFailure, TRequirements>[],
 	index: number,
-	afterEachPass: Effect.Effect<void, Failure, Requirements>,
-): Effect.Effect<number, Failure, Requirements> {
+	afterEachPass: Effect.Effect<void, TFailure, TRequirements>,
+): Effect.Effect<number, TFailure, TRequirements> {
 	return Effect.gen(function* () {
 		let total = 0;
 		const parts: string[] = [];
@@ -91,14 +91,14 @@ function unsettled(changed: ReadonlySet<string>): SetupFailure {
 					"Run `biome check --write --unsafe --verbose` to name them.",
 				];
 	return new SetupFailure({
-		message: [...named, "Two fixes probably undo each other there. Fix the code by hand, or turn off one of the rules."].join("\n"),
+		message: [...named, "Two fixes probably undo each other there. Repair the conflicting code by hand so both checks pass."].join("\n"),
 	});
 }
 
-export function settle<Failure, Requirements>({
+export function settle<TFailure, TRequirements>({
 	passes,
 	snapshot,
-}: Settling<Failure, Requirements>): Effect.Effect<void, Failure | SetupFailure, Requirements> {
+}: Settling<TFailure, TRequirements>): Effect.Effect<void, TFailure | SetupFailure, TRequirements> {
 	return Effect.gen(function* () {
 		for (let index = 1; index < MAX_FIX_ROUNDS; index += 1) {
 			if ((yield* round(passes, index, Effect.void)) === 0) {

package/src/cli/run-main.ts

@@ -47,7 +47,7 @@ export function quietOnClosedPipe(stream: EventEmitter): void {
 
 const services = NodeChildProcessSpawner.layer.pipe(Layer.provideMerge(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer)));
 
-export const runMain = <Value, Error>(program: Effect.Effect<Value, Error, FileSystem.FileSystem | Git>): void => {
+export const runMain = <TValue, TError>(program: Effect.Effect<TValue, TError, FileSystem.FileSystem | Git>): void => {
 	quietOnClosedPipe(process.stdout);
 	quietOnClosedPipe(process.stderr);
 	const explained = Effect.tapCause(program, (cause) => (Cause.hasInterruptsOnly(cause) ? Effect.void : explain(cause)));

package/src/config/decode.ts

@@ -12,7 +12,7 @@ const isRule = (value: unknown): value is Rule =>
 	&& "configure" in value
 	&& typeof value.configure === "function";
 
-const Level = Schema.Literals(["error", "warn", "off"]);
+const Level = Schema.Literal("error");
 
 const Setting = Schema.Union([Level, Schema.Struct({ level: Schema.optionalKey(Level), options: Schema.optionalKey(Schema.Unknown) })]);
 
@@ -22,13 +22,17 @@ const AdoptRemoved = Schema.Never.annotate({
 	message: "removed in quality 0.7.0. Delete the key, and record a rule's existing findings with `quality baseline write --rule <id>`.",
 });
 
+const PreCommitRemoved = Schema.Never.annotate({
+	message:
+		"removed. Put repository checks in the package.json quality:commit script; the hook also runs typecheck when present. Use `quality baseline tighten --staged` explicitly to lower staged debt.",
+});
+
 const ConfigInput = Schema.Struct({
 	adopt: Schema.optionalKey(AdoptRemoved),
 	baseline: Schema.optionalKey(Schema.String),
-	exclude: Schema.optionalKey(Schema.Array(Schema.String)),
 	extensions: Schema.optionalKey(Schema.Array(Schema.String)),
 	local: Schema.optionalKey(Schema.Array(LocalRule)),
-	preCommit: Schema.optionalKey(Schema.Struct({ run: Schema.optionalKey(Schema.Array(Schema.String)), tighten: Schema.optionalKey(Schema.Boolean) })),
+	preCommit: Schema.optionalKey(PreCommitRemoved),
 	registry: Schema.optionalKey(Schema.String),
 	rules: Schema.optionalKey(Schema.Record(Schema.String, Setting)),
 	sources: Schema.optionalKey(Schema.Array(Schema.String)),

package/src/config/load.ts

@@ -1,7 +1,6 @@
-import { dirname, resolve } from "node:path";
+import { basename, dirname, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { Effect, FileSystem } from "effect";
-import type { PreCommit } from "#config.ts";
 import { validOrFail } from "#decoded.ts";
 import { SetupFailure } from "#failure.ts";
 import type { InventoryScope } from "#inventory/collect.ts";
@@ -14,7 +13,6 @@ const DEFAULT_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs"
 export interface ResolvedConfig extends ResolvedRules, InventoryScope {
 	readonly baseline: string;
 	readonly file: string;
-	readonly preCommit: Required<PreCommit>;
 	readonly registry: string;
 	readonly root: string;
 }
@@ -36,10 +34,9 @@ const importDefault = (file: string): Effect.Effect<unknown, SetupFailure> =>
 const resolved = (root: string, file: string, config: ConfigInput, rules: ResolvedRules): ResolvedConfig => ({
 	...rules,
 	baseline: config.baseline ?? "quality/baseline.jsonl",
-	exclude: config.exclude ?? [],
+	exclude: [],
 	extensions: config.extensions ?? DEFAULT_EXTENSIONS,
 	file,
-	preCommit: { run: config.preCommit?.run ?? [], tighten: config.preCommit?.tighten ?? false },
 	registry: config.registry ?? "quality/registry.json",
 	root,
 	sources: config.sources ?? ["."],
@@ -49,11 +46,20 @@ export const loadConfig = (cwd: string, path: string | undefined): Effect.Effect
 	Effect.gen(function* () {
 		const fs = yield* FileSystem.FileSystem;
 		const file = resolve(cwd, path ?? CONFIG_FILE);
-		const present = yield* Effect.orElseSucceed(fs.exists(file), () => false);
-		if (!present) {
-			return yield* new SetupFailure({ message: `no config at ${file}. Create ${CONFIG_FILE} exporting defineConfig({ ... }), or pass --config.` });
+		const entries = yield* fs
+			.readDirectory(dirname(file))
+			.pipe(
+				Effect.catchTag("PlatformError", (error) =>
+					error.reason._tag === "NotFound"
+						? Effect.succeed<string[]>([])
+						: Effect.fail(new SetupFailure({ message: `cannot inspect ${file}: ${error.message}` })),
+				),
+			);
+		const present = entries.includes(basename(file));
+		if (!present && path !== undefined) {
+			return yield* new SetupFailure({ message: `no config at ${file}. Check the --config path.` });
 		}
-		const loaded = yield* importDefault(file);
+		const loaded = present ? yield* importDefault(file) : {};
 		const config = yield* validOrFail(file, yield* Effect.promise(() => decodeConfig(loaded)));
 		const rules = yield* validOrFail(file, yield* resolveRules(config));
 		return resolved(dirname(file), file, config, rules);

package/src/config/resolve.ts

@@ -1,5 +1,4 @@
 import { Effect } from "effect";
-import type { Level } from "#config.ts";
 import type { Decoded } from "#decoded.ts";
 import type { ActiveRule } from "#engine/run-rules.ts";
 import type { RuleIndex } from "#engine/violation.ts";
@@ -15,8 +14,6 @@ type Setting = NonNullable<ConfigInput["rules"]>[string];
 
 const messageOf = (cause: unknown): string => (cause instanceof Error ? cause.message : String(cause));
 
-const levelOf = (setting: Setting | undefined): Level => (typeof setting === "string" ? setting : (setting?.level ?? "error"));
-
 const optionsOf = (setting: Setting | undefined): unknown => (typeof setting === "object" ? setting.options : undefined);
 
 const duplicateIssues = (rules: readonly Rule[]): readonly string[] =>
@@ -24,23 +21,21 @@ const duplicateIssues = (rules: readonly Rule[]): readonly string[] =>
 		rules.findIndex((other) => other.id === rule.id) === index ? [] : [`local: rule id "${rule.id}" is already defined`],
 	);
 
-const activate = (rule: Rule, setting: Setting | undefined): Effect.Effect<Decoded<ActiveRule | undefined>> => {
-	const level = levelOf(setting);
-	if (level === "off") {
-		return Effect.succeed({ _tag: "Valid", value: undefined });
-	}
-	return Effect.tryPromise({ catch: messageOf, try: () => rule.configure(optionsOf(setting)) }).pipe(
+const activate = (rule: Rule, setting: Setting | undefined): Effect.Effect<Decoded<ActiveRule>> =>
+	Effect.tryPromise({ catch: messageOf, try: () => rule.configure(optionsOf(setting)) }).pipe(
 		Effect.map(
-			(configured): Decoded<ActiveRule | undefined> =>
+			(configured): Decoded<ActiveRule> =>
 				configured._tag === "Invalid"
 					? { _tag: "Invalid", issues: configured.issues.map((issue) => `rules.${rule.id}.options: ${issue}`) }
-					: { _tag: "Valid", value: { check: configured.check, description: rule.description, family: rule.family === true, id: rule.id, level } },
+					: {
+							_tag: "Valid",
+							value: { check: configured.check, description: rule.description, family: rule.family === true, id: rule.id, level: "error" },
+						},
 		),
 		Effect.catch((failure: string) =>
-			Effect.succeed<Decoded<ActiveRule | undefined>>({ _tag: "Invalid", issues: [`rules.${rule.id}.options: validation threw: ${failure}`] }),
+			Effect.succeed<Decoded<ActiveRule>>({ _tag: "Invalid", issues: [`rules.${rule.id}.options: validation threw: ${failure}`] }),
 		),
 	);
-};
 
 export const resolveRules = (config: ConfigInput): Effect.Effect<Decoded<ResolvedRules>> =>
 	Effect.gen(function* () {
@@ -58,8 +53,8 @@ export const resolveRules = (config: ConfigInput): Effect.Effect<Decoded<Resolve
 		if (issues.length > 0) {
 			return { _tag: "Invalid", issues };
 		}
-		const active = activated.flatMap((result) => (result._tag === "Valid" && result.value !== undefined ? [result.value] : []));
-		const levels = new Map(rules.map((rule) => [rule.id, levelOf(settings[rule.id])]));
+		const active = activated.flatMap((result) => (result._tag === "Valid" ? [result.value] : []));
+		const levels = new Map(rules.map((rule) => [rule.id, "error" as const]));
 		const unregistrable = new Set(rules.filter((rule) => rule.registrable === false).map((rule) => rule.id));
 		return { _tag: "Valid", value: { active, families, levels, unregistrable } };
 	});

package/src/config.ts

@@ -3,30 +3,23 @@ import type { Rule } from "./rule.ts";
 
 export type Level = "error" | "warn" | "off";
 
-export type RuleSetting<Input> = Level | { readonly level?: Level; readonly options?: Input };
+export type RuleSetting<TInput> = "error" | { readonly level?: "error"; readonly options?: TInput };
 
-type InputOf<Candidate> = Candidate extends Rule<string, infer Input> ? Input : never;
+type InputOf<TCandidate> = TCandidate extends Rule<string, infer TInput> ? TInput : never;
 
-export type RuleSettings<Rules extends readonly Rule[]> = {
-	readonly [Candidate in Rules[number] as Candidate["id"]]?: RuleSetting<InputOf<Candidate>>;
+export type RuleSettings<TRules extends readonly Rule[]> = {
+	readonly [TCandidate in TRules[number] as TCandidate["id"]]?: RuleSetting<InputOf<TCandidate>>;
 };
 
 export type BuiltInRules = typeof builtInRules;
 
-export interface PreCommit {
-	readonly run?: readonly string[];
-	readonly tighten?: boolean;
-}
-
-export interface QualityConfig<Local extends readonly Rule[] = readonly Rule[]> {
+export interface QualityConfig<TLocal extends readonly Rule[] = readonly Rule[]> {
 	readonly baseline?: string;
-	readonly exclude?: readonly string[];
 	readonly extensions?: readonly string[];
-	readonly local?: Local;
-	readonly preCommit?: PreCommit;
+	readonly local?: TLocal;
 	readonly registry?: string;
-	readonly rules?: RuleSettings<readonly [...BuiltInRules, ...Local]>;
+	readonly rules?: RuleSettings<readonly [...BuiltInRules, ...TLocal]>;
 	readonly sources?: readonly string[];
 }
 
-export const defineConfig = <const Local extends readonly Rule[] = readonly []>(config: QualityConfig<Local>): QualityConfig<Local> => config;
+export const defineConfig = <const TLocal extends readonly Rule[] = readonly []>(config: QualityConfig<TLocal>): QualityConfig<TLocal> => config;

package/src/decoded.ts

@@ -2,14 +2,14 @@ import { Effect } from "effect";
 import { SetupFailure } from "./failure.ts";
 import { describeIssue, type StandardSchemaV1 } from "./standard-schema.ts";
 
-export type Decoded<Value> = { readonly _tag: "Valid"; readonly value: Value } | { readonly _tag: "Invalid"; readonly issues: readonly string[] };
+export type Decoded<TValue> = { readonly _tag: "Valid"; readonly value: TValue } | { readonly _tag: "Invalid"; readonly issues: readonly string[] };
 
-export const decodeWith = async <Output>(schema: StandardSchemaV1<unknown, Output>, value: unknown): Promise<Decoded<Output>> => {
+export const decodeWith = async <TOutput>(schema: StandardSchemaV1<unknown, TOutput>, value: unknown): Promise<Decoded<TOutput>> => {
 	const result = await schema["~standard"].validate(value);
 	return result.issues === undefined ? { _tag: "Valid", value: result.value } : { _tag: "Invalid", issues: result.issues.map(describeIssue) };
 };
 
-export const validOrFail = <Value>(file: string, decoded: Decoded<Value>): Effect.Effect<Value, SetupFailure> =>
+export const validOrFail = <TValue>(file: string, decoded: Decoded<TValue>): Effect.Effect<TValue, SetupFailure> =>
 	decoded._tag === "Valid"
 		? Effect.succeed(decoded.value)
 		: Effect.fail(new SetupFailure({ message: `${file} is invalid:\n${decoded.issues.map((issue) => `  - ${issue}`).join("\n")}` }));

package/src/engine/session.ts

@@ -18,9 +18,9 @@ export interface Session {
 	readonly violations: readonly Violation[];
 }
 
-const setup = <Value, Requirements>(
-	effect: Effect.Effect<Value, FilesystemFailure, Requirements>,
-): Effect.Effect<Value, SetupFailure, Requirements> => Effect.mapError(effect, (failure) => new SetupFailure({ message: failure.message }));
+const setup = <TValue, TRequirements>(
+	effect: Effect.Effect<TValue, FilesystemFailure, TRequirements>,
+): Effect.Effect<TValue, SetupFailure, TRequirements> => Effect.mapError(effect, (failure) => new SetupFailure({ message: failure.message }));
 
 export const scan = (config: ResolvedConfig): Effect.Effect<Pick<Session, "inventory" | "violations">, SetupFailure, FileSystem.FileSystem> =>
 	Effect.gen(function* () {

package/src/engine/violation.ts

@@ -13,8 +13,8 @@ export const keyOf = (rule: string, file: string): string => `${rule}\u0000${fil
 export const byLocation = (left: Violation, right: Violation): number =>
 	left.rule.localeCompare(right.rule) || left.file.localeCompare(right.file) || (left.line ?? 0) - (right.line ?? 0);
 
-export const groupBy = <Item>(items: readonly Item[], key: (item: Item) => string): ReadonlyMap<string, readonly Item[]> => {
-	const groups = new Map<string, Item[]>();
+export const groupBy = <TItem>(items: readonly TItem[], key: (item: TItem) => string): ReadonlyMap<string, readonly TItem[]> => {
+	const groups = new Map<string, TItem[]>();
 	for (const item of items) {
 		const group = groups.get(key(item));
 		if (group === undefined) {

package/src/git/command.ts

@@ -1,5 +1,5 @@
 import { Effect, Stream } from "effect";
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
 import { SetupFailure } from "#failure.ts";
 
 export interface GitResult {

package/src/hooks/preCommit.ts

@@ -1,71 +1,62 @@
 import { join } from "node:path";
-import { Console, Effect, FileSystem } from "effect";
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-import type { Scope } from "#baseline/update.ts";
-import { shrinkBaseline } from "#cli/baseline.ts";
+import { Console, Effect, Schema } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
 import { lint } from "#cli/lint.ts";
-import { loadConfig, type ResolvedConfig } from "#config/load.ts";
+import { loadConfig } from "#config/load.ts";
+import { decodeWith, validOrFail } from "#decoded.ts";
 import { GateFailed, SetupFailure } from "#failure.ts";
-import { gitOrFail } from "#git/command.ts";
-import { changesSince } from "#git/history.ts";
+import { readOptionalText } from "#inventory/filesystem.ts";
 
 const COMMIT_AGAIN =
 	"help: fix what the output above reports, then commit again; `quality hooks pre-commit` repeats these checks without committing.";
 
-// A partly staged file is counted as it is on disk, which is not what the commit holds, so its entries wait for a later commit.
-const stagedScope = Effect.fnUntraced(function* (config: ResolvedConfig) {
-	const unstaged = (yield* changesSince(config.root, [])).files;
-	if (unstaged.has(config.baseline)) {
-		return undefined;
-	}
-	const staged = yield* changesSince(config.root, ["--cached"]);
-	const held = new Set([...unstaged, ...[...staged.moves].filter(([, to]) => unstaged.has(to)).map(([from]) => from)]);
-	const scope: Scope = {
-		files: new Set([...staged.files].filter((file) => !held.has(file))),
-		moves: new Map([...staged.moves].filter(([from]) => !held.has(from))),
-	};
-	return scope;
-});
+const Manifest = Schema.toStandardSchemaV1(
+	Schema.fromJsonString(
+		Schema.Struct({
+			packageManager: Schema.optionalKey(Schema.String),
+			scripts: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+		}),
+	),
+);
 
-const tighten = Effect.fnUntraced(function* (cwd: string, path: string | undefined, config: ResolvedConfig) {
-	const scope = yield* stagedScope(config);
-	if (scope === undefined) {
-		return yield* Console.error(
-			`quality: left ${config.baseline} as it is, because it has unstaged changes.\nhelp: stage or discard them to tighten it.`,
-		);
+const commitScripts = Effect.fnUntraced(function* (root: string) {
+	const file = join(root, "package.json");
+	const text = yield* readOptionalText(file).pipe(Effect.mapError((error) => new SetupFailure({ message: error.message })));
+	if (text === undefined) {
+		return { manager: "npm", scripts: [] };
 	}
-	yield* shrinkBaseline(cwd, path, () => Effect.succeed(scope));
-	const fs = yield* FileSystem.FileSystem;
-	if (yield* Effect.orElseSucceed(fs.exists(join(config.root, config.baseline)), () => false)) {
-		yield* gitOrFail(config.root, ["add", "--", config.baseline]);
+	const manifest = yield* validOrFail(file, yield* Effect.promise(() => decodeWith(Manifest, text)));
+	const manager = manifest.packageManager?.split("@")[0] ?? "npm";
+	if (!["npm", "pnpm", "yarn", "bun"].includes(manager)) {
+		return yield* new SetupFailure({ message: `${file}: unsupported packageManager "${manager}". Use npm, pnpm, yarn or bun.` });
 	}
+	return { manager, scripts: ["typecheck", "quality:commit"].filter((script) => manifest.scripts?.[script] !== undefined) };
 });
 
-const shell = Effect.fnUntraced(
-	function* (root: string, command: string) {
+const runScript = Effect.fnUntraced(
+	function* (root: string, manager: string, script: string) {
 		const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
 		const child = yield* spawner.spawn(
-			ChildProcess.make("sh", ["-c", command], { cwd: root, stderr: "inherit", stdin: "inherit", stdout: "inherit" }),
+			ChildProcess.make(manager, ["run", script], { cwd: root, stderr: "inherit", stdin: "inherit", stdout: "inherit" }),
 		);
 		return Number(yield* child.exitCode);
 	},
 	Effect.scoped,
-	Effect.mapError((error) => new SetupFailure({ message: `cannot run a pre-commit command: ${error.message}` })),
+	Effect.mapError((error) => new SetupFailure({ message: `cannot run a pre-commit script: ${error.message}` })),
 );
 
 export const preCommitHook = Effect.fn("Hooks.preCommitHook")(function* (cwd: string, path: string | undefined) {
 	const config = yield* loadConfig(cwd, path);
-	if (config.preCommit.tighten) {
-		yield* tighten(cwd, path, config);
-	}
+	const { manager, scripts } = yield* commitScripts(config.root);
 	const linted = yield* lint(cwd, path, "summary").pipe(
 		Effect.as(true),
 		Effect.catchTag("GateFailed", () => Effect.succeed(false)),
 	);
 	const failed = linted ? [] : ["quality lint"];
-	for (const command of config.preCommit.run) {
+	for (const script of scripts) {
+		const command = `${manager} run ${script}`;
 		yield* Console.log(`quality: running \`${command}\``);
-		const code = yield* shell(config.root, command);
+		const code = yield* runScript(config.root, manager, script);
 		if (code !== 0) {
 			failed.push(`\`${command}\` (exit code ${code})`);
 		}