@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/src/cli/commands/akuma.js

@@ -0,0 +1,224 @@
+import { CliUsageError, usageLine } from "../usage.js";
+import { parseAkumaAlias } from "../../identity/selector.js";
+import { parseAkuId } from "../../akuma/identity.js";
+const AKUMA_COMMAND_SPECS = {
+    call: {
+        arity: 1,
+        stdin: true,
+        flags: {
+            contract: "value",
+            alias: "value",
+            workdir: "value",
+            wait: "boolean",
+            timeout: "value",
+            detach: "boolean",
+            json: "boolean",
+        },
+        usage: "call <akuma> [--contract <kei/...>] [--alias @name] [--workdir <path>] [--wait [--timeout <duration>] | -d | --detach] [--json] -",
+        purpose: "Call an Akuma from an Archetype and stdin body.",
+    },
+    wait: {
+        arity: 1,
+        stdin: false,
+        flags: { timeout: "value", json: "boolean" },
+        usage: "wait <aku/...> [--timeout <duration>] [--json]",
+        purpose: "Wait for one Akuma or return its current snapshot at the timeout.",
+    },
+    tell: {
+        arity: 1,
+        stdin: true,
+        flags: { json: "boolean" },
+        usage: "tell <aku/...> [--json] -",
+        purpose: "Record and wake one Akuma with an stdin body.",
+    },
+    interrupt: {
+        arity: 1,
+        stdin: true,
+        flags: { json: "boolean" },
+        usage: "interrupt <aku/...> [--json] -",
+        purpose: "Put down the current body and deliver an stdin body.",
+    },
+    history: {
+        arity: 1,
+        stdin: false,
+        flags: { before: "value", since: "value", last: "boolean", json: "boolean" },
+        usage: "history <aku/...> [--before <index> | --since <index> | --last] [--json]",
+        purpose: "Read the persistent execution history or the last answer.",
+    },
+    fork: {
+        arity: 1,
+        stdin: false,
+        flags: { at: "value", json: "boolean" },
+        usage: "fork <aku/...> --at <historyId> [--json]",
+        purpose: "Fork one Akuma at a retained answered history point.",
+    },
+    kill: {
+        arity: 1,
+        stdin: false,
+        flags: { json: "boolean" },
+        usage: "kill <aku/...> [--json]",
+        purpose: "Record death and put down one Akuma.",
+    },
+};
+export function isAkumaAction(value) {
+    return value !== undefined && Object.hasOwn(AKUMA_COMMAND_SPECS, value);
+}
+export function isParsedAkumaCommand(command) {
+    return isAkumaAction(command.command);
+}
+export function renderAkumaRootRows() {
+    return Object.values(AKUMA_COMMAND_SPECS).flatMap((spec) => [`  ${spec.usage}`, `    ${spec.purpose}`]);
+}
+export function renderAkumaHelp(action) {
+    const spec = AKUMA_COMMAND_SPECS[action];
+    return `${spec.purpose}\n\n${usageLine(spec.usage)}`;
+}
+export function renderAkumaUsage(action) {
+    return usageLine(AKUMA_COMMAND_SPECS[action].usage);
+}
+function stringFlag(value, diagnostic, fail) {
+    if (typeof value !== "string")
+        fail(diagnostic);
+    return value;
+}
+function parseDuration(raw, fail) {
+    const match = typeof raw === "string" ? /^(0|[1-9][0-9]*)(ms|s|m|h)$/u.exec(raw) : null;
+    if (match === null)
+        fail("--timeout requires an integer duration with unit ms, s, m, or h");
+    const multipliers = { ms: 1n, s: 1000n, m: 60000n, h: 3600000n };
+    const milliseconds = BigInt(match[1]) * multipliers[match[2]];
+    if (milliseconds > BigInt(Number.MAX_SAFE_INTEGER))
+        fail("--timeout duration exceeds the safe millisecond range");
+    return Number(milliseconds);
+}
+function scanAkuma(action, argv, fail) {
+    const spec = AKUMA_COMMAND_SPECS[action];
+    const flags = {};
+    const positionals = [];
+    let stdin = false;
+    for (let index = 1; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "-") {
+            if (stdin || index !== argv.length - 1 || !spec.stdin)
+                fail(`stdin marker '-' is not valid for ${action}`);
+            stdin = true;
+        }
+        else if (token === "-d") {
+            if (action !== "call")
+                fail(`option ${token} is not valid for ${action}`);
+            if (flags.detach !== undefined)
+                fail("duplicate option: --detach");
+            flags.detach = true;
+        }
+        else if (!token.startsWith("--"))
+            positionals.push(token);
+        else {
+            const name = token.slice(2);
+            const kind = spec.flags[name];
+            if (kind === undefined)
+                fail(`option ${token} is not valid for ${action}`);
+            if (flags[name] !== undefined)
+                fail(`duplicate option: ${token}`);
+            if (kind === "boolean")
+                flags[name] = true;
+            else {
+                const value = argv[index + 1];
+                if (value === undefined || value === "-" || value === "-d" || value.startsWith("--")) {
+                    fail(`${token} requires a value`);
+                }
+                flags[name] = value;
+                index += 1;
+            }
+        }
+    }
+    return { flags, positionals, stdin };
+}
+function positiveIndex(raw, option, fail) {
+    if (typeof raw !== "string" || !/^[1-9][0-9]*$/u.test(raw))
+        fail(`${option} requires a positive integer`);
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value) || value <= 0)
+        fail(`${option} exceeds the safe integer range`);
+    return value;
+}
+function parseAddressed(action, rawId, flags, output, fail) {
+    let id;
+    try {
+        id = parseAkuId(rawId).id;
+    }
+    catch (error) {
+        fail(error instanceof Error ? error.message : "invalid Akuma identity");
+    }
+    if (action === "tell" || action === "interrupt" || action === "kill") {
+        return { command: action, id, output };
+    }
+    if (action === "wait") {
+        const raw = flags.timeout;
+        if (raw === undefined)
+            return { command: action, id, output };
+        return { command: action, id, timeoutMs: parseDuration(raw, fail), output };
+    }
+    if (action === "history") {
+        if (flags.before !== undefined && flags.since !== undefined)
+            fail("history --before and --since are mutually exclusive");
+        if (flags.last === true && (flags.before !== undefined || flags.since !== undefined)) {
+            fail("history --last cannot be combined with --before or --since");
+        }
+        return {
+            command: action,
+            id,
+            last: flags.last === true,
+            ...(flags.before === undefined ? {} : { before: positiveIndex(flags.before, "--before", fail) }),
+            ...(flags.since === undefined ? {} : { since: positiveIndex(flags.since, "--since", fail) }),
+            output,
+        };
+    }
+    const at = stringFlag(flags.at, "fork requires --at <historyId>", fail);
+    if (at.trim().length === 0)
+        fail("fork requires --at <historyId>");
+    return { command: action, id, at, output };
+}
+function parseCall(flags, positionals, output, fail) {
+    let alias;
+    if (flags.alias !== undefined) {
+        try {
+            alias = parseAkumaAlias(stringFlag(flags.alias, "--alias requires @name", fail));
+        }
+        catch (error) {
+            fail(error instanceof Error ? error.message : "invalid Akuma alias");
+        }
+    }
+    if (flags.detach === true && flags.wait === true)
+        fail("call --wait and --detach are mutually exclusive");
+    if (flags.detach === true && flags.timeout !== undefined)
+        fail("call --timeout and --detach are mutually exclusive");
+    const mode = flags.detach === true ? "detach" : "wait";
+    const timeoutMs = flags.timeout === undefined ? undefined : parseDuration(flags.timeout, fail);
+    return {
+        command: "call",
+        archetype: positionals[0],
+        ...(typeof flags.contract === "string" ? { contract: flags.contract } : {}),
+        ...(alias === undefined ? {} : { alias }),
+        ...(typeof flags.workdir === "string" ? { workdir: flags.workdir } : {}),
+        mode,
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        output,
+    };
+}
+export function parseAkumaCommand(argv) {
+    const candidate = argv[0];
+    if (!isAkumaAction(candidate))
+        throw new CliUsageError(`unknown command: ${candidate ?? ""}`);
+    const action = candidate;
+    const spec = AKUMA_COMMAND_SPECS[action];
+    const fail = (message) => { throw new CliUsageError(message, renderAkumaUsage(action)); };
+    const { flags, positionals, stdin } = scanAkuma(action, argv, fail);
+    if (positionals.length !== spec.arity)
+        fail(`${action} has invalid positional arguments`);
+    if (stdin !== spec.stdin)
+        fail(`${action} ${spec.stdin ? "requires" : "reads no"} stdin`);
+    const output = flags.json === true ? "json" : "text";
+    if (action === "call")
+        return parseCall(flags, positionals, output, fail);
+    return parseAddressed(action, positionals[0], flags, output, fail);
+}

