@astrosheep/keiyaku 2.8.5 → 2.9.1

package/build/cli/parse-flags.js

@@ -0,0 +1,197 @@
+import { FlowError } from "../flow-error.js";
+import { getCommandMetadata } from "./commands/registry.js";
+import { BOOLEAN_FLAGS, CONTROL_FLAGS, SHORT_FLAG_ALIASES, VALUE_FLAGS, } from "./flags.js";
+import { normalizeContractAddress, parseWaitTimeout } from "./parse-metadata.js";
+function allowedFlagsForParse(command) {
+    const meta = getCommandMetadata(command);
+    return meta.parseFlags ?? meta.flags;
+}
+export function parseFlagName(raw) {
+    return raw.slice(2);
+}
+export function assertAllowedFlag(command, name) {
+    if (!allowedFlagsForParse(command).includes(name)) {
+        throw new FlowError("EMPTY_PARAM", `option --${name} is not valid for ${command}`);
+    }
+}
+export function assignFlag(flags, name, value) {
+    switch (name) {
+        case "cwd":
+            flags.cwd = String(value);
+            return;
+        case "repo":
+            flags.repo = String(value);
+            return;
+        case "contract":
+            flags.contractId = normalizeContractAddress(String(value));
+            flags.contractAddressSource = "explicit-flag";
+            return;
+        case "akuma":
+            flags.akuma = String(value);
+            return;
+        case "projection":
+            flags.projection = String(value);
+            return;
+        case "alias":
+            flags.alias = String(value);
+            return;
+        case "timeout":
+        case "wait":
+            flags.timeoutMs = parseWaitTimeout(String(value));
+            return;
+        case "model":
+            flags.model = String(value);
+            return;
+        case "effort":
+            flags.effort = String(value);
+            return;
+        case "incognito":
+            flags.incognito = Boolean(value);
+            return;
+        case "bare":
+            flags.bare = Boolean(value);
+            return;
+        case "detach":
+            flags.detach = Boolean(value);
+            return;
+        case "draft-only":
+            flags.draftOnly = Boolean(value);
+            return;
+        case "exclusive":
+            flags.exclusive = Boolean(value);
+            return;
+        case "place":
+            if (flags.bindPlace !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --place may only be specified once");
+            }
+            flags.bindPlace = String(value);
+            return;
+        case "objective":
+            if (flags.bindObjective !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --objective may only be specified once");
+            }
+            flags.bindObjective = String(value);
+            return;
+        case "scope":
+            if (flags.bindScope !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --scope may only be specified once");
+            }
+            flags.bindScope = String(value);
+            return;
+        case "checks":
+            if (flags.bindChecks !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --checks may only be specified once");
+            }
+            flags.bindChecks = String(value);
+            return;
+        case "task":
+            if (flags.bindTaskId !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --task may only be specified once");
+            }
+            flags.bindTaskId = String(value);
+            return;
+        case "after":
+            flags.after = [...(flags.after ?? []), String(value)];
+            return;
+        case "force":
+            flags.force = Boolean(value);
+            return;
+        case "reason":
+            flags.reason = String(value);
+            return;
+        case "dry-run":
+            flags.dryRun = Boolean(value);
+            return;
+        case "waive":
+            flags.waivePaths = [...(flags.waivePaths ?? []), String(value)];
+            return;
+        case "shell":
+            flags.shell = String(value);
+            return;
+        case "word":
+            flags.word = String(value);
+            return;
+        case "previous":
+            flags.previous = String(value);
+            return;
+        case "complete":
+            flags.complete = Boolean(value);
+            return;
+        case "all":
+            flags.all = Boolean(value);
+            return;
+        case "target":
+            if (flags.target !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --target may only be specified once");
+            }
+            flags.target = String(value);
+            return;
+        case "json":
+            flags.json = Boolean(value);
+            return;
+        case "done":
+            flags.done = Boolean(value);
+            return;
+        case "pri": {
+            const raw = String(value);
+            if (!/^[0-3]$/.test(raw)) {
+                throw new FlowError("EMPTY_PARAM", "task priority must be an integer from 0 through 3");
+            }
+            if (flags.taskPri !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --pri may only be specified once");
+            }
+            flags.taskPri = Number(raw);
+            return;
+        }
+        case "needs":
+            flags.taskNeeds = [...(flags.taskNeeds ?? []), String(value)];
+            return;
+        case "drop-needs":
+            flags.taskDropNeeds = [...(flags.taskDropNeeds ?? []), String(value)];
+            return;
+        case "from":
+            flags.taskFrom = [...(flags.taskFrom ?? []), String(value)];
+            return;
+        case "parent":
+            if (flags.taskParent !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --parent may only be specified once");
+            }
+            flags.taskParent = String(value);
+            return;
+        case "no-parent":
+            flags.taskNoParent = Boolean(value);
+            return;
+        case "title":
+            if (flags.taskTitle !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --title may only be specified once");
+            }
+            flags.taskTitle = String(value);
+            return;
+        case "body":
+            if (flags.taskBody !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --body may only be specified once");
+            }
+            flags.taskBody = String(value);
+            return;
+        default:
+            throw new FlowError("EMPTY_PARAM", `unknown option: --${name}`);
+    }
+}
+export function readValueFlag(name, token, eq, tokens, index) {
+    if (eq !== -1) {
+        const value = token.slice(eq + 1);
+        if (value === "" && name !== "target" && name !== "body") {
+            throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
+        }
+        return { value, nextIndex: index };
+    }
+    const value = tokens[index + 1];
+    if (value === undefined || value === "--" || value.startsWith("--")) {
+        throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
+    }
+    if (value === "" && name !== "target" && name !== "body") {
+        throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
+    }
+    return { value, nextIndex: index + 1 };
+}
+export { BOOLEAN_FLAGS, CONTROL_FLAGS, SHORT_FLAG_ALIASES, VALUE_FLAGS };

