@astrosheep/keiyaku 4.5.28 → 4.6.1

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

@@ -1,402 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { squareAssignedParticipantName } from "@astrosheep/square";
-import { emitInitiatingPluginSignal } from "../../plugin/akuma-signals.js";
-import { observeAkumaStatus } from "../../akuma/akuma-observe.js";
-import { AuthorityCorruptionError, Keiyaku, } from "../../index.js";
-import { callObservationStream, waitObservationStream } from "../render/akuma-activity.js";
-import { callObservationHead, tellWaitProgressStream } from "../render/akuma.js";
-import { killAkuma, tellAkuma, tellWaitAkuma, waitAkuma } from "../../library/fleet.js";
-import { localExecutionContext } from "../../akuma/requests.js";
-import { Akuma, Schema } from "../../akuma/index.js";
-import { addressAkuma, resolveAkuma } from "../../library/address.js";
-import { executionChannel } from "../../akuma/requests.js";
-import { AkumaDecodeError } from "../../akuma/akuma-errors.js";
-import { requestForwardedFleetTellAnswer } from "../../akuma/fleet-request.js";
-/** The window a call observes for when the caller gives no `--wait` duration. */
-const CALL_TIMEOUT_MS = 300_000;
-function callSignalOption(signal) {
-    return signal === undefined ? {} : { signal };
-}
-function integrationFailure(error) {
-    return {
-        kind: error instanceof AuthorityCorruptionError ? "authority-corruption" : "infrastructure",
-        diagnostic: error instanceof Error ? error.message : String(error),
-    };
-}
-/** The display context the command result renders with, so live progress rows match the result. */
-function resultContext() {
-    const tty = process.stderr.isTTY === true;
-    return {
-        columns: tty && Number.isInteger(process.stderr.columns) ? process.stderr.columns : 80,
-        color: tty && process.env.NO_COLOR === undefined,
-    };
-}
-function writeProgress(body) {
-    process.stderr.write(body.endsWith("\n") ? body : `${body}\n`);
-}
-/**
- * The live half of an observe-mode call: the resolved birth opens one identity
- * frame (never the detached receipt's cwd row), each later observation prints
- * the settled rows that arrived since the previous one, and the return appends
- * one conclusion. The stream is append-only, so no final snapshot replays.
- */
-async function observeCallUntilComplete(command, input, born) {
-    const stream = callObservationStream(resultContext(), callObservationHead(born));
-    try {
-        const observed = await observeAkumaStatus(input.path, born.akuma, {
-            timeoutMs: command.timeoutMs ?? CALL_TIMEOUT_MS,
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-            observe: (observed) => {
-                const lines = stream.observe(observed);
-                if (lines.length > 0)
-                    writeProgress(lines.join("\n"));
-            },
-        });
-        const conclusion = stream.conclude({ kind: "observed", reason: observed.reason, status: observed.status });
-        if (conclusion.length > 0)
-            writeProgress(conclusion);
-        return { kind: "observed", reason: observed.reason, status: observed.status };
-    }
-    catch (error) {
-        if (input.signal?.aborted)
-            throw error;
-        const failure = integrationFailure(error);
-        const conclusion = stream.conclude({ kind: "failed", failure });
-        if (conclusion.length > 0)
-            writeProgress(conclusion);
-        return { kind: "failed", failure };
-    }
-}
-async function schemaFromFile(path) {
-    try {
-        const parsed = JSON.parse(await readFile(path, "utf8"));
-        return Schema.json(parsed, (value) => value);
-    }
-    catch (error) {
-        throw new Error(`cannot read JSON Schema file ${path}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-function inputAlias(selector) {
-    return selector.startsWith("@") ? selector : undefined;
-}
-async function promptBody(command, input) {
-    return command.prompt.kind === "stdin" ? await input.readStdin() : command.prompt.value;
-}
-/**
- * The live half of a local wait: each observation round opens every newly seen
- * Akuma with its identity frame, then prints only the rows that settled since
- * the previous round. The first sighting of an Akuma only establishes its
- * baseline, so an already settled Akuma prints no backlog rows. When the wait
- * ends, `conclude` prints its closing scoreboard on the same channel.
- */
-function waitObserver(stream, onSelected) {
-    return {
-        selected: (selected) => {
-            onSelected?.(selected);
-            stream.select(selected);
-        },
-        observe: (observed) => {
-            const lines = stream.observe(observed);
-            if (lines.length > 0)
-                writeProgress(lines.join("\n"));
-        },
-    };
-}
-async function invokeWait(command, input) {
-    const alias = command.akuma.length === 1 ? inputAlias(command.akuma[0]) : undefined;
-    const stream = command.output === "text" ? waitObservationStream(resultContext()) : undefined;
-    const startedAt = Date.now();
-    let selection;
-    const observer = stream === undefined
-        ? undefined
-        : waitObserver(stream, (selected) => {
-            selection = selected;
-        });
-    const result = await waitAkuma({
-        path: input.path,
-        akuma: command.akuma,
-        ...(input.repo === undefined ? {} : { repo: input.repo }),
-        ...(command.completion === undefined ? {} : { completion: command.completion }),
-        ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-    }, input.execution ?? localExecutionContext(), observer);
-    const frozen = {
-        startedAt,
-        ...(selection === undefined ? {} : { selection }),
-    };
-    if (stream !== undefined && stream.streamed()) {
-        const closing = stream.conclude(result);
-        if (closing.length > 0)
-            writeProgress(closing);
-        return {
-            kind: "akuma",
-            action: "wait",
-            result,
-            streamed: true,
-            ...(alias === undefined ? {} : { alias }),
-            ...frozen,
-        };
-    }
-    return {
-        kind: "akuma",
-        action: "wait",
-        result,
-        ...(alias === undefined ? {} : { alias }),
-        ...frozen,
-    };
-}
-async function inputInitiator(input) {
-    let initiator;
-    try {
-        initiator = squareAssignedParticipantName(input.environment);
-    }
-    catch { }
-    if (initiator === undefined)
-        return {};
-    try {
-        await emitInitiatingPluginSignal({
-            world: input.path,
-            ...(input.settings === undefined ? {} : { settings: input.settings }),
-            initiator,
-            reportDiagnostic: (message) => process.stderr.write(`${message}\n`),
-        });
-    }
-    catch (error) {
-        process.stderr.write(`! plugin initiation: ${error instanceof Error ? error.message : String(error)}\n`);
-    }
-    return { initiator };
-}
-function decodeWaitedTellSchema(result, schema) {
-    if (result.observation.reason !== "answered")
-        return result;
-    if (typeof result.observation.answer !== "string") {
-        throw new AkumaDecodeError("Answer is not valid JSON", String(result.observation.answer));
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(result.observation.answer);
-    }
-    catch (error) {
-        throw new AkumaDecodeError(error instanceof Error ? error.message : "Answer is not valid JSON", result.observation.answer);
-    }
-    try {
-        return { ...result, observation: { reason: "answered", answer: schema.decode(parsed) } };
-    }
-    catch (error) {
-        throw new AkumaDecodeError(error instanceof Error ? error.message : "Answer failed schema decode", result.observation.answer);
-    }
-}
-async function invokeWaitedTell(command, input, body) {
-    const schema = command.schema === undefined ? undefined : await schemaFromFile(command.schema);
-    const alias = inputAlias(command.akuma);
-    const progress = command.output === "text" ? tellWaitProgressStream(undefined, alias, resultContext()) : undefined;
-    const result = await tellWaitAkuma({
-        ...(await inputInitiator(input)),
-        path: input.path,
-        akuma: command.akuma,
-        body,
-        timeoutMs: command.timeoutMs,
-        ...(schema === undefined ? {} : { schema }),
-        ...(command.interrupt ? { interrupt: true } : {}),
-        ...(input.repo === undefined ? {} : { repo: input.repo }),
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-        ...(progress === undefined
-            ? {}
-            : {
-                observe: {
-                    admitted: (tell, id) => writeProgress(progress.admitted(tell, id).join("\n")),
-                    observe: (observation) => writeProgress(progress.observe(observation).join("\n")),
-                },
-            }),
-    }, input.execution ?? localExecutionContext());
-    const rendered = schema === undefined ? result : decodeWaitedTellSchema(result, schema);
-    if (progress !== undefined)
-        writeProgress(progress.conclude(rendered).join("\n"));
-    return {
-        kind: "akuma",
-        action: "tell",
-        mode: "wait",
-        result: rendered,
-        body,
-        ...(alias === undefined ? {} : { alias }),
-    };
-}
-async function invokeTell(command, input) {
-    const body = await promptBody(command, input);
-    if (command.timeoutMs !== undefined)
-        return await invokeWaitedTell(command, input, body);
-    if (command.schema !== undefined) {
-        const schema = await schemaFromFile(command.schema);
-        const channel = executionChannel(input.execution);
-        const values = {
-            path: input.path,
-            akuma: command.akuma,
-            ...(input.repo === undefined ? {} : { repo: input.repo }),
-        };
-        // A forwarded answer lets the parent Fleet prove the target, so it resolves
-        // coordinates here and never reads this process's own Heart files.
-        const addressed = channel.kind === "body-request" ? await resolveAkuma(values) : await addressAkuma(values);
-        const initiator = await inputInitiator(input);
-        const answer = channel.kind === "body-request"
-            ? await requestForwardedFleetTellAnswer({
-                directory: channel.directory,
-                target: addressed.id,
-                body,
-                schema,
-                interrupt: command.interrupt,
-                ...initiator,
-                ...(input.signal === undefined ? {} : { signal: input.signal }),
-            })
-            : await Akuma.select(addressed.path, addressed.id).tell(body, {
-                schema,
-                ...initiator,
-                ...(command.interrupt ? { interrupt: true } : {}),
-                ...(input.signal === undefined ? {} : { signal: input.signal }),
-            });
-        const alias = inputAlias(command.akuma);
-        return {
-            kind: "akuma",
-            action: "tell",
-            mode: "schema",
-            result: answer,
-            body,
-            ...(alias === undefined ? {} : { alias }),
-        };
-    }
-    const initiator = await inputInitiator(input);
-    if (command.interrupt) {
-        const result = await Keiyaku.interrupt({
-            ...initiator,
-            path: input.path,
-            akuma: command.akuma,
-            body,
-            ...(input.repo === undefined ? {} : { repo: input.repo }),
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-        });
-        const alias = inputAlias(command.akuma);
-        return {
-            kind: "akuma",
-            action: "tell",
-            mode: "interrupt",
-            result,
-            body,
-            ...(alias === undefined ? {} : { alias }),
-        };
-    }
-    const result = await tellAkuma({
-        ...initiator,
-        path: input.path,
-        akuma: command.akuma,
-        body,
-        ...(input.repo === undefined ? {} : { repo: input.repo }),
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-    }, input.execution ?? localExecutionContext());
-    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,
-        ...(input.repo === undefined ? {} : { repo: input.repo }),
-        ...(command.before === undefined ? {} : { before: command.before }),
-        ...(command.since === undefined ? {} : { since: command.since }),
-        ...(command.limit === undefined ? {} : { limit: command.limit }),
-        ...(command.id === undefined ? {} : { id: command.id }),
-        last: command.last,
-    });
-    return {
-        kind: "akuma",
-        action: "history",
-        akuma: result.id,
-        historyResult: result,
-        ...(inputAlias(command.akuma) === undefined ? {} : { alias: command.akuma }),
-        ...(command.id !== undefined
-            ? { mode: "exact" }
-            : 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,
-            ...(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 killAkuma({
-            path: input.path,
-            akuma: command.akuma,
-            ...(input.repo === undefined ? {} : { repo: input.repo }),
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-        }, input.execution ?? localExecutionContext()),
-        ...(alias === undefined ? {} : { alias }),
-    };
-}
-export async function invokeAkuma(command, input) {
-    switch (command.command) {
-        case "call": {
-            const body = await promptBody(command, input);
-            const schema = command.schema === undefined ? undefined : await schemaFromFile(command.schema);
-            const caller = input.execution === undefined ? Keiyaku : Keiyaku.withExecution({ execution: input.execution });
-            const request = {
-                ...(await inputInitiator(input)),
-                path: input.path,
-                archetype: command.archetype,
-                body,
-                ...(input.home === undefined ? {} : { home: input.home }),
-                ...(input.settings === undefined ? {} : { settings: input.settings }),
-                ...(input.executionCwd === undefined ? {} : { cwd: input.executionCwd }),
-                ...(input.contract === undefined ? {} : { contract: input.contract }),
-                ...(command.alias === undefined ? {} : { alias: command.alias }),
-                ...(command.allowed === undefined ? {} : { allowed: command.allowed }),
-                ...(schema === undefined ? {} : { schema }),
-                ...callSignalOption(input.signal),
-            };
-            const observing = schema === undefined && command.mode === "wait" && command.output === "text";
-            const born = await caller.call(observing
-                ? { ...request, mode: "detach" }
-                : {
-                    ...request,
-                    mode: command.mode,
-                    ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
-                });
-            const result = observing ? { ...born, observation: await observeCallUntilComplete(command, input, born) } : born;
-            if (schema !== undefined && command.mode === "wait" && result.schemaAnswer !== undefined) {
-                return { kind: "akuma", action: "call", result, world: input.path, schemaAnswer: result.schemaAnswer };
-            }
-            return { kind: "akuma", action: "call", result, world: input.path, ...(observing ? { streamed: true } : {}) };
-        }
-        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 async function invokeAkumaStatus(path, akuma, alias, repo) {
-    return {
-        kind: "akuma",
-        action: "status",
-        status: await Keiyaku.status({ path, akuma, ...(repo === undefined ? {} : { repo }) }),
-        ...(alias === undefined ? {} : { alias }),
-    };
-}

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

@@ -1,34 +0,0 @@
-import type { ExecutionEvent } from "../../library/execution.js";
-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";
-import type { ExecutionContext } from "../../akuma/requests.js";
-type ContractMutation = Extract<ParsedCommand, {
-    command: "bind" | "amend" | "deliver" | "review" | "arc" | "abandon" | "audit";
-}>;
-type InvocationEdge = Readonly<{
-    environment: NodeJS.ProcessEnv;
-    readStdin: () => Promise<string>;
-    signal?: AbortSignal;
-    progress?: (events: AsyncIterable<ExecutionEvent>) => Promise<void>;
-}>;
-export type ContractMutationInput = Readonly<{
-    parsed: ContractMutation;
-    repo: Repo;
-    edge: InvocationEdge;
-    scope: string;
-    configuration?: Settings;
-    hooks?: WorktreeHooks;
-    establishWorld: () => Promise<WorldRoot>;
-    execution: ExecutionContext;
-}>;
-export declare function admitMarkdownBindSyntax(input: Readonly<{
-    markdown: string;
-    processCwd?: string;
-    cwd?: string;
-}>): Promise<void>;
-export declare function invokeContractMutation(input: ContractMutationInput): Promise<InvocationResult>;
-export {};