@aklinker1/check 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Aaron Klinker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,46 @@
+# Check
+
+An opinionated CLI tool to run all your checks all at once. The command will only exit with code 0 when no warnings exist.
+
+https://github.com/aklinker1/check/assets/10101283/c8089e5c-e25f-4f59-8897-d2a6f97a3139
+
+> [!WARNING]
+> I have not actually published this to NPM yet.
+
+```sh
+pnpm i @aklinker1/check
+pnpm check
+pnpm check --fix
+```
+
+To enable checks for any of the following modules, just install them:
+
+```sh
+pnpm i -D typescript eslint prettier publint
+```
+
+## Contributing
+
+This project is built using [`bun`](https://bun.sh). Demo project uses PNPM.
+
+```sh
+# Setup
+bun i
+pushd demo
+    pnpm i
+popd
+
+# Build NPM package
+bun run build
+
+# Run checks
+bun check --help
+bun check
+bun check demo
+```
+
+### 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.

package/bin/check.mjs

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

package/dist/cli.d.ts

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

package/dist/cli.mjs

@@ -0,0 +1,29 @@
+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"
+    }
+  },
+  async run(ctx) {
+    await check(ctx.args);
+  }
+});
+runMain(main);

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { CheckOptions, Problem } from "./types";
+export type * from "./types";
+export declare function check(options?: CheckOptions): Promise<void>;
+export declare function renderProblem(problem: Problem): string;

package/dist/index.mjs

@@ -0,0 +1,103 @@
+import { ALL_TOOLS } from "./tools/index.mjs";
+import { p } from "@antfu/utils";
+import { bold, cyan, debug, dim, humanMs, isDebug, red, yellow } from "./utils.mjs";
+import { createTaskList } from "./tasklist/index.mjs";
+import { relative, resolve, sep } from "node:path";
+export async function check(options = {}) {
+  const { debug: debug2, fix, root } = options;
+  if (debug2) {
+    process.env.DEBUG = "true";
+  }
+  console.log();
+  const tools = await findInstalledTools(root);
+  if (tools.length === 0) {
+    console.log("No tools detected! Run with --debug for more info");
+    console.log();
+    process.exit(1);
+  }
+  const results = await createTaskList(
+    tools,
+    async ({ input: tool, fail, succeed, warn }) => {
+      const startTime = performance.now();
+      const fn = fix ? tool.fix ?? tool.check : tool.check;
+      const output = await fn(root);
+      if ("problems" in output) {
+        output.problems.forEach((problem) => {
+          problem.file = resolve(root ?? process.cwd(), problem.file);
+        });
+      }
+      const duration = humanMs(performance.now() - startTime);
+      const title = `${tool.name} ${dim(`(${duration})`)}`;
+      if (output.type === "error")
+        fail(title);
+      else if (output.type === "warning")
+        warn(title);
+      else
+        succeed(title);
+      return output;
+    }
+  );
+  const problems = results.flatMap((result) => result.type === "success" ? [] : result.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);
+  });
+  console.log();
+  if (problems.length === 0) {
+    process.exit(0);
+  }
+  console.log(plural(problems.length, "Problem:", "Problems:"));
+  problems.forEach((problem) => {
+    console.log(renderProblem(problem));
+  });
+  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();
+  const failedChecks = results.filter((res) => res.type === "error").length;
+  process.exit(failedChecks);
+}
+async function findInstalledTools(root) {
+  const status = await p(ALL_TOOLS).map(async (tool) => ({
+    tool,
+    isInstalled: await tool.isInstalled(root)
+  })).promise;
+  if (isDebug()) {
+    const getTools = (isInstalled) => status.filter((item) => item.isInstalled === isInstalled).map((item) => item.tool.name).join(", ");
+    const installed = getTools(true);
+    debug(`Installed: ${installed || "(none)"}`);
+    const skipped = getTools(false);
+    debug(`Skipping: ${skipped || "(none)"} `);
+  }
+  return status.filter(({ isInstalled }) => isInstalled).map((item) => item.tool);
+}
+function plural(count, singular, plural2) {
+  return `${count} ${count === 1 ? singular : plural2} `;
+}
+export function renderProblem(problem) {
+  const icon = problem.kind === "warning" ? bold(yellow("\u26A0")) : bold(red("\u2717"));
+  const path = relative(process.cwd(), problem.file);
+  const location = problem.location ? `${path}:${problem.location.line}:${problem.location.column}` : path;
+  const source = problem.rule ? dim(` (${problem.rule})`) : "";
+  const link = dim(`\u2192 .${sep}${location}`);
+  return `${icon} ${problem.message}${source}
+  ${link}`;
+}

