@maiaos/cli 0.1.0-canary.2

package/dist/command-line/output.d.ts

@@ -0,0 +1,57 @@
+import type { ProtocolError } from "@maiaos/sdk";
+import type * as Effect from "effect/Effect";
+import type { CliMutationRecovery, CliNodeResult } from "../local-node/index.js";
+import type { BoundedStdinRequest, CliArgumentError, PromptOptions } from "./input/index.js";
+export type CliIo = {
+    readonly cwd?: string;
+    readonly interactive?: boolean;
+    readonly prompt?: (question: string, options?: PromptOptions) => Effect.Effect<string | undefined>;
+    readonly stderr: (text: string) => void;
+    readonly stdin?: (request: BoundedStdinRequest) => Effect.Effect<string, CliArgumentError>;
+    readonly stdout: (text: string) => void;
+};
+export type CliSuccessResult = {
+    readonly command: string;
+};
+export type CliResolution = {
+    readonly argument: string;
+    readonly id: string;
+    readonly kind: string;
+    readonly label?: string;
+    readonly match: "id" | "name" | "path" | "prefix" | "selection";
+    readonly reference?: string;
+};
+export type CliSuccessOutput = {
+    readonly ok: boolean;
+    readonly resolved?: readonly CliResolution[];
+    readonly result: CliSuccessResult;
+};
+export type CliUsageHint = {
+    readonly hint: string;
+    readonly usage: readonly string[];
+};
+export type CliErrorOutput = Partial<CliUsageHint> & {
+    readonly error: ProtocolError;
+    readonly ok: false;
+    readonly recovery?: CliMutationRecovery;
+};
+export type OutputContext = {
+    readonly io: CliIo;
+    readonly json: boolean;
+    readonly ok?: boolean;
+    readonly resolved?: readonly CliResolution[];
+};
+type ErrorContext = OutputContext & {
+    readonly recovery?: CliMutationRecovery;
+    readonly usage?: CliUsageHint;
+};
+export type CliCommandOutput = CliSuccessResult;
+export declare const writeSuccess: <TResult extends CliCommandOutput>(result: TResult, { io, json, ok, resolved }: OutputContext, human: (result: TResult) => string) => void;
+export declare const reportError: (error: ProtocolError, context: ErrorContext) => number;
+export type NodeResultPresenter<TValue, TResult extends CliCommandOutput> = {
+    readonly toResult: (value: TValue) => TResult;
+    readonly toText: (result: TResult) => string;
+};
+export declare const writeNodeResult: <TValue, TResult extends CliCommandOutput>(result: CliNodeResult<TValue>, context: OutputContext, { toResult, toText }: NodeResultPresenter<TValue, TResult>) => number;
+export {};
+//# sourceMappingURL=output.d.ts.map

package/dist/command-line/output.js

