lintmax 0.1.44

package/dist/cli.mjs

@@ -0,0 +1,1687 @@
+#!/usr/bin/env bun
+import { i as DEFAULT_SHARED_IGNORE_PATTERNS, o as OXLINT_CLI_ALLOW } from "./constants-BRYEJmsZ.mjs";
+import { i as joinPath, n as fromFileUrl, t as dirnamePath } from "./path-Cu_Nf2ct.mjs";
+import { _ as run, a as PRETTIER_MD_ARGS, b as writeJson, c as decodeText, d as lintmaxRoot, f as pathExists, g as resolveBin, h as readVersion, i as CliExitError, l as ensureDirectory, m as readRequiredJson, o as cacheDir, p as readJson, r as sync, s as cwd, u as ignoreEntries, v as runCapture, y as usage } from "./src-D4isRHIx.mjs";
+import { Glob, env, file, spawnSync, write } from "bun";
+import { lstatSync } from "node:fs";
+import { join } from "node:path";
+import ts from "typescript";
+//#region src/init.ts
+const initScripts = async ({ pkg, pkgPath }) => {
+	const scripts = pkg.scripts ?? {};
+	let changed = false;
+	if (!scripts.fix) {
+		scripts.fix = "lintmax fix";
+		changed = true;
+	}
+	if (!scripts.check) {
+		scripts.check = "lintmax check";
+		changed = true;
+	}
+	if (!changed) return;
+	pkg.scripts = scripts;
+	await writeJson({
+		data: pkg,
+		path: pkgPath
+	});
+};
+const initTsconfig = async ({ configFiles }) => {
+	const tsconfigPath = joinPath(cwd, "tsconfig.json");
+	if (!await pathExists({ path: tsconfigPath })) {
+		const tsconfig = { extends: "lintmax/tsconfig" };
+		if (configFiles.length > 0) tsconfig.include = configFiles;
+		await writeJson({
+			data: tsconfig,
+			path: tsconfigPath
+		});
+		return;
+	}
+	try {
+		const tsconfig = await readRequiredJson({ path: tsconfigPath });
+		let changed = false;
+		if (tsconfig.extends !== "lintmax/tsconfig") {
+			tsconfig.extends = "lintmax/tsconfig";
+			changed = true;
+		}
+		const toAdd = configFiles.filter((f) => !(tsconfig.include ?? []).includes(f));
+		if (toAdd.length > 0) {
+			tsconfig.include = [...tsconfig.include ?? [], ...toAdd];
+			changed = true;
+		}
+		if (changed) await writeJson({
+			data: tsconfig,
+			path: tsconfigPath
+		});
+	} catch {
+		process.stderr.write("tsconfig.json: could not parse, add \"extends\": \"lintmax/tsconfig\" manually\n");
+	}
+};
+const initGitignore = async () => {
+	const gitignorePath = joinPath(cwd, ".gitignore");
+	if (await pathExists({ path: gitignorePath })) {
+		const content = await file(gitignorePath).text();
+		const toAdd = [];
+		for (const entry of ignoreEntries) if (!content.includes(entry)) toAdd.push(entry);
+		if (toAdd.length > 0) await write(gitignorePath, `${content.trimEnd()}\n${toAdd.join("\n")}\n`);
+		return;
+	}
+	await write(gitignorePath, `${ignoreEntries.join("\n")}\n`);
+};
+const findLegacyConfigs = async () => {
+	const checks = [
+		".eslintrc",
+		".eslintrc.json",
+		".eslintrc.js",
+		".eslintrc.cjs",
+		".eslintrc.yml",
+		".eslintrc.yaml",
+		".prettierrc",
+		".prettierrc.json",
+		".prettierrc.js",
+		".prettierrc.yml",
+		".prettierrc.yaml",
+		".prettierrc.toml",
+		"biome.json",
+		"biome.jsonc",
+		".oxlintrc.json"
+	].map(async (configFile) => ({
+		configFile,
+		exists: await pathExists({ path: joinPath(cwd, configFile) })
+	}));
+	const resolved = await Promise.all(checks);
+	const found = [];
+	for (const item of resolved) if (item.exists) found.push(item.configFile);
+	return found;
+};
+const runInit = async () => {
+	const pkgPath = joinPath(cwd, "package.json");
+	if (!await pathExists({ path: pkgPath })) throw new CliExitError({
+		code: 1,
+		message: "No package.json found"
+	});
+	const pkg = await readRequiredJson({ path: pkgPath });
+	const configFiles = [];
+	if (await pathExists({ path: joinPath(cwd, "lintmax.config.ts") })) configFiles.push("lintmax.config.ts");
+	await initScripts({
+		pkg,
+		pkgPath
+	});
+	await initTsconfig({ configFiles });
+	await initGitignore();
+	const foundLegacy = await findLegacyConfigs();
+	process.stdout.write("tsconfig.json    extends lintmax/tsconfig");
+	if (configFiles.length > 0) process.stdout.write(`, include: ${configFiles.join(", ")}`);
+	process.stdout.write("\n");
+	process.stdout.write("package.json     \"fix\": \"lintmax fix\", \"check\": \"lintmax check\"\n");
+	process.stdout.write(`.gitignore       ${ignoreEntries.join(", ")}\n`);
+	if (foundLegacy.length > 0) process.stdout.write(`\nLegacy configs found (can be removed): ${foundLegacy.join(", ")}\n`);
+	process.stdout.write("\nRun: bun fix\n");
+};
+//#endregion
+//#region src/rule-equivalence.ts
+const equivalenceGroups = [
+	[
+		"lint/suspicious/noExplicitAny",
+		"@typescript-eslint/no-explicit-any",
+		"typescript-eslint(no-explicit-any)"
+	],
+	[
+		"lint/correctness/noUnusedVariables",
+		"@typescript-eslint/no-unused-vars",
+		"eslint(no-unused-vars)"
+	],
+	[
+		"lint/suspicious/noDebugger",
+		"no-debugger",
+		"eslint(no-debugger)"
+	],
+	[
+		"lint/correctness/noUnreachable",
+		"no-unreachable",
+		"eslint(no-unreachable)"
+	],
+	[
+		"lint/suspicious/noDoubleEquals",
+		"eqeqeq",
+		"eslint(eqeqeq)"
+	],
+	[
+		"lint/suspicious/noDuplicateCase",
+		"no-duplicate-case",
+		"eslint(no-duplicate-case)"
+	],
+	[
+		"lint/suspicious/noFallthroughSwitchClause",
+		"no-fallthrough",
+		"eslint(no-fallthrough)"
+	],
+	[
+		"lint/suspicious/noRedeclare",
+		"@typescript-eslint/no-redeclare",
+		"typescript-eslint(no-redeclare)"
+	],
+	[
+		"lint/suspicious/noShadowRestrictedNames",
+		"no-shadow-restricted-names",
+		"eslint(no-shadow-restricted-names)"
+	],
+	[
+		"lint/correctness/useIsNan",
+		"use-isnan",
+		"eslint(use-isnan)"
+	],
+	[
+		"lint/correctness/noConstAssign",
+		"no-const-assign",
+		"eslint(no-const-assign)"
+	],
+	[
+		"lint/correctness/noNewSymbol",
+		"no-new-symbol",
+		"eslint(no-new-symbol)"
+	],
+	[
+		"lint/correctness/noUndeclaredVariables",
+		"no-undef",
+		"eslint(no-undef)"
+	],
+	[
+		"lint/suspicious/noEmptyBlockStatements",
+		"no-empty",
+		"eslint(no-empty)"
+	],
+	[
+		"lint/suspicious/noSelfCompare",
+		"no-self-compare",
+		"eslint(no-self-compare)"
+	],
+	[
+		"lint/complexity/noUselessConstructor",
+		"@typescript-eslint/no-useless-constructor",
+		"eslint(no-useless-constructor)"
+	],
+	[
+		"lint/suspicious/noArrayIndexKey",
+		"react/no-array-index-key",
+		"eslint-plugin-react(no-array-index-key)"
+	],
+	[
+		"lint/correctness/useExhaustiveDependencies",
+		"react-hooks/exhaustive-deps",
+		"react-hooks(exhaustive-deps)"
+	],
+	[
+		"lint/correctness/useHookAtTopLevel",
+		"react-hooks/rules-of-hooks",
+		"react-hooks(rules-of-hooks)"
+	]
+];
+const ruleToCanonical = /* @__PURE__ */ new Map();
+for (const group of equivalenceGroups) {
+	const canonical = group[0] ?? "";
+	for (const rule of group) ruleToCanonical.set(rule, canonical);
+}
+const getCanonicalRule = (rule) => ruleToCanonical.get(rule) ?? rule;
+//#endregion
+//#region src/aggregate.ts
+const LINTER_PRIORITY = {
+	biome: 0,
+	eslint: 2,
+	oxlint: 1,
+	prettier: 3,
+	"sort-package-json": 4
+};
+const cwdPrefix = `${process.cwd()}/`;
+const normalizePath = (filePath) => {
+	if (filePath.startsWith(cwdPrefix)) return filePath.slice(cwdPrefix.length);
+	return filePath;
+};
+const parseBiomeDiagnostics = ({ stdout }) => {
+	let parsed;
+	try {
+		parsed = JSON.parse(stdout);
+	} catch {
+		return [];
+	}
+	if (!Array.isArray(parsed.diagnostics)) return [];
+	const results = [];
+	for (const d of parsed.diagnostics) {
+		const filePath = d.location?.path;
+		const { category } = d;
+		if (filePath && category) {
+			const line = d.location?.start?.line ?? 0;
+			results.push({
+				file: normalizePath(filePath),
+				line,
+				linter: "biome",
+				rule: category
+			});
+		}
+	}
+	return results;
+};
+const parseOxlintDiagnostics = ({ stdout }) => {
+	let parsed;
+	try {
+		parsed = JSON.parse(stdout);
+	} catch {
+		return [];
+	}
+	if (!Array.isArray(parsed.diagnostics)) return [];
+	const results = [];
+	for (const d of parsed.diagnostics) {
+		const filePath = d.filename ?? "";
+		const rule = d.code;
+		if (rule) {
+			const line = d.labels?.[0]?.span?.line ?? 0;
+			results.push({
+				file: filePath.length > 0 ? normalizePath(filePath) : "<unknown>",
+				line,
+				linter: "oxlint",
+				rule
+			});
+		}
+	}
+	return results;
+};
+const parseEslintDiagnostics = ({ stdout }) => {
+	let parsed;
+	try {
+		parsed = JSON.parse(stdout);
+	} catch {
+		return [];
+	}
+	if (!Array.isArray(parsed)) return [];
+	const results = [];
+	for (const fileEntry of parsed) {
+		const { filePath } = fileEntry;
+		if (filePath && Array.isArray(fileEntry.messages)) for (const msg of fileEntry.messages) {
+			const rule = msg.ruleId ?? (msg.severity === 2 || msg.fatal ? `parse-error: ${msg.message?.slice(0, 80) ?? "unknown"}` : null);
+			if (rule) results.push({
+				file: normalizePath(filePath),
+				line: msg.line ?? 0,
+				linter: "eslint",
+				rule
+			});
+		}
+	}
+	return results;
+};
+const parsePrettierOutput = ({ stdout }) => {
+	const results = [];
+	const lines = stdout.trim().split("\n");
+	for (const line of lines) {
+		const filePath = line.trim();
+		if (filePath.length > 0) results.push({
+			file: normalizePath(filePath),
+			line: 0,
+			linter: "prettier",
+			rule: "unformatted"
+		});
+	}
+	return results;
+};
+const parseSortPackageJsonOutput = ({ exitCode, stdout }) => {
+	if (exitCode === 0) return [];
+	const results = [];
+	const lines = stdout.trim().split("\n");
+	for (const line of lines) {
+		const filePath = line.trim();
+		if (filePath.length > 0 && filePath.endsWith(".json")) results.push({
+			file: normalizePath(filePath),
+			line: 0,
+			linter: "sort-package-json",
+			rule: "unsorted"
+		});
+	}
+	return results;
+};
+const dedup = (diagnostics) => {
+	const seen = /* @__PURE__ */ new Map();
+	for (const d of diagnostics) if (d.line === 0) {
+		const key = `${d.file}\0${d.linter}\0${d.rule}`;
+		seen.set(key, d);
+	} else {
+		const canonical = getCanonicalRule(d.rule);
+		const key = `${d.file}\0${d.line}\0${canonical}`;
+		const existing = seen.get(key);
+		if (!existing || (LINTER_PRIORITY[d.linter] ?? 99) < (LINTER_PRIORITY[existing.linter] ?? 99)) seen.set(key, d);
+	}
+	return [...seen.values()];
+};
+const linterSort = (a, b) => (LINTER_PRIORITY[a] ?? 99) - (LINTER_PRIORITY[b] ?? 99);
+const aggregate = ({ diagnostics }) => {
+	const deduped = dedup(diagnostics);
+	const fileMap = /* @__PURE__ */ new Map();
+	for (const d of deduped) {
+		let linterMap = fileMap.get(d.file);
+		if (!linterMap) {
+			linterMap = /* @__PURE__ */ new Map();
+			fileMap.set(d.file, linterMap);
+		}
+		let ruleMap = linterMap.get(d.linter);
+		if (!ruleMap) {
+			ruleMap = /* @__PURE__ */ new Map();
+			linterMap.set(d.linter, ruleMap);
+		}
+		let lines = ruleMap.get(d.rule);
+		if (!lines) {
+			lines = [];
+			ruleMap.set(d.rule, lines);
+		}
+		if (d.line > 0) lines.push(d.line);
+	}
+	const files = [];
+	const sortedFiles = [...fileMap.keys()].toSorted();
+	for (const filePath of sortedFiles) {
+		const linterMap = fileMap.get(filePath) ?? /* @__PURE__ */ new Map();
+		const linters = [];
+		const sortedLinters = [...linterMap.keys()].toSorted(linterSort);
+		for (const linterName of sortedLinters) {
+			const ruleMap = linterMap.get(linterName) ?? /* @__PURE__ */ new Map();
+			const rules = [];
+			const sortedRules = [...ruleMap.keys()].toSorted();
+			for (const ruleName of sortedRules) {
+				const lines = ruleMap.get(ruleName) ?? [];
+				const uniqueLines = [...new Set(lines)].toSorted((a, b) => a - b);
+				rules.push({
+					lines: uniqueLines,
+					rule: ruleName
+				});
+			}
+			linters.push({
+				linter: linterName,
+				rules
+			});
+		}
+		files.push({
+			file: filePath,
+			linters
+		});
+	}
+	return files;
+};
+//#endregion
+//#region src/class-name.ts
+/** biome-ignore-all lint/nursery/noContinue: AST traversal requires continue */
+const CN_NAMES = new Set(["cn"]);
+const BANNED_CALLEE_NAMES = new Set([
+	"classnames",
+	"clsx",
+	"cx",
+	"twMerge"
+]);
+const isJsxClassName = (node) => ts.isJsxAttribute(node) && ts.isIdentifier(node.name) && node.name.text === "className";
+const isCallToCn = (node) => ts.isCallExpression(node) && ts.isIdentifier(node.expression) && CN_NAMES.has(node.expression.text);
+const isJoinCall = (node) => ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join";
+const isBannedCallee = (node) => ts.isCallExpression(node) && ts.isIdentifier(node.expression) && BANNED_CALLEE_NAMES.has(node.expression.text);
+const isStringLiteral = (node) => ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node);
+const findClassNameViolations = ({ sourceText }) => {
+	const sourceFile = ts.createSourceFile("file.tsx", sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+	const violations = [];
+	const visit = (node) => {
+		if (isJsxClassName(node)) {
+			const init = node.initializer;
+			if (init && ts.isJsxExpression(init) && init.expression) {
+				const expr = init.expression;
+				if (!(isStringLiteral(expr) || isCallToCn(expr))) {
+					const line = sourceFile.getLineAndCharacterOfPosition(expr.getStart()).line + 1;
+					if (ts.isTemplateLiteral(expr)) violations.push({
+						line,
+						rule: "cn/no-template-literal"
+					});
+					else if (ts.isConditionalExpression(expr)) violations.push({
+						line,
+						rule: "cn/no-ternary"
+					});
+					else if (ts.isBinaryExpression(expr) && expr.operatorToken.kind === ts.SyntaxKind.PlusToken) violations.push({
+						line,
+						rule: "cn/no-concatenation"
+					});
+					else if (isBannedCallee(expr)) violations.push({
+						line,
+						rule: "cn/no-banned-callee"
+					});
+					else if (isJoinCall(expr)) violations.push({
+						line,
+						rule: "cn/no-join"
+					});
+					else if (ts.isCallExpression(expr) && !isCallToCn(expr)) {
+						const callee = expr.expression;
+						if (ts.isIdentifier(callee) && BANNED_CALLEE_NAMES.has(callee.text)) violations.push({
+							line,
+							rule: "cn/no-banned-callee"
+						});
+					}
+				}
+			}
+		}
+		if (isBannedCallee(node)) {
+			const call = node;
+			const { parent } = call;
+			if (!(ts.isJsxExpression(parent) && isJsxClassName(parent.parent))) {
+				const line = sourceFile.getLineAndCharacterOfPosition(call.getStart()).line + 1;
+				violations.push({
+					line,
+					rule: "cn/no-banned-callee"
+				});
+			}
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return violations;
+};
+const TSX_EXTENSIONS = new Set([".tsx"]);
+const isTsxFile = (path) => {
+	const dot = path.lastIndexOf(".");
+	return dot > path.lastIndexOf("/") && TSX_EXTENSIONS.has(path.slice(dot));
+};
+const checkClassNameFile = async (filePath) => {
+	if (!isTsxFile(filePath)) return [];
+	const f = file(filePath);
+	if (!await f.exists()) return [];
+	return findClassNameViolations({ sourceText: await f.text() }).map((v) => ({
+		file: filePath,
+		line: v.line,
+		linter: "cn",
+		rule: v.rule
+	}));
+};
+const checkClassName = async ({ root }) => {
+	const glob = new Glob("**/*.tsx");
+	const allDiagnostics = [];
+	for await (const path of glob.scan({
+		absolute: true,
+		cwd: root,
+		dot: false
+	})) {
+		if (path.includes("node_modules") || path.includes("readonly") || path.includes(".next") || path.includes("dist")) continue;
+		const diagnostics = await checkClassNameFile(path);
+		allDiagnostics.push(...diagnostics);
+	}
+	return allDiagnostics;
+};
+//#endregion
+//#region src/rules.ts
+const extractBiomeRules = async () => {
+	const pkgPath = fromFileUrl(import.meta.resolve("@biomejs/biome/configuration_schema.json"));
+	const defs = JSON.parse(await file(pkgPath).text()).$defs ?? {};
+	const categories = [
+		"a11y",
+		"complexity",
+		"correctness",
+		"nursery",
+		"performance",
+		"security",
+		"style",
+		"suspicious"
+	];
+	const results = [];
+	for (const cat of categories) {
+		const key = cat.charAt(0).toUpperCase() + cat.slice(1);
+		const rules = Object.keys(defs[key]?.properties ?? {});
+		for (const rule of rules) results.push({
+			fixable: false,
+			linter: "biome",
+			rule: `lint/${cat}/${rule}`
+		});
+	}
+	return results;
+};
+const OXLINT_FIX_MARKERS = new Set([
+	"⚠️🛠️️",
+	"💡",
+	"🛠️",
+	"🛠️💡"
+]);
+const extractOxlintRules = () => {
+	const output = decodeText(spawnSync({
+		cmd: [
+			"bun",
+			"node_modules/.bin/oxlint",
+			"-c",
+			joinPath(cwd, "node_modules/.cache/lintmax/.oxlintrc.json"),
+			"--rules"
+		],
+		cwd,
+		stderr: "pipe",
+		stdout: "pipe"
+	}).stdout);
+	const results = [];
+	const lines = output.split("\n");
+	for (const line of lines) if (line.startsWith("|") && !line.includes("Rule name")) {
+		const cols = line.split("|").map((c) => c.trim());
+		const ruleName = cols[1];
+		const source = cols[2];
+		const fixCol = cols[5] ?? "";
+		const enabledCol = cols[4] ?? "";
+		if (ruleName && source && !ruleName.startsWith("---") && enabledCol.includes("✅")) results.push({
+			fixable: OXLINT_FIX_MARKERS.has(fixCol.trim()),
+			linter: "oxlint",
+			rule: source === "oxc" ? ruleName : `${source}(${ruleName})`
+		});
+	}
+	return results;
+};
+const extractEslintRules = async () => {
+	const eslintBin = await resolveBin({
+		bin: "eslint",
+		pkg: "eslint"
+	});
+	const configPath = joinPath(cwd, "node_modules/.cache/lintmax/eslint.generated.mjs");
+	const dummyFile = joinPath(cwd, "_lintmax_dummy.ts");
+	await write(dummyFile, "export {}\n");
+	const result = spawnSync({
+		cmd: [
+			"bun",
+			eslintBin,
+			"--config",
+			configPath,
+			"--print-config",
+			dummyFile
+		],
+		cwd,
+		stderr: "pipe",
+		stdout: "pipe"
+	});
+	spawnSync({
+		cmd: [
+			"rm",
+			"-f",
+			dummyFile
+		],
+		stderr: "pipe",
+		stdout: "pipe"
+	});
+	if (result.exitCode !== 0) return [];
+	let parsed;
+	try {
+		parsed = JSON.parse(decodeText(result.stdout));
+	} catch {
+		return [];
+	}
+	const allRules = parsed.rules ?? {};
+	const results = [];
+	for (const [rule, config] of Object.entries(allRules)) {
+		const level = Array.isArray(config) ? config[0] : config;
+		if (level !== 0 && level !== "off") results.push({
+			fixable: false,
+			linter: "eslint",
+			rule
+		});
+	}
+	return results;
+};
+const extractAllRules = async () => {
+	const oxlint = extractOxlintRules();
+	const [biome, eslint] = await Promise.all([extractBiomeRules(), extractEslintRules()]);
+	return [
+		...biome,
+		...oxlint,
+		...eslint
+	].toSorted((a, b) => {
+		const linterCmp = a.linter.localeCompare(b.linter);
+		if (linterCmp !== 0) return linterCmp;
+		return a.rule.localeCompare(b.rule);
+	});
+};
+const formatRulesCompact = (rules) => {
+	const byLinter = /* @__PURE__ */ new Map();
+	for (const r of rules) {
+		let list = byLinter.get(r.linter);
+		if (!list) {
+			list = [];
+			byLinter.set(r.linter, list);
+		}
+		list.push(r.rule);
+	}
+	const parts = [];
+	for (const [linter, ruleList] of byLinter) {
+		parts.push(`${linter} (${ruleList.length})`);
+		for (const rule of ruleList) parts.push(` ${rule}`);
+	}
+	return parts.join("\n");
+};
+const formatRulesHuman = (rules) => {
+	const header = "Linter          Rule";
+	const separator = "─".repeat(60);
+	const lines = [header, separator];
+	for (const r of rules) lines.push(`${r.linter.padEnd(16)}${r.rule}`);
+	lines.push(separator);
+	lines.push(`Total: ${rules.length} rules`);
+	return lines.join("\n");
+};
+//#endregion
+//#region src/clean-ignores.ts
+/** biome-ignore-all lint/performance/noAwaitInLoops: sequential file writes */
+/** biome-ignore-all lint/nursery/useNamedCaptureGroup: not needed */
+const eslintLineRe = /^(\s*(?:\/\/|\/\*)\s*(?:eslint-disable(?:-next-line)?)\s+)(.+?)(\s*\*\/)?$/u;
+const oxlintLineRe = /^(\s*(?:\/\/|\/\*)\s*(?:oxlint-disable(?:-next-line)?)\s+)(.+?)(\s*\*\/)?$/u;
+const biomeLineRe = /^(\s*(?:\/\/|\/\*\*)\s*biome-ignore(?:-all)?\s+)([\w/]+)(.*?)$/u;
+const trailingCommentRe = /\s*--.*$/u;
+const trailingCloseRe = /\s*\*\/$/u;
+const oxlintPrefixRe = /^(?:oxc|eslint|typescript-eslint|typescript_eslint|react|react-hooks|react_hooks|jsx-a11y|jsx_a11y|import|nextjs|next|jsdoc|promise|unicorn|vitest|jest|eslint-plugin-react-perf|eslint-plugin-jsx-a11y|eslint-plugin-react|eslint-plugin-promise|eslint-plugin-unicorn|react-perf|react_perf|@next\/next|@typescript-eslint|@eslint-react)[\\/(/]/u;
+const trailingParenRe = /\)$/u;
+const trailingSepRe = /[\\/(/]$/u;
+const eslintPluginPrefixRe = /^eslint-plugin-/u;
+const normalizeRule = (rule) => {
+	const variants = [rule];
+	const oxMatch = oxlintPrefixRe.exec(rule);
+	if (oxMatch) {
+		const bare = rule.slice(oxMatch[0].length).replace(trailingParenRe, "");
+		variants.push(bare);
+		const prefix = oxMatch[0].replace(trailingSepRe, "");
+		variants.push(`${prefix}/${bare}`);
+		variants.push(`${prefix}(${bare})`);
+		if (prefix === "eslint") variants.push(bare);
+		if (prefix === "typescript-eslint") variants.push(`@typescript-eslint/${bare}`);
+		if (prefix.startsWith("eslint-plugin-")) {
+			const short = prefix.replace(eslintPluginPrefixRe, "");
+			variants.push(`${short}/${bare}`);
+			variants.push(`${short}(${bare})`);
+		}
+	}
+	if (rule.startsWith("@typescript-eslint/")) variants.push(`typescript-eslint(${rule.slice(19)})`);
+	if (rule.startsWith("@next/next/")) variants.push(`nextjs(${rule.slice(11)})`);
+	if (rule.startsWith("@eslint-react/")) variants.push(`react(${rule.slice(14)})`);
+	const extra = [];
+	for (const v of variants) {
+		if (v.includes("_")) extra.push(v.replaceAll("_", "-"));
+		if (v.includes("-")) extra.push(v.replaceAll("-", "_"));
+	}
+	for (const e of extra) variants.push(e);
+	return variants;
+};
+const loadOxlintOffRules = async () => {
+	const config = await readRequiredJson({ path: joinPath(process.cwd(), cacheDir, ".oxlintrc.json") }).catch(() => null);
+	if (!config) return /* @__PURE__ */ new Set();
+	const off = /* @__PURE__ */ new Set();
+	for (const [rule, val] of Object.entries(config.rules ?? {})) if ((Array.isArray(val) ? String(val[0]) : val) === "off") {
+		off.add(rule);
+		for (const v of normalizeRule(rule)) off.add(v);
+	}
+	for (const rule of OXLINT_CLI_ALLOW) {
+		off.add(rule);
+		for (const v of normalizeRule(rule)) off.add(v);
+	}
+	return off;
+};
+const buildActiveRuleSet = async () => {
+	const rules = await extractAllRules();
+	const active = /* @__PURE__ */ new Set();
+	for (const r of rules) {
+		active.add(r.rule);
+		for (const v of normalizeRule(r.rule)) active.add(v);
+	}
+	return active;
+};
+const isRuleActive = (rule, active, oxlintOff) => {
+	if (oxlintOff?.has(rule)) return false;
+	if (oxlintOff) {
+		for (const v of normalizeRule(rule)) if (oxlintOff.has(v)) return false;
+	}
+	if (active.has(rule)) return true;
+	for (const v of normalizeRule(rule)) if (active.has(v)) return true;
+	if (!oxlintOff) return false;
+	return true;
+};
+const splitRules = (str) => str.split(",").map((r) => r.trim().replace(trailingCommentRe, "").replace(trailingCloseRe, "")).filter(Boolean);
+const processMultiRuleLine = ({ active, isOxlint, line, match, oxlintOff, result }) => {
+	const prefix = match[1] ?? "";
+	const rulesStr = match[2] ?? "";
+	const suffix = match[3] ?? "";
+	const rules = splitRules(rulesStr);
+	const kept = rules.filter((r) => isRuleActive(r, active, isOxlint ? oxlintOff : void 0));
+	if (kept.length === 0) return rules.length;
+	if (kept.length < rules.length) {
+		result.push(`${prefix}${kept.join(", ")}${suffix}`);
+		return rules.length - kept.length;
+	}
+	result.push(line);
+	return 0;
+};
+const cleanFileIgnores = async (filePath, active, oxlintOff) => {
+	const f = file(filePath);
+	if (!await f.exists()) return 0;
+	const lines = (await f.text()).split("\n");
+	const result = [];
+	let removed = 0;
+	for (const line of lines) {
+		eslintLineRe.lastIndex = 0;
+		oxlintLineRe.lastIndex = 0;
+		biomeLineRe.lastIndex = 0;
+		const eslintMatch = eslintLineRe.exec(line);
+		if (eslintMatch) removed += processMultiRuleLine({
+			active,
+			line,
+			match: eslintMatch,
+			result
+		});
+		else {
+			const oxlintMatch = oxlintLineRe.exec(line);
+			if (oxlintMatch) removed += processMultiRuleLine({
+				active,
+				isOxlint: true,
+				line,
+				match: oxlintMatch,
+				oxlintOff,
+				result
+			});
+			else {
+				const biomeMatch = biomeLineRe.exec(line);
+				if (biomeMatch && !isRuleActive(biomeMatch[2] ?? "", active)) removed += 1;
+				else result.push(line);
+			}
+		}
+	}
+	if (removed > 0) await write(filePath, result.join("\n"));
+	return removed;
+};
+const cleanIgnores = async (filePaths) => {
+	const active = await buildActiveRuleSet();
+	const oxlintOff = await loadOxlintOffRules();
+	let cleaned = 0;
+	const files = [];
+	for (const fp of filePaths) {
+		const count = await cleanFileIgnores(fp, active, oxlintOff);
+		if (count > 0) {
+			cleaned += count;
+			files.push(fp);
+		}
+	}
+	return {
+		cleaned,
+		files
+	};
+};
+//#endregion
+//#region src/comments.ts
+const KEEP_PATTERN = /eslint-disable|biome-ignore|oxlint-disable|@ts-nocheck|@ts-expect-error|@ts-ignore|@refresh|@flow|istanbul ignore|c8 ignore|webpackChunkName|prettier-ignore|noinspection|nolint|@jsx|@jsxImportSource|@jsxFrag|@license|@preserve|type-coverage:ignore/u;
+const WHITESPACE_ONLY = /^\s*$/u;
+const COMMENT_EXTENSIONS = new Set([
+	".cjs",
+	".js",
+	".jsx",
+	".mjs",
+	".mts",
+	".ts",
+	".tsx"
+]);
+const extOf = (path) => {
+	const dot = path.lastIndexOf(".");
+	return dot > path.lastIndexOf("/") ? path.slice(dot) : "";
+};
+const isCommentCandidate = (path) => COMMENT_EXTENSIONS.has(extOf(path));
+const findDeletableComments = ({ sourceText }) => {
+	const sourceFile = ts.createSourceFile("file.ts", sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+	const seen = /* @__PURE__ */ new Set();
+	const deletable = [];
+	const visit = (node) => {
+		const leading = ts.getLeadingCommentRanges(sourceText, node.getFullStart());
+		const trailing = ts.getTrailingCommentRanges(sourceText, node.getEnd());
+		const ranges = [...leading ?? [], ...trailing ?? []];
+		for (const range of ranges) if (!seen.has(range.pos)) {
+			seen.add(range.pos);
+			const text = sourceText.slice(range.pos, range.end);
+			if (!(text.startsWith("#!") || text.startsWith("/**") || text.startsWith("/// <") || KEEP_PATTERN.test(text))) {
+				const line = sourceFile.getLineAndCharacterOfPosition(range.pos).line + 1;
+				deletable.push({
+					end: range.end,
+					line,
+					start: range.pos
+				});
+			}
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	deletable.sort((a, b) => a.start - b.start);
+	return deletable;
+};
+const deleteComments = ({ sourceText }) => {
+	const comments = findDeletableComments({ sourceText });
+	if (comments.length === 0) return sourceText;
+	const parts = [];
+	let cursor = 0;
+	for (const c of comments) {
+		const beforeChunk = sourceText.slice(cursor, c.start);
+		const lineStart = beforeChunk.lastIndexOf("\n") + 1;
+		const indent = beforeChunk.slice(lineStart);
+		let afterEnd = c.end;
+		if (sourceText[afterEnd] === "\n") afterEnd += 1;
+		else if (sourceText[afterEnd] === "\r" && sourceText[afterEnd + 1] === "\n") afterEnd += 2;
+		if (WHITESPACE_ONLY.test(indent) && afterEnd <= sourceText.length) {
+			parts.push(beforeChunk.slice(0, lineStart));
+			cursor = afterEnd;
+		} else {
+			parts.push(beforeChunk);
+			cursor = c.end;
+		}
+	}
+	parts.push(sourceText.slice(cursor));
+	return parts.join("");
+};
+const processFile = async (filePath) => {
+	if (!isCommentCandidate(filePath)) return {
+		diagnostics: [],
+		modified: false
+	};
+	const f = file(filePath);
+	if (!await f.exists()) return {
+		diagnostics: [],
+		modified: false
+	};
+	const comments = findDeletableComments({ sourceText: await f.text() });
+	const diagnostics = [];
+	for (const c of comments) diagnostics.push({
+		file: filePath,
+		line: c.line,
+		linter: "comments",
+		rule: "deletable"
+	});
+	return {
+		diagnostics,
+		modified: false
+	};
+};
+const processFileForFix = async (filePath) => {
+	if (!isCommentCandidate(filePath)) return false;
+	const f = file(filePath);
+	if (!await f.exists()) return false;
+	const sourceText = await f.text();
+	const result = deleteComments({ sourceText });
+	if (result !== sourceText) {
+		await write(filePath, result);
+		return true;
+	}
+	return false;
+};
+const checkComments = async ({ files }) => {
+	return (await Promise.all(files.map(async (f) => processFile(f)))).flatMap((r) => r.diagnostics);
+};
+const fixComments = async ({ files }) => {
+	return (await Promise.all(files.map(async (f) => processFileForFix(f)))).filter(Boolean).length;
+};
+//#endregion
+//#region src/compact.ts
+const lstatSafe = (p) => {
+	try {
+		return lstatSync(p);
+	} catch {
+		return null;
+	}
+};
+const COMPACT_REGEX = /(?:\r?\n){2,}/gu;
+const compactBasenames = new Set([
+	".env.example",
+	".gitignore",
+	".npmrc",
+	".prettierignore",
+	"Dockerfile",
+	"Makefile"
+]);
+const compactExtensions = new Set([
+	".cjs",
+	".css",
+	".gql",
+	".graphql",
+	".html",
+	".js",
+	".json",
+	".jsonc",
+	".jsx",
+	".mjs",
+	".mts",
+	".scss",
+	".sql",
+	".ts",
+	".tsx",
+	".txt",
+	".yaml",
+	".yml"
+]);
+const basename = ({ path }) => {
+	const index = path.lastIndexOf("/");
+	if (index === -1) return path;
+	return path.slice(index + 1);
+};
+const extension = ({ path }) => {
+	const slashIndex = path.lastIndexOf("/");
+	const dotIndex = path.lastIndexOf(".");
+	return dotIndex > slashIndex ? path.slice(dotIndex) : "";
+};
+const compactContent = ({ content }) => content.replace(COMPACT_REGEX, "\n");
+const isCompactCandidate = ({ relativePath }) => {
+	const fileName = basename({ path: relativePath });
+	if (compactBasenames.has(fileName)) return true;
+	return compactExtensions.has(extension({ path: relativePath }));
+};
+const isBinary = ({ bytes }) => {
+	for (const byte of bytes) if (byte === 0) return true;
+	return false;
+};
+const listCompactFiles = ({ env, root }) => {
+	const result = spawnSync({
+		cmd: [
+			"git",
+			"-C",
+			root,
+			"ls-files",
+			"-z",
+			"--cached",
+			"--others",
+			"--exclude-standard"
+		],
+		env,
+		stderr: "pipe",
+		stdout: "pipe"
+	});
+	if (result.exitCode !== 0) {
+		const stderr = decodeText(result.stderr).trim();
+		if (stderr.toLowerCase().includes("not a git repository")) return [];
+		throw new CliExitError({
+			code: result.exitCode,
+			message: stderr.length > 0 ? stderr : "Failed to list files for compact step"
+		});
+	}
+	return decodeText(result.stdout).split("\0").filter((e) => e.length > 0 && e !== "bun.lock").filter((e) => !lstatSafe(join(root, e))?.isSymbolicLink());
+};
+const runCompact = async ({ env, human = false, mode, root }) => {
+	const files = listCompactFiles({
+		env,
+		root
+	});
+	const results = await Promise.all(files.map(async (relativePath) => {
+		if (!isCompactCandidate({ relativePath })) return {
+			changed: false,
+			relativePath,
+			scanned: false
+		};
+		const absolutePath = joinPath(root, relativePath);
+		const source = file(absolutePath);
+		if (!await source.exists()) return {
+			changed: false,
+			relativePath,
+			scanned: false
+		};
+		const bytes = new Uint8Array(await source.arrayBuffer());
+		if (isBinary({ bytes })) return {
+			changed: false,
+			relativePath,
+			scanned: true
+		};
+		const content = decodeText(bytes);
+		const compacted = compactContent({ content });
+		if (content === compacted) return {
+			changed: false,
+			relativePath,
+			scanned: true
+		};
+		if (mode === "fix") await write(absolutePath, compacted);
+		return {
+			changed: true,
+			relativePath,
+			scanned: true
+		};
+	}));
+	const changed = [];
+	let scanned = 0;
+	for (const result of results) {
+		if (result.scanned) scanned += 1;
+		if (result.changed) changed.push(result.relativePath);
+	}
+	if (mode === "fix") {
+		if (human) {
+			process.stdout.write(`[compact] Scanned ${scanned} files\n`);
+			process.stdout.write(`[compact] Updated ${changed.length} files\n`);
+		}
+		return;
+	}
+	if (changed.length === 0) return;
+	const shown = changed.slice(0, 10);
+	const suffix = changed.length > shown.length ? `\n...and ${changed.length - shown.length} more` : "";
+	throw new CliExitError({
+		code: 1,
+		message: `[compact]\nFiles requiring compaction:\n${shown.join("\n")}${suffix}\nRun: lintmax fix`
+	});
+};
+//#endregion
+//#region src/format.ts
+const formatGrouped = ({ files }) => {
+	if (files.length === 0) return "";
+	const parts = [];
+	for (const f of files) {
+		parts.push(f.file);
+		for (const l of f.linters) {
+			parts.push(` ${l.linter}`);
+			for (const r of l.rules) {
+				const lineStr = r.lines.length > 0 ? r.lines.join(",") : "";
+				parts.push(`  ${lineStr}${lineStr.length > 0 ? " " : ""}${r.rule}`);
+			}
+		}
+	}
+	return parts.join("\n");
+};
+//#endregion
+//#region src/jsx-extension.ts
+/** biome-ignore-all lint/nursery/noContinue: scan loop */
+const containsJsxNode = (sourceFile) => {
+	let found = false;
+	const visit = (node) => {
+		if (found) return;
+		if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node)) {
+			found = true;
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+	ts.forEachChild(sourceFile, visit);
+	return found;
+};
+const hasJsx = (sourceText) => {
+	const diags = ts.createSourceFile("file.ts", sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS).parseDiagnostics;
+	if (!(Array.isArray(diags) && diags.length > 0)) return false;
+	return containsJsxNode(ts.createSourceFile("file.tsx", sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX));
+};
+const checkJsxExtension = async ({ root }) => {
+	const glob = new Glob("**/*.ts");
+	const ignoreGlobs = DEFAULT_SHARED_IGNORE_PATTERNS.map((p) => new Glob(p));
+	const isIgnored = (p) => p.includes("node_modules") || p.endsWith(".d.ts") || ignoreGlobs.some((g) => g.match(p));
+	const diagnostics = [];
+	for await (const path of glob.scan({
+		absolute: false,
+		cwd: root,
+		dot: false
+	})) {
+		if (isIgnored(path)) continue;
+		if (hasJsx(await file(`${root}/${path}`).text())) diagnostics.push({
+			file: `${root}/${path}`,
+			line: 1,
+			linter: "lintmax",
+			rule: "jsx-requires-tsx-extension"
+		});
+	}
+	return diagnostics;
+};
+//#endregion
+//#region src/pipeline.ts
+const createStepExecutor = ({ env, failures, root }) => {
+	const runContinue = (opts) => {
+		try {
+			run(opts);
+		} catch (error) {
+			if (error instanceof CliExitError) {
+				failures.push({
+					code: error.code,
+					label: opts.label,
+					message: error.message.length > 0 ? error.message : void 0
+				});
+				return;
+			}
+			throw error;
+		}
+	};
+	const runCompactContinue = async ({ human = false, mode }) => {
+		try {
+			await runCompact({
+				env,
+				human,
+				mode,
+				root
+			});
+		} catch (error) {
+			if (error instanceof CliExitError) {
+				failures.push({
+					code: error.code,
+					label: "compact",
+					message: error.message.length > 0 ? error.message : void 0
+				});
+				return;
+			}
+			throw error;
+		}
+	};
+	const runSteps = ({ steps }) => {
+		for (const step of steps) runContinue({
+			args: step.args,
+			command: step.command ?? "bun",
+			env,
+			label: step.label,
+			silent: step.silent
+		});
+	};
+	const runStepsSilent = ({ steps }) => {
+		for (const step of steps) {
+			const result = runCapture({
+				args: step.args,
+				command: step.command ?? "bun",
+				env,
+				label: step.label
+			});
+			if (result.exitCode !== 0) failures.push({
+				code: result.exitCode,
+				label: step.label,
+				message: result.stderr.length > 0 ? result.stderr.trim() : void 0
+			});
+		}
+	};
+	const clearFailures = () => {
+		failures.length = 0;
+	};
+	const throwIfFailures = () => {
+		if (failures.length === 0) return;
+		const details = failures.map((item) => `- ${item.label} (exit ${item.code})${item.message ? `\n${item.message}` : ""}`).join("\n");
+		throw new CliExitError({
+			code: failures[0]?.code ?? 1,
+			message: `One or more steps failed:\n${details}`
+		});
+	};
+	return {
+		clearFailures,
+		runCompactContinue,
+		runSteps,
+		runStepsSilent,
+		throwIfFailures
+	};
+};
+const createCheckSteps = ({ biomeBin, dir, eslintArgs, eslintBin, oxlintBin, prettierBin, prettierMarkdownTargets, sortPkgJson }) => {
+	const oxlintCliAllow = OXLINT_CLI_ALLOW.flatMap((r) => ["--allow", r]);
+	const steps = [
+		{
+			args: [
+				sortPkgJson,
+				"--check",
+				"**/package.json",
+				"--ignore",
+				"**/node_modules/**"
+			],
+			label: "sort-package-json"
+		},
+		{
+			args: [
+				biomeBin,
+				"ci",
+				"--config-path",
+				dir,
+				"--diagnostic-level=error"
+			],
+			label: "biome"
+		},
+		{
+			args: [
+				oxlintBin,
+				"-c",
+				joinPath(dir, ".oxlintrc.json"),
+				"--quiet",
+				...oxlintCliAllow
+			],
+			label: "oxlint"
+		},
+		{
+			args: [
+				eslintBin,
+				"--no-error-on-unmatched-pattern",
+				...eslintArgs
+			],
+			label: "eslint"
+		}
+	];
+	if (prettierMarkdownTargets.length > 0) steps.push({
+		args: [
+			prettierBin,
+			...PRETTIER_MD_ARGS,
+			"--check",
+			"--no-error-on-unmatched-pattern",
+			...prettierMarkdownTargets
+		],
+		label: "prettier"
+	});
+	return steps;
+};
+const createFixSteps = ({ biomeBin, dir, eslintArgs, eslintBin, hasFlowmark, oxlintBin, prettierBin, prettierMarkdownTargets, sortPkgJson }) => {
+	const oxlintCliAllow = OXLINT_CLI_ALLOW.flatMap((r) => ["--allow", r]);
+	const steps = [
+		{
+			args: [
+				sortPkgJson,
+				"**/package.json",
+				"--ignore",
+				"**/node_modules/**"
+			],
+			label: "sort-package-json",
+			silent: true
+		},
+		{
+			args: [
+				biomeBin,
+				"check",
+				"--config-path",
+				dir,
+				"--fix",
+				"--diagnostic-level=error"
+			],
+			label: "biome",
+			silent: true
+		},
+		{
+			args: [
+				oxlintBin,
+				"-c",
+				joinPath(dir, ".oxlintrc.json"),
+				"--fix",
+				"--fix-suggestions",
+				"--quiet",
+				...oxlintCliAllow
+			],
+			label: "oxlint",
+			silent: true
+		},
+		{
+			args: [
+				eslintBin,
+				...eslintArgs,
+				"--fix"
+			],
+			label: "eslint",
+			silent: true
+		},
+		{
+			args: [
+				biomeBin,
+				"check",
+				"--config-path",
+				dir,
+				"--fix",
+				"--diagnostic-level=error"
+			],
+			label: "biome",
+			silent: true
+		}
+	];
+	if (hasFlowmark) steps.push({
+		args: [
+			"-w",
+			"0",
+			"--auto",
+			"."
+		],
+		command: "flowmark",
+		label: "flowmark",
+		silent: true
+	});
+	if (prettierMarkdownTargets.length > 0) steps.push({
+		args: [
+			prettierBin,
+			...PRETTIER_MD_ARGS,
+			"--write",
+			"--no-error-on-unmatched-pattern",
+			...prettierMarkdownTargets
+		],
+		label: "prettier",
+		silent: true
+	});
+	return steps;
+};
+const captureAndParse = ({ env, failures, label, opts, parser }) => {
+	const result = runCapture({
+		args: opts.args,
+		command: opts.command,
+		env,
+		label
+	});
+	if (result.exitCode === 0) return [];
+	const diagnostics = parser(result);
+	if (diagnostics.length > 0) return diagnostics;
+	const stderr = result.stderr.trim();
+	const stdout = result.stdout.trim();
+	const stdoutFirst = stdout.split("\n", 1)[0]?.trimStart() ?? "";
+	const stdoutIsJson = stdoutFirst.startsWith("[") || stdoutFirst.startsWith("{");
+	const message = stderr.length > 0 ? stderr : stdoutIsJson ? void 0 : stdout || void 0;
+	failures.push({
+		code: result.exitCode,
+		label,
+		message
+	});
+	return [];
+};
+const runAgentCheck = ({ biomeBin, dir, env, eslintArgs, eslintBin, failures, oxlintBin, prettierBin, prettierMarkdownTargets, sortPkgJson }) => {
+	const oxlintCliAllow = OXLINT_CLI_ALLOW.flatMap((r) => ["--allow", r]);
+	const allDiagnostics = [];
+	const push = (d) => {
+		if (d.length > 0) allDiagnostics.push(...d);
+	};
+	push(captureAndParse({
+		env,
+		failures,
+		label: "sort-package-json",
+		opts: {
+			args: [
+				sortPkgJson,
+				"--check",
+				"**/package.json",
+				"--ignore",
+				"**/node_modules/**"
+			],
+			command: "bun"
+		},
+		parser: parseSortPackageJsonOutput
+	}));
+	push(captureAndParse({
+		env,
+		failures,
+		label: "biome",
+		opts: {
+			args: [
+				biomeBin,
+				"check",
+				"--config-path",
+				dir,
+				"--reporter=json"
+			],
+			command: "bun"
+		},
+		parser: ({ stdout }) => parseBiomeDiagnostics({ stdout })
+	}));
+	push(captureAndParse({
+		env,
+		failures,
+		label: "oxlint",
+		opts: {
+			args: [
+				oxlintBin,
+				"-c",
+				joinPath(dir, ".oxlintrc.json"),
+				"--quiet",
+				"-f",
+				"json",
+				...oxlintCliAllow
+			],
+			command: "bun"
+		},
+		parser: ({ stdout }) => parseOxlintDiagnostics({ stdout })
+	}));
+	push(captureAndParse({
+		env,
+		failures,
+		label: "eslint",
+		opts: {
+			args: [
+				eslintBin,
+				"--no-error-on-unmatched-pattern",
+				...eslintArgs,
+				"-f",
+				"json"
+			],
+			command: "bun"
+		},
+		parser: ({ stdout }) => parseEslintDiagnostics({ stdout })
+	}));
+	if (prettierMarkdownTargets.length > 0) push(captureAndParse({
+		env,
+		failures,
+		label: "prettier",
+		opts: {
+			args: [
+				prettierBin,
+				...PRETTIER_MD_ARGS,
+				"--list-different",
+				"--no-error-on-unmatched-pattern",
+				...prettierMarkdownTargets
+			],
+			command: "bun"
+		},
+		parser: ({ stdout }) => parsePrettierOutput({ stdout })
+	}));
+	return allDiagnostics;
+};
+const isGitWorkTree = ({ env, root }) => spawnSync({
+	cmd: [
+		"git",
+		"-C",
+		root,
+		"rev-parse",
+		"--is-inside-work-tree"
+	],
+	env,
+	stderr: "pipe",
+	stdout: "pipe"
+}).exitCode === 0;
+const createPrettierMarkdownTargets = ({ gitFiles, gitWorkTree }) => {
+	if (!gitWorkTree) return ["**/*.md"];
+	return gitFiles.filter((filePath) => filePath.endsWith(".md"));
+};
+const throwAgentResults = ({ diagnostics, failures }) => {
+	if (diagnostics.length === 0 && failures.length === 0) return;
+	const output = formatGrouped({ files: aggregate({ diagnostics }) });
+	if (output.length > 0) process.stdout.write(`${output}\n`);
+	if (failures.length > 0) {
+		const details = failures.map((item) => `- ${item.label} (exit ${item.code})${item.message ? `\n${item.message}` : ""}`).join("\n");
+		process.stderr.write(`${details}\n`);
+	}
+	throw new CliExitError({ code: 1 });
+};
+const runLint = async ({ command, human = false }) => {
+	const dir = joinPath(cwd, cacheDir);
+	ensureDirectory({ directory: dir });
+	const configPath = joinPath(cwd, "lintmax.config.ts");
+	const hasConfig = await pathExists({ path: configPath });
+	const bundledBinA = joinPath(lintmaxRoot, "node_modules", ".bin");
+	const bundledBinB = joinPath(dirnamePath(lintmaxRoot), ".bin");
+	const cwdBinDir = joinPath(cwd, "node_modules", ".bin");
+	const runtimePath = joinPath(dir, "lintmax.json");
+	const env$1 = {
+		...env,
+		PATH: `${bundledBinA}:${bundledBinB}:${cwdBinDir}:${env.PATH ?? ""}`
+	};
+	if (hasConfig) run({
+		args: ["-e", `const m = await import('${configPath}'); const { sync: s } = await import('lintmax'); await s(m.default);`],
+		command: "bun",
+		env: env$1,
+		label: "config",
+		silent: true
+	});
+	else await sync();
+	const runtime = await readJson({ path: runtimePath });
+	const failures = [];
+	const { clearFailures, runCompactContinue, runSteps, runStepsSilent, throwIfFailures } = createStepExecutor({
+		env: env$1,
+		failures,
+		root: cwd
+	});
+	if (command === "fix" && runtime.compact === true) await runCompactContinue({
+		human,
+		mode: "fix"
+	});
+	const eslintArgs = ["--config", joinPath(dir, "eslint.generated.mjs")];
+	const [sortPkgJson, biomeBin, oxlintBin, eslintBin, prettierBin] = await Promise.all([
+		resolveBin({
+			bin: "sort-package-json",
+			pkg: "sort-package-json"
+		}),
+		resolveBin({
+			bin: "biome",
+			pkg: "@biomejs/biome"
+		}),
+		resolveBin({
+			bin: "oxlint",
+			pkg: "oxlint"
+		}),
+		resolveBin({
+			bin: "eslint",
+			pkg: "eslint"
+		}),
+		resolveBin({
+			bin: "prettier",
+			pkg: "prettier"
+		})
+	]);
+	const hasFlowmark = spawnSync({
+		cmd: ["which", "flowmark"],
+		env: env$1,
+		stderr: "pipe",
+		stdout: "pipe"
+	}).exitCode === 0;
+	const gitWorkTree = isGitWorkTree({
+		env: env$1,
+		root: cwd
+	});
+	const allGitFiles = gitWorkTree ? listCompactFiles({
+		env: env$1,
+		root: cwd
+	}) : [];
+	const prettierMarkdownTargets = createPrettierMarkdownTargets({
+		gitFiles: allGitFiles,
+		gitWorkTree
+	});
+	const checkSteps = createCheckSteps({
+		biomeBin,
+		dir,
+		eslintArgs,
+		eslintBin,
+		oxlintBin,
+		prettierBin,
+		prettierMarkdownTargets,
+		sortPkgJson
+	});
+	const shouldComments = runtime.comments !== false;
+	const ignoreGlobs = DEFAULT_SHARED_IGNORE_PATTERNS.map((p) => new Glob(p));
+	const isIgnored = (filePath) => ignoreGlobs.some((g) => g.match(filePath));
+	const sourceFiles = allGitFiles.filter((f) => !isIgnored(f));
+	if (command === "fix") {
+		if (shouldComments) await fixComments({ files: allGitFiles });
+		if (sourceFiles.length > 0) await cleanIgnores(sourceFiles.map((f) => joinPath(cwd, f)));
+		const fixSteps = createFixSteps({
+			biomeBin,
+			dir,
+			eslintArgs,
+			eslintBin,
+			hasFlowmark,
+			oxlintBin,
+			prettierBin,
+			prettierMarkdownTargets,
+			sortPkgJson
+		});
+		if (human) runSteps({ steps: fixSteps });
+		else runStepsSilent({ steps: fixSteps });
+		clearFailures();
+		if (human) {
+			runSteps({ steps: checkSteps });
+			throwIfFailures();
+			return;
+		}
+		const allDiagnostics = runAgentCheck({
+			biomeBin,
+			dir,
+			env: env$1,
+			eslintArgs,
+			eslintBin,
+			failures,
+			oxlintBin,
+			prettierBin,
+			prettierMarkdownTargets,
+			sortPkgJson
+		});
+		if (shouldComments) {
+			const commentDiags = await checkComments({ files: allGitFiles });
+			allDiagnostics.push(...commentDiags);
+		}
+		const cnDiags = await checkClassName({ root: cwd });
+		const jsxDiags = await checkJsxExtension({ root: cwd });
+		allDiagnostics.push(...cnDiags, ...jsxDiags);
+		throwAgentResults({
+			diagnostics: allDiagnostics,
+			failures
+		});
+		return;
+	}
+	if (human) {
+		runSteps({ steps: checkSteps });
+		const cnDiagsHuman = await checkClassName({ root: cwd });
+		const jsxDiagsHuman = await checkJsxExtension({ root: cwd });
+		const humanCustomDiags = [...cnDiagsHuman, ...jsxDiagsHuman];
+		if (humanCustomDiags.length > 0) {
+			const output = formatGrouped({ files: aggregate({ diagnostics: humanCustomDiags }) });
+			if (output.length > 0) process.stdout.write(`${output}\n`);
+			failures.push({
+				code: 1,
+				label: "cn"
+			});
+		}
+		throwIfFailures();
+		return;
+	}
+	const allDiagnostics = runAgentCheck({
+		biomeBin,
+		dir,
+		env: env$1,
+		eslintArgs,
+		eslintBin,
+		failures,
+		oxlintBin,
+		prettierBin,
+		prettierMarkdownTargets,
+		sortPkgJson
+	});
+	if (shouldComments) {
+		const commentDiags = await checkComments({ files: allGitFiles });
+		allDiagnostics.push(...commentDiags);
+	}
+	const cnDiags = await checkClassName({ root: cwd });
+	const jsxDiags = await checkJsxExtension({ root: cwd });
+	allDiagnostics.push(...cnDiags, ...jsxDiags);
+	if (allDiagnostics.length > 0 || failures.length > 0) {
+		const output = formatGrouped({ files: aggregate({ diagnostics: allDiagnostics }) });
+		if (output.length > 0) process.stdout.write(`${output}\n`);
+		if (failures.length > 0) {
+			const details = failures.map((item) => `- ${item.label} (exit ${item.code})${item.message ? `\n${item.message}` : ""}`).join("\n");
+			process.stderr.write(`${details}\n`);
+		}
+		throw new CliExitError({ code: 1 });
+	}
+};
+//#endregion
+//#region src/cli.ts
+const command = process.argv[2];
+const main = async () => {
+	const version = await readVersion();
+	if (command === "init") {
+		await runInit();
+		return;
+	}
+	if (command === "--version" || command === "-v") {
+		process.stdout.write(`${version}\n`);
+		return;
+	}
+	if (command === "rules") {
+		const human = process.argv.includes("--human");
+		const rules = await extractAllRules();
+		const output = human ? formatRulesHuman(rules) : formatRulesCompact(rules);
+		process.stdout.write(`${output}\n`);
+		return;
+	}
+	if (command === "ignores") {
+		const { runIgnores } = await import("./ignores-B1QoL99d.mjs");
+		await runIgnores(process.argv.includes("--verbose"));
+		return;
+	}
+	if (command !== "fix" && command !== "check") {
+		usage({ version });
+		if (command === "--help" || command === "-h") return;
+		throw new CliExitError({ code: 1 });
+	}
+	await runLint({
+		command,
+		human: process.argv.includes("--human")
+	});
+};
+try {
+	await main();
+} catch (error) {
+	if (error instanceof CliExitError) {
+		if (error.message.length > 0) process.stderr.write(`${error.message}\n`);
+		process.exitCode = error.code;
+	} else throw error;
+}
+//#endregion
+export {};