package/dist/tasklist/index.d.ts

@@ -0,0 +1,8 @@
+export declare function createTaskList<TInput extends {
+    name: string;
+}, TResult = void>(inputs: TInput[], run: (ctx: {
+    input: TInput;
+    succeed: (title?: string) => void;
+    warn: (title?: string) => void;
+    fail: (title?: string) => void;
+}) => Promise<TResult>): Promise<TResult[]>;

package/dist/tasklist/index.mjs

@@ -0,0 +1,76 @@
+import { cyan, dim, green, red, yellow } from "../utils.mjs";
+import readline from "node:readline";
+export 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 (!opts?.firstRender) {
+      readline.moveCursor(process.stderr, 0, -1 * states.length);
+    }
+    states.forEach(({ state, title }) => {
+      readline.clearLine(process.stderr, 0);
+      const frames = SPINNER_FRAMES[state];
+      process.stderr.write(`${frames[tick % frames.length]} ${title}
+`);
+    });
+    tick++;
+  };
+  render({ firstRender: true });
+  const renderInterval = setInterval(render, SPINNER_INTERVAL_MS);
+  try {
+    const result = 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));
+          throw err;
+        }
+      })
+    );
+    render({ lastRender: true });
+    return await result;
+  } finally {
+    clearInterval(renderInterval);
+  }
+}
+const SPINNER_INTERVAL_MS = 80;
+const SPINNER_FRAMES = {
+  pending: [dim("\u25A1")],
+  "in-progress": ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"].map(cyan),
+  success: [green("\u2714")],
+  warning: [yellow("\u26A0")],
+  error: [red("\u2717")]
+};

package/dist/tools/eslint.d.ts

@@ -0,0 +1,3 @@
+import type { OutputParser, Tool } from "../types";
+export declare const eslint: Tool;
+export declare const parseOuptut: OutputParser;

package/dist/tools/eslint.mjs

@@ -0,0 +1,44 @@
+import { isBinInstalled, execAndParse } from "../utils.mjs";
+const bin = "node_modules/.bin/eslint";
+const args = [
+  ".",
+  "--ext",
+  ".js,.ts,.jsx,.tsx,.mjs,.mts,.cjs,.cts,.vue",
+  "--format",
+  "compact",
+  "--max-warnings",
+  "0"
+];
+export const eslint = {
+  name: "ESLint",
+  isInstalled: (root) => isBinInstalled(bin, root),
+  check: (root) => execAndParse(root, bin, args, parseOuptut),
+  fix: (root) => execAndParse(root, bin, [...args, "--fix"], parseOuptut)
+};
+export const parseOuptut = ({ code, stdout, stderr }) => {
+  if (code === 0)
+    return { type: "success" };
+  const problems = `${stdout}
+${stderr}`.split(/\r?\n/).reduce((acc, line) => {
+    const match = /^(.*?): line ([0-9]+), col ([0-9]+), (\S+) - (.*?) \((\S*?)\)$/.exec(
+      line
+    );
+    if (match) {
+      acc.push({
+        file: match[1],
+        kind: match[4] === "Warning" ? "warning" : "error",
+        message: match[5],
+        location: {
+          line: parseInt(match[2], 10),
+          column: parseInt(match[3], 10)
+        },
+        rule: match[6]
+      });
+    }
+    return acc;
+  }, []);
+  return {
+    type: problems.some((problem) => problem.kind === "error") ? "error" : "warning",
+    problems
+  };
+};

package/dist/tools/eslint.test.d.ts

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

package/dist/tools/eslint.test.mjs