@@ -0,0 +1,94 @@
+const EXIT_DATA_NOT_FOUND = 66;
+const EXIT_USAGE = 64;
+const EXIT_UNAVAILABLE = 69;
+const EXIT_SOFTWARE = 70;
+const EXIT_DEADLINE = 74;
+const EXIT_TEMPORARY = 75;
+const EXIT_OUTCOME_UNKNOWN = 76;
+const EXIT_PERMISSION = 77;
+export const writeSuccess = (result, { io, json, ok = true, resolved = [] }, human) => {
+    if (json) {
+        const output = {
+            ok,
+            ...(resolved.length === 0 ? {} : { resolved }),
+            result,
+        };
+        io.stdout(`${JSON.stringify(output)}\n`);
+        return;
+    }
+    io.stdout(human(result));
+};
+const formatUsageHint = (error, hint) => {
+    if (hint !== undefined)
+        return `Usage:\n  ${hint.usage.join("\n  ")}\n${hint.hint}\n`;
+    return error.code === "invalid_argument" ||
+        error.code === "command_not_implemented"
+        ? "Run 'maia --help' for usage.\n"
+        : "";
+};
+const writeError = (error, context) => {
+    const { io, json, recovery, usage: hint } = context;
+    if (json) {
+        const output = {
+            error,
+            ok: false,
+            ...(recovery === undefined ? {} : { recovery }),
+            ...hint,
+        };
+        io.stderr(`${JSON.stringify(output)}\n`);
+        return;
+    }
+    const usage = formatUsageHint(error, hint);
+    const recoveryHint = recovery === undefined
+        ? ""
+        : `Outcome unknown. Recover with:\n  maia receipt show ${recovery.commandId}\n`;
+    io.stderr(`maia: ${error.message}\n${recoveryHint}${usage}`);
+};
+const TEMPORARY_ERROR_CODES = new Set([
+    "guard_leases_per_session_exceeded",
+    "guard_live_children_exceeded",
+    "guard_messages_per_minute_exceeded",
+    "held",
+    "saturated",
+]);
+const PERMISSION_ERROR_CODES = new Set([
+    "authentication_failed",
+    "context_override_forbidden",
+    "role_denied",
+]);
+export const reportError = (error, context) => {
+    writeError(error, context);
+    if (error.code === "invalid_argument" ||
+        error.code === "command_not_implemented") {
+        return EXIT_USAGE;
+    }
+    if (error.code === "resource_not_found" ||
+        error.code === "port_lease_not_found")
+        return EXIT_DATA_NOT_FOUND;
+    if (PERMISSION_ERROR_CODES.has(error.code))
+        return EXIT_PERMISSION;
+    if (error.code === "node_unavailable" ||
+        error.code === "node_context_unavailable") {
+        return EXIT_UNAVAILABLE;
+    }
+    if (error.code === "deadline_exceeded")
+        return EXIT_DEADLINE;
+    if (error.code === "outcome_unknown")
+        return EXIT_OUTCOME_UNKNOWN;
+    if (TEMPORARY_ERROR_CODES.has(error.code))
+        return EXIT_TEMPORARY;
+    if (error.retryable)
+        return EXIT_TEMPORARY;
+    return EXIT_SOFTWARE;
+};
+export const writeNodeResult = (result, context, { toResult, toText }) => {
+    if (!result.ok) {
+        return reportError(result.error, {
+            ...context,
+            ...(result.recovery === undefined ? {} : { recovery: result.recovery }),
+        });
+    }
+    writeSuccess(toResult(result.value), context, toText);
+    return 0;
+};
+//# sourceMappingURL=output.js.map

package/dist/command-line/rows.d.ts

@@ -0,0 +1,10 @@
+export declare const isTerminalControl: (character: string) => boolean;
+export declare const cell: (value: string) => string;
+export declare const tab: (values: readonly unknown[]) => string;
+export type CliTable = {
+    readonly empty: string;
+    readonly headers: readonly string[];
+};
+export declare const formatRows: <TValue>(items: readonly TValue[], format: (value: TValue) => string, text?: CliTable | string) => string;
+export declare const withNextPage: (text: string, nextCursor?: string) => string;
+//# sourceMappingURL=rows.d.ts.map

package/dist/command-line/rows.js

@@ -0,0 +1,32 @@
+const FORMAT_CHARACTER = /^\p{Cf}$/u;
+const JOINERS = new Set([8204, 8205]);
+export const isTerminalControl = (character) => {
+    const point = character.codePointAt(0) ?? 0;
+    return (point <= 31 ||
+        (point >= 127 && point <= 159) ||
+        point === 8232 ||
+        point === 8233 ||
+        (FORMAT_CHARACTER.test(character) && !JOINERS.has(point)));
+};
+export const cell = (value) => Array.from(value, (character) => isTerminalControl(character) ? "�" : character).join("");
+export const tab = (values) => values.join("\t");
+const align = (rows) => {
+    const widths = rows.reduce((sizes, row) => row.map((value, index) => Math.max(sizes[index] ?? 0, value.length)), []);
+    return `${rows
+        .map((row) => row
+        .map((value, index) => index === row.length - 1 ? value : value.padEnd(widths[index] ?? 0))
+        .join("  ")
+        .trimEnd())
+        .join("\n")}\n`;
+};
+export const formatRows = (items, format, text) => {
+    const empty = typeof text === "object" ? text.empty : text;
+    if (items.length === 0)
+        return empty === undefined ? "" : `${empty}\n`;
+    const lines = items.map(format);
+    return typeof text === "object"
+        ? align([text.headers, ...lines.map((line) => line.split("\t"))])
+        : `${lines.join("\n")}\n`;
+};
+export const withNextPage = (text, nextCursor) => nextCursor === undefined ? text : `${text}next: --after ${nextCursor}\n`;
+//# sourceMappingURL=rows.js.map

