@astrosheep/keiyaku 4.1.1 → 4.1.3

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 {};

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

@@ -1,3 +1,15 @@
+import { archetypeName } from "../../akuma/identity.js";
+import { CliUsageError, usageLine } from "../usage.js";
+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]) };
+}
 export const CONTRACT_COMMAND_SPECS = {
     bind: {
         positional: "none",
@@ -128,3 +140,220 @@ export const CONTRACT_COMMAND_SPECS = {
         purpose: "Read active declared Contract Regions.",
     },
 };
+function optionalFlag(flags, name) {
+    const value = flags[name];
+    return typeof value === "string" ? value : undefined;
+}
+function refuse(command, message) {
+    throw new CliUsageError(message, renderContractUsage(command));
+}
+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 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 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");
+    }
+}
+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}`;
+}
+export function renderContractUsage(command) {
+    return usageLine(CONTRACT_COMMAND_SPECS[command].usage);
+}
+export function parseContractCommand(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);
+    }
+}