@@ -0,0 +1,38 @@
+import { describe, it, expect } from "bun:test";
+import { parseOuptut } from "./eslint.mjs";
+describe("ESLint", () => {
+  it("should properly parse output", async () => {
+    const stdout = `/path/to/check/demo/test.ts: line 1, col 7, Warning - 'test' is assigned a value but never used. (@typescript-eslint/no-unused-vars)
+/path/to/check/demo/test.ts: line 5, col 7, Error - 'variable' is assigned a value but never used. (@typescript-eslint/no-unused-vars)
+
+4 problems
+`;
+    const stderr = "";
+    const code = 1;
+    expect(parseOuptut({ code, stdout, stderr })).toEqual({
+      type: "error",
+      problems: [
+        {
+          file: "/path/to/check/demo/test.ts",
+          message: "'test' is assigned a value but never used.",
+          kind: "warning",
+          location: {
+            line: 1,
+            column: 7
+          },
+          rule: "@typescript-eslint/no-unused-vars"
+        },
+        {
+          file: "/path/to/check/demo/test.ts",
+          message: "'variable' is assigned a value but never used.",
+          kind: "error",
+          location: {
+            line: 5,
+            column: 7
+          },
+          rule: "@typescript-eslint/no-unused-vars"
+        }
+      ]
+    });
+  });
+});

package/dist/tools/index.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from "../types";
+export declare const ALL_TOOLS: Tool[];

package/dist/tools/index.mjs

@@ -0,0 +1,5 @@
+import { eslint } from "./eslint.mjs";
+import { prettier } from "./prettier.mjs";
+import { typescript } from "./typescript.mjs";
+import { publint } from "./publint.mjs";
+export const ALL_TOOLS = [prettier, typescript, eslint, publint];

package/dist/tools/prettier.d.ts

@@ -0,0 +1,3 @@
+import type { Tool, OutputParser } from "../types";
+export declare const prettier: Tool;
+export declare const parseOuptut: OutputParser;

package/dist/tools/prettier.mjs

@@ -0,0 +1,25 @@
+import { execAndParse, isBinInstalled } from "../utils.mjs";
+const bin = "node_modules/.bin/prettier";
+const checkArgs = [".", "--list-different"];
+const fixArgs = [".", "--fix"];
+export const prettier = {
+  name: "Prettier",
+  isInstalled: (root) => isBinInstalled(bin, root),
+  check: (root) => execAndParse(root, bin, checkArgs, parseOuptut),
+  fix: (root) => execAndParse(root, bin, fixArgs, parseOuptut)
+};
+export const parseOuptut = ({ code, stdout }) => {
+  if (code === 0)
+    return { type: "success" };
+  const problems = stdout.trim().split(/\r?\n/).map(
+    (line) => ({
+      file: line.trim(),
+      kind: "warning",
+      message: "Not formatted."
+    })
+  );
+  return {
+    type: "warning",
+    problems
+  };
+};

package/dist/tools/prettier.test.d.ts

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

package/dist/tools/prettier.test.mjs

@@ -0,0 +1,26 @@
+import { describe, it, expect } from "bun:test";
+import { parseOuptut } from "./prettier.mjs";
+describe("Prettier", () => {
+  it("should properly parse output", async () => {
+    const stdout = `target/.rustc_info.json
+test.ts
+`;
+    const stderr = "";
+    const code = 1;
+    expect(parseOuptut({ code, stdout, stderr })).toEqual({
+      type: "warning",
+      problems: [
+        {
+          file: "target/.rustc_info.json",
+          message: "Not formatted.",
+          kind: "warning"
+        },
+        {
+          file: "test.ts",
+          message: "Not formatted.",
+          kind: "warning"
+        }
+      ]
+    });
+  });
+});

package/dist/tools/publint.d.ts

@@ -0,0 +1,3 @@
+import type { OutputParser, Tool } from "../types";
+export declare const publint: Tool;
+export declare const parseOuptut: OutputParser;

package/dist/tools/publint.mjs

@@ -0,0 +1,32 @@
+import { isBinInstalled, execAndParse } from "../utils.mjs";
+const bin = "node_modules/.bin/publint";
+const args = [];
+export const publint = {
+  name: "Publint",
+  isInstalled: (root) => isBinInstalled(bin, root),
+  check: (root) => execAndParse(root, bin, args, parseOuptut)
+};
+export const parseOuptut = ({ code, stdout, stderr }) => {
+  if (code === 0)
+    return { type: "success" };
+  let kind = "warning";
+  const problems = stdout.split(/\r?\n/).reduce((acc, line) => {
+    if (line.includes("Errors:")) {
+      kind = "error";
+      return acc;
+    }
+    const match = /^[0-9]+\.\s?(.*)$/.exec(line);
+    if (match == null)
+      return acc;
+    acc.push({
+      kind,
+      message: match[1],
+      file: "package.json"
+    });
+    return acc;
+  }, []);
+  return {
+    type: kind,
+    problems
+  };
+};

