@maiaos/cli 0.1.0-canary.2

package/dist/run-ledger/client.d.ts

@@ -0,0 +1,358 @@
+import { type RunLedgerCreateParameters, type RunLedgerListParameters, type RunLedgerTaskDispatchParameters, type RunLedgerTaskListParameters, type RunLedgerTaskSettleParameters, type RunLedgerTaskShowParameters } from "@maiaos/sdk";
+import type { CliNodeOperations } from "../local-node/index.js";
+export declare const makeRunLedgerClient: (node: CliNodeOperations) => {
+    createRunLedger: (input: Omit<RunLedgerCreateParameters, "tasks"> & {
+        readonly tasks: readonly unknown[];
+    }) => import("../local-node/client.js").CliNodeEffect<{
+        readonly commandId: string;
+        readonly delivery: "duplicate" | "new";
+        readonly receipt: {
+            readonly actorId: string;
+            readonly aggregateRevision: string;
+            readonly commandId: string;
+            readonly createdAt: string;
+            readonly eventCursor: string;
+            readonly method: string;
+            readonly receiptId: string;
+            readonly schemaVersion: 1;
+            readonly state: "succeeded";
+            readonly target: {
+                readonly id: string;
+                readonly type: string;
+            };
+            readonly updatedAt: string;
+        };
+        readonly method: "run.ledger.create";
+        readonly run: {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly schemaVersion: "maia.run-ledger/v1";
+            readonly state: "blocked" | "open" | "succeeded";
+            readonly taskCounts: {
+                readonly active: number;
+                readonly blocked: number;
+                readonly ready: number;
+                readonly stopped: number;
+                readonly succeeded: number;
+            };
+            readonly workspaceId: string;
+        };
+        readonly tasks: readonly {
+            readonly clientKey: string;
+            readonly createdAt: string;
+            readonly dependencyTaskIds: readonly string[];
+            readonly failedDispatches: number;
+            readonly id: string;
+            readonly revision: string;
+            readonly runId: string;
+            readonly schemaVersion: "maia.run-ledger/v1";
+            readonly state: "active" | "blocked" | "ready" | "stopped" | "succeeded";
+            readonly updatedAt: string;
+            readonly dispatches: readonly {
+                readonly createdAt: string;
+                readonly id: string;
+                readonly ordinal: number;
+                readonly sessionId: string;
+                readonly settledTurnId?: string | undefined;
+                readonly state: "active" | "failed" | "succeeded";
+                readonly turnId: string;
+                readonly updatedAt: string;
+            }[];
+        }[];
+    }>;
+    dispatchRunLedgerTask: (input: RunLedgerTaskDispatchParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly commandId: string;
+        readonly delivery: "duplicate" | "new";
+        readonly receipt: {
+            readonly actorId: string;
+            readonly aggregateRevision: string;
+            readonly commandId: string;
+            readonly createdAt: string;
+            readonly eventCursor: string;
+            readonly method: string;
+            readonly receiptId: string;
+            readonly schemaVersion: 1;
+            readonly state: "succeeded";
+            readonly target: {
+                readonly id: string;
+                readonly type: string;
+            };
+            readonly updatedAt: string;
+        };
+        readonly dispatch: {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly ordinal: number;
+            readonly sessionId: string;
+            readonly settledTurnId?: string | undefined;
+            readonly state: "active" | "failed" | "succeeded";
+            readonly turnId: string;
+            readonly updatedAt: string;
+        };
+        readonly method: "run.ledger.task.dispatch";
+        readonly task: {
+            readonly clientKey: string;
+            readonly createdAt: string;
+            readonly dependencyTaskIds: readonly string[];
+            readonly failedDispatches: number;
+            readonly id: string;
+            readonly revision: string;
+            readonly runId: string;
+            readonly schemaVersion: "maia.run-ledger/v1";
+            readonly state: "active" | "blocked" | "ready" | "stopped" | "succeeded";
+            readonly updatedAt: string;
+            readonly dispatches: readonly {
+                readonly createdAt: string;
+                readonly id: string;
+                readonly ordinal: number;
+                readonly sessionId: string;
+                readonly settledTurnId?: string | undefined;
+                readonly state: "active" | "failed" | "succeeded";
+                readonly turnId: string;
+                readonly updatedAt: string;
+            }[];
+        };
+        readonly turn: {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly input: {
+                readonly text: string;
+                readonly type: "text";
+            };
+            readonly revision: string;
+            readonly schemaVersion: 1;
+            readonly sessionId: string;
+            readonly sessionRevision: string;
+            readonly updatedAt: string;
+            readonly state: "queued";
+        } | {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly input: {
+                readonly text: string;
+                readonly type: "text";
+            };
+            readonly revision: string;
+            readonly schemaVersion: 1;
+            readonly sessionId: string;
+            readonly sessionRevision: string;
+            readonly updatedAt: string;
+            readonly state: "dispatching";
+        } | {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly input: {
+                readonly text: string;
+                readonly type: "text";
+            };
+            readonly revision: string;
+            readonly schemaVersion: 1;
+            readonly sessionId: string;
+            readonly sessionRevision: string;
+            readonly updatedAt: string;
+            readonly state: "running";
+        } | {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly input: {
+                readonly text: string;
+                readonly type: "text";
+            };
+            readonly revision: string;
+            readonly schemaVersion: 1;
+            readonly sessionId: string;
+            readonly sessionRevision: string;
+            readonly updatedAt: string;
+            readonly responseText: string;
+            readonly state: "completed";
+            readonly tokenUsage?: {
+                readonly cachedInputTokens: number;
+                readonly inputTokens: number;
+                readonly modelCallCount?: number | undefined;
+                readonly outputTokens: number;
+                readonly reasoningOutputTokens: number;
+                readonly totalTokens: number;
+            } | undefined;
+        } | {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly input: {
+                readonly text: string;
+                readonly type: "text";
+            };
+            readonly revision: string;
+            readonly schemaVersion: 1;
+            readonly sessionId: string;
+            readonly sessionRevision: string;
+            readonly updatedAt: string;
+            readonly failure?: {
+                readonly code: string;
+                readonly message: string;
+            } | undefined;
+            readonly failureReason: "approval_required" | "repository_changed" | "runtime_failed" | "turn_rejected";
+            readonly state: "failed";
+        } | {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly input: {
+                readonly text: string;
+                readonly type: "text";
+            };
+            readonly revision: string;
+            readonly schemaVersion: 1;
+            readonly sessionId: string;
+            readonly sessionRevision: string;
+            readonly updatedAt: string;
+            readonly failure?: {
+                readonly code: string;
+                readonly message: string;
+            } | undefined;
+            readonly failureReason: "output_limit_exceeded" | "protocol_invalid" | "runtime_exited" | "turn_deadline_exceeded";
+            readonly state: "outcome-unknown";
+        } | {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly input: {
+                readonly text: string;
+                readonly type: "text";
+            };
+            readonly revision: string;
+            readonly schemaVersion: 1;
+            readonly sessionId: string;
+            readonly sessionRevision: string;
+            readonly updatedAt: string;
+            readonly state: "interrupted";
+        };
+    }>;
+    settleRunLedgerTask: (input: RunLedgerTaskSettleParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly commandId: string;
+        readonly delivery: "duplicate" | "new";
+        readonly receipt: {
+            readonly actorId: string;
+            readonly aggregateRevision: string;
+            readonly commandId: string;
+            readonly createdAt: string;
+            readonly eventCursor: string;
+            readonly method: string;
+            readonly receiptId: string;
+            readonly schemaVersion: 1;
+            readonly state: "succeeded";
+            readonly target: {
+                readonly id: string;
+                readonly type: string;
+            };
+            readonly updatedAt: string;
+        };
+        readonly method: "run.ledger.task.settle";
+        readonly task: {
+            readonly clientKey: string;
+            readonly createdAt: string;
+            readonly dependencyTaskIds: readonly string[];
+            readonly failedDispatches: number;
+            readonly id: string;
+            readonly revision: string;
+            readonly runId: string;
+            readonly schemaVersion: "maia.run-ledger/v1";
+            readonly state: "active" | "blocked" | "ready" | "stopped" | "succeeded";
+            readonly updatedAt: string;
+            readonly dispatches: readonly {
+                readonly createdAt: string;
+                readonly id: string;
+                readonly ordinal: number;
+                readonly sessionId: string;
+                readonly settledTurnId?: string | undefined;
+                readonly state: "active" | "failed" | "succeeded";
+                readonly turnId: string;
+                readonly updatedAt: string;
+                readonly evidence?: string | undefined;
+            }[];
+            readonly objective: string;
+        };
+    }>;
+    listRunLedgers: (input: RunLedgerListParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly items: readonly {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly schemaVersion: "maia.run-ledger/v1";
+            readonly state: "blocked" | "open" | "succeeded";
+            readonly taskCounts: {
+                readonly active: number;
+                readonly blocked: number;
+                readonly ready: number;
+                readonly stopped: number;
+                readonly succeeded: number;
+            };
+            readonly workspaceId: string;
+        }[];
+        readonly method: "run.ledger.list";
+        readonly nextCursor?: string | undefined;
+    }>;
+    listRunLedgerTasks: (input: RunLedgerTaskListParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly items: readonly {
+            readonly clientKey: string;
+            readonly createdAt: string;
+            readonly dependencyTaskIds: readonly string[];
+            readonly failedDispatches: number;
+            readonly id: string;
+            readonly revision: string;
+            readonly runId: string;
+            readonly schemaVersion: "maia.run-ledger/v1";
+            readonly state: "active" | "blocked" | "ready" | "stopped" | "succeeded";
+            readonly updatedAt: string;
+            readonly dispatches: readonly {
+                readonly createdAt: string;
+                readonly id: string;
+                readonly ordinal: number;
+                readonly sessionId: string;
+                readonly settledTurnId?: string | undefined;
+                readonly state: "active" | "failed" | "succeeded";
+                readonly turnId: string;
+                readonly updatedAt: string;
+            }[];
+        }[];
+        readonly method: "run.ledger.task.list";
+        readonly run: {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly schemaVersion: "maia.run-ledger/v1";
+            readonly state: "blocked" | "open" | "succeeded";
+            readonly taskCounts: {
+                readonly active: number;
+                readonly blocked: number;
+                readonly ready: number;
+                readonly stopped: number;
+                readonly succeeded: number;
+            };
+            readonly workspaceId: string;
+        };
+    }>;
+    showRunLedgerTask: (input: RunLedgerTaskShowParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly method: "run.ledger.task.show";
+        readonly task: {
+            readonly clientKey: string;
+            readonly createdAt: string;
+            readonly dependencyTaskIds: readonly string[];
+            readonly failedDispatches: number;
+            readonly id: string;
+            readonly revision: string;
+            readonly runId: string;
+            readonly schemaVersion: "maia.run-ledger/v1";
+            readonly state: "active" | "blocked" | "ready" | "stopped" | "succeeded";
+            readonly updatedAt: string;
+            readonly dispatches: readonly {
+                readonly createdAt: string;
+                readonly id: string;
+                readonly ordinal: number;
+                readonly sessionId: string;
+                readonly settledTurnId?: string | undefined;
+                readonly state: "active" | "failed" | "succeeded";
+                readonly turnId: string;
+                readonly updatedAt: string;
+                readonly evidence?: string | undefined;
+            }[];
+            readonly objective: string;
+        };
+    }>;
+};
+export type RunLedgerCliDependencies = ReturnType<typeof makeRunLedgerClient>;
+//# sourceMappingURL=client.d.ts.map

