@astrosheep/keiyaku 4.1.1 → 4.1.2

package/build/src/akuma/request-serve.js

@@ -6,6 +6,7 @@ import { pathsForAkuId, worldRootForAkumaPaths } from "./identity.js";
 import { BIRTH_TIMEOUT_MS, publishAkuma } from "./publication.js";
 import { atomicJson, canonicalAkuId, decodeClaim, decodeRecipe, receiptPath, } from "./request-wire.js";
 import { isTaskMutationAction } from "../task/mutation.js";
+import { executeRequest } from "./request-execution.js";
 const POLL_MS = 100;
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
@@ -161,107 +162,6 @@ function failure(error) {
     }
     return { kind: "failed", diagnostic: diagnostic(error) };
 }
-async function execute(input, request) {
-    if (input.upstream === undefined)
-        throw new Error("upstream execution port is unavailable");
-    if (request.action === "akuma.wait") {
-        const result = await input.upstream.wait({
-            targets: request.targets,
-            completion: request.completion,
-            ...(request.timeoutMs === undefined ? {} : { timeoutMs: request.timeoutMs }),
-            signal: input.signal,
-        });
-        return { result, service: { action: request.action } };
-    }
-    if (request.action === "akuma.tell") {
-        const result = await input.upstream.tell({
-            target: request.target,
-            body: request.body,
-            tellId: request.id,
-            recordedAt: request.admittedAt,
-            signal: input.signal,
-        });
-        return {
-            result,
-            service: { action: request.action, target: request.target, tellId: request.id },
-        };
-    }
-    if (request.action === "akuma.kill") {
-        const served = await input.upstream.kill({
-            targets: request.targets,
-            signal: input.signal,
-        });
-        return {
-            result: served.result,
-            service: { action: request.action, results: served.service },
-        };
-    }
-    if (request.action === "contract.deliver") {
-        return await executeDeliver(input, request);
-    }
-    if (request.action === "contract.review") {
-        return await executeReview(input, request);
-    }
-    const task = request;
-    const result = await input.upstream.task({
-        world: task.world,
-        request: task.request,
-        requester: task.requester,
-        signal: input.signal,
-    });
-    return { result, service: { action: task.action } };
-}
-async function executeDeliver(input, request) {
-    if (input.upstream === undefined)
-        throw new Error("upstream execution port is unavailable");
-    const served = await input.upstream.deliver({
-        repoRoot: request.repoRoot,
-        contractId: request.contractId,
-        ...(request.message === undefined ? {} : { message: request.message }),
-        includeDirty: request.includeDirty,
-        materializeConflict: request.materializeConflict,
-        requester: request.requester,
-        signal: input.signal,
-    });
-    return {
-        result: served.result,
-        ...(served.deliveryFactId === undefined
-            ? {}
-            : {
-                service: {
-                    action: request.action,
-                    repoRoot: request.repoRoot,
-                    contractId: request.contractId,
-                    deliveryFactId: served.deliveryFactId,
-                },
-            }),
-    };
-}
-async function executeReview(input, request) {
-    if (input.upstream === undefined)
-        throw new Error("upstream execution port is unavailable");
-    const served = await input.upstream.review({
-        repoRoot: request.repoRoot,
-        contractId: request.contractId,
-        verdict: request.verdict,
-        ...(request.summary === undefined ? {} : { summary: request.summary }),
-        requester: request.requester,
-        signal: input.signal,
-    });
-    return {
-        result: served.result,
-        ...(served.reviewFactId === undefined
-            ? {}
-            : {
-                service: {
-                    action: request.action,
-                    repoRoot: request.repoRoot,
-                    contractId: request.contractId,
-                    reviewFactId: served.reviewFactId,
-                },
-            }),
-    };
-}
 function pendingService(request) {
     if (request.action === "akuma.wait")
         return { action: request.action };
@@ -303,7 +203,7 @@ async function serveUpstream(input) {
     let outcome;
     let service = pendingService(request);
     try {
-        const served = await execute(input, request);
+        const served = await executeRequest(input, request);
         outcome = { kind: "returned", result: served.result };
         if (served.service !== undefined)
             service = served.service;

package/build/src/akuma/{body-turn.d.ts → turn-drive.d.ts}

@@ -1,31 +1,8 @@
-import { type HeartSnapshot, type HeldAkumaLeash, type ResumeCoordinate, type Soul, type TellFact } from "./heart/index.js";
+import { type ResumeCoordinate, type Soul, type TellFact } from "./heart/index.js";
 import type { AkumaPaths } from "./identity.js";
 import { type ProviderAdapter, type TurnResult } from "./provider.js";
 import { type RequestChildLaunch, type UpstreamExecutionPort } from "./request-serve.js";
-export declare const CONTROL_RESPONSE_MS = 1000;
-export declare class BodySupervisor {
-    private readonly paths;
-    private readonly bodySequence;
-    private readonly leash;
-    readonly signal: AbortSignal;
-    private readonly controller;
-    private readonly finished;
-    private readonly observer;
-    private waiter;
-    private observation;
-    private stopping?;
-    private constructor();
-    static open(paths: AkumaPaths, bodySequence: number, leash: HeldAkumaLeash): Promise<BodySupervisor>;
-    get reason(): "control" | "heart-gone" | undefined;
-    current(): HeartSnapshot;
-    recordHung(diagnostic: string, at: string): Promise<void>;
-    refresh(): Promise<HeartSnapshot>;
-    next(after: HeartSnapshot): Promise<HeartSnapshot>;
-    cancel(reason: "control" | "heart-gone"): void;
-    close(): Promise<void>;
-    private publish;
-    private observe;
-}
+import { BodySupervisor } from "./body-supervisor.js";
 export declare function turnRecipe(paths: AkumaPaths, soul: Soul): Promise<Readonly<{
     cwd: string;
     options: Soul["options"];

package/build/src/akuma/{body-turn.js → turn-drive.js}

@@ -2,93 +2,7 @@ import { abortableDelay } from "./abort.js";
 import { appendActivity, beginTurn, breakBody, heartExists, readHeart, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
 import { encodeAgentEvent } from "./provider.js";
 import { BodyRequestPump } from "./request-serve.js";
-const BODY_CONTROL_OBSERVATION_MS = 100;
-export const CONTROL_RESPONSE_MS = 1_000;
-export class BodySupervisor {
-    paths;
-    bodySequence;
-    leash;
-    signal;
-    controller = new AbortController();
-    finished = new AbortController();
-    observer;
-    waiter;
-    observation;
-    stopping;
-    constructor(paths, bodySequence, leash, observation) {
-        this.paths = paths;
-        this.bodySequence = bodySequence;
-        this.leash = leash;
-        this.signal = this.controller.signal;
-        this.observation = observation;
-        this.observer = this.observe();
-    }
-    static async open(paths, bodySequence, leash) {
-        return new BodySupervisor(paths, bodySequence, leash, await readHeart(paths));
-    }
-    get reason() {
-        return this.stopping;
-    }
-    current() {
-        return this.observation;
-    }
-    async recordHung(diagnostic, at) {
-        await this.leash.recordBodyHung(this.paths, { sequence: this.bodySequence, diagnostic, at });
-    }
-    async refresh() {
-        this.publish(await readHeart(this.paths));
-        return this.observation;
-    }
-    next(after) {
-        if (this.observation !== after)
-            return Promise.resolve(this.observation);
-        return new Promise((resolve) => {
-            this.waiter = resolve;
-        });
-    }
-    cancel(reason) {
-        if (this.stopping !== undefined)
-            return;
-        this.stopping = reason;
-        this.controller.abort(new Error(reason === "control" ? "Akuma Body interrupted by durable control" : "Akuma Heart disappeared"));
-        this.waiter?.(this.observation);
-        this.waiter = undefined;
-    }
-    async close() {
-        this.finished.abort();
-        await this.observer;
-        this.waiter = undefined;
-    }
-    publish(snapshot) {
-        this.observation = snapshot;
-        this.waiter?.(snapshot);
-        this.waiter = undefined;
-    }
-    async observe() {
-        for (;;) {
-            const snapshot = this.observation;
-            if (!(await heartExists(this.paths)))
-                return this.cancel("heart-gone");
-            if (snapshot.stop?.bodySequence === this.bodySequence || snapshot.pause?.bodySequence === this.bodySequence) {
-                return this.cancel("control");
-            }
-            try {
-                await abortableDelay(BODY_CONTROL_OBSERVATION_MS, this.finished.signal);
-            }
-            catch {
-                return;
-            }
-            try {
-                await this.refresh();
-            }
-            catch (error) {
-                if (await heartExists(this.paths))
-                    throw error;
-                return this.cancel("heart-gone");
-            }
-        }
-    }
-}
+import { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
 function serializeEffects() {
     let tail = Promise.resolve();
     let failed = false;
@@ -132,11 +46,7 @@ async function failedTurnSetup(input, turnSequence, requests, cancelDrive, error
             throw error;
         return { kind: "stopped" };
     }
-    return {
-        kind: "failed",
-        turnSequence,
-        diagnostic: error instanceof Error ? error.message : String(error),
-    };
+    return { kind: "failed", turnSequence, diagnostic: error instanceof Error ? error.message : String(error) };
 }
 async function writeProviderEvent(input, active, event) {
     if (input.supervisor.signal.aborted)
@@ -151,11 +61,7 @@ async function writeProviderEvent(input, active, event) {
             admittedAt: at,
         });
     }
-    await appendActivity(input.paths, {
-        turnSequence: active.turnSequence,
-        event: encodeAgentEvent(event),
-        at,
-    });
+    await appendActivity(input.paths, { turnSequence: active.turnSequence, event: encodeAgentEvent(event), at });
 }
 async function startTurnDrive(input) {
     const { cwd, options, session } = await turnRecipe(input.paths, input.soul);
@@ -212,7 +118,7 @@ async function startTurnDrive(input) {
             }
             return { kind: "stopped" };
         }
-        if (input.launchTells.length > 0) {
+        if (input.launchTells.length > 0)
             await recordTellDeliveries(input.paths, input.launchTells.map((tell) => ({
                 tellId: tell.id,
                 route: "launch",
@@ -220,7 +126,6 @@ async function startTurnDrive(input) {
                 fence: selected.admission.fence,
                 deliveredAt: input.now(),
             })));
-        }
         void selected.completion.then(() => requests.stopAdmission());
         return {
             turnSequence: turn.sequence,

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

@@ -60,11 +60,5 @@ 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 {};

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

@@ -1,5 +1,5 @@
 import { CliUsageError, isBlankInput, usageLine } from "../usage.js";
-import { archetypeName, parseAkuId } from "../../akuma/identity.js";
+import { parseAkuId } from "../../akuma/identity.js";
 import { parseDuration as decodeDuration } from "../../duration.js";
 import { parseAkumaAlias, parseAkumaGlob } from "../../identity/selector.js";
 import { decodeAllowedActions } from "../../akuma/allowed.js";
@@ -84,16 +84,6 @@ export function renderAkumaHelp(action) {
 export function renderAkumaUsage(action) {
     return usageLine(AKUMA_COMMAND_SPECS[action].usage);
 }
-export function parseAkumaCatalogPath(value) {
-    if (value === "aku" || value === "aku/")
-        return { kind: "archetypes" };
-    if (value === "aku/*/*")
-        return { kind: "akuma" };
-    const match = /^aku\/([^/]+)\/?$/u.exec(value);
-    if (match === null)
-        return null;
-    return { kind: "akuma", archetype: archetypeName(match[1]) };
-}
 function stringFlag(value, diagnostic, fail) {
     if (typeof value !== "string")
         fail(diagnostic);

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

@@ -0,0 +1,25 @@
+import type { InvocationResult } from "../result.js";
+import type { ParsedCommand } from "../parse.js";
+import type { WorktreeHooks } from "../../library/configuration.js";
+import type { Repo } from "../../library/repo.js";
+import type { Settings } from "../../settings.js";
+import type { WorldRoot } from "../../world.js";
+type ContractMutation = Extract<ParsedCommand, {
+    command: "bind" | "amend" | "deliver" | "review" | "arc" | "abandon" | "audit";
+}>;
+type InvocationEdge = Readonly<{
+    environment: NodeJS.ProcessEnv;
+    readStdin: () => Promise<string>;
+}>;
+export type ContractMutationInput = Readonly<{
+    parsed: ContractMutation;
+    repo: Repo;
+    edge: InvocationEdge;
+    scope: string;
+    configuration?: Settings;
+    hooks: WorktreeHooks;
+    establishWorld: () => Promise<WorldRoot>;
+    forwarded?: true;
+}>;
+export declare function invokeContractMutation(input: ContractMutationInput): Promise<InvocationResult>;
+export {};

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

@@ -0,0 +1,193 @@
+import { resolveActor } from "../actor.js";
+import { CliUsageError } from "../usage.js";
+function actorFromEdge(actor, environment) {
+    try {
+        return resolveActor({ env: environment, ...(actor === undefined ? {} : { actor }) });
+    }
+    catch (error) {
+        throw new CliUsageError(error instanceof Error ? error.message : String(error));
+    }
+}
+function consumeSettings(run, ErrorType) {
+    try {
+        return run();
+    }
+    catch (error) {
+        if (error instanceof ErrorType)
+            throw new CliUsageError(error.message);
+        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);
+}
+async function selectContract(repo, selector, scope) {
+    const { contractFromInput, resolveContextualContract } = await import("../selectors.js");
+    if (selector !== undefined && !selector.startsWith("@"))
+        return contractFromInput(repo, selector);
+    const { Keiyaku } = await import("../../library/keiyaku.js");
+    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(input) {
+    const { parsed, repo, edge, configuration, hooks, establishWorld } = input;
+    if (parsed.command !== "bind")
+        throw new Error("bind invocation requires bind syntax");
+    const actor = actorFromEdge(parsed.actor, edge.environment);
+    const { bindFromCommand } = await import("./bind.js");
+    const { acceptedBind, resultFromMutationCall } = await import("../accepted.js");
+    if (parsed.forkOf !== undefined) {
+        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);
+        });
+    }
+    if (configuration === undefined)
+        throw new Error("bind invocation requires Settings");
+    const markdown = await edge.readStdin();
+    const gates = await selectedGates(configuration, parsed.gates);
+    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 existingSeat(input, parsed) {
+    const { repo, edge, scope, hooks } = input;
+    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 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 });
+}
+export async function invokeContractMutation(input) {
+    const { parsed, repo, edge, configuration, hooks, forwarded } = input;
+    if (parsed.command === "bind")
+        return invokeBind(input);
+    const seat = await existingSeat(input, parsed);
+    const { id, contract, actor } = seat;
+    switch (parsed.command) {
+        case "amend": {
+            if (configuration === undefined)
+                throw new Error("amend invocation requires Settings");
+            const markdown = parsed.stdin === true ? await edge.readStdin() : undefined;
+            const gates = parsed.gates === undefined ? undefined : await selectedGates(configuration, parsed.gates);
+            const { amendFromCommand } = await import("./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, forwarded === true ? false : 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": {
+            if (configuration === undefined)
+                throw new Error("audit invocation requires Settings");
+            const requireBranchesToBeUpToDate = await selectedGitPolicy(configuration);
+            const { acceptedAudit, resultFromMutationCall } = await import("../accepted.js");
+            return resultFromMutationCall("audit", () => contract.audit({
+                ...(actor === undefined ? {} : { actor }),
+                includeDirty: parsed.includeDirty,
+                showDiff: parsed.showDiff,
+                requireBranchesToBeUpToDate,
+                hooks,
+            }), (result) => acceptedAudit(result, id), { coordinate: id });
+        }
+    }
+}

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

@@ -252,4 +252,16 @@ export declare const CONTRACT_COMMAND_SPECS: {
     };
 };
 export type ContractCommand = keyof typeof CONTRACT_COMMAND_SPECS;
+export type ParsedContractParts = Readonly<{
+    command: ContractCommand;
+    flags: Readonly<Record<string, string | true | readonly string[]>>;
+    positionals: readonly string[];
+    stdin: boolean;
+    output: "text" | "json";
+    actor?: string;
+}>;
+export type ParsedContractCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedStatus | ParsedShow | ParsedLs | ParsedAudit | ParsedReconcile | ParsedNuke | ParsedSettings | ParsedRegion;
+export declare function renderContractHelp(command: ContractCommand): string;
+export declare function renderContractUsage(command: ContractCommand): string;
+export declare function parseContractCommand(parts: ParsedContractParts): ParsedContractCommand;
 export {};