package/dist/tools/publint.test.d.ts

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

package/dist/tools/publint.test.mjs

@@ -0,0 +1,36 @@
+import { describe, it, expect } from "bun:test";
+import { parseOuptut } from "./publint.mjs";
+describe("Publint", () => {
+  it("should properly parse output", async () => {
+    const stdout = `@aklinker1/check lint results:
+Suggestions:
+1. Consider being better lolz.
+Warnings:
+1. pkg.exports["."].import types is not exported. Consider adding pkg.exports["."].import.types: "./dist/index.d.ts" to be compatible with TypeScript's "moduleResolution": "bundler" compiler option.
+Errors:
+1. pkg.module is ./dist/index.cjs but the file does not exist.
+`;
+    const stderr = "";
+    const code = 1;
+    expect(parseOuptut({ code, stdout, stderr })).toEqual({
+      type: "error",
+      problems: [
+        {
+          file: "package.json",
+          message: "Consider being better lolz.",
+          kind: "warning"
+        },
+        {
+          file: "package.json",
+          message: `pkg.exports["."].import types is not exported. Consider adding pkg.exports["."].import.types: "./dist/index.d.ts" to be compatible with TypeScript's "moduleResolution": "bundler" compiler option.`,
+          kind: "warning"
+        },
+        {
+          file: "package.json",
+          message: "pkg.module is ./dist/index.cjs but the file does not exist.",
+          kind: "error"
+        }
+      ]
+    });
+  });
+});

package/dist/tools/typescript.d.ts

@@ -0,0 +1,3 @@
+import type { Tool, OutputParser } from "../types";
+export declare const typescript: Tool;
+export declare const parseOuptut: OutputParser;

package/dist/tools/typescript.mjs

@@ -0,0 +1,34 @@
+import { execAndParse, isBinInstalled } from "../utils.mjs";
+const bin = "node_modules/.bin/tsc";
+const checkArgs = ["--noEmit", "--pretty", "false"];
+export const typescript = {
+  name: "TypeScript",
+  isInstalled: (root) => isBinInstalled(bin, root),
+  check: (root) => execAndParse(root, bin, checkArgs, parseOuptut)
+};
+export const parseOuptut = ({ code, stdout }) => {
+  if (code === 0)
+    return { type: "success" };
+  const problems = stdout.split(/\r?\n/).reduce((acc, line) => {
+    const match = /^(\S+?)\(([0-9]+),([0-9]+)\): \w+? (TS[0-9]+): (.*)$/.exec(
+      line
+    );
+    if (match) {
+      acc.push({
+        file: match[1],
+        kind: "error",
+        message: match[5],
+        location: {
+          line: parseInt(match[2], 10),
+          column: parseInt(match[3], 10)
+        },
+        rule: match[4]
+      });
+    }
+    return acc;
+  }, []);
+  return {
+    type: "error",
+    problems
+  };
+};

package/dist/tools/typescript.test.d.ts

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

package/dist/tools/typescript.test.mjs

@@ -0,0 +1,36 @@
+import { describe, it, expect } from "bun:test";
+import { parseOuptut } from "./typescript.mjs";
+describe("TypeScript", () => {
+  it("should properly parse output", async () => {
+    const stdout = `test.ts(1,19): error TS2355: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
+test.ts(5,24): error TS7006: Parameter 'a' implicitly has an 'any' type.
+`;
+    const stderr = "";
+    const code = 1;
+    expect(parseOuptut({ code, stdout, stderr })).toEqual({
+      type: "error",
+      problems: [
+        {
+          file: "test.ts",
+          message: "A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.",
+          kind: "error",
+          location: {
+            line: 1,
+            column: 19
+          },
+          rule: "TS2355"
+        },
+        {
+          file: "test.ts",
+          message: "Parameter 'a' implicitly has an 'any' type.",
+          kind: "error",
+          location: {
+            line: 5,
+            column: 24
+          },
+          rule: "TS7006"
+        }
+      ]
+    });
+  });
+});

package/dist/types.d.ts

