@maiaos/cli 0.1.0-canary.2

package/dist/session/interaction/client.d.ts

@@ -0,0 +1,347 @@
+import { type InteractionCancelParameters, type InteractionCreateParameters, type InteractionListParameters, type InteractionRespondParameters, type InteractionShowParameters } from "@maiaos/sdk";
+import type { CliNodeOperations } from "../../local-node/index.js";
+export declare const makeInteractionClient: (node: CliNodeOperations) => {
+    listInteractions: (input: InteractionListParameters) => import("../../local-node/client.js").CliNodeEffect<{
+        readonly items: readonly ({
+            readonly activationId: null;
+            readonly answeredAt: string | null;
+            readonly answerSchemaDigest: string;
+            readonly body: string;
+            readonly createdAt: string;
+            readonly expiresAt: string | null;
+            readonly interactionId: string;
+            readonly lifecycleStatus: "answered" | "cancelled" | "expired" | "pending";
+            readonly origin: {
+                readonly kind: "external-cli";
+            };
+            readonly projectId: string;
+            readonly requestingActorId: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.interaction/v1";
+            readonly sessionId: string;
+            readonly subject: string;
+            readonly wakeDisposition: "record-only";
+            readonly kind: "question";
+        } | {
+            readonly activationId: null;
+            readonly answeredAt: string | null;
+            readonly answerSchemaDigest: string;
+            readonly body: string;
+            readonly createdAt: string;
+            readonly expiresAt: string | null;
+            readonly interactionId: string;
+            readonly lifecycleStatus: "answered" | "cancelled" | "expired" | "pending";
+            readonly origin: {
+                readonly kind: "external-cli";
+            };
+            readonly projectId: string;
+            readonly requestingActorId: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.interaction/v1";
+            readonly sessionId: string;
+            readonly subject: string;
+            readonly wakeDisposition: "record-only";
+            readonly kind: "selection";
+            readonly options: readonly {
+                readonly label: string;
+                readonly optionId: string;
+            }[];
+        })[];
+        readonly method: "interaction.list";
+        readonly nextCursor?: string | undefined;
+        readonly projectId: string;
+        readonly sessionId: string;
+    }>;
+    showInteraction: (input: InteractionShowParameters) => import("../../local-node/client.js").CliNodeEffect<{
+        readonly interaction: {
+            readonly activationId: null;
+            readonly answeredAt: string | null;
+            readonly answerSchemaDigest: string;
+            readonly body: string;
+            readonly createdAt: string;
+            readonly expiresAt: string | null;
+            readonly interactionId: string;
+            readonly lifecycleStatus: "answered" | "cancelled" | "expired" | "pending";
+            readonly origin: {
+                readonly kind: "external-cli";
+            };
+            readonly projectId: string;
+            readonly requestingActorId: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.interaction/v1";
+            readonly sessionId: string;
+            readonly subject: string;
+            readonly wakeDisposition: "record-only";
+            readonly kind: "question";
+            readonly answer?: {
+                readonly kind: "text";
+                readonly value: string;
+            } | {
+                readonly kind: "selection";
+                readonly optionIds: readonly string[];
+            } | undefined;
+            readonly respondingActorId?: string | undefined;
+            readonly responseDigest?: string | undefined;
+        } | {
+            readonly activationId: null;
+            readonly answeredAt: string | null;
+            readonly answerSchemaDigest: string;
+            readonly body: string;
+            readonly createdAt: string;
+            readonly expiresAt: string | null;
+            readonly interactionId: string;
+            readonly lifecycleStatus: "answered" | "cancelled" | "expired" | "pending";
+            readonly origin: {
+                readonly kind: "external-cli";
+            };
+            readonly projectId: string;
+            readonly requestingActorId: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.interaction/v1";
+            readonly sessionId: string;
+            readonly subject: string;
+            readonly wakeDisposition: "record-only";
+            readonly kind: "selection";
+            readonly options: readonly {
+                readonly label: string;
+                readonly optionId: string;
+            }[];
+            readonly answer?: {
+                readonly kind: "text";
+                readonly value: string;
+            } | {
+                readonly kind: "selection";
+                readonly optionIds: readonly string[];
+            } | undefined;
+            readonly respondingActorId?: string | undefined;
+            readonly responseDigest?: string | undefined;
+        };
+        readonly method: "interaction.show";
+    }>;
+    cancelInteraction: (input: InteractionCancelParameters) => import("../../local-node/client.js").CliNodeEffect<{
+        readonly actorId: string;
+        readonly commandId: string;
+        readonly delivery: "duplicate" | "new";
+        readonly inputDigest: string;
+        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 expectedRevision: string;
+        readonly interaction: {
+            readonly activationId: null;
+            readonly answeredAt: string | null;
+            readonly answerSchemaDigest: string;
+            readonly body: string;
+            readonly createdAt: string;
+            readonly expiresAt: string | null;
+            readonly interactionId: string;
+            readonly lifecycleStatus: "answered" | "cancelled" | "expired" | "pending";
+            readonly origin: {
+                readonly kind: "external-cli";
+            };
+            readonly projectId: string;
+            readonly requestingActorId: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.interaction/v1";
+            readonly sessionId: string;
+            readonly subject: string;
+            readonly wakeDisposition: "record-only";
+            readonly kind: "question";
+        } | {
+            readonly activationId: null;
+            readonly answeredAt: string | null;
+            readonly answerSchemaDigest: string;
+            readonly body: string;
+            readonly createdAt: string;
+            readonly expiresAt: string | null;
+            readonly interactionId: string;
+            readonly lifecycleStatus: "answered" | "cancelled" | "expired" | "pending";
+            readonly origin: {
+                readonly kind: "external-cli";
+            };
+            readonly projectId: string;
+            readonly requestingActorId: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.interaction/v1";
+            readonly sessionId: string;
+            readonly subject: string;
+            readonly wakeDisposition: "record-only";
+            readonly kind: "selection";
+            readonly options: readonly {
+                readonly label: string;
+                readonly optionId: string;
+            }[];
+        };
+        readonly method: "interaction.cancel";
+    }>;
+    createInteraction: (input: InteractionCreateParameters) => import("../../local-node/client.js").CliNodeEffect<{
+        readonly actorId: string;
+        readonly commandId: string;
+        readonly delivery: "duplicate" | "new";
+        readonly inputDigest: string;
+        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 interaction: {
+            readonly activationId: null;
+            readonly answeredAt: string | null;
+            readonly answerSchemaDigest: string;
+            readonly body: string;
+            readonly createdAt: string;
+            readonly expiresAt: string | null;
+            readonly interactionId: string;
+            readonly lifecycleStatus: "answered" | "cancelled" | "expired" | "pending";
+            readonly origin: {
+                readonly kind: "external-cli";
+            };
+            readonly projectId: string;
+            readonly requestingActorId: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.interaction/v1";
+            readonly sessionId: string;
+            readonly subject: string;
+            readonly wakeDisposition: "record-only";
+            readonly kind: "question";
+        } | {
+            readonly activationId: null;
+            readonly answeredAt: string | null;
+            readonly answerSchemaDigest: string;
+            readonly body: string;
+            readonly createdAt: string;
+            readonly expiresAt: string | null;
+            readonly interactionId: string;
+            readonly lifecycleStatus: "answered" | "cancelled" | "expired" | "pending";
+            readonly origin: {
+                readonly kind: "external-cli";
+            };
+            readonly projectId: string;
+            readonly requestingActorId: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.interaction/v1";
+            readonly sessionId: string;
+            readonly subject: string;
+            readonly wakeDisposition: "record-only";
+            readonly kind: "selection";
+            readonly options: readonly {
+                readonly label: string;
+                readonly optionId: string;
+            }[];
+        };
+        readonly method: "interaction.create";
+    }>;
+    respondToInteraction: (input: InteractionRespondParameters) => import("../../local-node/client.js").CliNodeEffect<{
+        readonly actorId: string;
+        readonly commandId: string;
+        readonly delivery: "duplicate" | "new";
+        readonly inputDigest: string;
+        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 expectedRevision: string;
+        readonly interaction: {
+            readonly activationId: null;
+            readonly answeredAt: string | null;
+            readonly answerSchemaDigest: string;
+            readonly body: string;
+            readonly createdAt: string;
+            readonly expiresAt: string | null;
+            readonly interactionId: string;
+            readonly lifecycleStatus: "answered" | "cancelled" | "expired" | "pending";
+            readonly origin: {
+                readonly kind: "external-cli";
+            };
+            readonly projectId: string;
+            readonly requestingActorId: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.interaction/v1";
+            readonly sessionId: string;
+            readonly subject: string;
+            readonly wakeDisposition: "record-only";
+            readonly kind: "question";
+            readonly answer?: {
+                readonly kind: "text";
+                readonly value: string;
+            } | {
+                readonly kind: "selection";
+                readonly optionIds: readonly string[];
+            } | undefined;
+            readonly respondingActorId?: string | undefined;
+            readonly responseDigest?: string | undefined;
+        } | {
+            readonly activationId: null;
+            readonly answeredAt: string | null;
+            readonly answerSchemaDigest: string;
+            readonly body: string;
+            readonly createdAt: string;
+            readonly expiresAt: string | null;
+            readonly interactionId: string;
+            readonly lifecycleStatus: "answered" | "cancelled" | "expired" | "pending";
+            readonly origin: {
+                readonly kind: "external-cli";
+            };
+            readonly projectId: string;
+            readonly requestingActorId: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.interaction/v1";
+            readonly sessionId: string;
+            readonly subject: string;
+            readonly wakeDisposition: "record-only";
+            readonly kind: "selection";
+            readonly options: readonly {
+                readonly label: string;
+                readonly optionId: string;
+            }[];
+            readonly answer?: {
+                readonly kind: "text";
+                readonly value: string;
+            } | {
+                readonly kind: "selection";
+                readonly optionIds: readonly string[];
+            } | undefined;
+            readonly respondingActorId?: string | undefined;
+            readonly responseDigest?: string | undefined;
+        };
+        readonly method: "interaction.respond";
+    }>;
+};
+export type InteractionCliDependencies = ReturnType<typeof makeInteractionClient>;
+//# sourceMappingURL=client.d.ts.map

