@astrosheep/keiyaku 4.1.0 → 4.1.2

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

@@ -1,8 +1,6 @@
 import { contractFromInput } from "../selectors.js";
-export function amendFromCommand({ command, repo, contract, markdown, gates, actor, hooks }) {
-    const after = command.clearAfter === true
-        ? []
-        : command.after?.map((id) => contractFromInput(repo, id).id);
+export function amendFromCommand({ command, repo, contract, markdown, gates, actor, hooks, }) {
+    const after = command.clearAfter === true ? [] : command.after?.map((id) => contractFromInput(repo, id).id);
     return contract.amend({
         ...(markdown === undefined ? {} : { markdown }),
         ...(actor === undefined ? {} : { actor }),

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

@@ -1,12 +1,12 @@
 import { type ActorId, type BindResult, type Gate, type Repo, type WorktreeHooks } from "../../index.js";
-import type { ParsedBind } from "../parse.js";
+import type { ParsedBind } from "./contract.js";
 type BindCommandInput = Readonly<{
     command: ParsedBind;
     repo: Repo;
-    markdown: string;
-    gates: readonly Gate[];
+    markdown?: string;
+    gates?: readonly Gate[];
     actor?: ActorId;
     hooks?: WorktreeHooks;
 }>;
-export declare function bindFromCommand({ command, repo, markdown, gates, actor, hooks }: BindCommandInput): Promise<BindResult>;
+export declare function bindFromCommand({ command, repo, markdown, gates, actor, hooks, }: BindCommandInput): Promise<BindResult>;
 export {};

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

@@ -1,14 +1,24 @@
-import { Keiyaku } from "../../index.js";
+import { Keiyaku, } from "../../index.js";
+import { bindFromCli } from "../../library/contract.js";
 import { contractFromInput } from "../selectors.js";
-export async function bindFromCommand({ command, repo, markdown, gates, actor, hooks }) {
+export async function bindFromCommand({ command, repo, markdown, gates, actor, hooks, }) {
+    if (command.forkOf !== undefined) {
+        return Keiyaku.bind({
+            repo,
+            forkOf: contractFromInput(repo, command.forkOf).id,
+            ...(command.target === undefined ? {} : { target: command.target }),
+            ...(actor === undefined ? {} : { actor }),
+            ...(hooks === undefined ? {} : { hooks }),
+        });
+    }
     const after = command.after?.map((id) => contractFromInput(repo, id).id);
-    const target = command.target ?? await repo.currentBranch();
-    return Keiyaku.bind({
+    if (markdown === undefined || gates === undefined)
+        throw new Error("Markdown bind command is missing stdin terms");
+    return bindFromCli({
         repo,
         markdown,
         ...(command.task === undefined ? {} : { task: command.task }),
-        ...(target === null ? {} : { target }),
-        ...(command.workspace === undefined ? {} : { workspace: command.workspace }),
+        ...(command.target === undefined ? {} : { target: command.target }),
         ...(actor === undefined ? {} : { actor }),
         ...(hooks === undefined ? {} : { hooks }),
         ...(after === undefined ? {} : { after }),

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

@@ -1,3 +1,4 @@
+import type { CatalogQuery } from "../../library/catalog.js";
 export type ContractFlagKind = "boolean" | "value" | "raw-value" | "repeat-value";
 export type ContractCommandSpec = Readonly<{
     positional: "none" | "optional";
@@ -5,23 +6,109 @@ export type ContractCommandSpec = Readonly<{
     flags: Readonly<Record<string, ContractFlagKind>>;
     usage: string;
     purpose: string;
-    help?: string;
+    details?: string;
+}>;
+type Output = Readonly<{
+    output: "text" | "json";
+}>;
+type Actor = Readonly<{
+    actor?: string;
+}>;
+export type ParsedBind = Output & Actor & Readonly<{
+    command: "bind";
+    forkOf?: string;
+    task?: string;
+    target?: string;
+    after?: readonly string[];
+    gates?: readonly string[];
+}>;
+export type ParsedAmend = Output & Actor & Readonly<{
+    command: "amend";
+    contract?: string;
+    after?: readonly string[];
+    clearAfter?: true;
+    gates?: readonly string[];
+    stdin?: true;
+}>;
+export type ParsedDeliver = Output & Actor & Readonly<{
+    command: "deliver";
+    contract?: string;
+    message?: string;
+    includeDirty: boolean;
+    materializeConflict: boolean;
+}>;
+export type ParsedReview = Output & Actor & Readonly<{
+    command: "review";
+    contract?: string;
+    verdict: "satisfied" | "unsatisfied";
+    summary?: string;
+    summaryFromStdin?: true;
+}>;
+export type ParsedArc = Output & Actor & Readonly<{
+    command: "arc";
+    contract?: string;
+}>;
+export type ParsedAbandon = Output & Actor & Readonly<{
+    command: "abandon";
+    contract?: string;
+    note?: string;
+}>;
+export type ParsedStatus = Output & (Readonly<{
+    command: "status";
+    contract?: string;
+    akuma?: never;
+}> | Readonly<{
+    command: "status";
+    contract: string;
+    akuma: true;
+}>);
+export type ParsedLs = Output & Readonly<{
+    command: "ls";
+    query: CatalogQuery;
+}>;
+export type ParsedAudit = Output & Readonly<{
+    command: "audit";
+    contract?: string;
+    includeDirty: boolean;
+    showDiff: boolean;
+    actor?: string;
+}>;
+export type ParsedReconcile = Output & Readonly<{
+    command: "reconcile";
+    contract?: string;
+    retryHooks: boolean;
+}>;
+export type ParsedNuke = Output & Readonly<{
+    command: "nuke";
+    confirm?: string;
+}>;
+export type ParsedSettings = Output & Readonly<{
+    command: "settings";
+}>;
+export type ParsedRegion = Output & Readonly<{
+    command: "region";
+    contract?: string;
+    paths?: readonly [string, ...string[]];
+}>;
+export type ParsedShow = Output & Readonly<{
+    command: "show";
+    contract?: string;
 }>;
 export declare const CONTRACT_COMMAND_SPECS: {
     readonly bind: {
         readonly positional: "none";
-        readonly stdin: "required";
+        readonly stdin: "optional";
         readonly flags: {
             readonly actor: "value";
             readonly task: "value";
             readonly target: "value";
-            readonly here: "boolean";
             readonly after: "repeat-value";
             readonly gates: "raw-value";
+            readonly "fork-of": "value";
             readonly json: "boolean";
         };
-        readonly usage: "bind [--task <task/...>] [--target <ref>] [--here] [--after <kei/...> ...] [--gates <name,...>] [--actor <actor>] -";
-        readonly purpose: "Create one Contract from stdin Markdown.";
+        readonly usage: "bind [--task <task/...>] [--target <ref>] [--after <kei/...> ...] [--gates <name,...>] [--actor <actor>] - | bind --fork-of <kei/...> [--target <ref>] [--actor <actor>]";
+        readonly purpose: "Create one Contract from stdin Markdown or a sibling fork.";
     };
     readonly amend: {
         readonly positional: "optional";
@@ -35,7 +122,7 @@ export declare const CONTRACT_COMMAND_SPECS: {
         };
         readonly usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name,...>] [--actor <actor>] [-]";
         readonly purpose: "Amend one Contract's document operations or structured terms.";
-        readonly help: string;
+        readonly details: string;
     };
     readonly deliver: {
         readonly positional: "optional";
@@ -49,7 +136,7 @@ export declare const CONTRACT_COMMAND_SPECS: {
         };
         readonly usage: "deliver [<contract>|@<contract>] [--message <text>] [--include-dirty] [--materialize-conflict] [--actor <actor>]";
         readonly purpose: "Deliver one Contract candidate from the appointed worktree.";
-        readonly help: string;
+        readonly details: string;
     };
     readonly review: {
         readonly positional: "optional";
@@ -157,12 +244,24 @@ export declare const CONTRACT_COMMAND_SPECS: {
         readonly positional: "optional";
         readonly stdin: "none";
         readonly flags: {
-            readonly overlap: "boolean";
-            readonly path: "value";
+            readonly path: "repeat-value";
             readonly json: "boolean";
         };
-        readonly usage: "region [<contract>] [--overlap]\n       region --path <repo-relative-path>";
+        readonly usage: "region [<contract>]\n       region --path <pattern> [--path <pattern> ...]";
         readonly purpose: "Read active declared Contract Regions.";
     };
 };
 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 {};