package/build/src/cli/commands/amend.d.ts

@@ -0,0 +1,13 @@
+import { type ActorId, type Gate, type Keiyaku, type Repo, type WorktreeHooks } from "../../index.js";
+import type { ParsedAmend } from "../parse.js";
+type AmendCommandInput = Readonly<{
+    command: ParsedAmend;
+    repo: Repo;
+    contract: Keiyaku;
+    markdown: string;
+    gates: readonly Gate[] | undefined;
+    actor?: ActorId;
+    hooks?: WorktreeHooks;
+}>;
+export declare function amendFromCommand({ command, repo, contract, markdown, gates, actor, hooks }: AmendCommandInput): ReturnType<Keiyaku["amend"]>;
+export {};

package/build/src/cli/commands/amend.js

@@ -0,0 +1,13 @@
+import { contractFromInput } from "../selectors.js";
+export function amendFromCommand({ command, repo, contract, markdown, gates, actor, hooks }) {
+    const after = command.clearAfter === true
+        ? []
+        : command.after?.map((id) => contractFromInput(repo, id).id);
+    return contract.amend({
+        markdown,
+        ...(actor === undefined ? {} : { actor }),
+        ...(hooks === undefined ? {} : { hooks }),
+        ...(after === undefined ? {} : { after }),
+        ...(gates === undefined ? {} : { gates }),
+    });
+}

