@astrosheep/keiyaku 4.1.1 → 4.1.2

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);
+    }
+}

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;