@astrosheep/keiyaku 4.1.0 → 4.1.2

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() {
@@ -11,6 +12,9 @@ async function readStdin() {
 function selectedStdinDiagnostic(command) {
     switch (command.command) {
         case "bind":
+            if (command.forkOf !== undefined)
+                return undefined;
+            return `${command.command} requires a nonblank stdin document`;
         case "arc":
             return `${command.command} requires a nonblank stdin document`;
         case "amend":
@@ -22,12 +26,18 @@ function selectedStdinDiagnostic(command) {
             return command.prompt.kind === "stdin" ? `${command.command} requires a nonblank prompt` : undefined;
         case "task":
             switch (command.stdin) {
-                case "document": return "task add requires a nonblank stdin document";
-                case "compose": return "task compose requires a nonblank stdin document";
-                case "body": return "task update --body requires a nonblank value";
-                case "append": return "task update --append requires a nonblank value";
-                case "note": return "task update --note requires a nonblank value";
-                default: return undefined;
+                case "document":
+                    return "task add requires a nonblank stdin document";
+                case "compose":
+                    return "task compose requires a nonblank stdin document";
+                case "body":
+                    return "task update --body requires a nonblank value";
+                case "append":
+                    return "task update --append requires a nonblank value";
+                case "note":
+                    return "task update --note requires a nonblank value";
+                default:
+                    return undefined;
             }
         default:
             return undefined;
@@ -56,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 {
@@ -90,156 +92,12 @@ 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 }) {
-    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 { path, statedCwd, repo, home, configuration, edge } = input;
+        const { statedCwd, repo, edge } = input;
+        const path = await akumaWorldFor(parsed, input.located, input.candidate, input.establish);
+        const home = parsed.command === "call" ? input.home : undefined;
+        const configuration = parsed.command === "call" ? await settingsAt(path, home) : undefined;
         if (parsed.command === "call" && parsed.contract !== undefined && repo === undefined) {
             throw new Error("call with Contract requires a resolved Repo");
         }
@@ -252,7 +110,7 @@ async function invokeAkumaFromEdge(parsed, input) {
             ...(statedCwd === undefined ? {} : { statedCwd }),
             ...(home === undefined ? {} : { home }),
             ...(configuration === undefined ? {} : { settings: configuration }),
-            ...(contract === undefined ? repo === undefined ? {} : { repo } : { contract }),
+            ...(contract === undefined ? (repo === undefined ? {} : { repo }) : { contract }),
             readStdin: edge.readStdin,
         });
     }
@@ -266,7 +124,7 @@ async function invokeAkumaFromEdge(parsed, input) {
     }
 }
 async function akumaWorldFor(parsed, located, candidate, establish) {
-    const world = parsed.command === "call" ? candidate ?? await establish() : located;
+    const world = parsed.command === "call" ? (candidate ?? (await establish())) : located;
     if (world === null)
         throw new CliUsageError("no Keiyaku world contains the invocation cwd");
     return world;
@@ -323,7 +181,13 @@ async function invokeStatus(parsed, world, repo) {
                     throw new CliUsageError("no Keiyaku world contains the invocation cwd");
                 return (await import("./commands/akuma-invoke.js")).invokeAkumaStatus(world, address.id, parsed.contract, repo);
             }
-            return { kind: "status", report: selectKanshi({ report: observation.report, contract: address.id }), selection: "contract" };
+            if (repo === undefined)
+                throw new CliUsageError("cannot select a contract while the Contract world is absent");
+            return {
+                kind: "status",
+                report: await kanshi({ world, repo, contract: address.id }),
+                selection: "contract",
+            };
         }
         catch (error) {
             if (error instanceof TypeError)
@@ -359,24 +223,34 @@ async function invokeRegion(parsed, world, repo) {
             throw error;
         }
     };
+    if (parsed.paths !== undefined) {
+        const report = await read({ kind: "path", patterns: parsed.paths });
+        return { kind: "region", region: report.region ?? { kind: "absent" } };
+    }
     if (parsed.contract === undefined) {
-        const selection = parsed.path !== undefined
-            ? { kind: "path", path: parsed.path }
-            : parsed.overlap ? { kind: "overlap" } : { kind: "declarations" };
-        const report = await read(selection);
+        const report = await read({ kind: "declarations" });
         return { kind: "region", region: report.region ?? { kind: "absent" } };
     }
     const report = await read({ kind: "declarations" });
     const { resolveKanshiContract } = await import("./selectors.js");
     const contract = resolveKanshiContract(report, parsed.contract);
-    if (report.contracts.kind !== "present" || report.contracts.value.rows.every((row) => row.id !== contract || row.disposition !== "active")) {
+    if (report.contracts.kind !== "present" ||
+        report.contracts.value.rows.every((row) => row.id !== contract || row.disposition !== "active")) {
         throw new CliUsageError(`unknown contract selector: ${parsed.contract}`);
     }
     if (report.region?.kind !== "present" || report.region.value.kind !== "declarations") {
         return { kind: "region", region: report.region ?? { kind: "absent" } };
     }
-    const selection = parsed.overlap ? { kind: "overlap", contract } : { kind: "contract", contract };
-    return { kind: "region", region: { kind: "present", value: selectRegion({ declarations: report.region.value.declarations, selection }) } };
+    return {
+        kind: "region",
+        region: {
+            kind: "present",
+            value: selectRegion({
+                declarations: report.region.value.declarations,
+                selection: { kind: "contract", contract },
+            }),
+        },
+    };
 }
 async function invokeContractHistory(repo, contract) {
     if (repo === undefined)
@@ -396,34 +270,45 @@ async function invokeContractHistory(repo, contract) {
         throw error;
     }
 }
-// eslint-disable-next-line complexity -- command dispatch keeps the CLI's existing boundary in one place.
-async function invokeParsed(invocation, runtime) {
-    const environment = runtime.environment ?? process.env;
-    const gitPath = gitPathFromEdge(environment);
+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");
-    const coordinates = await resolveCliCoordinates({
+    return resolveCliCoordinates({
         ...(runtime.cwd === undefined ? {} : { processCwd: runtime.cwd }),
         ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
         ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
         ...(gitPath === undefined ? {} : { gitPath }),
         command: invocation.command,
     });
+}
+// eslint-disable-next-line complexity -- command dispatch keeps the CLI's existing boundary in one place.
+async function invokeParsed(invocation, runtime) {
+    const environment = runtime.environment ?? process.env;
+    const coordinates = await resolveInvocationCoordinates(invocation, runtime);
     const { cwd, cwdSource, repo, world, candidateWorld, establishWorld, taskContext } = coordinates;
-    const edge = {
-        environment: runtime.environment ?? process.env,
-        readStdin: runtime.readStdin ?? readStdin,
-    };
+    const edge = { environment, readStdin: runtime.readStdin ?? readStdin };
     const parsed = invocation.command;
     const mapped = edge.environment.KEIYAKU_HOME?.trim();
     const home = mapped === undefined || mapped.length === 0 ? undefined : mapped;
-    if (parsed.command === "settings") {
+    if (parsed.command === "settings")
         return { kind: "settings", value: await settingsAt(world ?? undefined, home) };
-    }
-    if (parsed.command === "nuke") {
+    if (parsed.command === "nuke")
         return await (await import("./commands/nuke.js")).invokeNuke(parsed, world);
-    }
     if (parsed.command === "task") {
-        const actor = runtime.actor ?? actorFromEdge(typeof parsed.flags.actor === "string" ? parsed.flags.actor : undefined, edge.environment);
+        const actor = runtime.actor ??
+            actorFromEdge(typeof parsed.flags.actor === "string" ? parsed.flags.actor : undefined, edge.environment);
         return await (await import("./commands/task-invoke.js")).invokeTaskFromEdge({
             parsed,
             world,
@@ -436,14 +321,13 @@ async function invokeParsed(invocation, runtime) {
     if (parsed.command === "history" && "contract" in parsed)
         return await invokeContractHistory(repo, parsed.contract);
     if (isParsedAkumaCommand(parsed)) {
-        const akumaWorld = await akumaWorldFor(parsed, world, candidateWorld, coordinates.establishWorld);
-        const configuration = parsed.command === "call" ? await settingsAt(akumaWorld, home) : undefined;
         return await invokeAkumaFromEdge(parsed, {
-            path: akumaWorld,
+            located: world,
+            candidate: candidateWorld,
+            establish: coordinates.establishWorld,
             ...(cwdSource === "input" ? { statedCwd: cwd } : {}),
             ...(repo === undefined ? {} : { repo }),
-            ...(parsed.command === "call" && home !== undefined ? { home } : {}),
-            ...(configuration === undefined ? {} : { configuration }),
+            ...(home === undefined ? {} : { home }),
             edge,
         });
     }
@@ -456,12 +340,9 @@ async function invokeParsed(invocation, runtime) {
     if (parsed.command === "region")
         return invokeRegion(parsed, world, repo);
     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);
+    if ((parsed.command === "deliver" || parsed.command === "review") &&
+        (await import("../akuma/requests.js")).injectedBodyRequests() !== null) {
+        return invokeForwardedContractMutation(parsed, repo, edge, scope, establishWorld);
     }
     const configuration = await settingsAt(world ?? undefined, home);
     const { worktreeHooksFrom, SettingsError } = await import("../library/configuration.js");
@@ -470,19 +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", ...await repo.reconcile({ hooks, retryHooks: parsed.retryHooks }) };
-            }
-            const { contract } = await selectContract(repo, parsed.contract, scope);
-            return { kind: "observation", command: "reconcile", ...await contract.reconcile({ hooks, retryHooks: parsed.retryHooks }) };
+    if (parsed.command === "reconcile") {
+        if (parsed.contract === undefined) {
+            return {
+                kind: "observation",
+                command: "reconcile",
+                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/main.js

@@ -3,13 +3,15 @@ export async function main(argv = process.argv.slice(2)) {
     try {
         const parsed = parseArgv(argv);
         if ("help" in parsed) {
-            process.stdout.write(`${renderHelp(parsed.help)}\n`);
+            const help = renderHelp(parsed.help);
+            process.stdout.write(help.endsWith("\n") ? help : `${help}\n`);
             return 0;
         }
         return await (await import("./runtime.js")).runCliCommand(parsed);
     }
     catch (error) {
-        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        const diagnostic = error instanceof Error ? error.message : String(error);
+        process.stderr.write(diagnostic.endsWith("\n") ? diagnostic : `${diagnostic}\n`);
         return error instanceof CliUsageError ? 1 : 3;
     }
 }

package/build/src/cli/parse.d.ts

@@ -1,101 +1,14 @@
 import { type ParsedTaskCommand, type TaskAction } from "./commands/task.js";
 import { type AkumaAction, type ParsedAkumaCommand } from "./commands/akuma.js";
-import type { CatalogQuery } from "../library/catalog.js";
 import { type ParsedInstallCommand } from "./commands/install.js";
-import { type ContractCommand as Command } from "./commands/contract.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;
-type Output = Readonly<{
-    output: "text" | "json";
-}>;
-type Actor = Readonly<{
-    actor?: string;
-}>;
-export type ParsedBind = Output & Actor & Readonly<{
-    command: "bind";
-    task?: string;
-    target?: string;
-    workspace?: "here";
-    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;
-}>;
-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;
-}>;
-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;
-    overlap: boolean;
-    path?: string;
-}>;
-export type ParsedCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedStatus | (Output & Readonly<{
-    command: "show";
-    contract?: string;
-}>) | ParsedLs | ParsedAudit | ParsedReconcile | ParsedNuke | ParsedSettings | ParsedRegion | ParsedInstallCommand | ParsedAkumaCommand | ParsedTaskCommand;
+export type ParsedCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedStatus | ParsedShow | ParsedLs | ParsedAudit | ParsedReconcile | ParsedNuke | ParsedSettings | ParsedRegion | ParsedInstallCommand | ParsedAkumaCommand | ParsedTaskCommand;
 export type CliHelpCoordinate = Readonly<{
     kind: "root";
 }> | Readonly<{