@aklinker1/check 2.0.0 → 2.1.1

package/README.md

@@ -13,7 +13,7 @@ pnpm check --fix
 To enable checks for any of the following modules, just install them:
 
 ```sh
-pnpm i -D typescript oxlint prettier publint eslint
+pnpm i -D typescript oxlint prettier publint eslint markdownlint-cli
 ```
 
 ## Contributing
@@ -30,10 +30,14 @@ bun run build
 # Run checks
 bun check --help
 bun check
+
+# Debug commands used
+DEBUG=1 bun check
 ```
 
 ### Adding Tools
 
-I've added everything I use, so if you want to add support for another tool, feel free.
-
-Just copy `src/tools/prettier.ts` and `src/tools/prettier.test.ts`, update the implementations (yes, tests are required), and add your new tool to `src/tools/index.ts`'s `ALL_TOOLS` export.
+1. Copy and rename `src/tools/prettier.ts` and `src/tools/prettier.test.ts` accordingly
+2. Implement and update tests for your new tool
+3. Add your tool to the `ALL_TOOLS` array in `src/tools/index.ts`
+4. Add the tool's NPM package to the first section of this README

package/bin/check.mjs

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import "../dist/cli.mjs";
+import "../dist/cli.js";

package/dist/cli.d.ts

@@ -1 +1 @@
-export {};
+export { };

package/dist/cli.js

@@ -0,0 +1,37 @@
+import { i as ALL_TOOLS, t as check } from "./src-D3TrACF9.js";
+import { isCI } from "ci-info";
+
+//#region package.json
+var version = "2.1.1";
+
+//#endregion
+//#region src/cli.ts
+const help = `\x1b[34m\x1b[1mcheck\x1b[0m runs all your project checks at once, standardizing and combining the output. \x1b[2m(${version})\x1b[0m
+
+\x1b[1mSupported Tools:\x1b[0m
+  ${ALL_TOOLS.map((tool) => `\x1b[32m${tool.name}\x1b[0m`).sort().join(", ")}
+
+\x1b[1mUsage:\x1b[0m
+  \x1b[1mcheck\x1b[0m \x1b[1m\x1b[36m[flags]\x1b[0m [root]
+
+\x1b[1mArguments:\x1b[0m
+  root       Directory to run commands from (default: .)
+
+\x1b[1mFlags\x1b[0m:
+  \x1b[36m-f\x1b[0m, \x1b[36m--fix\x1b[0m      Fix problems when possible (default: false in CI, true everywhere else)
+  \x1b[36m-d\x1b[0m, \x1b[36m--debug\x1b[0m    Enable debug logs
+  \x1b[36m-h\x1b[0m, \x1b[36m--help\x1b[0m     Show this help message and exit`;
+const args = process.argv.slice(2);
+const boolArg = (arg) => args.includes(arg) || void 0;
+if (boolArg("-h") || boolArg("--help")) {
+	console.log(help);
+	process.exit(0);
+}
+await check({
+	fix: boolArg("-f") ?? boolArg("--fix") ?? !isCI,
+	debug: boolArg("-d") ?? boolArg("--debug") ?? false,
+	root: args.find((arg) => !arg.startsWith("-")) ?? "."
+});
+
+//#endregion
+export {  };

package/dist/index.d.ts

@@ -1,5 +1,63 @@
-import type { CheckOptions, Problem } from "./types";
-export type * from "./types";
-export declare function check(options?: CheckOptions): Promise<void>;
-export declare function renderProblemGroup(problems: Problem[]): string;
-export declare function renderProblem(problem: Problem): string;
+//#region src/types.d.ts
+interface CheckOptions {
+  /**
+  * Set to true to fix problems that can be automatically fixed.
+  *
+  * Defaults to `true` outside CI, and `false` inside CI.
+  */
+  fix?: boolean;
+  /**
+  * Directory to run commands in.
+  */
+  root?: string;
+  /**
+  * Set to true to enable debug logs.
+  */
+  debug?: boolean;
+}
+type ToolDefinition = (opts: {
+  root: string;
+  packageJson: any;
+}) => Promise<Tool> | Tool;
+interface Tool {
+  /**
+  * Name of tool shown in the console output.
+  */
+  name: string;
+  /**
+  * The name of the package in your `package.json`. If present, this tool will be ran.
+  */
+  packageName: string;
+  /**
+  * Run the tool, only checking for problems.
+  */
+  check: () => Promise<Problem[]>;
+  /**
+  * Run the tool, but fix problems if possible. If the tool doesn't support fixing problems, `check` will be called instead.
+  */
+  fix?: () => Promise<Problem[]>;
+}
+interface Problem {
+  location?: CodeLocation;
+  message: string;
+  file: string;
+  kind: ProblemKind;
+  rule?: string;
+}
+interface CodeLocation {
+  line: number;
+  column: number;
+}
+type ProblemKind = "warning" | "error";
+type OutputParser = (data: {
+  code: number;
+  stdout: string;
+  stderr: string;
+}) => Problem[];
+//#endregion
+//#region src/index.d.ts
+declare function check(options?: CheckOptions): Promise<never>;
+declare function renderProblemGroup(problems: Problem[]): string;
+declare function renderProblem(problem: Problem): string;
+//#endregion
+export { CheckOptions, CodeLocation, OutputParser, Problem, ProblemKind, Tool, ToolDefinition, check, renderProblem, renderProblemGroup };

package/dist/index.js

@@ -0,0 +1,3 @@
+import { n as renderProblem, r as renderProblemGroup, t as check } from "./src-D3TrACF9.js";
+
+export { check, renderProblem, renderProblemGroup };

package/dist/src-D3TrACF9.js

@@ -0,0 +1,490 @@
+import { isCI } from "ci-info";
+import { spawn } from "node:child_process";
+import readline from "node:readline";
+import { join, relative, resolve, sep } from "node:path";
+import { readFile } from "node:fs/promises";
+
+//#region src/utils.ts
+function exec(cmd, args, opts) {
+	return new Promise((resolve$1, reject) => {
+		const child = spawn(cmd, args, {
+			...opts,
+			shell: true
+		});
+		let stderr = "";
+		let stdout = "";
+		child.stdout.on("data", (data) => {
+			stdout += data.toString();
+		});
+		child.stderr.on("data", (data) => {
+			stderr += data.toString();
+		});
+		child.on("error", (error) => {
+			reject(error);
+		});
+		child.on("close", (exitCode) => {
+			resolve$1({
+				stderr,
+				stdout,
+				exitCode
+			});
+		});
+	});
+}
+async function execAndParse(bin, args, cwd, parser) {
+	const res = await exec(bin, args, { cwd });
+	if (res.exitCode == null) throw Error("Exit code was null");
+	if (isDebug()) console.debug({
+		bin,
+		args,
+		cwd,
+		...res
+	});
+	return parser({
+		code: res.exitCode,
+		stderr: res.stderr,
+		stdout: res.stdout
+	});
+}
+function isDebug() {
+	return process.env.DEBUG === "true" || process.env.DEBUG === "1";
+}
+const bold = (str) => `\x1b[1m${str}\x1b[0m`;
+const dim = (str) => `\x1b[2m${str}\x1b[0m`;
+const red = (str) => `\x1b[31m${str}\x1b[0m`;
+const green = (str) => `\x1b[32m${str}\x1b[0m`;
+const yellow = (str) => `\x1b[33m${str}\x1b[0m`;
+const cyan = (str) => `\x1b[36m${str}\x1b[0m`;
+function humanMs(ms) {
+	const minutes = Math.floor(ms / 6e4);
+	const seconds = (ms % 6e4 / 1e3).toFixed(minutes > 0 ? 0 : 3);
+	return `${minutes > 0 ? `${minutes}m ` : ""}${seconds}s`;
+}
+function debug(message) {
+	if (isDebug()) console.debug(dim("⚙ " + message));
+}
+
+//#endregion
+//#region src/tools/eslint.ts
+const eslint = ({ root }) => {
+	const bin = "eslint";
+	const checkArgs = [
+		".",
+		"--ext",
+		".js,.ts,.jsx,.tsx,.mjs,.mts,.cjs,.cts,.vue",
+		"--format",
+		"compact",
+		"--max-warnings",
+		"0"
+	];
+	const fixArgs = [...checkArgs, "--fix"];
+	return {
+		name: "ESLint",
+		packageName: "eslint",
+		check: () => execAndParse(bin, checkArgs, root, parseOutput$5),
+		fix: () => execAndParse(bin, fixArgs, root, parseOutput$5)
+	};
+};
+const parseOutput$5 = ({ stdout, stderr }) => {
+	return `${stdout}\n${stderr}`.split(/\r?\n/).reduce((acc, line) => {
+		const groups = /^(?<file>.*?): line (?<line>[0-9]+), col (?<column>[0-9]+), (?<kind>\S+) - (?<message>.*?) \((?<rule>\S*?)\)$/.exec(line)?.groups;
+		if (groups) acc.push({
+			file: groups.file,
+			kind: groups.kind === "Warning" ? "warning" : "error",
+			message: groups.message,
+			location: {
+				line: parseInt(groups.line, 10),
+				column: parseInt(groups.column, 10)
+			},
+			rule: groups.rule
+		});
+		return acc;
+	}, []);
+};
+
+//#endregion
+//#region src/tools/markdownlint.ts
+const markdownlint = ({ root }) => {
+	const bin = "markdownlint";
+	const checkArgs = [
+		".",
+		"--json",
+		"--ignore='**/dist/**'",
+		"--ignore='**/node_modules/**'",
+		"--ignore='**/.output/**'",
+		"--ignore='**/coverage/**'"
+	];
+	const fixArgs = [...checkArgs, "--fix"];
+	return {
+		name: "Markdownlint",
+		packageName: "markdownlint-cli",
+		check: () => execAndParse(bin, checkArgs, root, parseOutput$4),
+		fix: () => execAndParse(bin, fixArgs, root, parseOutput$4)
+	};
+};
+const parseOutput$4 = ({ stderr: _stderr }) => {
+	const stderr = _stderr.trim();
+	if (!stderr) return [];
+	return JSON.parse(stderr).map((warning) => ({
+		location: {
+			line: warning.lineNumber,
+			column: warning.errorRange?.[0] ?? 0
+		},
+		message: warning.ruleDescription,
+		file: warning.fileName,
+		kind: "warning",
+		rule: warning.ruleNames[0]
+	}));
+};
+
+//#endregion
+//#region src/tools/oxlint.ts
+const oxlint = ({ root }) => {
+	const bin = "oxlint";
+	const checkArgs = [
+		"--format=unix",
+		"--deny-warnings",
+		"--ignore-path=.oxlintignore",
+		"--ignore-pattern='**/dist/**'",
+		"--ignore-pattern='**/node_modules/**'",
+		"--ignore-pattern='**/.output/**'",
+		"--ignore-pattern='**/coverage/**'"
+	];
+	const fixArgs = [...checkArgs, "--fix"];
+	return {
+		name: "Oxlint",
+		packageName: "oxlint",
+		check: () => execAndParse(bin, checkArgs, root, parseOutput$3),
+		fix: () => execAndParse(bin, fixArgs, root, parseOutput$3)
+	};
+};
+const parseOutput$3 = ({ stdout }) => {
+	if (stdout.trim()) return stdout.split(/\r?\n/).reduce((acc, line) => {
+		const groups = /^(?<file>.+?):(?<line>[0-9]+):(?<column>[0-9]+):\s?(?<message>.*?)\s?\[(?<kind>Warning|Error)\/?(?<rule>.*?)\]\s?$/.exec(line)?.groups;
+		if (groups) acc.push({
+			file: groups.file,
+			kind: groups.kind === "Error" ? "error" : "warning",
+			message: groups.message,
+			rule: groups.rule || void 0,
+			location: {
+				line: parseInt(groups.line, 10),
+				column: parseInt(groups.column, 10)
+			}
+		});
+		return acc;
+	}, []);
+	return stdout.trim().split(/\r?\n/).map((line) => line.trim()).filter((line) => !!line && !line.includes(" ")).map((line) => ({
+		file: line.trim(),
+		kind: "warning",
+		message: "Not formatted."
+	}));
+};
+
+//#endregion
+//#region src/tools/prettier.ts
+const prettier = ({ root }) => {
+	const bin = "prettier";
+	const checkArgs = [".", "--list-different"];
+	const fixArgs = [".", "-w"];
+	return {
+		name: "Prettier",
+		packageName: "prettier",
+		check: () => execAndParse(bin, checkArgs, root, parseOutput$2),
+		fix: () => execAndParse(bin, fixArgs, root, parseOutput$2)
+	};
+};
+const parseOutput$2 = ({ stdout, stderr }) => {
+	if (stderr.trim()) return stderr.split(/\r?\n/).reduce((acc, line) => {
+		const groups = /^\[(?<kind>.+?)\]\s?(?<file>.+?):\s?(?<message>.*?)\s?\((?<line>[0-9]+):(?<column>[0-9]+)\)$/.exec(line)?.groups;
+		if (groups) acc.push({
+			file: groups.file,
+			kind: groups.kind === "error" ? "error" : "warning",
+			message: groups.message,
+			location: {
+				line: parseInt(groups.line, 10),
+				column: parseInt(groups.column, 10)
+			}
+		});
+		return acc;
+	}, []);
+	return stdout.trim().split(/\r?\n/).map((line) => line.trim()).filter((line) => !!line && !line.includes(" ")).map((line) => ({
+		file: line.trim(),
+		kind: "warning",
+		message: "Not formatted."
+	}));
+};
+
+//#endregion
+//#region src/tools/publint.ts
+const publint = ({ root }) => {
+	const bin = "publint";
+	const args = [];
+	return {
+		name: "Publint",
+		packageName: "publint",
+		check: () => execAndParse(bin, args, root, parseOutput$1)
+	};
+};
+const parseOutput$1 = ({ stdout }) => {
+	let kind = "warning";
+	return stdout.split(/\r?\n/).reduce((acc, line) => {
+		if (line.includes("Errors:")) {
+			kind = "error";
+			return acc;
+		}
+		const groups = /^[0-9]+\.\s?(?<message>.*)$/.exec(line)?.groups;
+		if (groups == null) return acc;
+		acc.push({
+			kind,
+			message: groups.message,
+			file: "package.json"
+		});
+		return acc;
+	}, []);
+};
+
+//#endregion
+//#region src/tools/typescript.ts
+const typescript = async ({ root, packageJson }) => {
+	const tsc = {
+		name: "TypeScript",
+		bin: "tsc",
+		packageName: "typescript",
+		args: [
+			"--noEmit",
+			"--pretty",
+			"false"
+		]
+	};
+	const vueTsc = {
+		name: "TypeScript (Vue)",
+		bin: "vue-tsc",
+		packageName: "vue-tsc",
+		args: [
+			"--noEmit",
+			"--pretty",
+			"false"
+		]
+	};
+	const isVueTsc = packageJson.devDependencies?.["vue-tsc"] !== void 0;
+	debug("TypeScript: Is vue-tsc installed? " + isVueTsc);
+	const cmd = isVueTsc ? vueTsc : tsc;
+	return {
+		name: cmd.name,
+		packageName: cmd.packageName,
+		check: async () => execAndParse(cmd.bin, cmd.args, root, parseOutput)
+	};
+};
+const parseOutput = ({ stdout }) => {
+	return stdout.split(/\r?\n/).reduce((acc, line) => {
+		const groups = /^(?<file>\S+?)\((?<line>[0-9]+),(?<column>[0-9]+)\): \w+? (?<rule>TS[0-9]+): (?<message>.*)$/.exec(line)?.groups;
+		if (groups) acc.push({
+			file: groups.file,
+			kind: "error",
+			message: groups.message,
+			location: {
+				line: parseInt(groups.line, 10),
+				column: parseInt(groups.column, 10)
+			},
+			rule: groups.rule
+		});
+		return acc;
+	}, []);
+};
+
+//#endregion
+//#region src/tools/index.ts
+const ALL_TOOLS = [
+	eslint,
+	markdownlint,
+	oxlint,
+	prettier,
+	publint,
+	typescript
+];
+
+//#endregion
+//#region src/tasklist/index.ts
+async function createTaskList(inputs, run) {
+	const states = inputs.map((item) => ({
+		title: item.name,
+		state: "pending"
+	}));
+	const isTty = process.stderr.isTTY;
+	let tick = 0;
+	const render = (opts) => {
+		if (isTty && !opts?.firstRender) readline.moveCursor(process.stderr, 0, -1 * states.length);
+		if (isTty || opts?.firstRender || opts?.lastRender) states.forEach(({ state, title }) => {
+			readline.clearLine(process.stderr, 0);
+			const frames = SPINNER_FRAMES[state];
+			process.stderr.write(`${frames[tick % frames.length]} ${title}\n`);
+		});
+		tick++;
+	};
+	render({ firstRender: true });
+	const renderInterval = setInterval(render, SPINNER_INTERVAL_MS);
+	try {
+		const result = await Promise.all(inputs.map(async (input, i) => {
+			const succeed = (title) => {
+				if (title != null) states[i].title = title;
+				states[i].state = "success";
+				render();
+			};
+			const warn = (title) => {
+				if (title != null) states[i].title = title;
+				states[i].state = "warning";
+				render();
+			};
+			const fail = (title) => {
+				if (title != null) states[i].title = title;
+				states[i].state = "error";
+				render();
+			};
+			try {
+				states[i].state = "in-progress";
+				render();
+				const res = await run({
+					input,
+					succeed,
+					warn,
+					fail
+				});
+				if (states[i].state === "in-progress") states[i].state = "success";
+				render();
+				return res;
+			} catch (err) {
+				if (err instanceof Error) fail(err.message);
+				else fail(String(err));
+				render();
+				throw err;
+			}
+		}));
+		render({ lastRender: true });
+		return result;
+	} finally {
+		clearInterval(renderInterval);
+	}
+}
+const SPINNER_INTERVAL_MS = 80;
+const SPINNER_FRAMES = {
+	pending: [dim("□")],
+	"in-progress": [
+		"⠋",
+		"⠙",
+		"⠹",
+		"⠸",
+		"⠼",
+		"⠴",
+		"⠦",
+		"⠧",
+		"⠇",
+		"⠏"
+	].map(cyan),
+	success: [green("✔")],
+	warning: [yellow("⚠")],
+	error: [red("✗")]
+};
+
+//#endregion
+//#region src/index.ts
+async function check(options = {}) {
+	const { debug: debug$1, fix = !isCI, root = process.cwd() } = options;
+	const packageJson = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+	if (debug$1) process.env.DEBUG = "true";
+	console.log();
+	debug("Options:" + JSON.stringify(options));
+	debug("Resolved options:" + JSON.stringify({
+		debug: debug$1,
+		fix,
+		root,
+		packageJson
+	}));
+	const tools = await findInstalledTools({
+		root,
+		packageJson
+	});
+	if (tools.length === 0) {
+		if (isDebug()) console.log("No tools detected!");
+		else console.log("No tools detected! Run with --debug for more info");
+		console.log();
+		process.exit(1);
+	}
+	const problems = (await createTaskList(tools, async ({ input: tool, fail, succeed, warn }) => {
+		const startTime = performance.now();
+		const problems$1 = await (fix ? tool.fix ?? tool.check : tool.check)();
+		problems$1.forEach((problem) => {
+			problem.file = resolve(root ?? process.cwd(), problem.file);
+		});
+		const duration = humanMs(performance.now() - startTime);
+		const title = `${tool.name} ${dim(`(${duration})`)}`;
+		if (problems$1.filter((p) => p.kind === "error").length > 0) fail(title);
+		else if (problems$1.length > 0) warn(title);
+		else succeed(title);
+		return problems$1;
+	})).flat();
+	console.log();
+	if (problems.length === 0) process.exit(0);
+	console.log(plural(problems.length, "Problem:", "Problems:"));
+	problems.sort((l, r) => {
+		const nameCompare = l.file.localeCompare(r.file);
+		if (nameCompare !== 0) return nameCompare;
+		const lineCompare = (l.location?.line ?? 0) - (r.location?.line ?? 0);
+		if (lineCompare !== 0) return lineCompare;
+		return (l.location?.column ?? 0) - (r.location?.column ?? 0);
+	});
+	const groupedProblems = problems.reduce((acc, problem) => {
+		const locationHash = `${problem.file}:${problem.location?.line}:${problem.location?.column}`;
+		const list = acc.get(locationHash) ?? [];
+		list.push(problem);
+		acc.set(locationHash, list);
+		return acc;
+	}, /* @__PURE__ */ new Map());
+	console.log([...groupedProblems.values()].map(renderProblemGroup).join("\n"));
+	const files = Object.entries(problems.reduce((acc, problem) => {
+		const file = "." + sep + relative(process.cwd(), problem.file);
+		acc[file] ??= 0;
+		acc[file]++;
+		return acc;
+	}, {}));
+	const maxLength = files.reduce((prev, [file]) => Math.max(prev, file.length), 0);
+	console.log();
+	console.log("Across " + plural(files.length, "File:", "Files:"));
+	files.forEach(([file, count]) => {
+		console.log(`${cyan(file.padEnd(maxLength, " "))} ${count}`);
+	});
+	console.log();
+	process.exit(problems.length);
+}
+async function findInstalledTools(opts) {
+	const status = await Promise.all(ALL_TOOLS.map(async (def) => {
+		const tool = await def(opts);
+		return {
+			tool,
+			isInstalled: !!opts.packageJson.devDependencies?.[tool.packageName]
+		};
+	}));
+	if (isDebug()) {
+		const getTools = (isInstalled) => status.filter((item) => item.isInstalled === isInstalled).map((item) => item.tool.name).join(", ");
+		debug(`Installed: ${getTools(true) || "(none)"}`);
+		debug(`Skipping: ${getTools(false) || "(none)"} `);
+	}
+	return status.filter(({ isInstalled }) => isInstalled).map((item) => item.tool);
+}
+function plural(count, singular, plural$1) {
+	return `${count} ${count === 1 ? singular : plural$1} `;
+}
+function renderProblemGroup(problems) {
+	const renderedProblems = problems.map(renderProblem);
+	const problem = problems[0];
+	const path = relative(process.cwd(), problem.file);
+	const link = dim(`→ .${sep}${problem.location ? `${path}:${problem.location.line}:${problem.location.column}` : path}`);
+	return `${renderedProblems.join("\n")}\n  ${link}`;
+}
+function renderProblem(problem) {
+	const icon = problem.kind === "warning" ? bold(yellow("⚠")) : bold(red("✗"));
+	const source = problem.rule ? dim(` (${problem.rule})`) : "";
+	return `${icon} ${problem.message}${source}`;
+}
+
+//#endregion
+export { ALL_TOOLS as i, renderProblem as n, renderProblemGroup as r, check as t };