package/dist/command-line/two-phase.d.ts

@@ -0,0 +1,57 @@
+import * as Effect from "effect/Effect";
+import type { CliNodeResult } from "../local-node/index.js";
+import type { CommandContext } from "./context.js";
+import { CliArgumentError } from "./input/index.js";
+export type TwoPhaseMode = "confirm-stdin" | "dry-run" | "prompt" | "yes";
+export declare const TWO_PHASE_FLAGS: readonly string[];
+export declare const canPrompt: (context: CommandContext) => boolean;
+export declare const requestedTwoPhaseMode: (flags: ReadonlySet<string>, offersYes?: boolean) => Exclude<TwoPhaseMode, "prompt"> | undefined;
+export declare const promptOrRefuse: (context: CommandContext, offersYes?: boolean) => "prompt";
+export declare const readTwoPhaseMode: (flags: ReadonlySet<string>, context: CommandContext, offersYes?: boolean) => TwoPhaseMode;
+export declare const readPipedPreview: (context: CommandContext) => Effect.Effect<object, CliArgumentError>;
+export declare const confirmParameters: <TParameters>(schema: {
+    readonly safeParse: (input: unknown) => {
+        readonly data: TParameters;
+        readonly success: true;
+    } | {
+        readonly success: false;
+    };
+}, preview: object, previewOnly?: readonly string[]) => Effect.Effect<TParameters, CliArgumentError>;
+export declare const confirmationOf: (preview: object, previewOnly?: readonly string[]) => Record<string, unknown>;
+export declare const askToConfirm: (context: CommandContext, question: string) => Effect.Effect<boolean>;
+export declare const EXIT_CANCELLED = 1;
+export type TwoPhaseSpec<TPreview extends object, TConfirm, TRequirements> = {
+    readonly confirm: (preview: object) => Effect.Effect<CliNodeResult<TConfirm>, CliArgumentError, TRequirements>;
+    readonly context: CommandContext;
+    readonly mode: TwoPhaseMode;
+    readonly preview: () => Effect.Effect<CliNodeResult<TPreview>, CliArgumentError, TRequirements>;
+    readonly prompt?: {
+        readonly describe: (preview: TPreview) => string;
+        readonly question: string;
+    };
+    readonly writeConfirm: (result: CliNodeResult<TConfirm>) => number;
+    readonly writePreview: (result: CliNodeResult<TPreview>) => number;
+};
+export declare const runTwoPhase: <TPreview extends object, TConfirm, TRequirements>(spec: TwoPhaseSpec<TPreview, TConfirm, TRequirements>) => Effect.Effect<number, CliArgumentError, TRequirements>;
+type SafeParser<TValue> = {
+    readonly safeParse: (input: unknown) => {
+        readonly data: TValue;
+        readonly success: true;
+    } | {
+        readonly success: false;
+    };
+};
+export type InputTwoPhaseSpec<TPreviewParameters, TPreview extends object, TConfirmParameters, TConfirm, TRequirements> = {
+    readonly confirm?: (parameters: TConfirmParameters) => Effect.Effect<CliNodeResult<TConfirm>, never, TRequirements>;
+    readonly confirmSchema: SafeParser<TConfirmParameters>;
+    readonly context: CommandContext;
+    readonly label: string;
+    readonly preview?: (parameters: TPreviewParameters) => Effect.Effect<CliNodeResult<TPreview>, never, TRequirements>;
+    readonly previewOnly?: readonly string[];
+    readonly previewSchema: SafeParser<TPreviewParameters>;
+    readonly tokens: readonly string[];
+    readonly write: (result: CliNodeResult<TConfirm | TPreview>) => number;
+};
+export declare const runInputTwoPhase: <TPreviewParameters, TPreview extends object, TConfirmParameters, TConfirm, TRequirements>(spec: InputTwoPhaseSpec<TPreviewParameters, TPreview, TConfirmParameters, TConfirm, TRequirements>) => Effect.Effect<number, CliArgumentError, TRequirements>;
+export {};
+//# sourceMappingURL=two-phase.d.ts.map