package/dist/run-ledger/client.js

@@ -0,0 +1,13 @@
+import { runLedgerCreateParametersSchema, runLedgerListParametersSchema, runLedgerTaskDispatchParametersSchema, runLedgerTaskListParametersSchema, runLedgerTaskSettleParametersSchema, runLedgerTaskShowParametersSchema, } from "@maiaos/sdk";
+const mutationClient = (node) => ({
+    createRunLedger: (input) => node.runValidatedNodeOperation(input, runLedgerCreateParametersSchema, (client, parameters, options) => client.createRunLedger(parameters, options), { commandId: input.commandId }),
+    dispatchRunLedgerTask: (input) => node.runValidatedNodeOperation(input, runLedgerTaskDispatchParametersSchema, (client, parameters, options) => client.dispatchRunLedgerTask(parameters, options), { commandId: input.commandId }),
+    settleRunLedgerTask: (input) => node.runValidatedNodeOperation(input, runLedgerTaskSettleParametersSchema, (client, parameters, options) => client.settleRunLedgerTask(parameters, options), { commandId: input.commandId }),
+});
+export const makeRunLedgerClient = (node) => ({
+    ...mutationClient(node),
+    listRunLedgers: (input) => node.runValidatedNodeOperation(input, runLedgerListParametersSchema, (client, parameters, options) => client.listRunLedgers(parameters, options)),
+    listRunLedgerTasks: (input) => node.runValidatedNodeOperation(input, runLedgerTaskListParametersSchema, (client, parameters, options) => client.listRunLedgerTasks(parameters, options)),
+    showRunLedgerTask: (input) => node.runValidatedNodeOperation(input, runLedgerTaskShowParametersSchema, (client, parameters, options) => client.showRunLedgerTask(parameters, options)),
+});
+//# sourceMappingURL=client.js.map

