@haltcase/run 3.0.1 → 5.0.0-beta.1

package/dist/util/resolveTaskFile.mjs

@@ -0,0 +1,13 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { SUPPORTED_EXTENSIONS } from "c12";
+//#region src/util/resolveTaskFile.ts
+const extensions = SUPPORTED_EXTENSIONS.filter((extension) => extension.endsWith("js") || extension.endsWith("ts"));
+const resolveTaskFile = (context) => {
+	if (context.taskFile.ext) return context.taskFile.path;
+	const foundConfigs = extensions.map((it) => join(context.taskFile.dir, `${context.taskFile.name}${it}`)).filter((path) => existsSync(path));
+	if (foundConfigs.length === 1) return foundConfigs[0];
+	return foundConfigs;
+};
+//#endregion
+export { extensions, resolveTaskFile };

package/package.json

@@ -1,77 +1,86 @@
 {
   "name": "@haltcase/run",
-  "version": "3.0.1",
+  "version": "5.0.0-beta.1",
   "description": "Flexible, function-based task runner where command line options are props",
   "keywords": [
-    "task",
-    "runner",
+    "arktype",
     "command",
-    "function",
-    "typescript",
     "execa",
-    "arktype"
+    "function",
+    "runner",
+    "task",
+    "typescript"
   ],
   "homepage": "https://github.com/haltcase/run#readme",
   "bugs": "https://github.com/haltcase/run/issues",
+  "license": "MIT",
+  "author": "Bo Lingen <bo@haltcase.dev> (https://haltcase.dev)",
   "repository": {
     "type": "git",
     "url": "https://github.com/haltcase/run.git"
   },
-  "license": "MIT",
-  "author": "Bo Lingen <bo@haltcase.dev> (https://haltcase.dev)",
-  "type": "module",
-  "exports": {
-    ".": "./dist/index.js"
-  },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "bin": {
-    "hr": "./dist/cli/bin.js"
+    "hr": "./dist/cli/bin.mjs"
   },
   "files": [
     "dist"
   ],
-  "lint-staged": {
-    "*.{js,jsx,ts,tsx,css,yml,yaml}": "pnpm prettier --write"
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
   },
-  "prettier": "@haltcase/style/prettier",
   "dependencies": {
-    "@favware/colorette-spinner": "^1.0.1",
-    "arktype": "^2.1.17",
-    "c12": "^3.0.3",
+    "arktype": "^2.2.0",
+    "c12": "^4.0.0-beta.5",
     "cliui": "^9.0.1",
-    "colorette": "^2.0.20",
-    "execa": "^9.5.1"
+    "execa": "^9.6.1"
   },
   "devDependencies": {
+    "@arethetypeswrong/core": "^0.18.3",
     "@haltcase/style": "^7.3.1",
-    "@types/node": "^22.8.6",
-    "eslint": "^9.24.0",
-    "husky": "^9.1.7",
-    "lint-staged": "^15.5.1",
-    "prettier": "^3.5.3",
-    "tsx": "^4.19.3",
-    "typescript": "^5.8.3",
-    "vitest": "^3.1.1"
+    "@types/node": "^24.13.1",
+    "@typescript/native-preview": "7.0.0-dev.20260608.1",
+    "eslint": "^9.39.4",
+    "jiti": "^2.7.0",
+    "oxlint-tsgolint": "^0.23.0",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.1.24",
+    "vite-plus": "0.1.24",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@0.1.24"
   },
-  "engines": {
-    "node": ">=20"
+  "peerDependencies": {
+    "jiti": "^2.7.0"
   },
-  "publishConfig": {
-    "access": "public"
+  "peerDependenciesMeta": {
+    "jiti": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22"
   },
   "haltcase.run": {
     "taskDirectory": "./scripts",
-    "quiet": true
+    "quiet": false
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "build:watch": "tsc -p tsconfig.build.json --watch",
+    "build": "vp pack",
+    "build:watch": "vp pack --watch",
+    "check": "pnpm eslint:check && vp check --no-lint",
     "eslint:check": "eslint src",
-    "format": "eslint --fix src && prettier src --write",
+    "format": "eslint --fix src && vp check --fix --no-lint",
     "hr": "tsx ./src/cli/bin.ts",
-    "prettier:check": "prettier --check src",
-    "test": "vitest",
-    "typescript:check": "tsc --noEmit && echo \"No errors reported by tsc.\""
+    "test": "vp test watch",
+    "test:run": "vp test",
+    "types": "vp check --no-fmt --no-lint"
   }
 }

package/dist/cli/bin.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/cli/bin.js

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-import { createHandler } from "./handler.js";
-import { main } from "./main.js";
-const handler = createHandler();
-void main({
-    handler
-});

package/dist/cli/handler.d.ts

@@ -1,28 +0,0 @@
-import { Spinner } from "@favware/colorette-spinner";
-import type { AppConfig } from "../config.js";
-import type { MainContextWithData } from "./main.js";
-export declare const failWith: (spinner: Spinner, message: unknown) => never;
-export declare const write: (message: string) => void;
-interface HelpContextCommand {
-    command: string;
-}
-interface HelpContextFile {
-    taskFileList: true;
-    config: AppConfig;
-}
-interface HelpContextScript extends MainContextWithData {
-    taskList: true;
-}
-type HelpContext = HelpContextCommand | HelpContextFile | HelpContextScript;
-export declare const commandHandler: (_context: HelpContextCommand) => string;
-export declare const taskFileListHandler: (context: HelpContextFile) => string;
-export declare const taskListHandler: (context: HelpContextScript) => string;
-export declare const help: (context: HelpContext) => string;
-export interface Handler {
-    spinner: Spinner;
-    help: (context: HelpContext) => string;
-    write: (message: string) => void;
-    failWith: (message: unknown) => never;
-}
-export declare const createHandler: () => Handler;
-export {};

package/dist/cli/handler.js

@@ -1,105 +0,0 @@
-import { readdirSync } from "node:fs";
-import { extname } from "node:path";
-import { Spinner } from "@favware/colorette-spinner";
-import cliui from "cliui";
-import { bold, gray, yellow } from "colorette";
-import { isBrandedTask } from "../tasks/guards.js";
-import { getSchemaProperties } from "../util/getSchemaProperties.js";
-import { extensions } from "../util/resolveTaskFile.js";
-export const failWith = (spinner, message) => {
-    let text;
-    if (Array.isArray(message)) {
-        text = message.map(String).join("\n");
-    }
-    if (text == null || typeof text !== "string") {
-        text = String(message);
-    }
-    spinner.error({
-        text
-    });
-    process.exit(1);
-};
-export const write = (message) => {
-    process.stdout.write(`${message}\n`);
-};
-const usage = `Usage: ${yellow("hr")} <taskFile> [task]`;
-export const commandHandler = (_context) => {
-    return usage;
-};
-export const taskFileListHandler = (context) => {
-    const fileList = readdirSync(context.config.taskDirectory).filter((file) => extensions.includes(extname(file)));
-    const content = [
-        usage,
-        "Available task files:",
-        fileList.map((it) => `  ${it}`).join("\n")
-    ].join("\n\n");
-    return `${content}\n`;
-};
-export const taskListHandler = (context) => {
-    const ui = cliui({
-        width: Math.max(0, process.stdout.columns - 4),
-        wrap: true
-    });
-    const { config } = context.taskFile.data;
-    const baseUsage = usage.replace("<taskFile>", context.taskFile.name);
-    ui.div(`${baseUsage} <parameter> [...options]`);
-    ui.div({
-        text: "Available tasks:",
-        padding: [1, 0, 1, 0]
-    });
-    const taskListPaddingX = 2;
-    const nameColumnWidth = Object.keys(config).reduce((previous, current) => Math.max(previous, current.length), 1) +
-        2 +
-        taskListPaddingX * 2;
-    for (const [name, value] of Object.entries(config)) {
-        if (!value) {
-            continue;
-        }
-        const formattedName = bold(name);
-        if (isBrandedTask(value)) {
-            if (value.kind === "strictTask") {
-                const properties = getSchemaProperties(value.schema) || gray("not available");
-                ui.div({
-                    text: formattedName,
-                    width: nameColumnWidth,
-                    padding: [0, taskListPaddingX, 0, taskListPaddingX]
-                }, properties);
-                continue;
-            }
-            ui.div({
-                text: formattedName,
-                width: nameColumnWidth,
-                padding: [0, taskListPaddingX, 0, taskListPaddingX]
-            });
-            continue;
-        }
-        ui.div({
-            text: formattedName,
-            width: nameColumnWidth,
-            padding: [0, taskListPaddingX, 0, taskListPaddingX]
-        });
-    }
-    ui.div("");
-    return ui.toString();
-};
-export const help = (context) => {
-    if ("command" in context) {
-        return commandHandler(context);
-    }
-    if ("taskFileList" in context) {
-        return taskFileListHandler(context);
-    }
-    if ("taskList" in context) {
-        return taskListHandler(context);
-    }
-    return "";
-};
-export const createHandler = () => {
-    const spinner = new Spinner();
-    return {
-        spinner,
-        help,
-        write,
-        failWith: (message) => failWith(spinner, message)
-    };
-};

package/dist/cli/main.d.ts

@@ -1,21 +0,0 @@
-import type { ParsedPath } from "node:path";
-import type { AppConfig } from "../config.js";
-import type { TaskCollection } from "../tasks/types.js";
-import type { ResolvedConfigWithFile } from "../util/loadTaskFile.js";
-import type { Handler } from "./handler.js";
-export interface MainProps {
-    handler: Handler;
-}
-export interface MainContext extends MainProps {
-    config: AppConfig;
-    taskFile: ParsedPath & {
-        path: string;
-    };
-    taskName: string;
-}
-export interface MainContextWithData extends MainContext {
-    taskFile: MainContext["taskFile"] & {
-        data: ResolvedConfigWithFile<TaskCollection>;
-    };
-}
-export declare const main: (props: MainProps) => Promise<void>;

package/dist/cli/main.js

@@ -1,64 +0,0 @@
-import { parse, resolve } from "node:path";
-import { getAppConfig } from "../config.js";
-import { executeTask } from "../tasks/executeTask.js";
-import { loadTaskFile } from "../util/loadTaskFile.js";
-import { resolveTaskFile } from "../util/resolveTaskFile.js";
-import { parseOptions } from "./parseOptions.js";
-export const main = async (props) => {
-    const { config } = await getAppConfig();
-    const inputFileName = process.argv[2];
-    const taskName = process.argv[3] ?? "";
-    if (!inputFileName) {
-        props.handler.write(props.handler.help({
-            taskFileList: true,
-            config
-        }));
-        props.handler.failWith("Task file name is required");
-    }
-    const fullFilePath = resolve(config.taskDirectory, inputFileName);
-    const context = {
-        ...props,
-        config,
-        taskFile: {
-            ...parse(fullFilePath),
-            path: fullFilePath
-        },
-        taskName
-    };
-    const resolutions = resolveTaskFile(context);
-    if (Array.isArray(resolutions)) {
-        props.handler.failWith([
-            `Found multiple task files with the name '${context.taskFile.name}'`,
-            `Rename the ambiguous files or specify an extension and try again`,
-            resolutions.map((it) => `  ${it}`).join("\n")
-        ]);
-    }
-    // update context with the fully resolved file path
-    context.taskFile = {
-        ...parse(resolutions),
-        path: resolutions
-    };
-    const taskFileResult = await loadTaskFile(context);
-    if (!taskFileResult.ok) {
-        props.handler.failWith(taskFileResult.error);
-    }
-    const contextWithData = {
-        ...context,
-        taskFile: {
-            ...context.taskFile,
-            data: taskFileResult.value
-        }
-    };
-    try {
-        const options = parseOptions(process.argv.slice(4));
-        await executeTask(contextWithData, options);
-        if (!config.quiet) {
-            props.handler.spinner.success({
-                text: "Success"
-            });
-        }
-    }
-    catch (error) {
-        props.handler.failWith([`Failed to execute task`, String(error)]);
-    }
-};

package/dist/cli/parseOptions.d.ts

@@ -1,13 +0,0 @@
-export interface ParsedOptions {
-    _: string[];
-    [key: string]: unknown;
-}
-export declare const reservedNames: Set<string>;
-/**
- * Wrapper around Node's {@link parseArgs} that treats options as strings
- * by default, instead of boolean flags.
- *
- * @param args - argv-like string
- * @returns
- */
-export declare const parseOptions: (args: string[]) => ParsedOptions;

package/dist/cli/parseOptions.js

@@ -1,48 +0,0 @@
-import { parseArgs } from "node:util";
-export const reservedNames = new Set(["_", "env"]);
-/**
- * Wrapper around Node's {@link parseArgs} that treats options as strings
- * by default, instead of boolean flags.
- *
- * @param args - argv-like string
- * @returns
- */
-export const parseOptions = (args) => {
-    const { tokens } = parseArgs({
-        args,
-        allowPositionals: true,
-        strict: false,
-        tokens: true
-    });
-    const options = {
-        _: []
-    };
-    for (let index = 0; index < tokens.length; index++) {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const token = tokens[index];
-        if (token.kind === "option-terminator") {
-            continue;
-        }
-        if (token.kind === "option") {
-            if (reservedNames.has(token.name)) {
-                throw new Error(`Reserved name '${token.name}' cannot be used as option`);
-            }
-            if (index + 1 < tokens.length) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                const next = tokens[index + 1];
-                if (next.kind !== "positional") {
-                    throw new Error(`Expected value for option ${token.rawName}`);
-                }
-                options[token.name] = next.value;
-                index++;
-            }
-            else {
-                throw new Error(`Expected option ${token.rawName} to be followed by a value`);
-            }
-        }
-        if (token.kind === "positional") {
-            options._.push(token.value);
-        }
-    }
-    return options;
-};

package/dist/config.d.ts

@@ -1,16 +0,0 @@
-export interface AppConfig {
-    /**
-     * Directory containing task files. Defaults to the `scripts` folder within
-     * the current working directory.
-     *
-     * @default `<cwd>/scripts`
-     */
-    taskDirectory: string;
-    /**
-     * Print no output unless errors occur.
-     *
-     * @default false
-     */
-    quiet: boolean;
-}
-export declare const getAppConfig: () => Promise<import("c12").ResolvedConfig<AppConfig, import("c12").ConfigLayerMeta>>;

package/dist/config.js

@@ -1,16 +0,0 @@
-import { join } from "node:path";
-import { cwd } from "node:process";
-import { loadConfig } from "c12";
-export const getAppConfig = async () => {
-    const configName = "haltcase.run";
-    return loadConfig({
-        name: configName,
-        configFile: configName,
-        packageJson: configName,
-        rcFile: configName,
-        defaults: {
-            taskDirectory: join(cwd(), "scripts"),
-            quiet: false
-        }
-    });
-};

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export type { ParsedOptions } from "./cli/parseOptions.js";
-export type { AppConfig as HaltcaseRunConfig } from "./config.js";
-export { task } from "./tasks/task.js";
-export type { Task } from "./tasks/types.js";

package/dist/index.js

@@ -1 +0,0 @@
-export { task } from "./tasks/task.js";

package/dist/tasks/executeTask.d.ts

@@ -1,12 +0,0 @@
-import type { MainContextWithData } from "../cli/main.js";
-import type { ParsedOptions } from "../cli/parseOptions.js";
-export declare const taskUtilities: {
-    command: import("execa").ExecaMethod<{}>;
-    $: import("execa").ExecaScriptMethod<{}>;
-    exec: import("execa").ExecaMethod<{
-        stdin: "inherit";
-        stdout: "inherit";
-        stderr: "inherit";
-    }>;
-};
-export declare const executeTask: (context: MainContextWithData, options: ParsedOptions) => Promise<void>;

package/dist/tasks/executeTask.js

@@ -1,45 +0,0 @@
-import { $, execa } from "execa";
-const execaInherited = execa({
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit"
-});
-export const taskUtilities = {
-    command: execa,
-    $,
-    exec: execaInherited
-};
-export const executeTask = async (context, options) => {
-    const taskFunction = context.taskFile.data.config[context.taskName];
-    const specifier = `${context.taskFile.name}::${context.taskName}`;
-    if (taskFunction == null) {
-        context.handler.write(context.handler.help({
-            taskList: true,
-            ...context
-        }));
-        if (!context.taskName) {
-            context.handler.failWith(`Task name is required.`);
-        }
-        context.handler.failWith([
-            `Task file '${context.taskFile.name}' does not export '${context.taskName}'`,
-            `Resolved to: ${context.taskFile.path}`
-        ]);
-    }
-    try {
-        const optionsWithEnvironment = {
-            ...options,
-            env: process.env
-        };
-        await taskFunction(optionsWithEnvironment, taskUtilities);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (message.includes("is not a function")) {
-            context.handler.failWith([
-                `Failed to execute ${specifier}`,
-                `Exported value '${context.taskName}' is not a function`
-            ]);
-        }
-        context.handler.failWith([`Failed to execute ${specifier}`, message]);
-    }
-};

package/dist/tasks/guards.d.ts

@@ -1,3 +0,0 @@
-import type { BrandedTask, BrandedTaskStrict, Task } from "./types.js";
-export declare const isBrandedTask: (task: Task) => task is BrandedTask;
-export declare const isBrandedTaskStrict: <T>(task: Task<T>) => task is BrandedTaskStrict<T>;

package/dist/tasks/guards.js

@@ -1,2 +0,0 @@
-export const isBrandedTask = (task) => "kind" in task;
-export const isBrandedTaskStrict = (task) => "kind" in task && task.kind === "strictTask";

package/dist/tasks/task.d.ts

@@ -1,14 +0,0 @@
-import type { Type } from "arktype";
-import { type } from "arktype";
-import type { BrandedTask, BrandedTaskStrict, DefaultOptionsInput, Task } from "./types.js";
-export declare const task: {
-    <T = DefaultOptionsInput>(fn: Task<T>): BrandedTask<T>;
-    strict<const TShape>(shape: type.validate<TShape>, fn: Task<NoInfer<Type<type.infer<TShape>>["infer"]>>): BrandedTaskStrict<Type<type.infer<TShape>>["inferIn"]>;
-};
-/**
- * Default schema for the options received by a {@link task}.
- */
-export declare const defaultOptionsInput: import("arktype/internal/methods/object.ts").ObjectType<{
-    _: string[];
-    env: Record<string, string | undefined>;
-}, {}>;

package/dist/tasks/task.js

@@ -1,55 +0,0 @@
-import { type } from "arktype";
-import { red } from "colorette";
-const formatValidationIssues = (errors) => errors
-    .map((error) => {
-    const propertyName = String(error.path[0]);
-    const dottedPath = error.path.join(".");
-    if (!propertyName) {
-        return error.message;
-    }
-    const messageWithoutProperty = error.message.startsWith(dottedPath)
-        ? error.message.slice(dottedPath.length + 1)
-        : error.message;
-    if (propertyName === "env") {
-        const prefix = red(`Environment variable '${String(error.path[1])}'`);
-        return `${prefix}: ${messageWithoutProperty}`;
-    }
-    const optionText = propertyName === "_" ? "Positionals" : `--${propertyName}`;
-    if (error.code === "predicate" && error.expected === "removed") {
-        return `${red(optionText)}: unknown option`;
-    }
-    // we currently assume there is only ever one path segment
-    return `${red(optionText)}: ${messageWithoutProperty}`;
-})
-    .join("\n");
-export const task = (fn) => {
-    fn.kind = "task";
-    return fn;
-};
-/**
- * Default schema for the options received by a {@link task}.
- */
-export const defaultOptionsInput = type({
-    _: "string[]",
-    env: "Record<string, string | undefined>"
-});
-/**
- * Create a task that validates its input against a schema.
- */
-task.strict = (shape, fn) => {
-    const schema = defaultOptionsInput
-        .merge(type.raw(shape))
-        .onUndeclaredKey("reject");
-    const taskFunction = (options, utilities) => {
-        const validationResult = schema(options);
-        if (validationResult instanceof type.errors) {
-            throw new TypeError(formatValidationIssues(validationResult), {
-                cause: validationResult
-            });
-        }
-        return fn(validationResult, utilities);
-    };
-    taskFunction.kind = "strictTask";
-    taskFunction.schema = schema;
-    return taskFunction;
-};