package/dist/command-line/two-phase.js

@@ -0,0 +1,148 @@
+import * as Effect from "effect/Effect";
+import { CliArgumentError, parseOptions, recoverStdin, requirePositionals, } from "./input/index.js";
+import { decodeJsonText } from "./json.js";
+export const TWO_PHASE_FLAGS = [
+    "--confirm-stdin",
+    "--dry-run",
+];
+export const canPrompt = (context) => context.io.interactive === true &&
+    context.io.prompt !== undefined &&
+    !context.json;
+export const requestedTwoPhaseMode = (flags, offersYes = false) => {
+    const offered = [...TWO_PHASE_FLAGS, ...(offersYes ? ["--yes"] : [])];
+    const chosen = offered.filter((flag) => flags.has(flag));
+    if (chosen.length > 1)
+        throw new CliArgumentError(`Use one of ${offered.map((flag) => `'${flag}'`).join(", ")}.`);
+    const [flag] = chosen;
+    if (flag === "--dry-run")
+        return "dry-run";
+    if (flag === "--confirm-stdin")
+        return "confirm-stdin";
+    return flag === "--yes" ? "yes" : undefined;
+};
+export const promptOrRefuse = (context, offersYes = false) => {
+    if (canPrompt(context))
+        return "prompt";
+    throw new CliArgumentError(`No person can confirm here: preview with '--dry-run', then pipe that preview to '--confirm-stdin'${offersYes ? ", or confirm at once with '--yes'" : ""}.`);
+};
+export const readTwoPhaseMode = (flags, context, offersYes = false) => requestedTwoPhaseMode(flags, offersYes) ?? promptOrRefuse(context, offersYes);
+const MAX_PREVIEW_BYTES = 64 * 1024;
+const invalidPreview = () => new CliArgumentError("The piped preview is invalid; pipe the output of the same command with '--json --dry-run'.");
+const unwrapPreview = (value) => {
+    const envelope = typeof value === "object" && value !== null && "ok" in value
+        ? Reflect.get(value, "result")
+        : value;
+    return typeof envelope === "object" &&
+        envelope !== null &&
+        "command" in envelope &&
+        "result" in envelope
+        ? Reflect.get(envelope, "result")
+        : envelope;
+};
+export const readPipedPreview = (context) => Effect.gen(function* () {
+    const stdin = context.io.stdin;
+    if (stdin === undefined)
+        return yield* new CliArgumentError("Standard input is unavailable.");
+    const text = yield* stdin({
+        label: "preview",
+        maxBytes: MAX_PREVIEW_BYTES,
+        maxChunks: 256,
+    });
+    const preview = unwrapPreview(yield* decodeJsonText(text, invalidPreview));
+    return typeof preview === "object" && preview !== null
+        ? preview
+        : yield* invalidPreview();
+});
+export const confirmParameters = (schema, preview, previewOnly = []) => {
+    const parsed = schema.safeParse(confirmationOf(preview, previewOnly));
+    return parsed.success
+        ? Effect.succeed(parsed.data)
+        : Effect.fail(invalidPreview());
+};
+export const confirmationOf = (preview, previewOnly = []) => Object.fromEntries(Object.entries(preview).filter(([key]) => ![
+    "actorId",
+    "expiresAt",
+    "issuedAt",
+    "method",
+    ...previewOnly,
+].includes(key)));
+export const askToConfirm = (context, question) => {
+    const prompt = context.io.prompt;
+    if (prompt === undefined)
+        return Effect.succeed(false);
+    return Effect.map(prompt(`${question} [y/N] `), (answer) => ["y", "yes"].includes((answer ?? "").toLowerCase()));
+};
+export const EXIT_CANCELLED = 1;
+const personConfirms = (context, description, question) => Effect.gen(function* () {
+    context.io.stderr(description);
+    if (yield* askToConfirm(context, question))
+        return true;
+    context.io.stderr("Cancelled; nothing changed.\n");
+    return false;
+});
+export const runTwoPhase = (spec) => Effect.gen(function* () {
+    const { context, mode } = spec;
+    if (mode === "confirm-stdin") {
+        const piped = yield* readPipedPreview(context);
+        return spec.writeConfirm(yield* spec.confirm(piped));
+    }
+    const { confirm, prompt, writeConfirm, writePreview } = spec;
+    const previewed = yield* spec.preview();
+    if (mode === "dry-run" || !previewed.ok)
+        return writePreview(previewed);
+    if (mode === "prompt" &&
+        (prompt === undefined ||
+            !(yield* personConfirms(context, prompt.describe(previewed.value), prompt.question))))
+        return EXIT_CANCELLED;
+    return writeConfirm(yield* confirm(previewed.value));
+});
+const withRecovery = (result, parameters) => {
+    if (result.ok || result.error.code !== "outcome_unknown")
+        return result;
+    const commandId = typeof parameters === "object" && parameters !== null
+        ? Reflect.get(parameters, "commandId")
+        : undefined;
+    const { recovery: _claimed, ...failure } = result;
+    return typeof commandId === "string"
+        ? { ...failure, recovery: { commandId } }
+        : failure;
+};
+const unavailableOperation = (label) => new CliArgumentError(`This CLI cannot send the ${label}.`);
+const previewFromStdin = (context, spec) => Effect.gen(function* () {
+    const invalid = () => new CliArgumentError(`The ${spec.label} is invalid.`);
+    const stdin = context.io.stdin;
+    if (stdin === undefined)
+        return yield* invalid();
+    const text = yield* recoverStdin(stdin({ label: spec.label, maxBytes: 8192, maxChunks: 32 }), invalid);
+    const input = spec.previewSchema.safeParse(yield* decodeJsonText(text, invalid));
+    if (!input.success)
+        return yield* invalid();
+    return spec.preview === undefined
+        ? yield* unavailableOperation(spec.label)
+        : yield* spec.preview(input.data);
+});
+const confirmPreview = (spec, previewed) => Effect.flatMap(confirmParameters(spec.confirmSchema, previewed, spec.previewOnly), (parameters) => spec.confirm === undefined
+    ? Effect.fail(unavailableOperation(spec.label))
+    : Effect.map(spec.confirm(parameters), (result) => withRecovery(result, parameters)));
+const readInputMode = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(), new Set(["--input-stdin", ...TWO_PHASE_FLAGS]));
+    requirePositionals(parsed.positionals, 0);
+    const mode = requestedTwoPhaseMode(parsed.flags);
+    const input = parsed.flags.has("--input-stdin");
+    if (mode === "confirm-stdin" && !input)
+        return mode;
+    if (mode === "dry-run" && input)
+        return mode;
+    throw new CliArgumentError(mode === "confirm-stdin"
+        ? "Use one of '--input-stdin' or '--confirm-stdin'."
+        : "Preview with '--input-stdin --dry-run', then pipe that preview to '--confirm-stdin'.");
+};
+export const runInputTwoPhase = (spec) => Effect.suspend(() => runTwoPhase({
+    confirm: (previewed) => confirmPreview(spec, previewed),
+    context: spec.context,
+    mode: readInputMode(spec.tokens),
+    preview: () => previewFromStdin(spec.context, spec),
+    writeConfirm: spec.write,
+    writePreview: spec.write,
+}));
+//# sourceMappingURL=two-phase.js.map