package/build/cli/parse-metadata.js

@@ -0,0 +1,129 @@
+import { FlowError } from "../flow-error.js";
+import { HELP_FLAGS, SHORT_FLAG_ALIASES, VALUE_FLAGS } from "./flags.js";
+import { commandParseOrder, getCommandMetadata } from "./commands/registry.js";
+import { TASK_SUBCOMMANDS } from "./types.js";
+export function normalizeContractAddress(raw) {
+    const value = raw.startsWith("@") ? raw.slice(1) : raw;
+    if (!value.trim()) {
+        throw new FlowError("EMPTY_PARAM", "contract address cannot be empty");
+    }
+    return value.trim();
+}
+export function isCallCommand(command) {
+    return command === "call";
+}
+export function isPetitionDryRunInvocation(tokens) {
+    const boundary = tokens.indexOf("--");
+    const head = boundary === -1 ? tokens : tokens.slice(0, boundary);
+    if (!head.some((token) => token === "--dry-run" || token.startsWith("--dry-run="))) {
+        return false;
+    }
+    for (let index = 0; index < head.length; index += 1) {
+        const token = head[index];
+        if (HELP_FLAGS.has(token) || token.startsWith("@")) {
+            continue;
+        }
+        if (/^-[A-Za-z]$/.test(token)) {
+            const name = SHORT_FLAG_ALIASES[token.slice(1)];
+            if (name && VALUE_FLAGS.has(name)) {
+                index += 1;
+            }
+            continue;
+        }
+        if (token.startsWith("--")) {
+            const eq = token.indexOf("=");
+            const name = (eq === -1 ? token : token.slice(0, eq)).slice(2);
+            if (eq === -1 && VALUE_FLAGS.has(name)) {
+                index += 1;
+            }
+            continue;
+        }
+        return token === "petition";
+    }
+    return false;
+}
+export function commandUsesPromptInput(command) {
+    return isCallCommand(command) || command === "tell" || command === "revive";
+}
+export function parseWaitTimeout(value) {
+    const matched = /^(?<amount>[1-9][0-9]*)(?<unit>[smh])$/.exec(value);
+    if (!matched?.groups) {
+        throw new FlowError("EMPTY_PARAM", "wait timeout must use <positive integer><s|m|h>, for example 45s, 5m, or 2h (maximum 24h)");
+    }
+    const amount = Number(matched.groups.amount);
+    const multiplier = matched.groups.unit === "s" ? 1_000 : matched.groups.unit === "m" ? 60_000 : 3_600_000;
+    const timeoutMs = amount * multiplier;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs > 24 * 3_600_000) {
+        throw new FlowError("EMPTY_PARAM", "wait timeout must use <positive integer><s|m|h>, for example 45s, 5m, or 2h (maximum 24h)");
+    }
+    return timeoutMs;
+}
+export function commandPositionalRange(command) {
+    if (command === "akuma view") {
+        return { min: 1, max: 1, label: "<name>" };
+    }
+    if (command === "log") {
+        return { min: 0, max: 0, label: "" };
+    }
+    if (isCallCommand(command)) {
+        return { min: 1, max: 1, label: "<BODY|->" };
+    }
+    if (command === "tell") {
+        return { min: 2, max: 2, label: "<PROJECTION> <BODY|->" };
+    }
+    if (command === "revive") {
+        return { min: 1, max: 2, label: "<ARTIFACT> [BODY|-]" };
+    }
+    if (command === "wait") {
+        return { min: 1, max: 1, label: "<projection-address>" };
+    }
+    if (command === "kill") {
+        return { min: 1, max: 1, label: "<projection-address>" };
+    }
+    if (command === "status") {
+        return { min: 0, max: 1, label: "[projection-id]" };
+    }
+    if (command === "task add") {
+        return { min: 1, max: 1, label: "<BODY|->" };
+    }
+    if (command === "task view" || command === "task start" || command === "task drop") {
+        return { min: 1, max: 1, label: "<ID>" };
+    }
+    if (command === "task update") {
+        return { min: 1, max: 1, label: "<ID>" };
+    }
+    if (command === "task stop" || command === "task done") {
+        return { min: 0, max: 1, label: "[ID]" };
+    }
+    return { min: 0, max: 0 };
+}
+export function commandRequiresStdin(command) {
+    return getCommandMetadata(command).stdin === "required";
+}
+export function resolveCommand(tokens) {
+    if (tokens[0] === "petition" && (tokens[1] === "claim" || tokens[1] === "forfeit")) {
+        throw new FlowError("UNKNOWN_COMMAND", `unknown command: petition ${tokens[1]}`);
+    }
+    for (const command of commandParseOrder()) {
+        const parts = command.split(" ");
+        if (parts.every((part, index) => tokens[index] === part)) {
+            return { command, rest: tokens.slice(parts.length) };
+        }
+    }
+    const [head] = tokens;
+    if (head === "skills") {
+        return { command: "skills", rest: tokens.slice(1) };
+    }
+    if (!head) {
+        throw new FlowError("EMPTY_PARAM", "command cannot be empty");
+    }
+    throw new FlowError("UNKNOWN_COMMAND", `unknown command: ${head ?? ""}`.trim());
+}
+export function splitAtLiteralBoundary(tokens) {
+    const boundary = tokens.indexOf("--");
+    if (boundary === -1) {
+        return { head: tokens, payload: [] };
+    }
+    return { head: tokens.slice(0, boundary), payload: tokens.slice(boundary + 1) };
+}
+export { TASK_SUBCOMMANDS };