package/dist/run-ledger/commands.d.ts

@@ -0,0 +1,8 @@
+import { type CommandContext, type CommandEffect } from "../command-line/index.js";
+export declare const runLedgerCreate: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runLedgerList: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runLedgerTaskList: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runLedgerTaskShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runLedgerTaskDispatch: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runLedgerTaskSettle: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+//# sourceMappingURL=commands.d.ts.map

package/dist/run-ledger/commands.js

@@ -0,0 +1,19 @@
+import * as Effect from "effect/Effect";
+import { writeNodeResult, } from "../command-line/index.js";
+import { readLedgerCreate, readLedgerDispatch, readLedgerList, readLedgerSettle, readLedgerShow, readLedgerTasks, } from "./input.js";
+import { formatRunLedgerResult, } from "./output/index.js";
+const run = (operation, input, context) => {
+    if (operation === undefined)
+        return Effect.die(new Error("Missing Run ledger client."));
+    return input.pipe(Effect.flatMap(operation), Effect.map((result) => writeNodeResult(result, context, {
+        toResult: (value) => ({ command: value.method, result: value }),
+        toText: formatRunLedgerResult,
+    })));
+};
+export const runLedgerCreate = (tokens, context) => run(context.dependencies.createRunLedger, readLedgerCreate(tokens, context), context);
+export const runLedgerList = (tokens, context) => run(context.dependencies.listRunLedgers, readLedgerList(tokens), context);
+export const runLedgerTaskList = (tokens, context) => run(context.dependencies.listRunLedgerTasks, readLedgerTasks(tokens), context);
+export const runLedgerTaskShow = (tokens, context) => run(context.dependencies.showRunLedgerTask, readLedgerShow(tokens), context);
+export const runLedgerTaskDispatch = (tokens, context) => run(context.dependencies.dispatchRunLedgerTask, readLedgerDispatch(tokens), context);
+export const runLedgerTaskSettle = (tokens, context) => run(context.dependencies.settleRunLedgerTask, readLedgerSettle(tokens, context), context);
+//# sourceMappingURL=commands.js.map