package/dist/command-receipt/command.d.ts

@@ -0,0 +1,4 @@
+import { type CommandContext, type CommandEffect } from "../command-line/index.js";
+export declare const runReceiptList: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runReceiptShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+//# sourceMappingURL=command.d.ts.map

package/dist/command-receipt/command.js

@@ -0,0 +1,59 @@
+import { DEFAULT_RECEIPT_LIST_PAGE_SIZE, } from "@maiaos/sdk";
+import * as Effect from "effect/Effect";
+import { CliArgumentError, parseOptions, requirePositionals, writeNodeResult, } from "../command-line/index.js";
+import { formatReceiptList, projectReceiptListResult } from "./compact-list.js";
+const readReceiptListPageSize = (value) => {
+    if (value === undefined)
+        return DEFAULT_RECEIPT_LIST_PAGE_SIZE;
+    if (!/^(?:[1-9]|[12]\d|3[0-2])$/u.test(value)) {
+        throw new CliArgumentError("Option '--limit' must be an integer from 1 to 32.");
+    }
+    return Number(value);
+};
+const optionalListFilter = (options, flag, key) => {
+    const value = options.get(flag);
+    return value === undefined ? {} : { [key]: value };
+};
+const readReceiptListParameters = (tokens) => {
+    const parsed = parseOptions(tokens, new Set([
+        "--actor",
+        "--after",
+        "--limit",
+        "--method",
+        "--since",
+        "--until",
+    ]));
+    requirePositionals(parsed.positionals, 0);
+    return {
+        limit: readReceiptListPageSize(parsed.options.get("--limit")),
+        ...optionalListFilter(parsed.options, "--actor", "actor"),
+        ...optionalListFilter(parsed.options, "--after", "afterCursor"),
+        ...optionalListFilter(parsed.options, "--method", "method"),
+        ...optionalListFilter(parsed.options, "--since", "since"),
+        ...optionalListFilter(parsed.options, "--until", "until"),
+    };
+};
+export const runReceiptList = (tokens, context) => Effect.gen(function* () {
+    const result = yield* context.dependencies.listReceipts(readReceiptListParameters(tokens));
+    return writeNodeResult(result, context, {
+        toResult: projectReceiptListResult,
+        toText: formatReceiptList,
+    });
+});
+export const runReceiptShow = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1);
+    const commandId = parsed.positionals[0];
+    if (commandId === undefined) {
+        throw new CliArgumentError("The command identifier is missing.");
+    }
+    const result = yield* context.dependencies.getReceipt(commandId);
+    return writeNodeResult(result, context, {
+        toResult: (value) => ({
+            command: "receipt.show",
+            result: value,
+        }),
+        toText: ({ result: { receipt } }) => `${receipt.receiptId}\t${receipt.state}\t${receipt.target.type}:${receipt.target.id}\n`,
+    });
+});
+//# sourceMappingURL=command.js.map