package/dist/session/interaction/client.js

@@ -0,0 +1,15 @@
+import { interactionCancelParametersSchema, interactionCreateParametersSchema, interactionListParametersSchema, interactionRespondParametersSchema, interactionShowParametersSchema, } from "@maiaos/sdk";
+const readClient = (node) => ({
+    listInteractions: (input) => node.runValidatedNodeOperation(input, interactionListParametersSchema, (client, parameters, options) => client.listInteractions(parameters, options)),
+    showInteraction: (input) => node.runValidatedNodeOperation(input, interactionShowParametersSchema, (client, parameters, options) => client.showInteraction(parameters, options)),
+});
+const mutationClient = (node) => ({
+    cancelInteraction: (input) => node.runValidatedNodeOperation(input, interactionCancelParametersSchema, (client, parameters, options) => client.cancelInteraction(parameters, options), { commandId: input.commandId }),
+    createInteraction: (input) => node.runValidatedNodeOperation(input, interactionCreateParametersSchema, (client, parameters, options) => client.createInteraction(parameters, options), { commandId: input.commandId }),
+    respondToInteraction: (input) => node.runValidatedNodeOperation(input, interactionRespondParametersSchema, (client, parameters, options) => client.respondToInteraction(parameters, options), { commandId: input.commandId }),
+});
+export const makeInteractionClient = (node) => ({
+    ...readClient(node),
+    ...mutationClient(node),
+});
+//# sourceMappingURL=client.js.map