package/build/src/cli/commands/bind.d.ts

@@ -0,0 +1,12 @@
+import { type ActorId, type BindResult, type Gate, type Repo, type WorktreeHooks } from "../../index.js";
+import type { ParsedBind } from "../parse.js";
+type BindCommandInput = Readonly<{
+    command: ParsedBind;
+    repo: Repo;
+    markdown: string;
+    gates: readonly Gate[];
+    actor?: ActorId;
+    hooks?: WorktreeHooks;
+}>;
+export declare function bindFromCommand({ command, repo, markdown, gates, actor, hooks }: BindCommandInput): Promise<BindResult>;
+export {};

package/build/src/cli/commands/bind.js

@@ -0,0 +1,17 @@
+import { Keiyaku } from "../../index.js";
+import { contractFromInput } from "../selectors.js";
+export async function bindFromCommand({ command, repo, markdown, gates, actor, hooks }) {
+    const after = command.after?.map((id) => contractFromInput(repo, id).id);
+    const target = command.target ?? await repo.currentBranch();
+    return Keiyaku.bind({
+        repo,
+        markdown,
+        ...(command.task === undefined ? {} : { task: command.task }),
+        ...(target === null ? {} : { target }),
+        ...(command.workspace === undefined ? {} : { workspace: command.workspace }),
+        ...(actor === undefined ? {} : { actor }),
+        ...(hooks === undefined ? {} : { hooks }),
+        ...(after === undefined ? {} : { after }),
+        gates,
+    });
+}

package/build/src/cli/commands/install.d.ts

@@ -0,0 +1,25 @@
+import { type ProcessInput, type ProcessOutcome } from "../../runtime/proc/run.js";
+export declare const HARNESS_NAMES: readonly ["codex", "claude", "opencode", "pi"];
+export type HarnessName = typeof HARNESS_NAMES[number];
+export type ParsedInstallCommand = Readonly<{
+    command: "install";
+    harnesses: readonly HarnessName[];
+    output: "text" | "json";
+}>;
+export type HarnessInstallResult = Readonly<{
+    harness: HarnessName;
+    status: "installed" | "failed";
+    diagnostic?: string;
+}>;
+export type InstallInvocationResult = Readonly<{
+    kind: "install";
+    results: readonly HarnessInstallResult[];
+}>;
+export type InstallRunner = (input: ProcessInput) => Promise<ProcessOutcome>;
+export declare const INSTALL_USAGE = "install <codex|claude|opencode|pi> [--json]\n       install --all [--json]";
+export declare function parseInstallCommand(argv: readonly string[]): ParsedInstallCommand;
+export declare function renderInstallHelp(): string;
+export declare function installAssetsRoot(): string;
+export declare function installHarnesses(harnesses: readonly HarnessName[], environment: NodeJS.ProcessEnv, runner?: InstallRunner): Promise<InstallInvocationResult>;
+export declare function renderInstallText(result: InstallInvocationResult): string;
+export declare function installExitCode(result: InstallInvocationResult): number;