package/dist/command-receipt/compact-list.d.ts

@@ -0,0 +1,20 @@
+import type { ReceiptListResult } from "@maiaos/sdk";
+type CliReceiptListItem = {
+    readonly commandId: ReceiptListResult["items"][number]["commandId"];
+    readonly createdAt: ReceiptListResult["items"][number]["createdAt"];
+    readonly method: ReceiptListResult["items"][number]["method"];
+    readonly receiptId: ReceiptListResult["items"][number]["receiptId"];
+    readonly state: ReceiptListResult["items"][number]["state"];
+    readonly target: ReceiptListResult["items"][number]["target"];
+};
+export type CliReceiptListResult = {
+    readonly command: "receipt.list";
+    readonly count: number;
+    readonly items: readonly CliReceiptListItem[];
+    readonly nextCursor?: ReceiptListResult["nextCursor"];
+};
+export declare const projectReceiptListItem: (item: ReceiptListResult["items"][number]) => CliReceiptListItem;
+export declare const projectReceiptListResult: (value: ReceiptListResult) => CliReceiptListResult;
+export declare const formatReceiptList: (result: CliReceiptListResult) => string;
+export {};
+//# sourceMappingURL=compact-list.d.ts.map

package/dist/command-receipt/compact-list.js

@@ -0,0 +1,29 @@
+import { formatRows, tab, withNextPage } from "../command-line/index.js";
+export const projectReceiptListItem = (item) => ({
+    commandId: item.commandId,
+    createdAt: item.createdAt,
+    method: item.method,
+    receiptId: item.receiptId,
+    state: item.state,
+    target: {
+        id: item.target.id,
+        type: item.target.type,
+    },
+});
+export const projectReceiptListResult = (value) => ({
+    command: "receipt.list",
+    count: value.items.length,
+    items: value.items.map(projectReceiptListItem),
+    ...(value.nextCursor === undefined ? {} : { nextCursor: value.nextCursor }),
+});
+export const formatReceiptList = (result) => withNextPage(formatRows(result.items, (item) => tab([
+    item.commandId,
+    item.method,
+    item.state,
+    item.target.type,
+    item.target.id,
+]), {
+    empty: "No receipts.",
+    headers: ["COMMAND", "METHOD", "STATE", "TARGET", "TARGET ID"],
+}), result.nextCursor);
+//# sourceMappingURL=compact-list.js.map

