@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/cli/render/akuma.d.ts

@@ -1,6 +1,8 @@
 import type { AkumaInvocationResult } from "../commands/akuma-invoke.js";
 import type { ParsedCommand } from "../parse.js";
-export declare function renderAkumaText(command: ParsedCommand, result: AkumaInvocationResult): string;
+import { type TextRenderContext } from "./terminal.js";
+export declare function akumaRawAnswer(result: AkumaInvocationResult): string | undefined;
+export declare function renderAkumaText(command: ParsedCommand, result: AkumaInvocationResult, context?: TextRenderContext): string;
 export declare function akumaExitCode(result: AkumaInvocationResult): number;
 export declare function akumaJsonValue(command: ParsedCommand, result: AkumaInvocationResult): unknown;
 export declare function renderAkumaJson(command: ParsedCommand, result: AkumaInvocationResult): string;

package/build/src/cli/render/akuma.js

@@ -1,253 +1,288 @@
 import { toolRepr } from "./akuma-tool.js";
-import { safeText } from "./terminal.js";
-const GUTTER_MS = 60_000;
-const LABEL_WIDTH = 8;
-function mark(life) {
-    switch (life) {
-        case "running": return "●";
-        case "dead": return "×";
-        case "asleep": return "○";
-        case "stranded":
-        case "headless": return "!";
-    }
+import { displayColumns, renderBoundedTextBlock, safeText, truncateMiddleDisplayText } from "./terminal.js";
+const DEFAULT_CONTEXT = { columns: 80, color: false };
+const OPENING_STROKE = "─────";
+const TIME_WIDTH = 5;
+const VERB_WIDTH = 6;
+function identity(id, alias) {
+    return `${id}${alias === undefined ? "" : ` (${alias})`}`;
+}
+function associatedIdentity(id, alias, contractId) {
+    return `${identity(id, alias)}${contractId === undefined ? "" : ` [${contractId}]`}`;
+}
+function snapshotHeading(id, alias, contractId) {
+    return [
+        OPENING_STROKE,
+        identity(id, alias),
+        ...(contractId === undefined ? [] : [`└─ ${contractId}`]),
+    ];
 }
-function ruler(parts) {
-    const prefix = `── ${parts.join(" ── ")} `;
-    return `${prefix}${"─".repeat(Math.max(1, 64 - prefix.length))}`;
+function lifeLabel(life) {
+    if (life === "running")
+        return "● running";
+    if (life === "asleep")
+        return "○ asleep";
+    if (life === "killed")
+        return "× killed";
+    return `? ${life}`;
 }
 function clock(at) {
-    if (at === undefined)
-        return "";
     const date = new Date(at);
-    if (!Number.isFinite(date.getTime()))
-        return "";
-    return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
-}
-function renderSpine(items) {
-    let lastPrintedAt;
-    return items.map((item) => {
-        const timestamp = item.at === undefined ? undefined : Date.parse(item.at);
-        const printable = timestamp !== undefined && Number.isFinite(timestamp)
-            && (lastPrintedAt === undefined || timestamp - lastPrintedAt >= GUTTER_MS);
-        if (printable)
-            lastPrintedAt = timestamp;
-        const time = printable ? clock(item.at) : "";
-        const index = item.index === undefined ? "" : String(item.index).padStart(4, " ");
-        const gutter = `${index}${index.length === 0 ? "" : " "}${time.padStart(5, " ")}`;
-        return `${gutter} │ ${item.label.padEnd(LABEL_WIDTH, " ")} ${item.text}`.trimEnd();
-    });
+    return Number.isFinite(date.getTime()) ? `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}` : "unknown";
 }
-function activityItem(row) {
+function label(row) {
     if (row.kind === "said")
-        return { at: row.at, label: "say", text: row.text };
+        return "say";
     if (row.kind === "thought")
-        return { at: row.at, label: "thought", text: row.text };
+        return "think";
     if (row.kind === "note")
-        return { at: row.at, label: "note", text: row.text };
-    const repr = toolRepr(row);
-    return {
-        at: row.at,
-        label: repr.label,
-        text: repr.text,
-    };
-}
-function pendingItems(status) {
-    return status.activity.pendingTells.map((tell) => ({ label: "⧗ tell", text: JSON.stringify(tell.body) }));
-}
-function outcomeItems(status) {
-    if (status.answer !== undefined) {
-        return [{
-                ...(status.outcomeAt === undefined ? {} : { at: status.outcomeAt }),
-                label: "✓",
-                text: `answered · keiyaku history ${status.answerHistoryId ?? ""} --last`.trim(),
-            }];
+        return "note";
+    if (row.kind === "call")
+        return "call";
+    if (row.kind === "tell")
+        return "tell";
+    if (row.kind === "outcome")
+        return row.outcome.kind === "answered" ? "say" : "error";
+    if (row.kind === "turn")
+        return "call";
+    return toolRepr(row).label;
+}
+function mark(row) {
+    if (row.kind === "outcome")
+        return row.outcome.kind === "answered" ? "✓" : "!";
+    if (row.kind === "tell" && row.state === "pending")
+        return "⧗";
+    if (row.kind === "tool") {
+        if (row.state === "active")
+            return "⧖";
+        if (row.state === "unsettled")
+            return "?";
+        return row.state.status === "ok" ? "✓" : "!";
     }
-    if (status.failure !== undefined) {
-        return [{
-                ...(status.outcomeAt === undefined ? {} : { at: status.outcomeAt }),
-                label: "!",
-                text: `failed · ${status.failure}`,
-            }];
+    return "·";
+}
+function rowText(row) {
+    if (row.kind === "said" || row.kind === "thought" || row.kind === "note" || row.kind === "call" || row.kind === "tell") {
+        return { text: row.text, lines: row.kind === "said" || row.kind === "thought" ? 2 : row.kind === "tell" || row.kind === "call" ? 1 : 2 };
     }
-    return [];
+    if (row.kind === "outcome")
+        return row.outcome.kind === "answered"
+            ? { text: row.outcome.answer, lines: 3 }
+            : { text: row.outcome.diagnostic, lines: 2 };
+    if (row.kind === "turn")
+        return { text: "", lines: 1 };
+    const repr = toolRepr(row);
+    return { text: repr.text, lines: 2, ...(repr.overflow === "middle-ellipsis" ? { middle: true } : {}), ...(repr.suffix === undefined ? {} : { suffix: repr.suffix }) };
 }
-function statusItems(status) {
-    return [
-        ...status.activity.rows.map(activityItem),
-        ...pendingItems(status),
-        ...outcomeItems(status),
-    ];
+function eventPrefix(glyph, verb, time) {
+    const gutter = time === undefined ? " ".repeat(TIME_WIDTH) : time.padEnd(TIME_WIDTH);
+    return `${gutter} ${glyph} ${verb.padEnd(VERB_WIDTH)} `;
 }
-function omission(status) {
-    return status.activity.omitted === 0
-        ? []
-        : [`      ⋮ +${status.activity.omitted}`];
+function continuationPrefix() {
+    return eventPrefix("│", "");
 }
-function statusText(status, facts = []) {
-    return [
-        ruler([`${mark(status.life)} ${status.id}`]),
-        ...facts,
-        ...omission(status),
-        ...renderSpine(statusItems(status)),
-    ].join("\n");
-}
-function historyItems(history) {
-    const activity = history.rows.map((row) => ({ ...activityItem(row), index: row.sequence }));
-    const boundaries = history.turns.map((turn) => turn.outcome.kind === "answered"
-        ? { at: turn.completedAt, label: "✓", text: `answered · keiyaku history ${turn.outcome.historyId} --last` }
-        : { at: turn.completedAt, label: "!", text: `failed · ${turn.outcome.diagnostic}` });
-    return [...activity, ...boundaries].sort((left, right) => {
-        const leftAt = left.at === undefined ? Number.POSITIVE_INFINITY : Date.parse(left.at);
-        const rightAt = right.at === undefined ? Number.POSITIVE_INFINITY : Date.parse(right.at);
-        return (Number.isFinite(leftAt) ? leftAt : Number.POSITIVE_INFINITY)
-            - (Number.isFinite(rightAt) ? rightAt : Number.POSITIVE_INFINITY);
+function quotedBody(row) {
+    return row.kind === "said" || row.kind === "thought" || row.kind === "tell"
+        || (row.kind === "outcome" && row.outcome.kind === "answered");
+}
+function quoteLines(lines, prefix) {
+    const prefixWidth = prefix.length;
+    return lines.map((line) => {
+        const body = line.slice(prefixWidth);
+        if (body.length === 0)
+            return line;
+        return `${line.slice(0, prefixWidth)}“${body}”`;
     });
 }
-function historyText(command, result) {
-    if (command.last)
-        return result.answer ?? "";
-    const history = result.history;
-    const scope = command.before === undefined && command.since === undefined
-        ? "history"
-        : `history ── ${command.before === undefined ? `since ${command.since}` : `before ${command.before}`}`;
-    const lines = [ruler([result.akuma, scope])];
-    const first = history.rows[0]?.sequence;
-    const last = history.rows.at(-1)?.sequence;
-    if (history.hasEarlier && first !== undefined) {
-        lines.push(`   ⋮ ${history.omitted} earlier · keiyaku history ${result.akuma} --before ${first}`);
-    }
-    else if (history.historyLost) {
-        lines.push("   ⋮ earlier history no longer kept");
-    }
-    if (history.hasLater && last !== undefined) {
-        lines.push(`   ⋮ more · keiyaku history ${result.akuma} --since ${last}`);
+function renderMiddleEllipsis(first, text, suffix, columns) {
+    const prefixWidth = displayColumns(first);
+    const remaining = columns - prefixWidth;
+    const suffixWidth = displayColumns(suffix);
+    const withSuffix = remaining - suffixWidth;
+    // `$ ` + one head char + ellipsis + tail; cue and ellipsis alone are not a subject.
+    const showSuffix = suffix.length > 0 && withSuffix >= 6;
+    return `${first}${truncateMiddleDisplayText(text, Math.max(0, showSuffix ? withSuffix : remaining))}${showSuffix ? suffix : ""}`;
+}
+function renderRow(row, context, history, first) {
+    const value = rowText(row);
+    const quoted = quotedBody(row);
+    const quoteWidth = quoted ? 2 : 0;
+    if (value.middle === true) {
+        return [renderMiddleEllipsis(first, value.text, value.suffix ?? "", context.columns - quoteWidth)];
     }
-    if (command.since !== undefined && history.rows.length === 0) {
-        lines.push(`   ⋮ no activity since ${command.since}`);
+    const lines = renderBoundedTextBlock(value.text, {
+        first,
+        continuation: continuationPrefix(),
+        columns: context.columns - quoteWidth,
+        lines: history ? Number.MAX_SAFE_INTEGER : value.lines,
+        ...("truncated" in row && row.truncated === true ? { truncated: true } : {}),
+    });
+    return quoted ? quoteLines(lines, first) : lines;
+}
+function groupedEntries(entries, context, history = false) {
+    const lines = [];
+    let previousClock;
+    for (const entry of entries) {
+        if (entry.kind === "gap") {
+            lines.push(`${" ".repeat(TIME_WIDTH)} ⋮ ${entry.count} omitted`);
+            continue;
+        }
+        const row = entry.row;
+        const at = clock(row.at);
+        const changed = previousClock === undefined || at !== previousClock;
+        lines.push(...renderRow(row, context, history, eventPrefix(mark(row), label(row), changed ? at : undefined)));
+        previousClock = at;
     }
-    lines.push(...renderSpine(historyItems(history)));
-    return lines.join("\n");
+    return lines;
 }
-function waitText(status) {
-    if (status.life === "running")
-        return statusText(status);
-    if (status.answer !== undefined)
-        return status.answer;
-    if (status.failure !== undefined)
-        return `failure ${status.failure}`;
-    return statusText(status);
+function groupedRows(rows, context, history = false) {
+    return groupedEntries(rows.filter((row) => row.kind !== "turn").map((row) => ({ kind: "row", row })), context, history);
 }
-function wakeFailure(receipt) {
-    return typeof receipt.wake === "string" ? null : `wake failed: ${safeText(receipt.wake.diagnostic)}`;
+function snapshotText(view, context, options = {}) {
+    const snapshot = view.status.timeline;
+    const activity = snapshot.kind === "idle" && snapshot.outcome !== undefined
+        ? groupedRows([
+            ...snapshot.entries.filter((entry) => entry.kind === "row").map((entry) => entry.row),
+            snapshot.outcome,
+        ].sort((left, right) => left.sequence - right.sequence), context)
+        : groupedEntries(snapshot.entries, context);
+    const facts = [
+        ...(view.status.readonly?.enforcement === "none" ? [`! ${safeText(view.status.readonly.diagnostic)}`] : []),
+        ...(options.facts ?? []),
+    ];
+    const footer = options.showLife === false ? [] : [`  ${lifeLabel(view.status.life)}`];
+    return [...snapshotHeading(view.status.id, options.alias, view.contractId), ...facts, ...activity, ...footer].join("\n");
 }
-function tellText(status, receipt) {
-    const failure = wakeFailure(receipt);
-    return failure === null ? statusText(status) : `${statusText(status)}\n${failure}`;
+function historyText(command, result, context) {
+    if (command.last)
+        return result.mode === "last" ? result.answer : "no answer retained";
+    if (result.mode !== "page")
+        throw new Error("history result lacks page");
+    const contractId = result.historyResult.contractId;
+    return [...snapshotHeading(result.akuma, result.alias, contractId), ...groupedRows(result.history.rows, context, true)].join("\n");
+}
+function tellText(result, context) {
+    const facts = typeof result.result.tell.wake === "string" ? [] : [`! error ${safeText(result.result.tell.wake.diagnostic)}`];
+    return snapshotText(result.result.observation, context, { ...(result.alias === undefined ? {} : { alias: result.alias }), facts, showLife: false });
 }
 function dispatchLines(stage) {
-    if (stage.kind === "none")
+    if (stage.kind === "none" || stage.kind === "dispatched")
         return [];
-    if (stage.kind === "dispatched")
-        return [`dispatch ${stage.dispatch.contractId}`];
-    const failure = stage.failure;
-    if (failure.kind === "conflict") {
-        return [`dispatch failed conflict ${failure.current.contractId}`];
-    }
-    if (failure.kind === "contention")
+    if (stage.failure.kind === "conflict")
+        return [`dispatch failed conflict ${stage.failure.current.contractId}`];
+    if (stage.failure.kind === "contention")
         return ["dispatch failed contention"];
-    return [`dispatch failed ${failure.kind} ${safeText(failure.diagnostic)}`];
-}
-function callText(result) {
-    const called = result.result;
-    const stages = [...dispatchLines(called.dispatch)];
-    if (called.alias.kind === "aliased")
-        stages.push(`alias ${called.alias.alias.alias}`);
-    else if (called.alias.kind === "failed") {
-        stages.push(`alias failed ${called.alias.failure.kind} ${safeText(called.alias.failure.diagnostic)}`);
+    return [`dispatch failed ${stage.failure.kind} ${safeText(stage.failure.diagnostic)}`];
+}
+function callFailed(result) {
+    return result.dispatch.kind === "failed"
+        || result.alias.kind === "failed"
+        || result.readonly?.enforcement === "none";
+}
+function statusAnswer(view) {
+    if (view.status.life !== "asleep")
+        return undefined;
+    if (view.status.readonly?.enforcement === "none")
+        return undefined;
+    const timeline = view.status.timeline;
+    if (timeline.kind !== "idle" || timeline.outcome?.outcome.kind !== "answered")
+        return undefined;
+    return timeline.outcome.outcome.answer;
+}
+export function akumaRawAnswer(result) {
+    if (result.action === "call") {
+        if (callFailed(result.result) || result.result.observation.kind !== "observed")
+            return undefined;
+        return statusAnswer({ status: result.result.observation.status });
     }
-    if (called.observation.kind === "detached")
-        return [called.akuma, ...stages].join("\n");
-    if (called.observation.kind === "failed") {
-        return [
-            called.akuma,
-            ...stages,
-            `wait failed ${called.observation.failure.kind} ${safeText(called.observation.failure.diagnostic)}`,
-        ].join("\n");
+    if (result.action === "wait" && result.result.statuses.length === 1)
+        return statusAnswer(result.result.statuses[0]);
+    return undefined;
+}
+function executionCwdLine(result) {
+    return result.execution.source === "contract-worktree" ? [`cwd ${result.execution.cwd}`] : [];
+}
+function callText(result, context) {
+    const alias = result.result.alias.kind === "aliased" ? result.result.alias.alias.alias : undefined;
+    const contractId = result.result.dispatch.kind === "dispatched" ? result.result.dispatch.dispatch.contractId : undefined;
+    const facts = [...dispatchLines(result.result.dispatch)];
+    const restraint = result.result.readonly?.enforcement === "none" ? [`! ${safeText(result.result.readonly.diagnostic)}`] : [];
+    if (result.result.alias.kind === "failed")
+        facts.push(`alias failed ${result.result.alias.failure.kind} ${safeText(result.result.alias.failure.diagnostic)}`);
+    const cwd = executionCwdLine(result.result);
+    if (result.result.observation.kind === "detached") {
+        const lines = [...snapshotHeading(result.result.akuma, alias, contractId), ...cwd, ...restraint, ...facts];
+        if (!callFailed(result.result)) {
+            const selector = result.result.alias.kind === "aliased" ? result.result.alias.alias.alias : result.result.akuma;
+            lines.push(`$ keiyaku -C ${result.world} wait ${selector} --timeout 5m`);
+        }
+        return lines.join("\n");
     }
-    const status = called.observation.status;
-    if (status.answer !== undefined || status.failure !== undefined) {
-        return [called.akuma, ...stages, waitText(status)].join("\n");
+    if (result.result.observation.kind === "failed") {
+        return [...snapshotHeading(result.result.akuma, alias, contractId), ...cwd, ...restraint, ...facts, `! error ${safeText(result.result.observation.failure.diagnostic)}`].join("\n");
     }
-    return statusText(status, stages);
+    return snapshotText({ status: result.result.observation.status, ...(contractId === undefined ? {} : { contractId }) }, context, {
+        ...(alias === undefined ? {} : { alias }),
+        facts: [...cwd, ...facts],
+    });
 }
-export function renderAkumaText(command, result) {
+export function renderAkumaText(command, result, context = DEFAULT_CONTEXT) {
+    const answer = akumaRawAnswer(result);
+    if (answer !== undefined) {
+        if (result.action !== "call")
+            return answer;
+        const cwd = executionCwdLine(result.result);
+        return cwd.length === 0 ? answer : `${cwd.join("\n")}\n${answer}`;
+    }
     switch (result.action) {
-        case "call": return callText(result);
-        case "status": return statusText(result.status);
-        case "wait": return waitText(result.status);
-        case "tell": return tellText(result.status, result.receipt);
-        case "interrupt": {
-            const receipt = result.receipt;
-            if (receipt.kind === "dead")
-                return `${result.akuma} interrupt dead`;
-            if (receipt.kind === "unstoppable")
-                return `${result.akuma} interrupt unstoppable ${receipt.evidence}`;
-            if ("kind" in receipt.tell)
-                return `${result.akuma} interrupted ${receipt.putDown} · tell refused: dead`;
-            const failure = wakeFailure(receipt.tell);
-            return `${result.akuma} interrupted ${receipt.putDown}${failure === null ? "" : ` · ${failure}`}`;
-        }
-        case "history": return historyText(command, result);
+        case "call": return callText(result, context);
+        case "status": return snapshotText(result.status, context, { ...(result.alias === undefined ? {} : { alias: result.alias }) });
+        case "wait": return result.result.statuses.map((status) => snapshotText(status, context, { ...(result.alias === undefined ? {} : { alias: result.alias }) })).join("\n\n");
+        case "tell": return result.mode === "ordinary" ? tellText(result, context) : snapshotText(result.result.observation, context, { ...(result.alias === undefined ? {} : { alias: result.alias }), showLife: false });
+        case "history": return historyText(command, result, context);
         case "fork": {
-            const receipt = result.receipt;
-            if (receipt.kind === "forked")
-                return [receipt.child, ...dispatchLines(receipt.dispatch)].join("\n");
-            if (receipt.kind === "provider-cannot-fork")
-                return `${receipt.provider} cannot fork`;
-            if (receipt.kind === "unknown-history")
-                return `${receipt.at} has no matching retained answered turn`;
-            if (receipt.kind === "fork-failed")
-                return receipt.diagnostic;
-            return `session ${receipt.childSession.sessionId}\n${receipt.diagnostic}`;
+            if (result.receipt.kind !== "forked")
+                return result.receipt.kind === "unknown-history" ? `${result.receipt.at} has no matching retained answered turn` : result.receipt.kind === "provider-cannot-fork" ? `${result.receipt.provider} cannot fork` : result.receipt.diagnostic;
+            const contractId = result.receipt.dispatch.kind === "dispatched" ? result.receipt.dispatch.dispatch.contractId : undefined;
+            return associatedIdentity(result.receipt.child, undefined, contractId);
         }
-        case "kill": return `${result.id} ${result.evidence}`;
+        case "kill": return result.result.results.map((member) => snapshotText(member.observation, context, { facts: [`kill ${member.evidence}`], ...(result.alias === undefined ? {} : { alias: result.alias }) })).join("\n\n");
     }
 }
-export function akumaExitCode(result) {
-    if (result.action === "call"
-        && (result.result.dispatch.kind === "failed"
-            || result.result.alias.kind === "failed"
-            || result.result.observation.kind === "failed"))
-        return 2;
-    if (result.action === "kill" && (result.evidence === "unavailable" || result.evidence === "alive-after-sigkill"))
-        return 1;
-    if (result.action === "tell" && typeof result.receipt.wake !== "string")
+function callExitCode(result) {
+    if (result.result.dispatch.kind === "failed" || result.result.alias.kind === "failed" || result.result.observation.kind === "failed")
         return 2;
-    if (result.action === "interrupt") {
-        if (result.receipt.kind !== "interrupted" || "kind" in result.receipt.tell)
-            return 1;
-        if (typeof result.receipt.tell.wake !== "string")
-            return 2;
-    }
-    if (result.action === "fork") {
-        if (result.receipt.kind === "forked")
-            return result.receipt.dispatch.kind === "failed" ? 2 : 0;
-        return result.receipt.kind === "upstream-forked" ? 2 : 1;
+    if (result.result.observation.kind !== "observed")
+        return 0;
+    const timeline = result.result.observation.status.timeline;
+    return timeline.kind === "idle" && timeline.outcome?.outcome.kind === "failed" ? 2 : 0;
+}
+function killExitCode(result) {
+    return result.result.results.some((member) => member.evidence === "unavailable" || member.evidence === "hung" || member.evidence === "untidy") ? 1 : 0;
+}
+function tellExitCode(result) {
+    if (result.mode === "ordinary")
+        return typeof result.result.tell.wake === "string" ? 0 : 2;
+    return result.result.receipt.kind === "interrupted" ? 0 : 1;
+}
+function forkExitCode(result) {
+    return result.receipt.kind === "forked" ? 0 : result.receipt.kind === "upstream-forked" ? 2 : 1;
+}
+export function akumaExitCode(result) {
+    switch (result.action) {
+        case "call": return callExitCode(result);
+        case "kill": return killExitCode(result);
+        case "tell": return tellExitCode(result);
+        case "fork": return forkExitCode(result);
+        default: return 0;
     }
-    return 0;
 }
 export function akumaJsonValue(command, result) {
-    if (result.action === "call")
-        return result.result;
-    if (result.action === "fork")
-        return result.receipt;
-    if (result.action === "status" || result.action === "wait")
-        return result.status;
-    if (result.action === "tell")
-        return { receipt: result.receipt, status: result.status };
-    if (result.action === "history")
-        return command.command === "history" && command.last ? result.answer ?? "" : result.history;
-    return result;
+    if (result.action === "call" || result.action === "fork" || result.action === "status" || result.action === "wait" || result.action === "tell" || result.action === "kill")
+        return result.action === "status" ? result.status : result.action === "wait" ? result.result : result.action === "tell" ? result.result : result.action === "kill" ? result.result : result.action === "call" ? result.result : result.receipt;
+    if (command.command !== "history")
+        throw new Error("history result requires the history command");
+    return result.historyResult;
 }
 export function renderAkumaJson(command, result) {
     return JSON.stringify(akumaJsonValue(command, result));

package/build/src/cli/render/audit.d.ts

@@ -0,0 +1,3 @@
+import type { AcceptedAuditResult } from "../result.js";
+import { type TextRenderContext } from "./terminal.js";
+export declare function renderAcceptedAudit(result: AcceptedAuditResult, context?: TextRenderContext): string;

package/build/src/cli/render/audit.js

@@ -0,0 +1,104 @@
+import { cleanupLines, leakLines, outcomeLines, receiptPayload, receiptRow, stopLines, } from "./receipt.js";
+import { renderRefusalFacts } from "./refusal.js";
+import { gitShortStat, renderBoundedTextBlock, renderOpaqueBlock, } from "./terminal.js";
+const CHILD = "  ";
+function workspaceEvidence(workspace, columns) {
+    return renderOpaqueBlock(`workspace ${workspace.kind} ${workspace.path}`, CHILD, columns);
+}
+function candidateLines(report, columns, addressed) {
+    const candidate = report.candidate;
+    const lines = [];
+    if (candidate.kind === "blocked") {
+        receiptRow(lines, "!", "candidate", [{ text: "blocked" }], columns);
+        lines.push(...renderRefusalFacts(candidate.refusal, CHILD, columns, addressed));
+        return lines;
+    }
+    const identity = candidate.identity;
+    receiptRow(lines, "✓", "candidate", [{ text: "ready" }], columns);
+    lines.push(...renderOpaqueBlock(`tender=${identity.tenderSnapshot}`, CHILD, columns));
+    lines.push(...renderOpaqueBlock(`integration=${identity.integration.snapshot}`, CHILD, columns));
+    lines.push(...renderOpaqueBlock(`change=${identity.integration.changeId}`, CHILD, columns));
+    lines.push(...workspaceEvidence(candidate.workspace, columns));
+    lines.push(...renderOpaqueBlock(gitShortStat(candidate.scope), CHILD, columns));
+    if (candidate.scope.paths !== undefined) {
+        for (const path of candidate.scope.paths) {
+            lines.push(...renderOpaqueBlock(path, CHILD, columns));
+        }
+    }
+    if (report.delivery !== undefined) {
+        lines.push(...renderOpaqueBlock(`delivery change=${report.delivery.changeId} ${report.delivery.relation}`, CHILD, columns));
+    }
+    if (candidate.diff !== undefined)
+        receiptPayload(lines, "diff", candidate.diff);
+    return lines;
+}
+function verificationLines(verification, columns, addressed) {
+    const lines = [];
+    if (verification.kind === "not-run") {
+        receiptRow(lines, "·", "verification", [{ text: "not-run" }], columns);
+        return lines;
+    }
+    if (verification.kind === "stopped") {
+        return stopLines("verification", verification.stop, columns, addressed);
+    }
+    receiptRow(lines, verification.kind === "satisfied" ? "✓" : "!", "verification", [
+        { text: verification.kind },
+        { text: `${verification.passed} of ${verification.total}` },
+    ], columns);
+    if (verification.summary !== undefined) {
+        lines.push(...renderBoundedTextBlock(verification.summary, {
+            first: `${CHILD}summary `,
+            continuation: CHILD,
+            columns,
+        }));
+    }
+    return lines;
+}
+function targetLines(target, columns, addressed) {
+    const lines = [];
+    if (target.kind === "not-observed") {
+        receiptRow(lines, "·", "target", [{ text: "not-observed" }], columns);
+        return lines;
+    }
+    if (target.kind === "placeable") {
+        receiptRow(lines, "✓", "target", [
+            { text: "placeable" },
+            { text: target.ref, opaque: true },
+            { text: target.head, opaque: true },
+        ], columns);
+        return lines;
+    }
+    if (target.kind === "moved") {
+        receiptRow(lines, "!", "target", [
+            { text: "moved" },
+            { text: target.ref, opaque: true },
+            { text: `${target.expected} -> ${target.observed}`, opaque: true },
+        ], columns);
+        return lines;
+    }
+    if (target.kind === "failed") {
+        receiptRow(lines, "!", "target", [{ text: "failed" }], columns);
+        receiptPayload(lines, "diagnostic", target.diagnostic);
+        return lines;
+    }
+    receiptRow(lines, "!", "target", [{ text: "refused" }], columns);
+    lines.push(...renderRefusalFacts(target.refusal, CHILD, columns, addressed));
+    return lines;
+}
+function obligationLines(result, columns) {
+    return [
+        ...(result.cleanup === undefined ? [] : cleanupLines(result.cleanup, columns)),
+        ...(result.leak === undefined ? [] : leakLines(result.leak, columns)),
+    ];
+}
+export function renderAcceptedAudit(result, context) {
+    const report = result.report;
+    const columns = context?.columns ?? 80;
+    return [
+        ...outcomeLines("✓", result.verb, "accepted", result.contract, columns),
+        ...candidateLines(report, columns, result.contract),
+        ...verificationLines(report.verification, columns, result.contract),
+        ...targetLines(report.target, columns, result.contract),
+        ...obligationLines(result, columns),
+    ].join("\n");
+}

package/build/src/cli/render/catalog.d.ts

@@ -0,0 +1,2 @@
+import type { Catalog } from "../../index.js";
+export declare function renderCatalogText(catalog: Catalog): string;