package/dist/run-ledger/index.d.ts

@@ -0,0 +1,3 @@
+export { makeRunLedgerClient, type RunLedgerCliDependencies, } from "./client.js";
+export { runLedgerCreate, runLedgerList, runLedgerTaskDispatch, runLedgerTaskList, runLedgerTaskSettle, runLedgerTaskShow, } from "./commands.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/run-ledger/index.js

@@ -0,0 +1,3 @@
+export { makeRunLedgerClient, } from "./client.js";
+export { runLedgerCreate, runLedgerList, runLedgerTaskDispatch, runLedgerTaskList, runLedgerTaskSettle, runLedgerTaskShow, } from "./commands.js";
+//# sourceMappingURL=index.js.map

package/dist/run-ledger/input.d.ts

@@ -0,0 +1,42 @@
+import * as Effect from "effect/Effect";
+import { CliArgumentError, type CommandContext } from "../command-line/index.js";
+export declare const readLedgerCreate: (tokens: readonly string[], context: CommandContext) => Effect.Effect<{
+    commandId: string;
+} & {
+    tasks: readonly unknown[];
+    workspaceId: string;
+}, CliArgumentError, import("effect/Crypto").Crypto>;
+export declare const readLedgerList: (tokens: readonly string[]) => Effect.Effect<{
+    limit: number;
+    workspaceId: string;
+    afterCursor?: string | undefined;
+}, never, never>;
+export declare const readLedgerTasks: (tokens: readonly string[]) => Effect.Effect<{
+    runId: string;
+    ready?: true | undefined;
+}, never, never>;
+export declare const readLedgerShow: (tokens: readonly string[]) => Effect.Effect<{
+    runId: string;
+    taskId: string;
+}, never, never>;
+export declare const readLedgerDispatch: (tokens: readonly string[]) => Effect.Effect<{
+    commandId: string;
+} & {
+    expectedSessionRevision: string;
+    expectedTaskRevision: string;
+    runId: string;
+    sessionId: string;
+    taskId: string;
+}, never, import("effect/Crypto").Crypto>;
+export declare const readLedgerSettle: (tokens: readonly string[], context: CommandContext) => Effect.Effect<{
+    commandId: string;
+} & {
+    expectedTaskRevision: string;
+    outcome: "failed" | "succeeded";
+    runId: string;
+    sessionId: string;
+    taskId: string;
+    turnId?: string | undefined;
+    evidence: string;
+}, CliArgumentError, import("effect/Crypto").Crypto>;
+//# sourceMappingURL=input.d.ts.map