package/build/src/cli/commands/install.js

@@ -0,0 +1,103 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runProcess } from "../../runtime/proc/run.js";
+import { CliUsageError, usageLine } from "../usage.js";
+export const HARNESS_NAMES = ["codex", "claude", "opencode", "pi"];
+export const INSTALL_USAGE = "install <codex|claude|opencode|pi> [--json]\n       install --all [--json]";
+function isHarness(value) {
+    return value !== undefined && HARNESS_NAMES.includes(value);
+}
+export function parseInstallCommand(argv) {
+    let all = false;
+    let json = false;
+    const positionals = [];
+    for (const token of argv) {
+        if (token === "--all") {
+            if (all)
+                throw new CliUsageError("duplicate option: --all", usageLine(INSTALL_USAGE));
+            all = true;
+        }
+        else if (token === "--json") {
+            if (json)
+                throw new CliUsageError("duplicate option: --json", usageLine(INSTALL_USAGE));
+            json = true;
+        }
+        else if (token.startsWith("--")) {
+            throw new CliUsageError(`option ${token} is not valid for install`, usageLine(INSTALL_USAGE));
+        }
+        else {
+            positionals.push(token);
+        }
+    }
+    if (positionals.length > 1)
+        throw new CliUsageError("install accepts at most one harness", usageLine(INSTALL_USAGE));
+    const harness = positionals[0];
+    if (all && harness !== undefined)
+        throw new CliUsageError("install accepts either a harness or --all", usageLine(INSTALL_USAGE));
+    if (!all && !isHarness(harness))
+        throw new CliUsageError("install requires a supported harness or --all", usageLine(INSTALL_USAGE));
+    return {
+        command: "install",
+        harnesses: all ? HARNESS_NAMES : [harness],
+        output: json ? "json" : "text",
+    };
+}
+export function renderInstallHelp() {
+    return `Install the Keiyaku skills into one or more agent harnesses.\n\n${usageLine(INSTALL_USAGE)}`;
+}
+const INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
+const ASSET_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../../../integrations/marketplace");
+const PLUGIN_ROOT = resolve(ASSET_ROOT, "plugins/keiyaku");
+function recipes(harness) {
+    switch (harness) {
+        case "codex": return [
+            ["codex", "plugin", "marketplace", "add", ASSET_ROOT, "--json"],
+            ["codex", "plugin", "add", "keiyaku", "--marketplace", "keiyaku", "--json"],
+        ];
+        case "claude": return [
+            ["claude", "plugin", "marketplace", "add", ASSET_ROOT],
+            ["claude", "plugin", "install", "keiyaku@keiyaku", "--scope", "user"],
+            ["claude", "plugin", "update", "keiyaku@keiyaku", "--scope", "user"],
+        ];
+        case "opencode": return [["opencode", "plugin", PLUGIN_ROOT, "--global", "--force"]];
+        case "pi": return [["pi", "install", PLUGIN_ROOT]];
+    }
+}
+function diagnostic(argv, outcome) {
+    if (outcome.kind === "spawn-error")
+        return `${argv[0]} unavailable: ${outcome.diagnostic}`;
+    if (outcome.kind === "timeout")
+        return `${argv[0]} timed out`;
+    if (outcome.kind === "unknown-exit")
+        return `${argv[0]} exited without a status`;
+    if (outcome.code === 0)
+        return "";
+    const detail = outcome.stderr.trim() || outcome.stdout.trim();
+    return `${argv[0]} exited ${outcome.code}${detail.length === 0 ? "" : `: ${detail}`}`;
+}
+export function installAssetsRoot() {
+    return ASSET_ROOT;
+}
+export async function installHarnesses(harnesses, environment, runner = runProcess) {
+    const results = [];
+    for (const harness of harnesses) {
+        let failure;
+        for (const argv of recipes(harness)) {
+            const detail = diagnostic(argv, await runner({ argv, env: environment, timeoutMs: INSTALL_TIMEOUT_MS }));
+            if (detail.length > 0) {
+                failure = detail;
+                break;
+            }
+        }
+        results.push({ harness, status: failure === undefined ? "installed" : "failed", ...(failure === undefined ? {} : { diagnostic: failure }) });
+    }
+    return { kind: "install", results };
+}
+export function renderInstallText(result) {
+    return result.results.map((item) => item.status === "installed"
+        ? `${item.harness} installed`
+        : `${item.harness} failed: ${item.diagnostic}`).join("\n");
+}
+export function installExitCode(result) {
+    return result.results.some((item) => item.status === "failed") ? 1 : 0;
+}

