hereby 1.13.0 → 1.15.0

package/dist/cli/formatTasks.js

@@ -1,18 +1,17 @@
-import pc from "picocolors";
-import Wordwrap from "wordwrapjs";
+import * as style from "./style.js";
 import { compareTaskNames } from "./utils.js";
 export function formatTasks(format, tasks, defaultTask, columns) {
     const visibleTasks = [...tasks].filter(isTaskVisible).sort(compareTaskNames);
     if (format === "simple") {
         return visibleTasks.map((task) => task.options.name).join("\n");
     }
-    const names = visibleTasks.map((task) => task === defaultTask ? `${pc.green(task.options.name)} (default)` : pc.blue(task.options.name));
+    const names = visibleTasks.map((task) => task === defaultTask ? `${style.green(task.options.name)} (default)` : style.blue(task.options.name));
     const descriptions = visibleTasks.map((task) => {
         var _a, _b;
         let parts = task.options.description ? [task.options.description] : undefined;
         const deps = (_a = task.options.dependencies) === null || _a === void 0 ? void 0 : _a.filter(isTaskVisible).sort(compareTaskNames);
         if (deps === null || deps === void 0 ? void 0 : deps.length) {
-            const depNames = deps.map((task) => pc.blue(task.options.name));
+            const depNames = deps.map((task) => style.blue(task.options.name));
             (parts !== null && parts !== void 0 ? parts : (parts = [])).push(`Depends on: ${depNames.join(", ")}`);
         }
         return (_b = parts === null || parts === void 0 ? void 0 : parts.join("\n")) !== null && _b !== void 0 ? _b : "";
@@ -26,7 +25,7 @@ export function formatTasks(format, tasks, defaultTask, columns) {
     const descriptionWidth = maxTotalWidth - nameWidth;
     const formatted = names.map((name, i) => formatAsColumns("  ", name, nameWidth, descriptions[i], descriptionWidth));
     return `
-${pc.bold(pc.underline("Available tasks"))}
+${style.bold(style.underline("Available tasks"))}
 
 ${formatted.join("")}`;
 }
@@ -41,7 +40,7 @@ function formatAsColumns(indent, leftText, leftWidth, rightText, rightWidth) {
     for (let i = 0; i < maxLines; i++) {
         const leftPart = leftLines[i] || "";
         const rightPart = rightLines[i] || "";
-        const paddedLeft = leftPart.padEnd(leftWidth, " ");
+        const paddedLeft = leftPart + " ".repeat(Math.max(0, leftWidth - visibleLength(leftPart)));
         result += `${indent}${paddedLeft}   ${rightPart}\n`;
     }
     return result;
@@ -51,7 +50,30 @@ const ANSI_REGEX = /\u001B\[([0-9]{1,2})m/g;
 function visibleLength(str) {
     return str.replace(ANSI_REGEX, "").length;
 }
+const TOKEN_REGEX = /[^\s-]+?-\b|\S+|\s+/g;
 function wrapText(text, maxWidth) {
-    return Wordwrap.lines(text, { width: maxWidth, break: true });
+    var _a;
+    const result = [];
+    for (const line of text.split(/\r?\n/)) {
+        let current = "";
+        for (const token of (_a = line.match(TOKEN_REGEX)) !== null && _a !== void 0 ? _a : []) {
+            if (visibleLength(current) + visibleLength(token) > maxWidth && current.trim()) {
+                result.push(current.trim());
+                current = "";
+            }
+            if (visibleLength(token) > maxWidth) {
+                // eslint-disable-next-line @typescript-eslint/no-misused-spread
+                const chars = [...token];
+                while (chars.length > 0)
+                    result.push(chars.splice(0, maxWidth).join(""));
+            }
+            else {
+                current += /^\s/.test(token) && !current ? "" : token;
+            }
+        }
+        if (current.trim())
+            result.push(current.trim());
+    }
+    return result.length > 0 ? result : [""];
 }
 //# sourceMappingURL=formatTasks.js.map

package/dist/cli/index.js

@@ -1,20 +1,19 @@
 import path from "node:path";
 import { performance } from "node:perf_hooks";
 import { types } from "node:util";
-import pc from "picocolors";
-import { formatTasks } from "./formatTasks.js";
 import { findHerebyfile, loadHerebyfile } from "./loadHerebyfile.js";
 import { getUsage, parseArgs } from "./parseArgs.js";
 import { reexec } from "./reexec.js";
 import { Runner } from "./runner.js";
-import { prettyMilliseconds, UserError } from "./utils.js";
+import * as style from "./style.js";
+import { findSimilar, prettyMilliseconds, UserError } from "./utils.js";
 export async function main(d) {
     try {
         await mainWorker(d);
     }
     catch (e) {
         if (e instanceof UserError) {
-            d.error(`${pc.red("Error")}: ${e.message}`);
+            d.error(`${style.red("Error")}: ${e.message}`);
         }
         else if (types.isNativeError(e) && e.stack) { // eslint-disable-line @typescript-eslint/no-deprecated
             d.error(e.stack);
@@ -42,12 +41,13 @@ async function mainWorker(d) {
     d.chdir(path.dirname(herebyfilePath));
     const herebyfile = await loadHerebyfile(herebyfilePath);
     if (args.printTasks) {
+        const { formatTasks } = await import("./formatTasks.js");
         d.log(formatTasks(args.printTasks, herebyfile.tasks.values(), herebyfile.defaultTask, d.columns()));
         return;
     }
     const tasks = await selectTasks(d, herebyfile, herebyfilePath, args.run);
-    const taskNames = tasks.map((task) => pc.blue(task.options.name)).join(", ");
-    d.log(`Using ${pc.yellow(d.simplifyPath(herebyfilePath))} to run ${taskNames}`);
+    const taskNames = tasks.map((task) => style.blue(task.options.name)).join(", ");
+    d.log(`Using ${style.yellow(d.simplifyPath(herebyfilePath))} to run ${taskNames}`);
     const start = performance.now();
     const runner = new Runner(d);
     try {
@@ -62,9 +62,9 @@ async function mainWorker(d) {
     finally {
         const took = performance.now() - start;
         const failed = runner.failedTasks.length > 0;
-        d.log(`Completed ${taskNames}${failed ? pc.red(" with errors") : ""} in ${prettyMilliseconds(took)}`);
+        d.log(`Completed ${taskNames}${failed ? style.red(" with errors") : ""} in ${prettyMilliseconds(took)}`);
         if (failed) {
-            const names = runner.failedTasks.sort().map((task) => pc.red(task)).join(", ");
+            const names = runner.failedTasks.sort().map((task) => style.red(task)).join(", ");
             d.log(`Failed tasks: ${names}`);
         }
     }
@@ -76,20 +76,13 @@ export async function selectTasks(d, herebyfile, herebyfilePath, taskNames) {
             return [herebyfile.defaultTask];
         throw new UserError(`No default task has been exported from ${d.simplifyPath(herebyfilePath)}; please specify a task name.`);
     }
-    const tasks = [];
-    for (const name of taskNames) {
+    return taskNames.map((name) => {
         const task = herebyfile.tasks.get(name);
-        if (!task) {
-            let message = `Task "${name}" does not exist or is not exported from ${d.simplifyPath(herebyfilePath)}.`;
-            const { closest, distance } = await import("fastest-levenshtein");
-            const candidate = closest(name, [...herebyfile.tasks.keys()]);
-            if (distance(name, candidate) < name.length * 0.4) {
-                message += ` Did you mean "${candidate}"?`;
-            }
-            throw new UserError(message);
-        }
-        tasks.push(task);
-    }
-    return tasks;
+        if (task)
+            return task;
+        const suggestion = findSimilar(name, herebyfile.tasks.keys());
+        throw new UserError(`Task "${name}" does not exist or is not exported from ${d.simplifyPath(herebyfilePath)}.`
+            + (suggestion ? ` Did you mean "${suggestion}"?` : ""));
+    });
 }
 //# sourceMappingURL=index.js.map

package/dist/cli/loadHerebyfile.js

@@ -1,8 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-import pc from "picocolors";
 import { Task } from "../index.js";
+import * as style from "./style.js";
 import { findUp, UserError } from "./utils.js";
 const herebyfileRegExp = /^herebyfile\.m?[jt]s$/i;
 export function findHerebyfile(dir) {
@@ -42,7 +42,7 @@ export async function loadHerebyfile(herebyfilePath) {
             defaultTask = value;
         }
         else if (exportedTasks.has(value)) {
-            throw new UserError(`Task "${pc.blue(value.options.name)}" has been exported twice.`);
+            throw new UserError(`Task "${style.blue(value.options.name)}" has been exported twice.`);
         }
         else {
             exportedTasks.add(value);
@@ -60,30 +60,24 @@ export async function loadHerebyfile(herebyfilePath) {
     const tasks = new Map([...exportedTasks].map((task) => [task.options.name, task]));
     return { tasks, defaultTask };
 }
-function checkTaskInvariants(tasks) {
-    const checkedTasks = new Set();
-    const taskStack = new Set();
-    const seenNames = new Set();
-    checkTaskInvariantsWorker(tasks);
-    function checkTaskInvariantsWorker(tasks) {
-        for (const task of tasks) {
-            if (checkedTasks.has(task))
-                continue;
-            if (taskStack.has(task)) {
-                throw new UserError(`Task "${pc.blue(task.options.name)}" references itself.`);
-            }
-            const name = task.options.name;
-            if (seenNames.has(name)) {
-                throw new UserError(`Task "${pc.blue(name)}" was declared twice.`);
-            }
-            seenNames.add(name);
-            if (task.options.dependencies) {
-                taskStack.add(task);
-                checkTaskInvariantsWorker(task.options.dependencies);
-                taskStack.delete(task);
-            }
-            checkedTasks.add(task);
+function checkTaskInvariants(tasks, checkedTasks = new Set(), taskStack = new Set(), seenNames = new Set()) {
+    for (const task of tasks) {
+        if (checkedTasks.has(task))
+            continue;
+        if (taskStack.has(task)) {
+            throw new UserError(`Task "${style.blue(task.options.name)}" references itself.`);
+        }
+        const name = task.options.name;
+        if (seenNames.has(name)) {
+            throw new UserError(`Task "${style.blue(name)}" was declared twice.`);
+        }
+        seenNames.add(name);
+        if (task.options.dependencies) {
+            taskStack.add(task);
+            checkTaskInvariants(task.options.dependencies, checkedTasks, taskStack, seenNames);
+            taskStack.delete(task);
         }
+        checkedTasks.add(task);
     }
 }
 //# sourceMappingURL=loadHerebyfile.js.map

package/dist/cli/parseArgs.js

@@ -1,27 +1,46 @@
-import minimist from "minimist";
-import pc from "picocolors";
+import * as style from "./style.js";
+import { UserError } from "./utils.js";
 export function parseArgs(argv) {
-    let parseUnknownAsTask = true;
-    const options = minimist(argv, {
-        "--": true,
-        string: ["herebyfile"],
-        boolean: ["tasks", "tasks-simple", "help", "version"],
-        alias: {
-            "h": "help",
-            "T": "tasks",
-        },
-        unknown: (name) => parseUnknownAsTask && (parseUnknownAsTask = !name.startsWith("-")),
-    });
-    return {
-        help: options["help"],
-        run: options._,
-        herebyfile: options["herebyfile"],
-        printTasks: options["tasks"] ? "normal" : (options["tasks-simple"] ? "simple" : undefined),
-        version: options["version"],
-    };
+    const run = [];
+    let help = false, version = false, collect = true, tasks = false, tasksSimple = false;
+    let herebyfile;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--")
+            break;
+        if (!arg.startsWith("-") || arg === "-") {
+            if (collect)
+                run.push(arg);
+            continue;
+        }
+        const eq = arg.indexOf("=");
+        const name = (eq === -1 ? arg : arg.slice(0, eq)).replace(/^--?/, "");
+        const peek = eq !== -1 ? arg.slice(eq + 1) : argv[i + 1];
+        const consume = (pred) => eq !== -1 || (pred(peek) && ++i) ? peek : undefined;
+        const bool = () => consume((s) => s === "true" || s === "false") !== "false";
+        const str = () => {
+            const v = consume((s) => s !== undefined && !s.startsWith("-"));
+            if (!v)
+                throw new UserError(`Option --${name} requires a value.`);
+            return v;
+        };
+        if (name === "h" || name === "help")
+            help = bool();
+        else if (name === "T" || name === "tasks")
+            tasks = bool();
+        else if (name === "tasks-simple")
+            tasksSimple = bool();
+        else if (name === "version")
+            version = bool();
+        else if (name === "herebyfile")
+            herebyfile = str();
+        else
+            collect = false;
+    }
+    return { help, run, herebyfile, printTasks: tasks ? "normal" : tasksSimple ? "simple" : undefined, version };
 }
 export function getUsage() {
-    const header = (text) => pc.bold(pc.underline(text));
+    const header = (text) => style.bold(style.underline(text));
     return `
 ${header("hereby")}
 
@@ -33,10 +52,10 @@ ${header("Synopsis")}
 
 ${header("Options")}
 
-  ${pc.bold("-h, --help")}          Display this usage guide.
-  ${pc.bold("--herebyfile")} ${pc.underline("path")}   A path to a Herebyfile. Optional.
-  ${pc.bold("-T, --tasks")}         Print a listing of the available tasks.
-  ${pc.bold("--version")}           Print the current hereby version.
+  ${style.bold("-h, --help")}          Display this usage guide.
+  ${style.bold("--herebyfile")} ${style.underline("path")}   A path to a Herebyfile. Optional.
+  ${style.bold("-T, --tasks")}         Print a listing of the available tasks.
+  ${style.bold("--version")}           Print the current hereby version.
 
 ${header("Example usage")}
 

package/dist/cli/runner.js

@@ -1,5 +1,5 @@
 import { performance } from "node:perf_hooks";
-import pc from "picocolors";
+import * as style from "./style.js";
 import { prettyMilliseconds } from "./utils.js";
 export class Runner {
     constructor(_d) {
@@ -35,19 +35,19 @@ export class Runner {
         const start = performance.now();
         try {
             if (this.failedTasks.length === 0) {
-                this._d.log(`Starting ${pc.blue(task.options.name)}`);
+                this._d.log(`Starting ${style.blue(task.options.name)}`);
             }
             await run();
             if (this.failedTasks.length === 0) {
                 const took = performance.now() - start;
-                this._d.log(`Finished ${pc.green(task.options.name)} in ${prettyMilliseconds(took)}`);
+                this._d.log(`Finished ${style.green(task.options.name)} in ${prettyMilliseconds(took)}`);
             }
         }
         catch (e) {
             this.failedTasks.push(task.options.name);
             if (this.failedTasks.length === 1) {
                 const took = performance.now() - start;
-                this._d.error(`Error in ${pc.red(task.options.name)} in ${prettyMilliseconds(took)}\n${e}`);
+                this._d.error(`Error in ${style.red(task.options.name)} in ${prettyMilliseconds(took)}\n${e}`);
             }
             throw e;
         }

package/dist/cli/style.js

@@ -0,0 +1,25 @@
+/* eslint-disable no-restricted-globals, @typescript-eslint/prefer-nullish-coalescing */
+// NO_COLOR (https://no-color.org) takes precedence over everything when set
+// to any non-empty value. FORCE_COLOR=0/false explicitly disables; any other
+// truthy value forces colors on. Otherwise we enable colors for TTY stdout
+// (excluding TERM=dumb) or when running in CI.
+export function isColorEnabled(env, isTTY, platform) {
+    if (env["NO_COLOR"])
+        return false;
+    const forceColor = env["FORCE_COLOR"];
+    if (forceColor === "0" || forceColor === "false")
+        return false;
+    return !!(forceColor || platform === "win32" || (isTTY && env["TERM"] !== "dumb") || env["CI"]);
+}
+export const enabled = isColorEnabled(process.env, process.stdout.isTTY, process.platform);
+/* eslint-enable no-restricted-globals, @typescript-eslint/prefer-nullish-coalescing */
+export function wrap(enabled, open, close) {
+    return enabled ? (s) => open + s + close : (s) => s;
+}
+export const red = wrap(enabled, "\u001B[31m", "\u001B[39m");
+export const green = wrap(enabled, "\u001B[32m", "\u001B[39m");
+export const yellow = wrap(enabled, "\u001B[33m", "\u001B[39m");
+export const blue = wrap(enabled, "\u001B[34m", "\u001B[39m");
+export const bold = wrap(enabled, "\u001B[1m", "\u001B[22m");
+export const underline = wrap(enabled, "\u001B[4m", "\u001B[24m");
+//# sourceMappingURL=style.js.map

package/dist/cli/utils.js

@@ -8,13 +8,9 @@ export function compareTaskNames(a, b) {
 const compareStrings = new Intl.Collator(undefined, { numeric: true }).compare;
 // Exported for testing.
 export function simplifyPath(p) {
-    p = path.normalize(p);
+    const normalized = path.normalize(p);
     const homedir = path.normalize(os.homedir() + path.sep);
-    if (p.startsWith(homedir)) {
-        p = p.slice(homedir.length);
-        return `~${path.sep}${p}`;
-    }
-    return p;
+    return normalized.startsWith(homedir) ? `~${path.sep}${normalized.slice(homedir.length)}` : normalized;
 }
 export function findUp(dir, predicate) {
     const root = path.parse(dir).root;
@@ -36,15 +32,11 @@ export function prettyMilliseconds(ms) {
     const hours = Math.floor(ms / 3600000);
     // Round to one decimal, with an epsilon to avoid floating point errors (e.g. 5.0000001 -> 5).
     const roundedSeconds = Math.floor(seconds * 10 + 1e-7) / 10;
-    const parts = [];
-    if (hours > 0)
-        parts.push(`${hours}h`);
-    if (minutes > 0)
-        parts.push(`${minutes}m`);
-    if (roundedSeconds > 0) {
-        parts.push(roundedSeconds % 1 === 0 ? `${roundedSeconds}s` : `${roundedSeconds.toFixed(1)}s`);
-    }
-    return parts.join(" ");
+    return [
+        hours > 0 && `${hours}h`,
+        minutes > 0 && `${minutes}m`,
+        roundedSeconds > 0 && (roundedSeconds % 1 === 0 ? `${roundedSeconds}s` : `${roundedSeconds.toFixed(1)}s`),
+    ].filter(Boolean).join(" ");
 }
 /**
  * UserError is a special error that, when caught in the CLI will be printed
@@ -52,6 +44,31 @@ export function prettyMilliseconds(ms) {
  */
 export class UserError extends Error {
 }
+/**
+ * Returns the candidate most similar to `target`, if any is close enough
+ * to be a plausible typo correction.
+ */
+export function findSimilar(target, candidates) {
+    let best;
+    let bestDistance = Math.ceil(target.length * 0.4);
+    for (const candidate of candidates) {
+        const row = Array.from({ length: candidate.length + 1 }, (_, j) => j);
+        for (let i = 1; i <= target.length; i++) {
+            let diag = row[0];
+            row[0] = i;
+            for (let j = 1; j <= candidate.length; j++) {
+                const tmp = row[j];
+                row[j] = Math.min(row[j - 1] + 1, tmp + 1, diag + (target[i - 1] === candidate[j - 1] ? 0 : 1));
+                diag = tmp;
+            }
+        }
+        if (row[candidate.length] < bestDistance) {
+            best = candidate;
+            bestDistance = row[candidate.length];
+        }
+    }
+    return best;
+}
 export function real() {
     /* eslint-disable no-restricted-globals */
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hereby",
-    "version": "1.13.0",
+    "version": "1.15.0",
     "description": "A simple task runner",
     "repository": "github:jakebailey/hereby",
     "type": "module",
@@ -38,73 +38,26 @@
         "!**/__tests__/**",
         "./dist/index.d.ts"
     ],
-    "dependencies": {
-        "fastest-levenshtein": "^1.0.16",
-        "minimist": "^1.2.8",
-        "picocolors": "^1.1.0",
-        "wordwrapjs": "^5.1.1"
-    },
     "devDependencies": {
-        "@ava/typescript": "^3.0.1",
-        "@changesets/cli": "^2.30.0",
+        "@changesets/cli": "^2.31.0",
         "@eslint/js": "^10.0.1",
-        "@tsconfig/node12": "^12.1.7",
-        "@types/minimist": "^1.2.5",
-        "@types/node": "^25.3.3",
-        "@types/tmp": "^0.2.6",
-        "@types/wordwrapjs": "^5.1.2",
-        "ava": "~5.0.1",
-        "c8": "^11.0.0",
-        "dprint": "^0.52.0",
-        "eslint": "^10.0.2",
-        "eslint-plugin-ava": "^16.0.0",
-        "eslint-plugin-simple-import-sort": "^12.1.1",
-        "eslint-plugin-unicorn": "^63.0.0",
-        "execa": "^6.1.0",
-        "globals": "^17.4.0",
-        "monocart-coverage-reports": "^2.12.9",
-        "moq.ts": "^10.1.0",
-        "rimraf": "^5.0.10",
-        "tmp": "0.2.1",
-        "typescript": "^5.9.3",
-        "typescript-eslint": "^8.56.1"
-    },
-    "overrides": {
-        "ava": {
-            "emittery": "1.0.0"
-        }
+        "@types/node": "^25.6.0",
+        "dprint": "^0.54.0",
+        "eslint": "^10.2.1",
+        "eslint-plugin-simple-import-sort": "^13.0.0",
+        "globals": "^17.5.0",
+        "monocart-coverage-reports": "^2.12.11",
+        "typescript": "^6.0.3",
+        "typescript-eslint": "^8.59.0"
     },
     "packageManager": "npm@8.19.4",
     "scripts": {
         "ci": "npm ci",
         "build": "tsc",
         "watch": "tsc --watch",
-        "test": "ava",
-        "coverage": "c8 --experimental-monocart ava",
-        "prepack": "rimraf dist && npm run build",
+        "test": "node dist/__tests__/runTests.js",
+        "coverage": "mcr node dist/__tests__/runTests.js",
+        "prepack": "node -e \"fs.rmSync('dist', { recursive: true, force: true })\" && npm run build",
         "version": "changeset version && npm install"
-    },
-    "ava": {
-        "files": [
-            "**/*.test.ts"
-        ],
-        "typescript": {
-            "rewritePaths": {
-                "src/": "dist/"
-            },
-            "compile": false
-        },
-        "environmentVariables": {
-            "NO_COLOR": "1"
-        }
-    },
-    "c8": {
-        "all": true,
-        "include": "dist",
-        "reporter": [
-            "text",
-            "html",
-            "lcov"
-        ]
     }
 }