package/build/cli/parse-selectors.js

@@ -0,0 +1,65 @@
+import { FlowError } from "../flow-error.js";
+import { assignFlag } from "./parse-flags.js";
+import { normalizeContractAddress } from "./parse-metadata.js";
+const COMMISSION_SELECTOR_COMMANDS = new Set([
+    "arc",
+    "amend",
+    "call",
+    "wait",
+    "tell",
+    "kill",
+    "log",
+    "renew",
+    "petition",
+    "forfeit",
+]);
+function formatSelectorList(items) {
+    if (items.length <= 1) {
+        return items[0] ?? "";
+    }
+    if (items.length === 2) {
+        return `${items[0]} and ${items[1]}`;
+    }
+    return `${items.slice(0, -1).join(", ")}, and ${items[items.length - 1]}`;
+}
+export function applyCommissionSelector(command, flags, atTokens, contractFlagRaws) {
+    if (atTokens.length > 0 && contractFlagRaws.length > 0) {
+        throw new FlowError("EMPTY_PARAM", `commission address supplied twice: ${atTokens[0]} and --contract ${contractFlagRaws[0]}; use exactly one form`);
+    }
+    if (atTokens.length > 1) {
+        throw new FlowError("EMPTY_PARAM", `${command} accepts one commission address; got ${formatSelectorList(atTokens)}`);
+    }
+    if (contractFlagRaws.length > 1) {
+        throw new FlowError("EMPTY_PARAM", `${command} accepts one commission address; got ${formatSelectorList(contractFlagRaws.map((raw) => `--contract ${raw}`))}`);
+    }
+    if (atTokens.length === 1) {
+        flags.contractId = normalizeContractAddress(atTokens[0]);
+        flags.contractAddressSource = "at-address";
+    }
+    else if (contractFlagRaws.length === 1) {
+        assignFlag(flags, "contract", contractFlagRaws[0]);
+    }
+}
+export function assertCommissionSelectorAllowed(command, flags) {
+    if (flags.contractId === undefined || COMMISSION_SELECTOR_COMMANDS.has(command)) {
+        return;
+    }
+    throw new FlowError("EMPTY_PARAM", command === "bind"
+        ? `bind creates a commission and does not accept @${flags.contractId}; use -C/--cwd to select the repository`
+        : `contract address @${flags.contractId} is not valid for ${command}`);
+}
+export function assertProjectionSelectorPresent(command, flags, atTokens, contractFlagRaws, restLength, payloadLength) {
+    if ((command !== "wait" && command !== "tell") || flags.contractId === undefined) {
+        return;
+    }
+    const selectorSpelling = flags.contractAddressSource === "at-address"
+        ? atTokens[0] ?? `@${flags.contractId}`
+        : `--contract ${contractFlagRaws[0] ?? flags.contractId}`;
+    const message = `${command} requires a projection id or alias; ${selectorSpelling} only limits projection lookup, so add the projection address`;
+    if (command === "wait" && restLength + payloadLength === 0) {
+        throw new FlowError("EMPTY_PARAM", message);
+    }
+    if (command === "tell" && restLength === 0) {
+        throw new FlowError("EMPTY_PARAM", message);
+    }
+}