@astrosheep/keiyaku 4.1.1 → 4.1.3

package/build/src/cli/invoke.js

@@ -1,5 +1,6 @@
 import { resolveActor } from "./actor.js";
 import { isParsedAkumaCommand } from "./commands/akuma.js";
+import { invokeContractMutation } from "./commands/contract-invoke.js";
 import { assertExplicitRepoUse, CliUsageError, renderCommandUsage, } from "./parse.js";
 import { isBlankInput } from "./usage.js";
 async function readStdin() {
@@ -65,14 +66,6 @@ function consumeSettings(run, ErrorType) {
         throw error;
     }
 }
-async function selectedGates(value, names) {
-    const { gatesFrom, SettingsError } = await import("../library/configuration.js");
-    return consumeSettings(() => gatesFrom({ settings: value, ...(names === undefined ? {} : { names }) }), SettingsError);
-}
-async function selectedGitPolicy(value) {
-    const { requireBranchesToBeUpToDateFrom, SettingsError } = await import("../library/configuration.js");
-    return consumeSettings(() => requireBranchesToBeUpToDateFrom({ settings: value }), SettingsError);
-}
 function actorFromEdge(actor, environment) {
     let resolved;
     try {
@@ -99,162 +92,6 @@ async function selectContract(repo, selector, scope) {
     const id = resolveContextualContract(await Keiyaku.list({ repo }), selector, scope);
     return contractFromInput(repo, id);
 }
-async function bindDraftReceipt(establishWorld, markdown) {
-    const { preserveBindDraft } = await import("./draft.js");
-    try {
-        return preserveBindDraft(await establishWorld(), markdown);
-    }
-    catch (error) {
-        return { warning: `bind draft could not be preserved: ${error instanceof Error ? error.message : String(error)}` };
-    }
-}
-async function invokeBind({ parsed, repo, edge, configuration, hooks, establishWorld, }) {
-    if (parsed.forkOf !== undefined) {
-        const actor = actorFromEdge(parsed.actor, edge.environment);
-        const { bindFromCommand } = await import("./commands/bind.js");
-        const { acceptedBind, resultFromMutationCall } = await import("./accepted.js");
-        return resultFromMutationCall("bind", () => bindFromCommand({ command: parsed, repo, ...(actor === undefined ? {} : { actor }), hooks }), (accepted) => {
-            const bound = accepted.facts.find((fact) => fact.kind === "bind");
-            if (bound === undefined || bound.kind !== "bind")
-                throw new Error("accepted bind is missing its bind fact");
-            return acceptedBind(accepted, bound.data.coordinates);
-        });
-    }
-    const markdown = await edge.readStdin();
-    const gates = await selectedGates(configuration, parsed.gates);
-    const actor = actorFromEdge(parsed.actor, edge.environment);
-    const { bindFromCommand } = await import("./commands/bind.js");
-    const { acceptedBind, resultFromMutationCall } = await import("./accepted.js");
-    try {
-        const result = await resultFromMutationCall("bind", () => bindFromCommand({
-            command: parsed,
-            repo,
-            markdown,
-            gates,
-            ...(actor === undefined ? {} : { actor }),
-            hooks,
-        }), (accepted) => {
-            const bound = accepted.facts.find((fact) => fact.kind === "bind");
-            if (bound === undefined || bound.kind !== "bind")
-                throw new Error("accepted bind is missing its bind fact");
-            return acceptedBind(accepted, bound.data.coordinates);
-        });
-        if (result.kind !== "refused")
-            return result;
-        return { ...result, draft: await bindDraftReceipt(establishWorld, markdown) };
-    }
-    catch (error) {
-        if (!(error instanceof TypeError))
-            throw error;
-        const { BindDraftError } = await import("./draft.js");
-        throw new BindDraftError(error, await bindDraftReceipt(establishWorld, markdown));
-    }
-}
-function deliverRefusal(refusal) {
-    if (typeof refusal !== "object" || refusal === null || !("kind" in refusal) || refusal.kind !== "dirty-workspace") {
-        return refusal;
-    }
-    const submodules = "submodules" in refusal && Array.isArray(refusal.submodules) ? refusal.submodules : [];
-    return { ...refusal, option: { flag: "--include-dirty", available: submodules.length === 0 } };
-}
-async function invokeDeliver(parsed, seat, requireBranchesToBeUpToDate) {
-    const { acceptedDeliver } = await import("./accepted.js");
-    try {
-        const delivered = await seat.contract.deliver({
-            ...(seat.actor === undefined ? {} : { actor: seat.actor }),
-            ...(parsed.message === undefined ? {} : { message: parsed.message }),
-            requireBranchesToBeUpToDate,
-            includeDirty: parsed.includeDirty,
-            materializeConflict: parsed.materializeConflict,
-            hooks: seat.hooks,
-        });
-        if (!("facts" in delivered))
-            return delivered;
-        return acceptedDeliver(delivered, seat.id);
-    }
-    catch (error) {
-        const { KeiyakuRefused, KeiyakuRetry } = await import("../library/keiyaku.js");
-        if (error instanceof KeiyakuRefused) {
-            return { kind: "refused", verb: "deliver", contract: seat.id, refusal: deliverRefusal(error.refusal) };
-        }
-        if (error instanceof KeiyakuRetry) {
-            return { kind: "retry", verb: "deliver", contract: seat.id, detail: error.reason };
-        }
-        throw error;
-    }
-}
-async function invokeReview(parsed, seat, readStdin) {
-    const summary = parsed.summaryFromStdin === true ? await readStdin() : parsed.summary;
-    const { acceptedReview, resultFromMutationCall } = await import("./accepted.js");
-    return resultFromMutationCall("review", () => seat.contract.review({
-        verdict: parsed.verdict,
-        ...(seat.actor === undefined ? {} : { actor: seat.actor }),
-        ...(summary === undefined ? {} : { summary }),
-        hooks: seat.hooks,
-    }), (result) => acceptedReview(result, seat.id), { coordinate: seat.id });
-}
-async function invokeAudit(parsed, seat, requireBranchesToBeUpToDate) {
-    const { acceptedAudit, resultFromMutationCall } = await import("./accepted.js");
-    return resultFromMutationCall("audit", () => seat.contract.audit({
-        ...(seat.actor === undefined ? {} : { actor: seat.actor }),
-        includeDirty: parsed.includeDirty,
-        showDiff: parsed.showDiff,
-        requireBranchesToBeUpToDate,
-        hooks: seat.hooks,
-    }), (result) => acceptedAudit(result, seat.id), { coordinate: seat.id });
-}
-async function existingSeat({ parsed, repo, edge, scope, hooks, }) {
-    const { id, contract } = await selectContract(repo, parsed.contract, scope);
-    const actor = actorFromEdge(parsed.actor, edge.environment);
-    return { contract, id, ...(actor === undefined ? {} : { actor }), hooks };
-}
-async function invokeExisting(input) {
-    const { parsed, repo, edge, configuration, hooks } = input;
-    const seat = await existingSeat(input);
-    const { id, contract, actor } = seat;
-    switch (parsed.command) {
-        case "amend": {
-            const markdown = parsed.stdin === true ? await edge.readStdin() : undefined;
-            const gates = parsed.gates === undefined ? undefined : await selectedGates(configuration, parsed.gates);
-            const { amendFromCommand } = await import("./commands/amend.js");
-            const { acceptedAmend, resultFromMutationCall } = await import("./accepted.js");
-            return resultFromMutationCall("amend", () => amendFromCommand({
-                command: parsed,
-                repo,
-                contract,
-                ...(markdown === undefined ? {} : { markdown }),
-                gates,
-                ...(actor === undefined ? {} : { actor }),
-                hooks,
-            }), (result) => acceptedAmend(result, id), { coordinate: id });
-        }
-        case "deliver":
-            return invokeDeliver(parsed, seat, await selectedGitPolicy(configuration));
-        case "review":
-            return invokeReview(parsed, seat, edge.readStdin);
-        case "arc": {
-            const markdown = await edge.readStdin();
-            const { acceptedArc, resultFromMutationCall } = await import("./accepted.js");
-            return resultFromMutationCall("arc", () => contract.arc({
-                markdown,
-                ...(actor === undefined ? {} : { actor }),
-                hooks,
-            }), (result) => acceptedArc(result, id), { coordinate: id });
-        }
-        case "abandon": {
-            const { acceptedAbandon, resultFromMutationCall } = await import("./accepted.js");
-            return resultFromMutationCall("abandon", () => contract.abandon({
-                ...(actor === undefined ? {} : { actor }),
-                ...(parsed.note === undefined ? {} : { note: parsed.note }),
-                hooks,
-            }), (result) => acceptedAbandon(result, id), { coordinate: id });
-        }
-        case "audit":
-            return invokeAudit(parsed, seat, await selectedGitPolicy(configuration));
-        default:
-            return parsed;
-    }
-}
 async function invokeAkumaFromEdge(parsed, input) {
     try {
         const { statedCwd, repo, edge } = input;
@@ -433,6 +270,18 @@ async function invokeContractHistory(repo, contract) {
         throw error;
     }
 }
+async function invokeForwardedContractMutation(parsed, repo, edge, scope, establishWorld) {
+    const { EMPTY_WORKTREE_HOOKS } = await import("../library/configuration.js");
+    return invokeContractMutation({
+        parsed,
+        repo,
+        edge,
+        scope,
+        hooks: EMPTY_WORKTREE_HOOKS,
+        establishWorld,
+        forwarded: true,
+    });
+}
 async function resolveInvocationCoordinates(invocation, runtime) {
     const environment = runtime.environment ?? process.env, gitPath = gitPathFromEdge(environment);
     const { resolveCliCoordinates } = await import("./coordinates.js");
@@ -493,11 +342,7 @@ async function invokeParsed(invocation, runtime) {
     const scope = cwd;
     if ((parsed.command === "deliver" || parsed.command === "review") &&
         (await import("../akuma/requests.js")).injectedBodyRequests() !== null) {
-        const { EMPTY_WORKTREE_HOOKS } = await import("../library/configuration.js");
-        const seat = await existingSeat({ parsed, repo, edge, scope, hooks: EMPTY_WORKTREE_HOOKS });
-        return parsed.command === "deliver"
-            ? await invokeDeliver(parsed, seat, false)
-            : await invokeReview(parsed, seat, edge.readStdin);
+        return invokeForwardedContractMutation(parsed, repo, edge, scope, establishWorld);
     }
     const configuration = await settingsAt(world ?? undefined, home);
     const { worktreeHooksFrom, SettingsError } = await import("../library/configuration.js");
@@ -506,27 +351,22 @@ async function invokeParsed(invocation, runtime) {
         const selected = await selectContract(repo, parsed.contract, scope);
         return { kind: "guidance", contract: selected.id, guidance: await selected.contract.guidance() };
     }
-    switch (parsed.command) {
-        case "reconcile": {
-            if (parsed.contract === undefined) {
-                return {
-                    kind: "observation",
-                    command: "reconcile",
-                    report: await repo.reconcile({ hooks, retryHooks: parsed.retryHooks }),
-                };
-            }
-            const { contract } = await selectContract(repo, parsed.contract, scope);
+    if (parsed.command === "reconcile") {
+        if (parsed.contract === undefined) {
             return {
                 kind: "observation",
                 command: "reconcile",
-                ...(await contract.reconcile({ hooks, retryHooks: parsed.retryHooks })),
+                report: await repo.reconcile({ hooks, retryHooks: parsed.retryHooks }),
             };
         }
-        case "bind":
-            return invokeBind({ parsed, repo, edge, configuration, hooks, establishWorld });
-        default:
-            return invokeExisting({ parsed, repo, edge, scope, configuration, hooks });
+        const { contract } = await selectContract(repo, parsed.contract, scope);
+        return {
+            kind: "observation",
+            command: "reconcile",
+            ...(await contract.reconcile({ hooks, retryHooks: parsed.retryHooks })),
+        };
     }
+    return invokeContractMutation({ parsed, repo, edge, scope, configuration, hooks, establishWorld });
 }
 function withResolvedTaskActor(command, runtime) {
     if (command.command !== "task" || (command.action !== "add" && command.action !== "compose"))

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

@@ -3,9 +3,9 @@ import { type AkumaAction, type ParsedAkumaCommand } from "./commands/akuma.js";
 import { type ParsedInstallCommand } from "./commands/install.js";
 import { type ContractCommand as Command, type ParsedAbandon, type ParsedAmend, type ParsedArc, type ParsedAudit, type ParsedBind, type ParsedDeliver, type ParsedLs, type ParsedNuke, type ParsedReconcile, type ParsedRegion, type ParsedReview, type ParsedSettings, type ParsedShow, type ParsedStatus } from "./commands/contract.js";
 export { CliUsageError } from "./usage.js";
+export { renderContractHelp } from "./commands/contract.js";
 export type { Command };
 export declare function renderRootHelp(): string;
-export declare function renderContractHelp(command: Command): string;
 export declare function renderCommandUsage(command: ParsedCommand): string;
 export declare function renderHelp(coordinate: CliHelpCoordinate): string;
 export type ParsedCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedStatus | ParsedShow | ParsedLs | ParsedAudit | ParsedReconcile | ParsedNuke | ParsedSettings | ParsedRegion | ParsedInstallCommand | ParsedAkumaCommand | ParsedTaskCommand;

package/build/src/cli/parse.js

@@ -1,9 +1,10 @@
 import { isTaskAction, parseTaskCommand, renderTaskHelp, renderTaskUsage, } from "./commands/task.js";
-import { isAkumaAction, parseAkumaCatalogPath, parseAkumaCommand, renderAkumaHelp, renderAkumaRootRows, renderAkumaUsage, } from "./commands/akuma.js";
+import { isAkumaAction, parseAkumaCommand, renderAkumaHelp, renderAkumaRootRows, renderAkumaUsage, } from "./commands/akuma.js";
 import { INSTALL_USAGE, parseInstallCommand, renderInstallHelp, } from "./commands/install.js";
-import { CONTRACT_COMMAND_SPECS, } from "./commands/contract.js";
-import { CliUsageError, isBlankInput, usageLine } from "./usage.js";
+import { CONTRACT_COMMAND_SPECS, parseContractCommand, renderContractHelp as renderContractHelpForOwner, renderContractUsage, } from "./commands/contract.js";
+import { CliUsageError, isBlankInput } from "./usage.js";
 export { CliUsageError } from "./usage.js";
+export { renderContractHelp } from "./commands/contract.js";
 const ROOT_USAGE = "usage: keiyaku [-C <path>] [--repo <path>] <command> [<contract>|@<contract>] [--flag ...] [-]";
 export function renderRootHelp() {
     return [
@@ -22,13 +23,8 @@ export function renderRootHelp() {
         ...renderAkumaRootRows(),
     ].join("\n");
 }
-export function renderContractHelp(command) {
-    const spec = CONTRACT_COMMAND_SPECS[command];
-    const help = `${spec.purpose}\n\n${usageLine(spec.usage)}`;
-    return spec.details === undefined ? help : `${help}\n\n${spec.details}`;
-}
 function contractUsage(command) {
-    return usageLine(CONTRACT_COMMAND_SPECS[command].usage);
+    return renderContractUsage(command);
 }
 export function renderCommandUsage(command) {
     if (command.command === "install")
@@ -44,7 +40,7 @@ export function renderHelp(coordinate) {
         case "root":
             return renderRootHelp();
         case "contract":
-            return renderContractHelp(coordinate.command);
+            return renderContractHelpForOwner(coordinate.command);
         case "task":
             return renderTaskHelp(coordinate.action);
         case "install":
@@ -103,10 +99,6 @@ export function assertExplicitRepoUse(command, repo) {
     if (repo !== undefined && !commandRepoPolicy(command).acceptsExplicit)
         refuseUnusedRepo(command);
 }
-function optionalFlag(flags, name) {
-    const value = flags[name];
-    return typeof value === "string" ? value : undefined;
-}
 function refuse(command, message) {
     throw new CliUsageError(message, contractUsage(command));
 }
@@ -179,147 +171,9 @@ function scanArgv(argv) {
         refuse(command, `${command} requires stdin`);
     }
     const output = state.flags.json === true ? "json" : "text";
-    const actor = optionalFlag(state.flags, "actor");
+    const actor = typeof state.flags.actor === "string" ? state.flags.actor : undefined;
     return { command, ...state, output, ...(actor === undefined ? {} : { actor }) };
 }
-function parseBind(parts) {
-    const forkOf = optionalFlag(parts.flags, "fork-of");
-    if (forkOf !== undefined) {
-        if (parts.stdin)
-            refuse("bind", "fork bind reads no stdin");
-        for (const option of ["task", "after", "gates"]) {
-            if (parts.flags[option] !== undefined)
-                refuse("bind", `--${option} is not valid with --fork-of`);
-        }
-        const target = optionalFlag(parts.flags, "target");
-        return {
-            command: "bind",
-            forkOf,
-            ...(target === undefined ? {} : { target }),
-            ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-            output: parts.output,
-        };
-    }
-    if (!parts.stdin)
-        refuse("bind", "bind requires stdin");
-    const task = optionalFlag(parts.flags, "task");
-    const target = optionalFlag(parts.flags, "target");
-    const after = parts.flags.after === undefined ? [] : Array.isArray(parts.flags.after) ? parts.flags.after : [parts.flags.after];
-    const gates = parseGateBundleNames(parts, "bind");
-    return {
-        command: "bind",
-        ...(task === undefined ? {} : { task }),
-        ...(target === undefined ? {} : { target }),
-        ...(parts.flags.after === undefined ? {} : { after }),
-        ...(gates === undefined ? {} : { gates }),
-        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-        output: parts.output,
-    };
-}
-function parseAmend(parts) {
-    const contract = parts.positionals[0];
-    const after = parts.flags.after === undefined ? [] : Array.isArray(parts.flags.after) ? parts.flags.after : [parts.flags.after];
-    if (parts.flags["clear-after"] === true && after.length > 0)
-        refuse("amend", "--clear-after and --after are mutually exclusive");
-    const gates = parseGateBundleNames(parts, "amend");
-    if (!parts.stdin && parts.flags.after === undefined && parts.flags["clear-after"] !== true && gates === undefined) {
-        refuse("amend", "amend requires stdin or --after, --clear-after, or --gates");
-    }
-    return {
-        command: "amend",
-        ...(contract === undefined ? {} : { contract }),
-        ...(parts.flags.after === undefined ? {} : { after }),
-        ...(parts.flags["clear-after"] === true ? { clearAfter: true } : {}),
-        ...(gates === undefined ? {} : { gates }),
-        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-        ...(parts.stdin ? { stdin: true } : {}),
-        output: parts.output,
-    };
-}
-function parseGateBundleNames(parts, command) {
-    const value = optionalFlag(parts.flags, "gates");
-    if (value === undefined)
-        return undefined;
-    const names = value.split(",");
-    if (names.some((name) => name.length === 0)) {
-        refuse(command, "--gates requires nonempty comma-separated names");
-    }
-    return names;
-}
-function parseDeliver(parts) {
-    const contract = parts.positionals[0];
-    const message = optionalFlag(parts.flags, "message");
-    return {
-        command: "deliver",
-        ...(contract === undefined ? {} : { contract }),
-        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-        ...(message === undefined ? {} : { message }),
-        includeDirty: parts.flags["include-dirty"] === true,
-        materializeConflict: parts.flags["materialize-conflict"] === true,
-        output: parts.output,
-    };
-}
-function parseReview(parts) {
-    if (Number(parts.flags.satisfied === true) + Number(parts.flags.unsatisfied === true) !== 1) {
-        refuse("review", "review requires exactly one verdict flag");
-    }
-    const summary = optionalFlag(parts.flags, "summary");
-    if (parts.stdin === (summary !== undefined)) {
-        refuse("review", "review requires exactly one of --summary <text> or stdin '-'");
-    }
-    const contract = parts.positionals[0];
-    return {
-        command: "review",
-        ...(contract === undefined ? {} : { contract }),
-        verdict: parts.flags.satisfied === true ? "satisfied" : "unsatisfied",
-        ...(summary === undefined ? {} : { summary }),
-        ...(parts.stdin ? { summaryFromStdin: true } : {}),
-        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-        output: parts.output,
-    };
-}
-function parseStatus(parts) {
-    const contract = parts.positionals[0];
-    if (contract?.startsWith("aku/") === true) {
-        return { command: "status", contract, akuma: true, output: parts.output };
-    }
-    return {
-        command: "status",
-        ...(contract === undefined ? {} : { contract }),
-        output: parts.output,
-    };
-}
-function parseRegion(parts) {
-    const contract = parts.positionals[0];
-    const pathFlag = parts.flags.path;
-    const paths = pathFlag === undefined ? undefined : Array.isArray(pathFlag) ? pathFlag : [pathFlag];
-    if (paths !== undefined && contract !== undefined)
-        refuse("region", "--path cannot combine with a contract");
-    return {
-        command: "region",
-        ...(contract === undefined ? {} : { contract }),
-        ...(paths === undefined ? {} : { paths: paths }),
-        output: parts.output,
-    };
-}
-function parseLs(parts) {
-    const path = parts.positionals[0];
-    if (path === "task" || path === "task/")
-        return { command: "ls", query: { kind: "tasks" }, output: parts.output };
-    if (path === "kei" || path === "kei/")
-        return { command: "ls", query: { kind: "contracts" }, output: parts.output };
-    try {
-        const query = parseAkumaCatalogPath(path);
-        if (query === null)
-            refuse("ls", "ls requires a supported identity directory selector");
-        return { command: "ls", query, output: parts.output };
-    }
-    catch (error) {
-        if (error instanceof CliUsageError)
-            throw error;
-        refuse("ls", error instanceof Error ? error.message : "invalid ls directory");
-    }
-}
 function invocationOptions(argv) {
     let cwd;
     let repo;
@@ -371,74 +225,6 @@ function helpCoordinate(argv) {
     }
     return { kind: "root" };
 }
-function parseCommand(parts) {
-    switch (parts.command) {
-        case "bind":
-            return parseBind(parts);
-        case "amend":
-            return parseAmend(parts);
-        case "deliver":
-            return parseDeliver(parts);
-        case "review":
-            return parseReview(parts);
-        case "arc": {
-            const contract = parts.positionals[0];
-            return {
-                command: "arc",
-                ...(contract === undefined ? {} : { contract }),
-                ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-                output: parts.output,
-            };
-        }
-        case "abandon": {
-            const contract = parts.positionals[0];
-            const note = optionalFlag(parts.flags, "note");
-            return {
-                command: "abandon",
-                ...(contract === undefined ? {} : { contract }),
-                ...(note === undefined ? {} : { note }),
-                ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-                output: parts.output,
-            };
-        }
-        case "status":
-            return parseStatus(parts);
-        case "show": {
-            const contract = parts.positionals[0];
-            return { command: "show", ...(contract === undefined ? {} : { contract }), output: parts.output };
-        }
-        case "ls":
-            return parseLs(parts);
-        case "audit": {
-            const contract = parts.positionals[0];
-            return {
-                command: "audit",
-                ...(contract === undefined ? {} : { contract }),
-                includeDirty: parts.flags["include-dirty"] === true,
-                showDiff: parts.flags.diff === true,
-                ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-                output: parts.output,
-            };
-        }
-        case "reconcile": {
-            const contract = parts.positionals[0];
-            return {
-                command: "reconcile",
-                ...(contract === undefined ? {} : { contract }),
-                retryHooks: parts.flags["retry-hooks"] === true,
-                output: parts.output,
-            };
-        }
-        case "nuke": {
-            const confirm = optionalFlag(parts.flags, "confirm");
-            return { command: "nuke", ...(confirm === undefined ? {} : { confirm }), output: parts.output };
-        }
-        case "settings":
-            return { command: "settings", output: parts.output };
-        case "region":
-            return parseRegion(parts);
-    }
-}
 export function parseArgv(argv) {
     const invocation = invocationOptions(argv);
     const help = helpCoordinate(invocation.commandArgv);
@@ -455,6 +241,6 @@ export function parseArgv(argv) {
     return {
         ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
         ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
-        command: task ?? akuma ?? install ?? parseCommand(scanArgv(invocation.commandArgv)),
+        command: task ?? akuma ?? install ?? parseContractCommand(scanArgv(invocation.commandArgv)),
     };
 }

package/build/src/cli/render/akuma-activity.d.ts

@@ -0,0 +1,38 @@
+import type { AkumaObservation, AkumaObservationStage, CreatedTaskObservation, DispatchAssociation } from "../../index.js";
+import type { AkumaInvocationResult } from "../commands/akuma-invoke.js";
+import type { ParsedCommand } from "../parse.js";
+import { type TextRenderContext } from "./terminal.js";
+export declare const DEFAULT_CONTEXT: TextRenderContext;
+export declare function associatedIdentity(id: string, alias?: string, contract?: DispatchAssociation): string;
+export declare function snapshotHeading(id: string, alias: string | undefined, contract: DispatchAssociation | undefined): readonly string[];
+type SnapshotView = Readonly<{
+    status: AkumaObservation["status"];
+    contract: DispatchAssociation;
+    createdTasks?: CreatedTaskObservation;
+}>;
+type SnapshotCoreOptions = Readonly<{
+    alias?: string;
+    facts?: readonly string[];
+}>;
+export declare function snapshotText(view: SnapshotView, context: TextRenderContext, options?: SnapshotCoreOptions): string;
+export declare function mutationObservationStageText(id: string, observation: AkumaObservationStage, context: TextRenderContext, options?: SnapshotCoreOptions & Readonly<{
+    showLife?: boolean;
+}>): string;
+export declare function statusAnswer(view: Readonly<{
+    status: AkumaObservation["status"];
+}>): string | undefined;
+export declare function akumaRawAnswer(result: AkumaInvocationResult): string | undefined;
+export declare function waitText(result: Extract<AkumaInvocationResult, {
+    action: "wait";
+}>, context: TextRenderContext): string;
+export declare function historyText(command: Extract<ParsedCommand, {
+    command: "history";
+    last: boolean;
+}>, result: Extract<AkumaInvocationResult, {
+    action: "history";
+}>, context: TextRenderContext): string;
+export declare function tellText(result: Extract<AkumaInvocationResult, {
+    action: "tell";
+    mode: "ordinary";
+}>, context: TextRenderContext): string;
+export {};