@astrosheep/keiyaku 4.0.0 → 4.0.2

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

@@ -1,16 +1,22 @@
-import { type ContractId, type MutationResult } from "../index.js";
-import type { AcceptedResult, InvocationResult } from "./result.js";
+import { type AmendResult, type AuditReport, type BindResult, type ContractId, type Delivery, type MutationResult, type Review } from "../index.js";
+import type { AcceptedAbandonResult, AcceptedAmendResult, AcceptedArcResult, AcceptedAuditResult, AcceptedBindResult, AcceptedDeliverResult, AcceptedResult, AcceptedReviewResult, InvocationResult } from "./result.js";
 type MutationObservation = Pick<MutationResult<unknown>, "facts" | "head" | "effects" | "lags" | "settlement">;
-type ResultOptions = Readonly<{
+type MutationCallOptions = Readonly<{
     coordinate?: ContractId;
-    target?: string | null;
-    report?: import("../index.js").AuditReport;
-    obligations?: Pick<AcceptedResult, "verification" | "placement" | "leak">;
-    diff?: AcceptedResult["diff"];
+    projectRefusal?: (refusal: unknown) => unknown;
 }>;
-type MutationCallOptions<Result extends MutationObservation> = Readonly<{
-    coordinate?: ContractId;
-    project?: (result: Result) => ResultOptions | Promise<ResultOptions>;
-}>;
-export declare function resultFromMutationCall<Result extends MutationObservation & object>(verb: string, call: () => Promise<Result>, options?: MutationCallOptions<Result>): Promise<InvocationResult>;
+export declare function acceptedBind(result: BindResult, target: string | null): AcceptedBindResult;
+export declare function acceptedAmend(result: AmendResult, coordinate: ContractId): AcceptedAmendResult;
+export declare function acceptedDeliver(result: MutationResult<Delivery>, coordinate: ContractId): AcceptedDeliverResult;
+export declare function acceptedReview(result: MutationResult<Review>, coordinate: ContractId): AcceptedReviewResult;
+export declare function acceptedArc(result: MutationResult<void>, coordinate: ContractId): AcceptedArcResult;
+export declare function acceptedAbandon(result: MutationResult<void>, coordinate: ContractId): AcceptedAbandonResult;
+export declare function acceptedAudit(result: MutationResult<AuditReport>, coordinate: ContractId): AcceptedAuditResult;
+export declare function resultFromMutationCall<const Verb extends AcceptedResult["verb"], Result extends MutationObservation>(verb: Verb, call: () => Promise<Result>, project: (result: Result) => Extract<AcceptedResult, {
+    verb: NoInfer<Verb>;
+}>, options?: MutationCallOptions): Promise<Extract<AcceptedResult, {
+    verb: Verb;
+}> | Extract<InvocationResult, {
+    kind: "refused" | "retry";
+}>>;
 export {};

package/build/src/cli/accepted.js

@@ -1,47 +1,86 @@
 import { KeiyakuRefused, KeiyakuRetry, } from "../index.js";
-function hasOverlaps(value) {
-    return "overlaps" in value;
+function acceptedFacts(result) {
+    return result.facts.map((fact) => ({
+        contract: fact.contract,
+        entry: fact.entry,
+        kind: fact.kind,
+    }));
 }
-function hasOverlapFailure(value) {
-    return "overlapFailure" in value;
-}
-function hasDocumentDiff(value) {
-    return "documentDiff" in value && typeof value.documentDiff === "string";
-}
-function resultFromMutation(verb, result, options) {
-    const acceptedContract = options.coordinate ?? result.facts[0]?.contract;
-    if (acceptedContract === undefined)
+function acceptedEnvelope(result, coordinate) {
+    const contract = coordinate ?? result.facts[0]?.contract;
+    if (contract === undefined)
         throw new Error("accepted mutation is missing its contract identity");
+    const firstLag = result.lags[0];
     return {
         kind: "accepted",
-        verb,
-        contract: acceptedContract,
+        contract,
         head: result.head,
-        facts: result.facts.map((fact) => ({
-            contract: fact.contract,
-            entry: fact.entry,
-            kind: fact.kind,
-        })),
+        facts: acceptedFacts(result),
         effects: result.effects,
         settlement: result.settlement,
-        ...(options.target === undefined ? {} : { target: options.target }),
-        ...options.obligations,
-        ...(hasOverlaps(result) ? { overlaps: result.overlaps } : {}),
-        ...(hasOverlapFailure(result) ? { overlapFailure: result.overlapFailure } : {}),
-        ...(hasDocumentDiff(result) ? { diff: result.documentDiff } : {}),
-        ...(options.report === undefined ? {} : { report: options.report }),
-        ...(options.diff === undefined ? {} : { diff: options.diff }),
-        ...(result.lags.length === 0 ? {} : { lag: result.lags }),
+        ...(result.lags.length === 0 || firstLag === undefined ? {} : { lag: [firstLag, ...result.lags.slice(1)] }),
+    };
+}
+function acceptedRegion(result) {
+    if (result.overlapFailure !== undefined)
+        return { overlapFailure: result.overlapFailure };
+    return { overlaps: result.overlaps };
+}
+export function acceptedBind(result, target) {
+    return {
+        ...acceptedEnvelope(result, undefined),
+        verb: "bind",
+        target,
+        ...acceptedRegion(result),
+    };
+}
+export function acceptedAmend(result, coordinate) {
+    return {
+        ...acceptedEnvelope(result, coordinate),
+        verb: "amend",
+        diff: result.documentDiff,
+        ...acceptedRegion(result),
+    };
+}
+export function acceptedDeliver(result, coordinate) {
+    const value = result.value;
+    return {
+        ...acceptedEnvelope(result, coordinate),
+        verb: "deliver",
+        ...(value.verification === undefined ? {} : { verification: value.verification }),
+        ...(value.verificationReuse === undefined ? {} : { verificationReuse: value.verificationReuse }),
+        ...(value.placement === undefined ? {} : { placement: value.placement }),
+        ...(value.cleanup === undefined ? {} : { cleanup: value.cleanup }),
+        ...(value.leak === undefined ? {} : { leak: value.leak }),
+    };
+}
+export function acceptedReview(result, coordinate) {
+    const value = result.value;
+    return {
+        ...acceptedEnvelope(result, coordinate),
+        verb: "review",
+        ...(value.placement === undefined ? {} : { placement: value.placement }),
+        ...(value.workspace === undefined ? {} : { workspace: value.workspace }),
+    };
+}
+export function acceptedArc(result, coordinate) {
+    return { ...acceptedEnvelope(result, coordinate), verb: "arc" };
+}
+export function acceptedAbandon(result, coordinate) {
+    return { ...acceptedEnvelope(result, coordinate), verb: "abandon" };
+}
+export function acceptedAudit(result, coordinate) {
+    return {
+        ...acceptedEnvelope(result, coordinate),
+        verb: "audit",
+        report: result.value,
+        ...(result.cleanup === undefined ? {} : { cleanup: result.cleanup }),
+        ...(result.leak === undefined ? {} : { leak: result.leak }),
     };
 }
-export async function resultFromMutationCall(verb, call, options = {}) {
+export async function resultFromMutationCall(verb, call, project, options = {}) {
     try {
-        const result = await call();
-        const projected = options.project === undefined ? {} : await options.project(result);
-        return resultFromMutation(verb, result, {
-            ...projected,
-            ...(options.coordinate === undefined ? {} : { coordinate: options.coordinate }),
-        });
+        return project(await call());
     }
     catch (error) {
         if (error instanceof KeiyakuRefused) {
@@ -49,7 +88,7 @@ export async function resultFromMutationCall(verb, call, options = {}) {
                 kind: "refused",
                 verb,
                 ...(options.coordinate === undefined ? {} : { contract: options.coordinate }),
-                refusal: error.refusal,
+                refusal: options.projectRefusal === undefined ? error.refusal : options.projectRefusal(error.refusal),
             };
         }
         if (error instanceof KeiyakuRetry) {

package/build/src/cli/actor.js

@@ -1,4 +1,4 @@
-const PROJECTION_ID_ENV = "KEIYAKU_PROJECTION_ID";
+const ACTOR_ID_ENV = "KEIYAKU_ACTOR_ID";
 /** Resolve optional caller testimony from the current CLI edge vocabulary. */
 export function resolveActor(input = {}) {
     if (input.actor !== undefined) {
@@ -6,6 +6,6 @@ export function resolveActor(input = {}) {
             throw new TypeError("actor must be a nonblank string");
         return input.actor;
     }
-    const projectionId = input.env?.[PROJECTION_ID_ENV];
-    return projectionId !== undefined && projectionId.trim().length > 0 ? projectionId : undefined;
+    const actorId = input.env?.[ACTOR_ID_ENV];
+    return actorId !== undefined && actorId.trim().length > 0 ? actorId : undefined;
 }

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

@@ -1,53 +1,78 @@
-import { type AkuId, type AkumaStatus, type InterruptReceipt, type KillEvidence, type TellReceipt } from "../../akuma/index.js";
-import type { ActivityHistory } from "../../akuma/index.js";
-import { type CallResult, type ForkResult, type Keiyaku as KeiyakuContract, type Repo } from "../../index.js";
+import { type AkuId, type ActivityHistory } from "../../akuma/index.js";
+import { Keiyaku, type AkumaKillResult, type AkumaHistoryResult, type AkumaStatusView, type AkumaTellResult, type AkumaWaitResult, type CallResult, type ForkResult, type Keiyaku as KeiyakuContract, type Repo } from "../../index.js";
 import type { Settings } from "../../settings.js";
+import type { WorldRoot } from "../../world.js";
 import type { ParsedAkumaCommand } from "./akuma.js";
 export type AkumaInvocationResult = Readonly<{
     kind: "akuma";
     action: "call";
     result: CallResult;
+    world: WorldRoot;
 }> | Readonly<{
     kind: "akuma";
     action: "status";
-    status: AkumaStatus;
+    status: AkumaStatusView;
+    alias?: string;
 }> | Readonly<{
     kind: "akuma";
     action: "wait";
-    status: AkumaStatus;
+    result: AkumaWaitResult;
+    alias?: string;
 }> | Readonly<{
     kind: "akuma";
     action: "tell";
+    mode: "ordinary";
+    result: AkumaTellResult;
+    body: string;
+    alias?: string;
+}> | Readonly<{
+    kind: "akuma";
+    action: "tell";
+    mode: "interrupt";
+    result: Awaited<ReturnType<typeof Keiyaku.interrupt>>;
+    body: string;
+    alias?: string;
+}> | Readonly<{
+    kind: "akuma";
+    action: "history";
     akuma: AkuId;
-    receipt: TellReceipt;
-    status: AkumaStatus;
+    mode: "page";
+    history: ActivityHistory;
+    historyResult: AkumaHistoryResult;
+    alias?: string;
 }> | Readonly<{
     kind: "akuma";
-    action: "interrupt";
+    action: "history";
     akuma: AkuId;
-    receipt: InterruptReceipt;
+    mode: "last";
+    answer: string;
+    historyResult: AkumaHistoryResult;
+    alias?: string;
 }> | Readonly<{
     kind: "akuma";
     action: "history";
     akuma: AkuId;
-    history: ActivityHistory;
-    answer?: string;
+    mode: "no-answer";
+    historyResult: AkumaHistoryResult;
+    alias?: string;
 }> | Readonly<{
     kind: "akuma";
     action: "fork";
-    akuma: AkuId;
     receipt: ForkResult;
 }> | Readonly<{
     kind: "akuma";
     action: "kill";
-    id: AkuId;
-    evidence: KillEvidence;
+    result: AkumaKillResult;
+    alias?: string;
 }>;
-export declare function invokeAkuma(command: ParsedAkumaCommand, input: Readonly<{
-    path: string;
+type InvokeInput = Readonly<{
+    path: WorldRoot;
+    executionCwd?: string;
     settings: Settings;
     contract?: KeiyakuContract;
     repo?: Repo;
-    readStdin(): string;
-}>): Promise<AkumaInvocationResult>;
-export declare function invokeAkumaStatus(path: string, id: string): AkumaInvocationResult;
+    readStdin(): Promise<string>;
+}>;
+export declare function invokeAkuma(command: ParsedAkumaCommand, input: InvokeInput): Promise<AkumaInvocationResult>;
+export declare function invokeAkumaStatus(path: WorldRoot, akuma: string, settings: Settings, alias?: string, repo?: Repo): Promise<AkumaInvocationResult>;
+export {};

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

@@ -1,68 +1,117 @@
-import { resolve } from "node:path";
-import { Akuma, } from "../../akuma/index.js";
-import { Keiyaku } from "../../index.js";
+import { Keiyaku, } from "../../index.js";
+function inputAlias(selector) {
+    return selector.startsWith("@") ? selector : undefined;
+}
+async function promptBody(command, input) {
+    return command.prompt.kind === "stdin" ? await input.readStdin() : command.prompt.value;
+}
+async function invokeWait(command, input) {
+    const alias = command.akuma.length === 1 ? inputAlias(command.akuma[0]) : undefined;
+    return {
+        kind: "akuma",
+        action: "wait",
+        result: await Keiyaku.wait({
+            path: input.path,
+            akuma: command.akuma,
+            settings: input.settings,
+            ...(input.repo === undefined ? {} : { repo: input.repo }),
+            ...(command.completion === undefined ? {} : { completion: command.completion }),
+            ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
+        }),
+        ...(alias === undefined ? {} : { alias }),
+    };
+}
+async function invokeTell(command, input) {
+    const body = await promptBody(command, input);
+    if (command.interrupt) {
+        const result = await Keiyaku.interrupt({ path: input.path, akuma: command.akuma, settings: input.settings, body, ...(input.repo === undefined ? {} : { repo: input.repo }) });
+        const alias = inputAlias(command.akuma);
+        return { kind: "akuma", action: "tell", mode: "interrupt", result, body, ...(alias === undefined ? {} : { alias }) };
+    }
+    const result = await Keiyaku.tell({ path: input.path, akuma: command.akuma, settings: input.settings, body, ...(input.repo === undefined ? {} : { repo: input.repo }) });
+    const alias = inputAlias(command.akuma);
+    return { kind: "akuma", action: "tell", mode: "ordinary", result, body, ...(alias === undefined ? {} : { alias }) };
+}
+async function invokeHistory(command, input) {
+    const result = await Keiyaku.history({
+        path: input.path,
+        akuma: command.akuma,
+        settings: input.settings,
+        ...(input.repo === undefined ? {} : { repo: input.repo }),
+        ...(command.before === undefined ? {} : { before: command.before }),
+        ...(command.since === undefined ? {} : { since: command.since }),
+        ...(command.limit === undefined ? {} : { limit: command.limit }),
+        last: command.last,
+    });
+    return {
+        kind: "akuma",
+        action: "history",
+        akuma: result.id,
+        historyResult: result,
+        ...(inputAlias(command.akuma) === undefined ? {} : { alias: command.akuma }),
+        ...(result.kind === "history"
+            ? { mode: "page", history: result.history }
+            : result.kind === "last"
+                ? { mode: "last", answer: result.answer }
+                : { mode: "no-answer" }),
+    };
+}
+async function invokeFork(command, input) {
+    return {
+        kind: "akuma",
+        action: "fork",
+        receipt: await Keiyaku.fork({
+            path: input.path,
+            akuma: command.akuma,
+            at: command.at,
+            settings: input.settings,
+            ...(input.repo === undefined ? {} : { repo: input.repo }),
+        }),
+    };
+}
+async function invokeKill(command, input) {
+    const alias = command.akuma.length === 1 ? inputAlias(command.akuma[0]) : undefined;
+    return {
+        kind: "akuma",
+        action: "kill",
+        result: await Keiyaku.kill({
+            path: input.path,
+            akuma: command.akuma,
+            settings: input.settings,
+            ...(input.repo === undefined ? {} : { repo: input.repo }),
+        }),
+        ...(alias === undefined ? {} : { alias }),
+    };
+}
 export async function invokeAkuma(command, input) {
-    const world = () => Akuma.at({ path: input.path, settings: input.settings });
     switch (command.command) {
         case "call": {
+            const body = await promptBody(command, input);
             const result = await Keiyaku.call({
                 path: input.path,
                 archetype: command.archetype,
-                body: input.readStdin(),
+                body,
                 settings: input.settings,
-                ...(command.workdir === undefined ? {} : { cwd: resolve(input.path, command.workdir) }),
+                ...(input.executionCwd === undefined ? {} : { cwd: input.executionCwd }),
                 mode: command.mode,
                 ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
                 ...(input.contract === undefined ? {} : { contract: input.contract }),
                 ...(command.alias === undefined ? {} : { alias: command.alias }),
             });
-            return { kind: "akuma", action: "call", result };
-        }
-        case "wait": return {
-            kind: "akuma",
-            action: "wait",
-            status: await world().of({ id: command.id }).wait(undefined, command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
-        };
-        case "tell": {
-            const handle = world().of({ id: command.id });
-            const receipt = await handle.tell(input.readStdin());
-            return { kind: "akuma", action: "tell", akuma: command.id, receipt, status: handle.status() };
-        }
-        case "interrupt": return {
-            kind: "akuma",
-            action: "interrupt",
-            akuma: command.id,
-            receipt: await world().of({ id: command.id }).interrupt(input.readStdin()),
-        };
-        case "history": {
-            const handle = world().of({ id: command.id });
-            const history = handle.history({
-                ...(command.before === undefined ? {} : { before: command.before }),
-                ...(command.since === undefined ? {} : { since: command.since }),
-            });
-            return {
-                kind: "akuma",
-                action: "history",
-                akuma: command.id,
-                history,
-                ...(command.last ? { answer: handle.lastAnswer() } : {}),
-            };
+            return { kind: "akuma", action: "call", result, world: input.path };
         }
-        case "fork": return {
-            kind: "akuma",
-            action: "fork",
-            akuma: command.id,
-            receipt: await Keiyaku.fork({
-                path: input.path,
-                akuma: command.id,
-                at: command.at,
-                settings: input.settings,
-                ...(input.repo === undefined ? {} : { repo: input.repo }),
-            }),
-        };
-        case "kill": return { kind: "akuma", action: "kill", id: command.id, evidence: await world().of({ id: command.id }).kill() };
+        case "wait": return await invokeWait(command, input);
+        case "tell": return await invokeTell(command, input);
+        case "history": return await invokeHistory(command, input);
+        case "fork": return await invokeFork(command, input);
+        case "kill": return await invokeKill(command, input);
     }
 }
-export function invokeAkumaStatus(path, id) {
-    return { kind: "akuma", action: "status", status: Akuma.at({ path }).of({ id }).status() };
+export async function invokeAkumaStatus(path, akuma, settings, alias, repo) {
+    return {
+        kind: "akuma",
+        action: "status",
+        status: await Keiyaku.status({ path, akuma, settings, ...(repo === undefined ? {} : { repo }) }),
+        ...(alias === undefined ? {} : { alias }),
+    };
 }

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

@@ -1,31 +1,43 @@
 import { type AkumaAlias } from "../../identity/selector.js";
-import { type AkuId } from "../../akuma/identity.js";
 type Output = Readonly<{
     output: "text" | "json";
 }>;
 type Addressed = Readonly<{
-    id: AkuId;
+    akuma: string;
 }>;
-export type ParsedAkumaCommand = Output & (Readonly<{
+export type AkumaPromptSource = Readonly<{
+    kind: "argument";
+    value: string;
+}> | Readonly<{
+    kind: "stdin";
+}>;
+type Prompted = Readonly<{
+    prompt: AkumaPromptSource;
+}>;
+export type ParsedAkumaCommand = Output & ((Readonly<{
     command: "call";
     archetype: string;
-    workdir?: string;
     contract?: string;
     alias?: AkumaAlias;
     mode: "wait" | "detach";
     timeoutMs?: number;
-}> | (Readonly<{
+}> & Prompted) | Readonly<{
     command: "kill";
-}> & Addressed) | (Readonly<{
+    akuma: readonly string[];
+}> | Readonly<{
     command: "wait";
+    akuma: readonly string[];
+    completion?: "any" | "all";
     timeoutMs?: number;
-}> & Addressed) | (Readonly<{
-    command: "tell" | "interrupt";
-}> & Addressed) | (Readonly<{
+}> | (Readonly<{
+    command: "tell";
+    interrupt: boolean;
+}> & Addressed & Prompted) | (Readonly<{
     command: "history";
     last: boolean;
     before?: number;
     since?: number;
+    limit?: number;
 }> & Addressed) | (Readonly<{
     command: "fork";
     at: string;
@@ -38,5 +50,11 @@ export declare function isParsedAkumaCommand(command: Readonly<{
 export declare function renderAkumaRootRows(): readonly string[];
 export declare function renderAkumaHelp(action: AkumaAction): string;
 export declare function renderAkumaUsage(action: AkumaAction): string;
+export declare function parseAkumaCatalogPath(value: string): Readonly<{
+    kind: "archetypes";
+} | {
+    kind: "akuma";
+    archetype?: string;
+}> | null;
 export declare function parseAkumaCommand(argv: readonly string[]): ParsedAkumaCommand;
 export {};