@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/src/cli/invoke.js

@@ -0,0 +1,463 @@
+import { readFileSync, realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import { gatesFrom, Keiyaku, NoGitWorldError, Repo, requireBranchesToBeUpToDateFrom, settings, SettingsError, worktreeHooksFrom } from "../index.js";
+import { kanshi, selectKanshi } from "../kanshi/index.js";
+import { resolveActor } from "./actor.js";
+import { resultFromMutationCall } from "./accepted.js";
+import { amendFromCommand } from "./commands/amend.js";
+import { invokeAkuma, invokeAkumaStatus } from "./commands/akuma-invoke.js";
+import { isParsedAkumaCommand } from "./commands/akuma.js";
+import { bindFromCommand } from "./commands/bind.js";
+import { installHarnesses } from "./commands/install.js";
+import { invokeTask } from "./commands/task-invoke.js";
+import { CliUsageError, renderCommandUsage } from "./parse.js";
+import { contractFromInput, resolveContextualContract, resolveKanshiContract } from "./selectors.js";
+import { resolveNamedAddress } from "../library/address.js";
+import { World, WorldError } from "../world.js";
+function settingsAt(root, environment) {
+    const home = environment.KEIYAKU_HOME?.trim();
+    return settings({ ...(root === undefined ? {} : { root }), ...(home === undefined || home.length === 0 ? {} : { home }) });
+}
+function locateWorld(coordinate) {
+    try {
+        return World.locate(coordinate);
+    }
+    catch (error) {
+        if (error instanceof WorldError)
+            throw new CliUsageError(error.message);
+        throw error;
+    }
+}
+function canonicalInvocationCwd(input) {
+    try {
+        return realpathSync(input);
+    }
+    catch {
+        throw new CliUsageError(`invocation cwd is not an existing directory: ${input}`);
+    }
+}
+function establishWorld(coordinate, located) {
+    if (located !== null)
+        return located;
+    try {
+        return World.at(coordinate);
+    }
+    catch (error) {
+        if (error instanceof WorldError)
+            throw new CliUsageError(error.message);
+        throw error;
+    }
+}
+function selectedGates(value, name) {
+    try {
+        return gatesFrom({ settings: value, ...(name === undefined ? {} : { name }) });
+    }
+    catch (error) {
+        if (error instanceof SettingsError)
+            throw new CliUsageError(error.message);
+        throw error;
+    }
+}
+function selectedHooks(value) {
+    try {
+        return worktreeHooksFrom({ settings: value });
+    }
+    catch (error) {
+        if (error instanceof SettingsError)
+            throw new CliUsageError(error.message);
+        throw error;
+    }
+}
+function selectedGitPolicy(value) {
+    try {
+        return requireBranchesToBeUpToDateFrom({ settings: value });
+    }
+    catch (error) {
+        if (error instanceof SettingsError)
+            throw new CliUsageError(error.message);
+        throw error;
+    }
+}
+function actorFromEdge(actor, environment) {
+    let resolved;
+    try {
+        resolved = resolveActor({ env: environment, ...(actor === undefined ? {} : { actor }) });
+    }
+    catch (error) {
+        throw new CliUsageError(error instanceof Error ? error.message : String(error));
+    }
+    return resolved;
+}
+function repoAt(coordinate) {
+    return Repo.at({ path: coordinate });
+}
+function optionalRepoAt(coordinate) {
+    try {
+        return repoAt(coordinate);
+    }
+    catch (error) {
+        if (error instanceof NoGitWorldError)
+            return undefined;
+        throw error;
+    }
+}
+function repoUse(command) {
+    switch (command.command) {
+        case "bind":
+        case "amend":
+        case "deliver":
+        case "review":
+        case "arc":
+        case "abandon":
+        case "audit":
+        case "reconcile":
+        case "show":
+            return "required";
+        case "ls":
+            return command.query.kind === "contracts" ? "required" : "none";
+        case "status":
+        case "tell":
+        case "history":
+        case "fork":
+            return "optional";
+        case "wait":
+        case "kill":
+            return command.akuma.some((selector) => selector.startsWith("kei/")) ? "required" : "optional";
+        case "call":
+            return command.contract === undefined ? "none" : "required";
+        case "settings":
+        case "task":
+        case "install":
+            return "none";
+    }
+}
+function refuseUnusedRepo(command) {
+    if (command.command === "call")
+        throw new CliUsageError("--repo has no consumer without --contract");
+    throw new CliUsageError(`--repo has no consumer for ${command.command}`);
+}
+function repoFor(use, coordinate) {
+    switch (use) {
+        case "none": return undefined;
+        case "optional": return optionalRepoAt(coordinate);
+        case "required": return repoAt(coordinate);
+    }
+}
+async function selectContract(repo, selector, scope) {
+    if (selector !== undefined && !selector.startsWith("@"))
+        return contractFromInput(repo, selector);
+    const id = resolveContextualContract(await Keiyaku.list({ repo }), selector, scope);
+    return contractFromInput(repo, id);
+}
+async function invokeBind(parsed, repo, edge, configuration, hooks) {
+    const markdown = edge.readStdin();
+    const gates = selectedGates(configuration, parsed.gates);
+    const actor = actorFromEdge(parsed.actor, edge.environment);
+    return resultFromMutationCall("bind", () => bindFromCommand({
+        command: parsed,
+        repo,
+        markdown,
+        gates,
+        ...(actor === undefined ? {} : { actor }),
+        hooks,
+    }), {
+        project: (result) => {
+            const bound = result.facts.find((fact) => fact.kind === "bind");
+            if (bound === undefined || bound.kind !== "bind")
+                throw new Error("accepted bind is missing its bind fact");
+            return { target: bound.data.coordinates.target ?? null };
+        },
+    });
+}
+function unavailableDiff(delivery) {
+    return {
+        reason: "git-unavailable",
+        integrationSnapshot: delivery.integration.snapshot,
+        changeId: delivery.integration.changeId,
+    };
+}
+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) {
+    return resultFromMutationCall("deliver", () => seat.contract.deliver({
+        ...(seat.actor === undefined ? {} : { actor: seat.actor }),
+        ...(parsed.message === undefined ? {} : { message: parsed.message }),
+        requireBranchesToBeUpToDate,
+        includeDirty: parsed.includeDirty,
+        hooks: seat.hooks,
+    }), {
+        coordinate: seat.id,
+        projectRefusal: deliverRefusal,
+        project: (result) => ({
+            obligations: {
+                ...(result.value.verification === undefined ? {} : { verification: result.value.verification }),
+                ...(result.value.placement === undefined ? {} : { placement: result.value.placement }),
+                ...(result.value.cleanup === undefined ? {} : { cleanup: result.value.cleanup }),
+                ...(result.value.leak === undefined ? {} : { leak: result.value.leak }),
+            },
+        }),
+    });
+}
+async function invokeReview(parsed, seat, readStdin) {
+    const summary = parsed.summaryFromStdin === true ? readStdin() : parsed.summary;
+    return resultFromMutationCall("review", () => seat.contract.review({
+        verdict: parsed.verdict,
+        ...(seat.actor === undefined ? {} : { actor: seat.actor }),
+        ...(summary === undefined ? {} : { summary }),
+        hooks: seat.hooks,
+    }), {
+        coordinate: seat.id,
+        project: (result) => ({
+            obligations: result.value.placement === undefined ? {} : { placement: result.value.placement },
+            workspace: result.value.workspace,
+        }),
+    });
+}
+async function invokeAudit(parsed, seat) {
+    const delivery = parsed.showDiffBody ? await seat.contract.delivery() : null;
+    return resultFromMutationCall("audit", () => seat.contract.audit({ ...(seat.actor === undefined ? {} : { actor: seat.actor }), hooks: seat.hooks }), {
+        coordinate: seat.id,
+        project: async (result) => {
+            let renderedDiff;
+            if (parsed.showDiffBody && delivery !== null) {
+                const diff = await delivery.diff();
+                renderedDiff = diff === null ? unavailableDiff(delivery) : diff;
+            }
+            return {
+                report: result.value,
+                ...(renderedDiff === undefined ? {} : { diff: renderedDiff }),
+            };
+        },
+    });
+}
+async function invokeExisting({ parsed, repo, edge, scope, configuration, hooks }) {
+    const { id, contract } = await selectContract(repo, parsed.contract, scope);
+    const actor = actorFromEdge(parsed.actor, edge.environment);
+    const seat = { contract, id, ...(actor === undefined ? {} : { actor }), hooks };
+    switch (parsed.command) {
+        case "amend": {
+            const markdown = edge.readStdin();
+            const gates = parsed.gates === undefined
+                ? undefined
+                : selectedGates(configuration, parsed.gates);
+            return resultFromMutationCall("amend", () => amendFromCommand({ command: parsed, repo, contract, markdown, gates, ...(actor === undefined ? {} : { actor }), hooks }), { coordinate: id });
+        }
+        case "deliver":
+            return invokeDeliver(parsed, seat, selectedGitPolicy(configuration));
+        case "review":
+            return invokeReview(parsed, seat, edge.readStdin);
+        case "arc": {
+            const markdown = edge.readStdin();
+            return resultFromMutationCall("arc", () => contract.arc({
+                markdown,
+                ...(actor === undefined ? {} : { actor }),
+                hooks,
+            }), { coordinate: id });
+        }
+        case "abandon":
+            return resultFromMutationCall("abandon", () => contract.abandon({
+                ...(actor === undefined ? {} : { actor }),
+                ...(parsed.note === undefined ? {} : { note: parsed.note }),
+                hooks,
+            }), { coordinate: id });
+        case "audit":
+            return invokeAudit(parsed, seat);
+        default:
+            return parsed;
+    }
+}
+async function invokeAkumaCommand(parsed, input) {
+    const { path, executionCwd, repo, configuration, edge } = input;
+    if (parsed.command === "call" && parsed.contract !== undefined) {
+        if (repo === undefined)
+            throw new Error("call with Contract requires a resolved Repo");
+        const selected = contractFromInput(repo, parsed.contract);
+        return await invokeAkuma(parsed, {
+            path,
+            executionCwd,
+            settings: configuration,
+            contract: selected.contract,
+            readStdin: edge.readStdin,
+        });
+    }
+    return await invokeAkuma(parsed, {
+        path,
+        executionCwd,
+        settings: configuration,
+        ...(repo === undefined ? {} : { repo }),
+        readStdin: edge.readStdin,
+    });
+}
+async function invokeAkumaFromEdge(parsed, input) {
+    try {
+        return await invokeAkumaCommand(parsed, input);
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            throw new CliUsageError(error.message);
+        throw error;
+    }
+}
+function akumaWorldFor(parsed, cwd, located) {
+    const world = parsed.command === "call" ? establishWorld(cwd, located) : located;
+    if (world === null)
+        throw new CliUsageError("no Keiyaku world contains the invocation cwd");
+    return world;
+}
+async function invokeCatalog(parsed, world, repo, edge) {
+    try {
+        if (parsed.query.kind === "contracts") {
+            if (repo === undefined)
+                throw new Error("Contract catalog requires a resolved Repo");
+            return { kind: "catalog", catalog: await Keiyaku.ls({ query: parsed.query, repo }) };
+        }
+        if (parsed.query.kind === "archetypes") {
+            return {
+                kind: "catalog",
+                catalog: await Keiyaku.ls({ query: parsed.query, settings: settingsAt(undefined, edge.environment) }),
+            };
+        }
+        if (world === null)
+            throw new CliUsageError("no Keiyaku world contains the invocation cwd");
+        if (parsed.query.kind === "tasks") {
+            return { kind: "catalog", catalog: await Keiyaku.ls({ query: parsed.query, path: world }) };
+        }
+        return { kind: "catalog", catalog: await Keiyaku.ls({ query: parsed.query, path: world }) };
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            throw new CliUsageError(error.message);
+        throw error;
+    }
+}
+async function invokeStatus(parsed, world, repo, edge) {
+    const configuration = settingsAt(world ?? undefined, edge.environment);
+    if (parsed.akuma === true) {
+        if (world === null)
+            throw new CliUsageError("no Keiyaku world contains the invocation cwd");
+        return invokeAkumaStatus(world, parsed.contract, configuration, undefined, repo);
+    }
+    if (parsed.contract === undefined) {
+        const report = await kanshi({ world, ...(repo === undefined ? {} : { repo }) });
+        return { kind: "status", report, selection: "world" };
+    }
+    if (parsed.contract.startsWith("@")) {
+        try {
+            const address = resolveNamedAddress({
+                path: world,
+                selector: parsed.contract,
+                contracts: repo === undefined ? [] : (await Keiyaku.list({ repo })).rows,
+            });
+            if (address.kind === "akuma") {
+                if (world === null)
+                    throw new CliUsageError("no Keiyaku world contains the invocation cwd");
+                return invokeAkumaStatus(world, address.id, configuration, parsed.contract, repo);
+            }
+            const report = await kanshi({ world, ...(repo === undefined ? {} : { repo }) });
+            return { kind: "status", report: selectKanshi({ report, contract: address.id }), selection: "contract" };
+        }
+        catch (error) {
+            if (error instanceof TypeError)
+                throw new CliUsageError(error.message);
+            throw error;
+        }
+    }
+    const report = await kanshi({ world, ...(repo === undefined ? {} : { repo }) });
+    const contract = resolveKanshiContract(report, parsed.contract);
+    return { kind: "status", report: selectKanshi({ report, contract }), selection: "contract" };
+}
+async function invokeParsed(invocation, runtime, use) {
+    const processCwd = resolve(runtime.cwd ?? ".");
+    const cwd = canonicalInvocationCwd(resolve(processCwd, invocation.cwd ?? "."));
+    const edge = {
+        environment: runtime.environment ?? process.env,
+        readStdin: runtime.readStdin ?? (() => readFileSync(0, "utf8")),
+    };
+    const parsed = invocation.command;
+    const repoCoordinate = resolve(cwd, invocation.repo ?? ".");
+    const repo = repoFor(use, repoCoordinate);
+    const world = locateWorld(cwd);
+    if (parsed.command === "settings") {
+        return { kind: "settings", value: settingsAt(world ?? undefined, edge.environment) };
+    }
+    if (parsed.command === "task") {
+        try {
+            return await invokeTask(parsed, {
+                world,
+                establish: () => establishWorld(cwd, world),
+                readStdin: edge.readStdin,
+            });
+        }
+        catch (error) {
+            if (error instanceof TypeError)
+                throw new CliUsageError(error.message);
+            throw error;
+        }
+    }
+    if (isParsedAkumaCommand(parsed)) {
+        const akumaWorld = akumaWorldFor(parsed, cwd, world);
+        const configuration = settingsAt(akumaWorld, edge.environment);
+        return await invokeAkumaFromEdge(parsed, {
+            path: akumaWorld,
+            executionCwd: cwd,
+            ...(repo === undefined ? {} : { repo }),
+            configuration,
+            edge,
+        });
+    }
+    if (parsed.command === "ls")
+        return await invokeCatalog(parsed, world, repo, edge);
+    if (parsed.command === "status")
+        return await invokeStatus(parsed, world, repo, edge);
+    if (repo === undefined)
+        throw new Error(`${parsed.command} requires a resolved Repo`);
+    const scope = cwd;
+    const configuration = settingsAt(world ?? undefined, edge.environment);
+    const hooks = selectedHooks(configuration);
+    if (parsed.command === "show") {
+        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 }) };
+        }
+        case "bind":
+            return invokeBind(parsed, repo, edge, configuration, hooks);
+        default:
+            return invokeExisting({ parsed, repo, edge, scope, configuration, hooks });
+    }
+}
+async function invokeInstall(command, runtime) {
+    return installHarnesses(command.harnesses, runtime.environment ?? process.env);
+}
+export async function invoke(invocation, runtime = {}) {
+    try {
+        const command = invocation.command;
+        const use = repoUse(command);
+        if (invocation.repo !== undefined && use === "none")
+            refuseUnusedRepo(command);
+        if (command.command === "install")
+            return await invokeInstall(command, runtime);
+        return await invokeParsed({
+            ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
+            ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
+            command,
+        }, runtime, use);
+    }
+    catch (error) {
+        if (error instanceof CliUsageError && error.projection === undefined) {
+            throw new CliUsageError(error.diagnostic, renderCommandUsage(invocation.command));
+        }
+        throw error;
+    }
+}

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

