@astrosheep/keiyaku 2.9.13 → 4.0.1

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

@@ -0,0 +1,117 @@
+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}`);
+    }
+}
+function missingWorld(command) {
+    const missing = (id) => ({
+        kind: "refused",
+        refusal: { kind: "task-missing", taskId: id },
+    });
+    if (command.action === "doctor")
+        return { issues: [] };
+    if (command.action === "ls" || command.action === "ready" || command.action === "blocked" || command.action === "namespace") {
+        return { kind: "accepted", value: [] };
+    }
+    if (command.action === "hold" || command.action === "done" || command.action === "drop") {
+        return { items: command.positionals.map((id) => ({ id: id, outcome: missing(id) })) };
+    }
+    return missing(command.positionals[0]);
+}
+export async function invokeTask(command, input) {
+    let world = input.world;
+    if (world === null && (command.action === "add" || command.action === "compose"
+        || (command.action === "namespace" && command.positionals.length > 0))) {
+        world = input.establish();
+    }
+    if (world === null)
+        return missingWorld(command);
+    const tasks = Tasks.of(world);
+    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": {
+            const note = value(command, "note");
+            return tasks.batch({ verb: "done", ids: command.positionals, ...(note === undefined ? {} : { note }) });
+        }
+        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 {};

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

@@ -0,0 +1,144 @@
+import { CliUsageError, usageLine } from "../usage.js";
+const COMMON = { json: "boolean" };
+const TASK_COMMAND_SPECS = {
+    add: {
+        arity: [0, 1], stdin: "document", flags: { ...COMMON, namespace: "value", state: "value", priority: "value", needs: "repeat", parent: "value", supersedes: "repeat", relates: "repeat", body: "value", note: "value" },
+        usage: `task add <TITLE> [--namespace <ns>] [--priority 0..3]
+  [--state open|in_progress|on_hold|done|drop]
+  [--note <text>]
+  [--needs <TaskId>]... [--parent <TaskId>]
+  [--supersedes <TaskId>]... [--relates <TaskId>]...
+  [--body <text>] [--json]
+task add [--namespace <ns>] [--json] -`,
+        purpose: "Create one Task from flags or a canonical stdin document.",
+    },
+    show: { arity: [1, 1], flags: COMMON, usage: "task show <TaskId> [--json]", purpose: "Read one Task and its relationships." },
+    ls: { arity: [0, 0], flags: { ...COMMON, closed: "boolean", all: "boolean", world: "boolean" }, usage: "task ls [--closed | --all] [--world] [--json]", purpose: "List Tasks in the selected scope." },
+    ready: { arity: [0, 0], flags: { ...COMMON, world: "boolean" }, usage: "task ready [--world] [--json]", purpose: "List Tasks whose dependencies are satisfied." },
+    blocked: { arity: [0, 0], flags: { ...COMMON, world: "boolean" }, usage: "task blocked [--world] [--json]", purpose: "List Tasks blocked by dependencies." },
+    tree: { arity: [1, 1], flags: { ...COMMON, full: "boolean" }, usage: "task tree <TaskId> [--full] [--json]", purpose: "Read one Task dependency tree." },
+    doctor: { arity: [0, 0], flags: COMMON, usage: "task doctor [--json]", purpose: "Inspect Task authority without repairing it." },
+    update: {
+        arity: [1, 1], flags: { ...COMMON, title: "value", body: "value", append: "value", note: "value", priority: "value", needs: "repeat", "drop-needs": "repeat", parent: "value", "no-parent": "boolean", supersedes: "repeat", "drop-supersedes": "repeat", relates: "repeat", "drop-relates": "repeat" },
+        usage: `task update <TaskId> [--title <text>] [--body <text>|- | --append <text>|-]
+  [--note <text>|-]
+  [--priority 0..3] [--needs <TaskId>]... [--drop-needs <TaskId>]...
+  [--parent <TaskId> | --no-parent]
+  [--supersedes <TaskId>]... [--drop-supersedes <TaskId>]...
+  [--relates <TaskId>]... [--drop-relates <TaskId>]... [--json]`,
+        purpose: "Apply one or more patches to a Task.",
+    },
+    start: { arity: [1, 1], flags: COMMON, usage: "task start <TaskId> [--json]", purpose: "Move one open Task into progress." },
+    stop: { arity: [1, 1], flags: COMMON, usage: "task stop <TaskId> [--json]", purpose: "Return one in-progress Task to open." },
+    hold: { arity: [1, Number.POSITIVE_INFINITY], flags: COMMON, usage: "task hold <TaskId>... [--json]", purpose: "Put one or more Tasks on hold." },
+    resume: { arity: [1, 1], flags: COMMON, usage: "task resume <TaskId> [--json]", purpose: "Return one held Task to open." },
+    done: { arity: [1, Number.POSITIVE_INFINITY], flags: { ...COMMON, note: "value" }, usage: "task done <TaskId>... [--note <text>] [--json]", purpose: "Mark one or more Tasks done." },
+    drop: { arity: [1, Number.POSITIVE_INFINITY], flags: { ...COMMON, note: "value" }, usage: "task drop <TaskId>... [--note <text>] [--json]", purpose: "Drop one or more Tasks." },
+    namespace: { arity: [0, 1], flags: COMMON, usage: "task namespace [<namespace>] [--json]", purpose: "Read or replace the current Task namespace." },
+    compose: { arity: [0, 0], stdin: "compose", flags: COMMON, usage: "task compose [--json] -", purpose: "Admit independent Task document changes from stdin; partial admission is reported." },
+};
+export function isTaskAction(value) {
+    return value !== undefined && Object.hasOwn(TASK_COMMAND_SPECS, value);
+}
+export function renderTaskHelp(action) {
+    if (action !== undefined) {
+        const spec = TASK_COMMAND_SPECS[action];
+        return `${spec.purpose}\n\n${usageLine(spec.usage)}`;
+    }
+    return [
+        "usage: keiyaku task <command> ...",
+        "",
+        "commands:",
+        ...Object.values(TASK_COMMAND_SPECS).flatMap((spec) => spec.usage.split("\n").map((line) => `  ${line}`).concat(`    ${spec.purpose}`)),
+    ].join("\n");
+}
+export function renderTaskUsage(action) {
+    return usageLine(TASK_COMMAND_SPECS[action].usage);
+}
+function setFlag(flags, name, kind, value, fail) {
+    if (flags[name] !== undefined && kind !== "repeat")
+        fail(`duplicate option: --${name}`);
+    if (kind === "boolean") {
+        flags[name] = true;
+        return;
+    }
+    if (value === undefined)
+        fail(`--${name} requires a value`);
+    if (kind === "repeat") {
+        const current = flags[name];
+        flags[name] = [...(Array.isArray(current) ? current : []), value];
+    }
+    else
+        flags[name] = value;
+}
+function scanTaskOption(input, fail) {
+    const token = input.argv[input.index], name = token.slice(2), kind = input.spec.flags[name];
+    if (kind === undefined)
+        fail(`option ${token} is not valid for task ${input.action}`);
+    const next = kind === "boolean" ? undefined : input.argv[input.index + 1];
+    if (next === "-" && input.action === "update" && (name === "body" || name === "append" || name === "note")) {
+        if (input.index + 1 !== input.argv.length - 1 || input.stdin !== undefined)
+            fail("stdin update marker '-' must be final");
+        input.flags[name] = "";
+        return { index: input.index + 1, stdin: name };
+    }
+    if (kind !== "boolean" && (next === undefined || next.startsWith("--") || next === "-"))
+        fail(`--${name} requires a value`);
+    setFlag(input.flags, name, kind, next, fail);
+    return { index: input.index + (kind === "boolean" ? 0 : 1), ...(input.stdin === undefined ? {} : { stdin: input.stdin }) };
+}
+function scanTaskArgv(action, argv, fail) {
+    const spec = TASK_COMMAND_SPECS[action], positionals = [], flags = {};
+    let stdin;
+    for (let index = 1; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "-") {
+            if (index !== argv.length - 1 || stdin !== undefined || spec.stdin === undefined)
+                fail("stdin marker '-' is not valid here");
+            stdin = spec.stdin;
+            continue;
+        }
+        if (!token.startsWith("--")) {
+            positionals.push(token);
+            continue;
+        }
+        const scanned = scanTaskOption({ action, spec, argv, index, flags, ...(stdin === undefined ? {} : { stdin }) }, fail);
+        index = scanned.index;
+        stdin = scanned.stdin;
+    }
+    return { positionals, flags, ...(stdin === undefined ? {} : { stdin }) };
+}
+function validateUpdate(scanned, fail) {
+    const flags = scanned.flags;
+    if (flags.body !== undefined && flags.append !== undefined)
+        fail("--body and --append are mutually exclusive");
+    if (flags.parent !== undefined && flags["no-parent"] === true)
+        fail("--parent and --no-parent are mutually exclusive");
+    if (Object.keys(flags).every((name) => name === "json"))
+        fail("task update requires at least one patch option");
+}
+function validateTaskScan(action, scanned, fail) {
+    const spec = TASK_COMMAND_SPECS[action], { positionals, flags, stdin } = scanned;
+    if (positionals.length < spec.arity[0] || positionals.length > spec.arity[1])
+        fail(`task ${action} has invalid positional arguments`);
+    if (action === "add" && (stdin === "document") === (positionals.length === 1))
+        fail("task add requires either TITLE or final '-' input");
+    if (action === "add" && stdin === "document" && Object.keys(flags).some((name) => name !== "json" && name !== "namespace"))
+        fail("task add document input owns its creation fields");
+    if (action === "compose" && stdin !== "compose")
+        fail("task compose requires final '-' input");
+    if (action === "ls" && flags.closed === true && flags.all === true)
+        fail("--closed and --all are mutually exclusive");
+    if (action === "update")
+        validateUpdate(scanned, fail);
+}
+export function parseTaskCommand(argv) {
+    const candidate = argv[0];
+    if (!isTaskAction(candidate))
+        throw new CliUsageError(`unknown task command: ${candidate ?? ""}`, renderTaskHelp());
+    const action = candidate;
+    const fail = (message) => { throw new CliUsageError(message, renderTaskUsage(action)); };
+    const scanned = scanTaskArgv(action, argv, fail);
+    validateTaskScan(action, scanned, fail);
+    return { command: "task", action, output: scanned.flags.json === true ? "json" : "text", ...scanned };
+}

package/build/src/cli/index.d.ts

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

package/build/src/cli/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from "./main.js";
+process.exitCode = await main();

package/build/src/cli/invoke.d.ts

@@ -0,0 +1,22 @@
+import { type ContractId, type Settings } from "../index.js";
+import { type AkumaInvocationResult } from "./commands/akuma-invoke.js";
+import { type InstallInvocationResult } from "./commands/install.js";
+import { type TaskInvocationResult } from "./commands/task-invoke.js";
+import { type ParsedExecution } from "./parse.js";
+import type { InvocationResult } from "./result.js";
+export type { AcceptedFact, DiffUnavailable, InvocationResult, Lag } from "./result.js";
+type InvokeRuntime = Readonly<{
+    cwd?: string;
+    environment?: NodeJS.ProcessEnv;
+    readStdin?: () => string;
+}>;
+export type SettingsInvocationResult = Readonly<{
+    kind: "settings";
+    value: Settings;
+}>;
+export type GuidanceInvocationResult = Readonly<{
+    kind: "guidance";
+    contract: ContractId;
+    guidance: string;
+}>;
+export declare function invoke(invocation: ParsedExecution, runtime?: InvokeRuntime): Promise<InvocationResult | TaskInvocationResult | AkumaInvocationResult | SettingsInvocationResult | InstallInvocationResult>;