package/dist/session/interaction/commands.d.ts

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

package/dist/session/interaction/commands.js

@@ -0,0 +1,101 @@
+import { interactionCancelParametersSchema, interactionCreateParametersSchema, interactionListParametersSchema, interactionRespondParametersSchema, interactionShowParametersSchema, protocolErrorSchema, } from "@maiaos/sdk";
+import { Cause, Effect } from "effect";
+import { CliArgumentError, reportError, writeSuccess, } from "../../command-line/index.js";
+import { invalidInteractionInput, readInteractionInput, readInteractionList, readInteractionShow, } from "./input.js";
+import { formatInteractionResult, } from "./output/index.js";
+const recoveryFor = (parameters) => typeof parameters === "object" &&
+    parameters !== null &&
+    "commandId" in parameters &&
+    typeof parameters.commandId === "string"
+    ? { recovery: { commandId: parameters.commandId } }
+    : {};
+const boundaryFailure = (parameters) => ({
+    error: {
+        code: "recovery" in recoveryFor(parameters)
+            ? "outcome_unknown"
+            : "node_unavailable",
+        message: "Interaction response unavailable. Reconcile the original command before retrying a mutation.",
+        retryable: false,
+    },
+    ok: false,
+    ...recoveryFor(parameters),
+});
+const writeResponse = (response, parameters, context) => {
+    if (!response.ok) {
+        const error = protocolErrorSchema.parse(response.error);
+        return reportError({
+            ...error,
+            message: "Interaction operation failed. Answers never authorize operations.",
+        }, {
+            ...context,
+            ...(error.code === "outcome_unknown" ? recoveryFor(parameters) : {}),
+        });
+    }
+    writeSuccess({ command: response.value.method, result: response.value }, context, formatInteractionResult);
+    return 0;
+};
+const callNode = (operation, parameters) => operation(parameters).pipe(Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause)
+    ? Effect.interrupt
+    : Effect.succeed(boundaryFailure(parameters))));
+const invoke = (spec, context) => Effect.gen(function* () {
+    const input = yield* spec.input;
+    const parameters = yield* Effect.try({
+        catch: invalidInteractionInput,
+        try: () => spec.parameters.parse(input),
+    });
+    const operation = spec.operation;
+    if (operation === undefined)
+        return yield* Effect.fail(new Error("Missing interaction client."));
+    const response = yield* callNode(operation, parameters);
+    return yield* Effect.try({
+        catch: () => new Error("Invalid interaction response."),
+        try: () => writeResponse(response, parameters, context),
+    }).pipe(Effect.catch(() => Effect.sync(() => writeResponse(boundaryFailure(parameters), parameters, context))));
+});
+const mutations = {
+    cancel: (input, context) => invoke({
+        input,
+        operation: context.dependencies.cancelInteraction,
+        parameters: interactionCancelParametersSchema,
+    }, context),
+    create: (input, context) => invoke({
+        input,
+        operation: context.dependencies.createInteraction,
+        parameters: interactionCreateParametersSchema,
+    }, context),
+    respond: (input, context) => invoke({
+        input,
+        operation: context.dependencies.respondToInteraction,
+        parameters: interactionRespondParametersSchema,
+    }, context),
+};
+const recover = (context) => (error) => Effect.sync(() => reportError({
+    code: error instanceof CliArgumentError
+        ? "invalid_argument"
+        : "internal_error",
+    message: error instanceof CliArgumentError
+        ? error.message
+        : "Interaction command failed.",
+    retryable: false,
+}, context));
+const mutation = (action) => (tokens, context) => mutations[action](readInteractionInput(tokens, context), context).pipe(Effect.catch(recover(context)));
+export const runInteractionCreate = mutation("create");
+export const runInteractionRespond = mutation("respond");
+export const runInteractionCancel = mutation("cancel");
+export const runInteractionList = (tokens, context) => invoke({
+    input: Effect.try({
+        catch: invalidInteractionInput,
+        try: () => readInteractionList(tokens),
+    }),
+    operation: context.dependencies.listInteractions,
+    parameters: interactionListParametersSchema,
+}, context).pipe(Effect.catch(recover(context)));
+export const runInteractionShow = (tokens, context) => invoke({
+    input: Effect.try({
+        catch: invalidInteractionInput,
+        try: () => readInteractionShow(tokens),
+    }),
+    operation: context.dependencies.showInteraction,
+    parameters: interactionShowParametersSchema,
+}, context).pipe(Effect.catch(recover(context)));
+//# sourceMappingURL=commands.js.map