@@ -0,0 +1 @@
+export declare function main(argv?: readonly string[]): Promise<number>;

package/build/src/cli/main.js

@@ -0,0 +1,98 @@
+import { CliUsageError, parseArgv, renderContractHelp, renderRootHelp, } from "./parse.js";
+import { renderText } from "./render/text.js";
+import { renderTaskIncompleteDiagnostic, renderTaskText, taskExitCode } from "./render/task.js";
+import { akumaExitCode, renderAkumaJson, renderAkumaText } from "./render/akuma.js";
+import { isParsedAkumaCommand, renderAkumaHelp } from "./commands/akuma.js";
+import { installExitCode, renderInstallHelp, renderInstallText } from "./commands/install.js";
+import { renderTaskHelp } from "./commands/task.js";
+import { renderSettingsText, settingsJsonValue } from "./render/settings.js";
+import { renderCatalogText } from "./render/catalog.js";
+function writeTask(command, result) {
+    if (command.output === "json")
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+    else if (command.action === "compose" && typeof result === "object" && result !== null && "kind" in result && result.kind === "incomplete") {
+        const diagnostic = renderTaskIncompleteDiagnostic(result);
+        if (diagnostic.length > 0)
+            process.stderr.write(`${diagnostic}\n`);
+        process.stdout.write(result.draft);
+    }
+    else
+        process.stdout.write(`${renderTaskText(command, result)}\n`);
+    return taskExitCode(result);
+}
+function writeAkuma(command, result) {
+    const output = command.output === "json" ? renderAkumaJson(command, result) : renderAkumaText(command, result, {
+        columns: process.stdout.isTTY === true && Number.isInteger(process.stdout.columns) ? process.stdout.columns : 80,
+        color: process.stdout.isTTY === true && process.env.NO_COLOR === undefined,
+    });
+    const rawLast = command.command === "history" && command.last && command.output === "text";
+    process.stdout.write(rawLast ? output : `${output}\n`);
+    return akumaExitCode(result);
+}
+function renderHelp(coordinate) {
+    switch (coordinate.kind) {
+        case "root": return renderRootHelp();
+        case "contract": return renderContractHelp(coordinate.command);
+        case "task": return renderTaskHelp(coordinate.action);
+        case "install": return renderInstallHelp();
+        case "akuma": return renderAkumaHelp(coordinate.action);
+    }
+}
+function writeGuidance(command, result) {
+    if (command.output === "json")
+        process.stdout.write(`${JSON.stringify({ contract: result.contract, guidance: result.guidance })}\n`);
+    else
+        process.stdout.write(result.guidance.endsWith("\n") ? result.guidance : `${result.guidance}\n`);
+    return 0;
+}
+function writeCatalog(command, result) {
+    process.stdout.write(`${command.output === "json" ? JSON.stringify(result.catalog) : renderCatalogText(result.catalog)}\n`);
+    return 0;
+}
+function writeResult(command, result) {
+    if (command.command === "install") {
+        const value = result;
+        process.stdout.write(`${command.output === "json" ? JSON.stringify(value) : renderInstallText(value)}\n`);
+        return installExitCode(value);
+    }
+    if (command.command === "task")
+        return writeTask(command, result);
+    if (command.command === "settings") {
+        const value = result.value;
+        process.stdout.write(`${command.output === "json" ? JSON.stringify(settingsJsonValue(value)) : renderSettingsText(value)}\n`);
+        return 0;
+    }
+    if (isParsedAkumaCommand(command)
+        || (typeof result === "object" && result !== null && "kind" in result && result.kind === "akuma")) {
+        return writeAkuma(command, result);
+    }
+    const contractResult = result;
+    if (contractResult.kind === "guidance")
+        return writeGuidance(command, contractResult);
+    if (contractResult.kind === "catalog")
+        return writeCatalog(command, contractResult);
+    const output = command.output === "json"
+        ? JSON.stringify(contractResult.kind === "status" ? contractResult.report : contractResult)
+        : renderText(contractResult, {
+            columns: process.stdout.isTTY === true && Number.isInteger(process.stdout.columns) ? process.stdout.columns : 80,
+            color: process.stdout.isTTY === true && process.env.NO_COLOR === undefined,
+        });
+    process.stdout.write(`${output}\n`);
+    return contractResult.kind === "refused" ? 1 : contractResult.kind === "retry" ? 2 : 0;
+}
+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`);
+            return 0;
+        }
+        const { invoke } = await import("./invoke.js");
+        const result = await invoke(parsed, { cwd: process.cwd() });
+        return writeResult(parsed.command, result);
+    }
+    catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        return error instanceof CliUsageError ? 1 : 3;
+    }
+}

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

@@ -0,0 +1,107 @@
+import { type ParsedTaskCommand, type TaskAction } from "./commands/task.js";
+import { type AkumaAction, type ParsedAkumaCommand } from "./commands/akuma.js";
+import type { CatalogQuery } from "../index.js";
+import { type ParsedInstallCommand } from "./commands/install.js";
+import { type ContractCommand as Command } from "./commands/contract.js";
+export { CliUsageError } from "./usage.js";
+export type { Command };
+export declare function renderRootHelp(): string;
+export declare function renderContractHelp(command: Command): string;
+export declare function renderCommandUsage(command: ParsedCommand): 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?: string;
+}>;
+export type ParsedAmend = Output & Actor & Readonly<{
+    command: "amend";
+    contract?: string;
+    after?: readonly string[];
+    clearAfter?: true;
+    gates?: string;
+}>;
+export type ParsedDeliver = Output & Actor & Readonly<{
+    command: "deliver";
+    contract?: string;
+    message?: string;
+    includeDirty: 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;
+    showDiffBody: boolean;
+    actor?: string;
+}>;
+type ParsedReconcile = Output & Readonly<{
+    command: "reconcile";
+    contract?: string;
+    retryHooks: boolean;
+}>;
+export type ParsedSettings = Output & Readonly<{
+    command: "settings";
+}>;
+export type ParsedCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedStatus | (Output & Readonly<{
+    command: "show";
+    contract?: string;
+}>) | ParsedLs | ParsedAudit | ParsedReconcile | ParsedSettings | ParsedInstallCommand | ParsedAkumaCommand | ParsedTaskCommand;
+export type CliHelpCoordinate = Readonly<{
+    kind: "root";
+}> | Readonly<{
+    kind: "contract";
+    command: Command;
+}> | Readonly<{
+    kind: "task";
+    action?: TaskAction;
+}> | Readonly<{
+    kind: "install";
+}> | Readonly<{
+    kind: "akuma";
+    action: AkumaAction;
+}>;
+export type ParsedExecution = Readonly<{
+    cwd?: string;
+    repo?: string;
+    command: ParsedCommand;
+}>;
+export type ParsedInvocation = ParsedExecution | Readonly<{
+    help: CliHelpCoordinate;
+}>;
+export declare function parseArgv(argv: readonly string[]): ParsedInvocation;