package/dist/command-receipt/index.d.ts

@@ -0,0 +1,3 @@
+export { runReceiptList, runReceiptShow } from "./command.js";
+export { type CliReceiptListResult, formatReceiptList, } from "./compact-list.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/command-receipt/index.js

@@ -0,0 +1,3 @@
+export { runReceiptList, runReceiptShow } from "./command.js";
+export { formatReceiptList, } from "./compact-list.js";
+//# sourceMappingURL=index.js.map

package/dist/command-tree/commands.d.ts

@@ -0,0 +1,17 @@
+import { type CommandContext, type CommandEffect } from "../command-line/index.js";
+export declare const CLI_PROTOCOL_VERSION = "maia.protocol/v1alpha1";
+export type CliVersionResult = {
+    readonly command: "version";
+    readonly commit?: string;
+    readonly name: "maia";
+    readonly protocol: string;
+    readonly version: string;
+};
+export declare const runVersion: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runHelp: () => CommandEffect;
+export declare const runCompletion: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+declare const agentArguments: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runAgent: typeof agentArguments;
+export declare const runAgentExtensionDigest: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export {};
+//# sourceMappingURL=commands.d.ts.map

package/dist/command-tree/commands.js

@@ -0,0 +1,41 @@
+import * as Effect from "effect/Effect";
+import { CliArgumentError, requireNoArguments, writeSuccess, } from "../command-line/index.js";
+import { completionScript, isCompletionShell } from "./completion.js";
+export const CLI_PROTOCOL_VERSION = "maia.protocol/v1alpha1";
+const buildCommit = () => typeof MAIA_CLI_COMMIT === "string" && /^[0-9a-f]{40}$/u.test(MAIA_CLI_COMMIT)
+    ? MAIA_CLI_COMMIT
+    : undefined;
+export const runVersion = (tokens, context) => Effect.sync(() => {
+    requireNoArguments(tokens, "Version");
+    const commit = buildCommit();
+    const result = {
+        command: "version",
+        ...(commit === undefined ? {} : { commit }),
+        name: "maia",
+        protocol: CLI_PROTOCOL_VERSION,
+        version: context.version,
+    };
+    writeSuccess(result, context, () => `${context.version}\n`);
+    return 0;
+});
+export const runHelp = () => Effect.die(new Error("Help runs before dispatch."));
+export const runCompletion = (tokens, context) => Effect.sync(() => {
+    const [shell, ...rest] = tokens;
+    if (rest.length > 0 || !isCompletionShell(shell))
+        throw new CliArgumentError("Name one shell: bash, zsh or fish.");
+    if (context.json)
+        throw new CliArgumentError("Completion prints a shell script; omit '--json'.");
+    context.io.stdout(completionScript(shell));
+    return 0;
+});
+const agentArguments = (tokens, context) => {
+    if (context.json)
+        return Effect.fail(new CliArgumentError("Global '--json' is not supported by maia agent; use '--json-events' with print mode."));
+    const operation = context.dependencies.runAgent;
+    if (operation === undefined)
+        return Effect.fail(new CliArgumentError("The Maia agent harness is unavailable."));
+    return Effect.orDie(operation(tokens, context.io));
+};
+export const runAgent = agentArguments;
+export const runAgentExtensionDigest = (tokens, context) => agentArguments(["extension", "digest", ...tokens], context);
+//# sourceMappingURL=commands.js.map