package/dist/session/interaction/index.d.ts

@@ -0,0 +1,3 @@
+export { type InteractionCliDependencies, makeInteractionClient, } from "./client.js";
+export { runInteractionCancel, runInteractionCreate, runInteractionList, runInteractionRespond, runInteractionShow, } from "./commands.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/session/interaction/index.js

@@ -0,0 +1,3 @@
+export { makeInteractionClient, } from "./client.js";
+export { runInteractionCancel, runInteractionCreate, runInteractionList, runInteractionRespond, runInteractionShow, } from "./commands.js";
+//# sourceMappingURL=index.js.map

package/dist/session/interaction/input.d.ts

@@ -0,0 +1,15 @@
+import { Effect } from "effect";
+import { CliArgumentError, type CommandContext } from "../../command-line/index.js";
+export declare const invalidInteractionInput: () => CliArgumentError;
+export declare const readInteractionInput: (tokens: readonly string[], context: CommandContext) => Effect.Effect<unknown, CliArgumentError, never>;
+export declare const readInteractionList: (tokens: readonly string[]) => {
+    limit: number;
+    projectId: string | undefined;
+    sessionId: string | undefined;
+    afterCursor?: string | undefined;
+    lifecycleStatus?: string | undefined;
+};
+export declare const readInteractionShow: (tokens: readonly string[]) => {
+    interactionId: string | undefined;
+};
+//# sourceMappingURL=input.d.ts.map