package/dist/run-ledger/input.js

@@ -0,0 +1,107 @@
+import { MAX_RUN_LEDGER_EVIDENCE_BYTES } from "@maiaos/sdk";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+import { CliArgumentError, decodeJsonText, parseOptions, readPageSize, readRevisionOption, requirePositionals, } from "../command-line/index.js";
+import { commandIdentifier } from "../local-node/index.js";
+const withCommandId = (options, input) => Effect.map(commandIdentifier(options.get("--command-id")), (commandId) => ({
+    commandId,
+    ...input,
+}));
+const requireOption = (options, name) => {
+    const value = options.get(name);
+    if (value === undefined)
+        throw new CliArgumentError(`Option '${name}' is required.`);
+    return value;
+};
+const readStdin = (context, label, maxBytes) => {
+    const stdin = context.io.stdin;
+    if (stdin === undefined)
+        return Effect.fail(new CliArgumentError("Standard input is unavailable."));
+    return stdin({ label, maxBytes, maxChunks: 1024 });
+};
+const readTasks = (context) => Effect.flatMap(readStdin(context, "Run ledger graph", 64 * 1024), (text) => Effect.flatMap(decodeJsonText(text, () => new CliArgumentError("Standard input must be one valid JSON graph.")), (graph) => Predicate.hasProperty(graph, "tasks") && Array.isArray(graph.tasks)
+    ? Effect.succeed(graph.tasks)
+    : Effect.fail(new CliArgumentError('Standard input must be { "tasks": [...] }.'))));
+export const readLedgerCreate = (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--workspace"]), new Set(["--graph-stdin"]));
+    requirePositionals(parsed.positionals, 0);
+    if (!parsed.flags.has("--graph-stdin"))
+        throw new CliArgumentError("Option '--graph-stdin' is required.");
+    const workspaceId = requireOption(parsed.options, "--workspace");
+    return Effect.flatMap(readTasks(context), (tasks) => withCommandId(parsed.options, { tasks, workspaceId }));
+};
+export const readLedgerList = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit", "--workspace"]));
+    requirePositionals(parsed.positionals, 0);
+    const afterCursor = parsed.options.get("--after");
+    return Effect.succeed({
+        limit: readPageSize(parsed.options.get("--limit")),
+        workspaceId: requireOption(parsed.options, "--workspace"),
+        ...(afterCursor === undefined ? {} : { afterCursor }),
+    });
+};
+export const readLedgerTasks = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--run"]), new Set(["--ready"]));
+    requirePositionals(parsed.positionals, 0);
+    return Effect.succeed({
+        runId: requireOption(parsed.options, "--run"),
+        ...(parsed.flags.has("--ready") ? { ready: true } : {}),
+    });
+};
+export const readLedgerShow = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--run"]));
+    requirePositionals(parsed.positionals, 1);
+    return Effect.succeed({
+        runId: requireOption(parsed.options, "--run"),
+        taskId: parsed.positionals[0] ?? "",
+    });
+};
+export const readLedgerDispatch = (tokens) => {
+    const parsed = parseOptions(tokens, new Set([
+        "--command-id",
+        "--expected-session-revision",
+        "--expected-task-revision",
+        "--run",
+        "--session",
+    ]));
+    requirePositionals(parsed.positionals, 1);
+    return withCommandId(parsed.options, {
+        expectedSessionRevision: readRevisionOption(parsed.options.get("--expected-session-revision"), "--expected-session-revision"),
+        expectedTaskRevision: readRevisionOption(parsed.options.get("--expected-task-revision"), "--expected-task-revision"),
+        runId: requireOption(parsed.options, "--run"),
+        sessionId: requireOption(parsed.options, "--session"),
+        taskId: parsed.positionals[0] ?? "",
+    });
+};
+const readOutcome = (value) => {
+    if (value === "succeeded" || value === "failed")
+        return value;
+    throw new CliArgumentError("Option '--outcome' must be succeeded or failed.");
+};
+const settleFields = (parsed) => {
+    const turnId = parsed.options.get("--turn");
+    return {
+        expectedTaskRevision: readRevisionOption(parsed.options.get("--expected-task-revision"), "--expected-task-revision"),
+        outcome: readOutcome(requireOption(parsed.options, "--outcome")),
+        runId: requireOption(parsed.options, "--run"),
+        sessionId: requireOption(parsed.options, "--session"),
+        taskId: parsed.positionals[0] ?? "",
+        ...(turnId === undefined ? {} : { turnId }),
+    };
+};
+export const readLedgerSettle = (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set([
+        "--command-id",
+        "--expected-task-revision",
+        "--outcome",
+        "--run",
+        "--session",
+        "--turn",
+    ]), new Set(["--evidence-stdin"]));
+    requirePositionals(parsed.positionals, 1);
+    if (!parsed.flags.has("--evidence-stdin"))
+        throw new CliArgumentError("Option '--evidence-stdin' is required.");
+    const fields = settleFields(parsed);
+    return Effect.flatMap(readStdin(context, "settlement evidence", MAX_RUN_LEDGER_EVIDENCE_BYTES), (evidence) => withCommandId(parsed.options, { ...fields, evidence }));
+};
+//# sourceMappingURL=input.js.map