@@ -0,0 +1,61 @@
+export interface CheckOptions {
+    /**
+     * Set to true to fix problems that can be automatically fixed.
+     */
+    fix?: boolean;
+    /**
+     * Directory to run commands in.
+     */
+    root?: string;
+    /**
+     * Set to true to enable debug logs.
+     */
+    debug?: boolean;
+}
+export interface Tool {
+    /**
+     * Name of tool shown in the console output.
+     */
+    name: string;
+    /**
+     * Check if the tool is installed.
+     */
+    isInstalled: (root: string | undefined) => Promise<boolean>;
+    /**
+     * Run the tool, only checking for problems.
+     */
+    check: (root: string | undefined) => Promise<Output>;
+    /**
+     * Run the tool, but fix problems if possible. If the tool doesn't support fixing problems, `check` will be called instead.
+     */
+    fix?: (root: string | undefined) => Promise<Output>;
+}
+export type Output = OutputSuccess | OutputWarning | OutputError;
+export interface OutputSuccess {
+    type: "success";
+}
+export interface OutputWarning {
+    type: "warning";
+    problems: Problem[];
+}
+export interface OutputError {
+    type: "error";
+    problems: Problem[];
+}
+export interface Problem {
+    location?: CodeLocation;
+    message: string;
+    file: string;
+    kind: ProblemKind;
+    rule?: string;
+}
+export interface CodeLocation {
+    line: number;
+    column: number;
+}
+export type ProblemKind = "warning" | "error";
+export type OutputParser = (data: {
+    code: number;
+    stdout: string;
+    stderr: string;
+}) => Output;

package/dist/utils.d.ts

@@ -0,0 +1,12 @@
+import type { OutputParser, Output } from "./types";
+export declare function isBinInstalled(bin: string, root?: string): Promise<boolean>;
+export declare function execAndParse(root: string | undefined, bin: string, args: string[], parser: OutputParser): Promise<Output>;
+export declare function isDebug(): boolean;
+export declare const bold: (str: string) => string;
+export declare const dim: (str: string) => string;
+export declare const red: (str: string) => string;
+export declare const green: (str: string) => string;
+export declare const yellow: (str: string) => string;
+export declare const cyan: (str: string) => string;
+export declare function humanMs(ms: number): string;
+export declare function debug(message: string): void;

package/dist/utils.mjs

@@ -0,0 +1,64 @@
+import { spawn } from "node:child_process";
+import { stat } from "fs/promises";
+import { resolve } from "node:path";
+function resolveRoot(root, ...path) {
+  return root != null ? resolve(root, ...path) : resolve(...path);
+}
+export async function isBinInstalled(bin, root) {
+  try {
+    const binPath = resolveRoot(root, bin);
+    if (isDebug())
+      debug(`Checking if binary exists: ${binPath}`);
+    await stat(resolveRoot(root, bin));
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+function exec(cmd, args, opts) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(cmd, args, opts);
+    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) => {
+      resolve2({ stderr, stdout, exitCode });
+    });
+  });
+}
+export async function execAndParse(root, bin, args, parser) {
+  const res = await exec(resolveRoot(root, bin), args, { cwd: root });
+  if (res.exitCode == null)
+    throw Error("Exit code was null");
+  return parser({
+    code: res.exitCode,
+    stderr: res.stderr,
+    stdout: res.stdout
+  });
+}
+export function isDebug() {
+  return process.env.DEBUG === "true" || process.env.DEBUG === "1";
+}
+export const bold = (str) => `\x1B[1m${str}\x1B[0m`;
+export const dim = (str) => `\x1B[2m${str}\x1B[0m`;
+export const red = (str) => `\x1B[31m${str}\x1B[0m`;
+export const green = (str) => `\x1B[32m${str}\x1B[0m`;
+export const yellow = (str) => `\x1B[33m${str}\x1B[0m`;
+export const cyan = (str) => `\x1B[36m${str}\x1B[0m`;
+export 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`;
+}
+export function debug(message) {
+  if (isDebug())
+    console.debug(dim("\u2699 " + message));
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@aklinker1/check",
+  "version": "1.0.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": ["dist"],
+  "bin": {
+    "check": "bin/check.mjs"
+  },
+  "scripts": {
+    "build": "bunx unbuild",
+    "check": "bun src/cli.ts",
+    "prepublish": "bun build"
+  },
+  "dependencies": {
+    "@antfu/utils": "^0.7.7",
+    "citty": "^0.1.6"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "publint": "^0.2.7",
+    "unbuild": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "unbuild": {
+    "entries": [
+      {
+        "builder": "mkdist",
+        "input": "./src/",
+        "outDir": "./dist"
+      }
+    ],
+    "declaration": true
+  }
+}