package/build/src/cli/commands/task-invoke.d.ts

@@ -0,0 +1,9 @@
+import { type BlockedTaskList, type TaskBatchResult, type TaskCompositionResult, type TaskDependencyTree, type TaskDetail, type TaskDoctorReport, type TaskList, type TaskMutationResult, type TaskNamespaceResult, type TaskUpdateResult } from "../../task/index.js";
+import type { ParsedTaskCommand } from "./task.js";
+export type TaskInvocationResult = TaskMutationResult | TaskUpdateResult | TaskBatchResult | TaskCompositionResult | TaskDetail | TaskList | BlockedTaskList | TaskDependencyTree | TaskDoctorReport | TaskNamespaceResult;
+type TaskInput = Readonly<{
+    path?: string;
+    readStdin(): string;
+}>;
+export declare function invokeTask(command: ParsedTaskCommand, input: TaskInput): Promise<TaskInvocationResult>;
+export {};

package/build/src/cli/commands/task-invoke.js

@@ -0,0 +1,92 @@
+import { Tasks, } from "../../task/index.js";
+function value(command, name) {
+    const item = command.flags[name];
+    return typeof item === "string" ? item : undefined;
+}
+function values(command, name) {
+    const item = command.flags[name];
+    return Array.isArray(item) ? item : undefined;
+}
+function namespace(raw) { return raw === undefined ? undefined : raw === "" ? [] : raw.split("/"); }
+function priority(raw) {
+    if (raw === undefined)
+        return undefined;
+    const number = Number(raw);
+    return number;
+}
+function state(raw) { return raw; }
+function ids(items) { return items; }
+function invokeAdd(tasks, command, readStdin) {
+    const selectedNamespace = namespace(value(command, "namespace"));
+    if (command.stdin === "document")
+        return tasks.addDocument({ markdown: readStdin(), ...(selectedNamespace === undefined ? {} : { namespace: selectedNamespace }) });
+    const body = value(command, "body"), note = value(command, "note"), initialState = state(value(command, "state")), selectedPriority = priority(value(command, "priority"));
+    const needs = ids(values(command, "needs")), parent = value(command, "parent");
+    const supersedes = ids(values(command, "supersedes")), relates = ids(values(command, "relates"));
+    return tasks.add({
+        title: command.positionals[0], ...(selectedNamespace === undefined ? {} : { namespace: selectedNamespace }),
+        ...(body === undefined ? {} : { body }), ...(note === undefined ? {} : { note }), ...(initialState === undefined ? {} : { state: initialState }), ...(selectedPriority === undefined ? {} : { priority: selectedPriority }),
+        ...(needs === undefined ? {} : { needs }), ...(parent === undefined ? {} : { parent: parent }),
+        ...(supersedes === undefined ? {} : { supersedes }), ...(relates === undefined ? {} : { relates }),
+    });
+}
+function invokeUpdate(tasks, command, readStdin) {
+    const body = command.stdin === "body" ? readStdin() : value(command, "body"), appendBody = command.stdin === "append" ? readStdin() : value(command, "append");
+    const note = command.stdin === "note" ? readStdin() : value(command, "note");
+    const title = value(command, "title"), selectedPriority = priority(value(command, "priority"));
+    const addNeeds = ids(values(command, "needs")), dropNeeds = ids(values(command, "drop-needs"));
+    const parent = value(command, "parent"), addSupersedes = ids(values(command, "supersedes"));
+    const dropSupersedes = ids(values(command, "drop-supersedes")), addRelates = ids(values(command, "relates"));
+    const dropRelates = ids(values(command, "drop-relates"));
+    return tasks.task({ id: command.positionals[0] }).update({
+        ...(title === undefined ? {} : { title }), ...(body === undefined ? {} : { body }), ...(appendBody === undefined ? {} : { appendBody }), ...(note === undefined ? {} : { note }),
+        ...(selectedPriority === undefined ? {} : { priority: selectedPriority }), ...(addNeeds === undefined ? {} : { addNeeds }),
+        ...(dropNeeds === undefined ? {} : { dropNeeds }), ...(command.flags["no-parent"] === true ? { parent: null } : parent === undefined ? {} : { parent: parent }),
+        ...(addSupersedes === undefined ? {} : { addSupersedes }), ...(dropSupersedes === undefined ? {} : { dropSupersedes }),
+        ...(addRelates === undefined ? {} : { addRelates }), ...(dropRelates === undefined ? {} : { dropRelates }),
+    });
+}
+async function invokeRead(tasks, command) {
+    const id = command.positionals[0];
+    switch (command.action) {
+        case "show": {
+            const detail = await tasks.task({ id }).read();
+            return detail ?? { kind: "refused", refusal: { kind: "task-missing", taskId: id } };
+        }
+        case "ls": return tasks.list({ selection: command.flags.all === true ? "all" : command.flags.closed === true ? "closed" : "active", ...(command.flags.world === true ? { scope: "world" } : {}) });
+        case "ready": return tasks.ready(command.flags.world === true ? { scope: "world" } : {});
+        case "blocked": return tasks.blocked(command.flags.world === true ? { scope: "world" } : {});
+        case "tree": return tasks.task({ id }).tree(command.flags.full === true ? { full: true } : {});
+        case "doctor": return tasks.doctor();
+        default: throw new Error(`task action is not a read: ${command.action}`);
+    }
+}
+export async function invokeTask(command, input) {
+    const tasks = input.path === undefined ? Tasks.at() : Tasks.at({ path: input.path });
+    if (["show", "ls", "ready", "blocked", "tree", "doctor"].includes(command.action))
+        return invokeRead(tasks, command);
+    if (command.action === "add")
+        return invokeAdd(tasks, command, input.readStdin);
+    if (command.action === "update")
+        return invokeUpdate(tasks, command, input.readStdin);
+    const id = command.positionals[0];
+    switch (command.action) {
+        case "start": return tasks.task({ id }).start();
+        case "stop": return tasks.task({ id }).stop();
+        case "resume": return tasks.task({ id }).resume();
+        case "hold": return tasks.batch({ verb: "hold", ids: command.positionals });
+        case "done": return tasks.batch({ verb: "done", ids: command.positionals });
+        case "drop": {
+            const note = value(command, "note");
+            return tasks.batch({ verb: "drop", ids: command.positionals, ...(note === undefined ? {} : { note }) });
+        }
+        case "namespace": {
+            const selected = namespace(command.positionals[0]);
+            if (selected !== undefined)
+                await tasks.setNamespace({ namespace: selected });
+            return tasks.namespace();
+        }
+        case "compose": return tasks.compose({ markdown: input.readStdin() });
+        default: throw new Error(`task action has no invocation: ${command.action}`);
+    }
+}

package/build/src/cli/commands/task.d.ts

@@ -0,0 +1,16 @@
+export type TaskAction = "add" | "show" | "ls" | "ready" | "blocked" | "tree" | "doctor" | "update" | "start" | "stop" | "hold" | "resume" | "done" | "drop" | "namespace" | "compose";
+type TaskFlagValue = string | true | readonly string[];
+type TaskStdin = "document" | "body" | "append" | "note" | "compose";
+export type ParsedTaskCommand = Readonly<{
+    command: "task";
+    action: TaskAction;
+    output: "text" | "json";
+    positionals: readonly string[];
+    flags: Readonly<Record<string, TaskFlagValue>>;
+    stdin?: TaskStdin;
+}>;
+export declare function isTaskAction(value: string | undefined): value is TaskAction;
+export declare function renderTaskHelp(action?: TaskAction): string;
+export declare function renderTaskUsage(action: TaskAction): string;
+export declare function parseTaskCommand(argv: readonly string[]): ParsedTaskCommand;
+export {};