package/dist/command-tree/completion.d.ts

@@ -0,0 +1,6 @@
+declare const SHELLS: readonly ["bash", "zsh", "fish"];
+export type CompletionShell = (typeof SHELLS)[number];
+export declare const isCompletionShell: (value: string | undefined) => value is CompletionShell;
+export declare const completionScript: (shell: CompletionShell) => string;
+export {};
+//# sourceMappingURL=completion.d.ts.map

package/dist/command-tree/completion.js

@@ -0,0 +1,36 @@
+import { commandTree, treeNodes } from "./tree.js";
+const SHELLS = ["bash", "zsh", "fish"];
+const SHELL_NAMES = new Set(SHELLS);
+export const isCompletionShell = (value) => value !== undefined && SHELL_NAMES.has(value);
+const groups = () => [commandTree(), ...treeNodes()]
+    .filter((node) => node.children.length > 0)
+    .map((node) => [
+    node.path.join(" "),
+    node.children.map((child) => child.name).join(" "),
+]);
+const bash = () => [
+    "_maia() {",
+    '  local path="${COMP_WORDS[*]:1:COMP_CWORD-1}" words=""',
+    '  case "$path" in',
+    ...groups().map(([path, words]) => `    "${path}") words="${words}" ;;`),
+    "  esac",
+    '  COMPREPLY=($(compgen -W "$words" -- "${COMP_WORDS[COMP_CWORD]}"))',
+    "}",
+    "complete -F _maia maia",
+    "",
+].join("\n");
+const fish = () => [
+    "function __maia_path",
+    "  string join ' ' (commandline -opc)[2..-1]",
+    "end",
+    ...groups().map(([path, words]) => `complete -c maia -f -n 'test "(__maia_path)" = "${path}"' -a '${words}'`),
+    "",
+].join("\n");
+export const completionScript = (shell) => {
+    if (shell === "fish")
+        return fish();
+    return shell === "zsh"
+        ? `autoload -U +X bashcompinit && bashcompinit\n${bash()}`
+        : bash();
+};
+//# sourceMappingURL=completion.js.map

package/dist/command-tree/grammar.d.ts

@@ -0,0 +1,18 @@
+export type TreeArgument = {
+    readonly choices?: readonly string[];
+    readonly max?: number;
+    readonly min?: number;
+    readonly name: string;
+    readonly oneOf?: number;
+    readonly repeated?: true;
+    readonly required?: true;
+    readonly type?: string;
+    readonly value?: string;
+};
+export type TreeForm = {
+    readonly args: readonly TreeArgument[];
+    readonly path: readonly string[];
+};
+export declare const parseUsage: (usage: string) => TreeForm;
+export declare const exampleFor: (form: TreeForm) => string;
+//# sourceMappingURL=grammar.d.ts.map