package/dist/run-ledger/output/format.d.ts

@@ -0,0 +1,11 @@
+import type { RunLedgerCreateResult, RunLedgerListResult, RunLedgerTaskDispatchResult, RunLedgerTaskListResult, RunLedgerTaskSettleResult, RunLedgerTaskShowResult } from "@maiaos/sdk";
+export type RunLedgerCliResult = RunLedgerCreateResult | RunLedgerListResult | RunLedgerTaskDispatchResult | RunLedgerTaskListResult | RunLedgerTaskSettleResult | RunLedgerTaskShowResult;
+export type CliRunLedgerResult = {
+    readonly command: RunLedgerCliResult["method"];
+    readonly result: RunLedgerCliResult;
+};
+export declare const isRunLedgerResult: (result: {
+    readonly command: string;
+}) => result is CliRunLedgerResult;
+export declare const formatRunLedgerResult: ({ result }: CliRunLedgerResult) => string;
+//# sourceMappingURL=format.d.ts.map

package/dist/run-ledger/output/format.js

@@ -0,0 +1,49 @@
+import { formatRows, withNextPage } from "../../command-line/index.js";
+export const isRunLedgerResult = (result) => result.command.startsWith("run.ledger.");
+const runLine = (run) => {
+    const counts = Object.entries(run.taskCounts)
+        .filter(([, count]) => count > 0)
+        .map(([state, count]) => `${state}=${String(count)}`)
+        .join(" ");
+    return `${run.id}\t${run.state}\t${counts}`;
+};
+const taskLine = (task) => {
+    const last = task.dispatches.at(-1);
+    const dispatch = last === undefined
+        ? ""
+        : `\t${last.state}:${last.sessionId}:${last.turnId}`;
+    return `${task.id}\t${task.clientKey}\t${task.state}\trevision=${task.revision}\tfailed=${String(task.failedDispatches)}${dispatch}`;
+};
+const taskRow = (task) => {
+    const last = task.dispatches.at(-1);
+    return `${task.id}\t${task.clientKey}\t${task.state}\t${task.revision}\t${String(task.failedDispatches)}\t${last === undefined ? "-" : `${last.state}:${last.sessionId}:${last.turnId}`}`;
+};
+const lines = (result) => {
+    switch (result.method) {
+        case "run.ledger.create":
+            return [runLine(result.run), ...result.tasks.map(taskLine)];
+        case "run.ledger.list":
+            return [
+                withNextPage(formatRows(result.items, runLine, {
+                    empty: "No ledger runs.",
+                    headers: ["RUN", "STATE", "TASKS"],
+                }), result.nextCursor).trimEnd(),
+            ];
+        case "run.ledger.task.dispatch":
+            return [taskLine(result.task), `turn: ${result.turn.id}`];
+        case "run.ledger.task.list":
+            return [
+                runLine(result.run),
+                formatRows(result.items, taskRow, {
+                    empty: "No tasks.",
+                    headers: ["TASK", "KEY", "STATE", "REVISION", "FAILED", "DISPATCH"],
+                }).trimEnd(),
+            ];
+        case "run.ledger.task.settle":
+            return [taskLine(result.task)];
+        case "run.ledger.task.show":
+            return [taskLine(result.task), result.task.objective];
+    }
+};
+export const formatRunLedgerResult = ({ result }) => `${lines(result).join("\n")}\n`;
+//# sourceMappingURL=format.js.map

package/dist/run-ledger/output/index.d.ts

@@ -0,0 +1,2 @@
+export { type CliRunLedgerResult, formatRunLedgerResult, isRunLedgerResult, type RunLedgerCliResult, } from "./format.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/run-ledger/output/index.js

@@ -0,0 +1,2 @@
+export { formatRunLedgerResult, isRunLedgerResult, } from "./format.js";
+//# sourceMappingURL=index.js.map