@aklinker1/check 2.1.0 → 2.1.2

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-CKPF6CV1.js";
+import { isCI } from "ci-info";
+
+//#region package.json
+var version = "2.1.2";
+
+//#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-CKPF6CV1.js";
+
+export { check, renderProblem, renderProblemGroup };

package/dist/src-CKPF6CV1.js

@@ -0,0 +1,451 @@
+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, opts) {
+	return new Promise((resolve$1, reject) => {
+		const child = spawn(cmd, {
+			...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(cmd, cwd, parser) {
+	const res = await exec(cmd, { cwd });
+	if (res.exitCode == null) throw Error("Exit code was null");
+	if (isDebug()) console.debug({
+		cmd,
+		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 checkCmd = `eslint . --ext .js,.ts,.jsx,.tsx,.mjs,.mts,.cjs,.cts,.vue --format compact --max-warnings 0`;
+	const fixCmd = `${checkCmd} --fix`;
+	return {
+		name: "ESLint",
+		packageName: "eslint",
+		check: () => execAndParse(checkCmd, root, parseOutput$5),
+		fix: () => execAndParse(fixCmd, 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 checkCmd = "markdownlint . --json --ignore='**/dist/**' --ignore='**/node_modules/**' --ignore='**/.output/**' --ignore='**/coverage/**'";
+	const fixCmd = `${checkCmd} --fix`;
+	return {
+		name: "Markdownlint",
+		packageName: "markdownlint-cli",
+		check: () => execAndParse(checkCmd, root, parseOutput$4),
+		fix: () => execAndParse(fixCmd, 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 checkCmd = "oxlint . --format=unix --deny-warnings --ignore-path=.oxlintignore --ignore-pattern='**/dist/**' --ignore-pattern='**/node_modules/**' --ignore-pattern='**/.output/**' --ignore-pattern='**/coverage/**'";
+	const fixCmd = `${checkCmd} --fix`;
+	return {
+		name: "Oxlint",
+		packageName: "oxlint",
+		check: () => execAndParse(checkCmd, root, parseOutput$3),
+		fix: () => execAndParse(fixCmd, 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 checkCmd = "prettier . --list-different";
+	const fixCmd = "prettier . -w";
+	return {
+		name: "Prettier",
+		packageName: "prettier",
+		check: () => execAndParse(checkCmd, root, parseOutput$2),
+		fix: () => execAndParse(fixCmd, 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 cmd = "publint";
+	return {
+		name: "Publint",
+		packageName: "publint",
+		check: () => execAndParse(cmd, 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",
+		cmd: "tsc --noEmit --pretty false",
+		packageName: "typescript"
+	};
+	const vueTsc = {
+		name: "TypeScript (Vue)",
+		cmd: "vue-tsc --noEmit --pretty false",
+		packageName: "vue-tsc"
+	};
+	const isVueTsc = packageJson.devDependencies?.["vue-tsc"] !== void 0;
+	debug("TypeScript: Is vue-tsc installed? " + isVueTsc);
+	const mod = isVueTsc ? vueTsc : tsc;
+	return {
+		name: mod.name,
+		packageName: mod.packageName,
+		check: async () => execAndParse(mod.cmd, 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 };

package/package.json

@@ -1,11 +1,28 @@
 {
   "name": "@aklinker1/check",
-  "version": "2.1.0",
-  "packageManager": "bun@1.2.11",
+  "version": "2.1.2",
+  "packageManager": "bun@1.3.0",
+  "type": "module",
+  "scripts": {
+    "build": "tsdown src/index.ts src/cli.ts",
+    "check": "bun src/cli.ts",
+    "prepack": "bun run build",
+    "prepublish": "bun run build"
+  },
+  "dependencies": {
+    "ci-info": "*"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "oxlint": "^1.22.0",
+    "publint": "^0.3.14",
+    "tsdown": "^0.15.9",
+    "typescript": "^5.9.3"
+  },
   "repository": {
-    "type": "git",
     "url": "https://github.com/aklinker1/check"
   },
+  "license": "MIT",
   "homepage": "https://github.com/aklinker1/check",
   "author": {
     "name": "Aaron Klinker",
@@ -20,14 +37,13 @@
     "prettier",
     "typescript"
   ],
-  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs"
+      "import": "./dist/index.js"
     }
   },
-  "module": "./dist/index.mjs",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
     "bin",
@@ -35,36 +51,5 @@
   ],
   "bin": {
     "check": "bin/check.mjs"
-  },
-  "dependencies": {
-    "@antfu/utils": "^0.7.7",
-    "citty": "^0.1.6",
-    "ci-info": "^4.0.0"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "publint": "^0.2.7",
-    "typescript": "^5.0.0",
-    "unbuild": "latest"
-  },
-  "unbuild": {
-    "entries": [
-      {
-        "builder": "mkdist",
-        "input": "./src/",
-        "outDir": "./dist"
-      }
-    ],
-    "declaration": true
-  },
-  "changelog": {
-    "excludeAuthors": [
-      "aaronklinker1@gmail.com"
-    ]
-  },
-  "scripts": {
-    "build": "bunx --bun unbuild",
-    "check": "bun src/cli.ts",
-    "prepublish": "bun run build"
   }
-}
+}

package/dist/cli.mjs

@@ -1,34 +0,0 @@
-import { defineCommand, runMain } from "citty";
-import { check } from "./index.mjs";
-const main = defineCommand({
-  meta: {
-    name: "check",
-    description: "@aklinker1/check"
-  },
-  args: {
-    root: {
-      type: "positional",
-      description: "Root directory to run commands from",
-      required: false
-    },
-    fix: {
-      type: "boolean",
-      alias: "f",
-      description: "Fix problems if possible instead of just reporting them"
-    },
-    debug: {
-      type: "boolean",
-      alias: "d",
-      description: "Enable debug logs"
-    },
-    binDir: {
-      type: "string",
-      alias: "b",
-      description: "Directory where binaries are located"
-    }
-  },
-  async run(ctx) {
-    await check(ctx.args);
-  }
-});
-runMain(main);