package/dist/session/interaction/input.js

@@ -0,0 +1,46 @@
+import { Buffer } from "node:buffer";
+import { Effect } from "effect";
+import { CliArgumentError, decodeJsonText, parseOptions, readPageSize, recoverStdin, requirePositionals, } from "../../command-line/index.js";
+export const invalidInteractionInput = () => new CliArgumentError("Invalid interaction input. Use 'maia help session interaction' for usage.");
+const stdinBounds = {
+    label: "interaction input",
+    maxBytes: 131_072,
+    maxChunks: 32,
+};
+const parseInput = (text) => Buffer.byteLength(text, "utf8") > stdinBounds.maxBytes
+    ? Effect.fail(invalidInteractionInput())
+    : decodeJsonText(text, invalidInteractionInput);
+const requireStdin = (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(), new Set(["--input-stdin"]));
+    requirePositionals(parsed.positionals, 0);
+    if (!parsed.flags.has("--input-stdin") || context.io.stdin === undefined)
+        throw invalidInteractionInput();
+    return context.io.stdin;
+};
+export const readInteractionInput = (tokens, context) => Effect.gen(function* () {
+    const stdin = yield* Effect.try({
+        catch: invalidInteractionInput,
+        try: () => requireStdin(tokens, context),
+    });
+    const text = yield* recoverStdin(stdin(stdinBounds), invalidInteractionInput);
+    return yield* parseInput(text);
+});
+export const readInteractionList = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit", "--project", "--session", "--status"]));
+    requirePositionals(parsed.positionals, 0);
+    const afterCursor = parsed.options.get("--after");
+    const lifecycleStatus = parsed.options.get("--status");
+    return {
+        limit: readPageSize(parsed.options.get("--limit")),
+        projectId: parsed.options.get("--project"),
+        sessionId: parsed.options.get("--session"),
+        ...(afterCursor === undefined ? {} : { afterCursor }),
+        ...(lifecycleStatus === undefined ? {} : { lifecycleStatus }),
+    };
+};
+export const readInteractionShow = (tokens) => {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1);
+    return { interactionId: parsed.positionals[0] };
+};
+//# sourceMappingURL=input.js.map

package/dist/session/interaction/output/format.d.ts

@@ -0,0 +1,11 @@
+import type { InteractionCancelResult, InteractionCreateResult, InteractionListResult, InteractionRespondResult, InteractionShowResult } from "@maiaos/sdk";
+export type InteractionResult = InteractionCancelResult | InteractionCreateResult | InteractionListResult | InteractionRespondResult | InteractionShowResult;
+export type CliInteractionResult = {
+    readonly command: InteractionResult["method"];
+    readonly result: InteractionResult;
+};
+export declare const isInteractionResult: (result: {
+    readonly command: string;
+}) => result is CliInteractionResult;
+export declare const formatInteractionResult: ({ result, }: CliInteractionResult) => string;
+//# sourceMappingURL=format.d.ts.map

package/dist/session/interaction/output/format.js

@@ -0,0 +1,3 @@
+export const isInteractionResult = (result) => result.command.startsWith("interaction.");
+export const formatInteractionResult = ({ result, }) => `Recorded only; does not authorize any operation.\n${JSON.stringify(result)}\n`;
+//# sourceMappingURL=format.js.map

package/dist/session/interaction/output/index.d.ts

@@ -0,0 +1,2 @@
+export { type CliInteractionResult, formatInteractionResult, type InteractionResult, isInteractionResult, } from "./format.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/session/interaction/output/index.js

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

package/dist/session/output/diff.d.ts

@@ -0,0 +1,3 @@
+import type { SessionDiffResult } from "@maiaos/sdk";
+export declare const formatSessionDiff: (result: SessionDiffResult) => string;
+//# sourceMappingURL=diff.d.ts.map

package/dist/session/output/diff.js

@@ -0,0 +1,30 @@
+const isUnsafeControl = (character) => {
+    const point = character.codePointAt(0) ?? 0;
+    return ((point <= 31 && point !== 9 && point !== 10) ||
+        (point >= 127 && point <= 159) ||
+        point === 8232 ||
+        point === 8233);
+};
+const safeText = (value) => Array.from(value, (character) => isUnsafeControl(character) ? "�" : character).join("");
+const counts = (file) => file.insertions === undefined || file.deletions === undefined
+    ? "binary"
+    : `+${String(file.insertions)}\t-${String(file.deletions)}`;
+const fileLine = (file) => [
+    file.status,
+    counts(file),
+    safeText(file.previousPath === undefined
+        ? file.path
+        : `${file.previousPath} -> ${file.path}`),
+].join("\t");
+export const formatSessionDiff = (result) => {
+    const omitted = result.totalFiles - result.files.length;
+    const lines = [
+        ...result.files.map(fileLine),
+        `total\t+${String(result.insertions)}\t-${String(result.deletions)}\t${String(result.totalFiles)} files${omitted > 0 ? ` (${String(omitted)} not listed)` : ""}`,
+    ];
+    const patch = result.patch === undefined
+        ? ""
+        : `${safeText(result.patch)}${result.patchTruncated === true ? "[patch truncated]\n" : ""}`;
+    return `${lines.join("\n")}\n${patch}`;
+};
+//# sourceMappingURL=diff.js.map

package/dist/session/output/failure.d.ts

@@ -0,0 +1,11 @@
+import type { SessionEventsListResult } from "@maiaos/sdk";
+type Failure = {
+    readonly code: string;
+    readonly message: string;
+};
+type SessionEvent = SessionEventsListResult["items"][number];
+export declare const formatFailureCell: (failure: Failure) => string;
+export declare const formatFailure: (failure?: Failure, state?: "failed" | "outcome-unknown") => string;
+export declare const formatSessionEvents: (items: readonly SessionEvent[]) => string;
+export {};
+//# sourceMappingURL=failure.d.ts.map

package/dist/session/output/failure.js

@@ -0,0 +1,24 @@
+import { formatRows } from "../../command-line/index.js";
+const isTerminalControl = (character) => {
+    const point = character.codePointAt(0) ?? 0;
+    return (point <= 31 ||
+        (point >= 127 && point <= 159) ||
+        point === 8232 ||
+        point === 8233);
+};
+export const formatFailureCell = (failure) => `${failure.code}: ${Array.from(failure.message, (character) => isTerminalControl(character) ? "�" : character).join("")}`;
+export const formatFailure = (failure, state = "failed") => failure === undefined ? "" : `${state}: ${formatFailureCell(failure)}\n`;
+const eventFailure = (event) => {
+    const { eventType, payload } = event;
+    if ((eventType !== "session.runtime.failed" && eventType !== "turn.failed") ||
+        !("reason" in payload) ||
+        typeof payload.reason !== "string")
+        return "";
+    const failure = "failure" in payload ? payload.failure : undefined;
+    return `\t${payload.reason}${failure === undefined ? "" : `\t${formatFailureCell(failure)}`}`;
+};
+export const formatSessionEvents = (items) => formatRows(items, (event) => `${event.sessionCursor}\t${event.eventType}\t${event.globalCursor}${eventFailure(event)}`, {
+    empty: "No events.",
+    headers: ["CURSOR", "EVENT", "GLOBAL", "REASON", "FAILURE"],
+});
+//# sourceMappingURL=failure.js.map