@astrosheep/keiyaku 4.1.1 → 4.1.3

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

@@ -0,0 +1,362 @@
+import { defaultWaitComplete } from "../../akuma/index.js";
+import { toolRepr } from "./akuma-tool.js";
+import { displayColumns, renderBoundedTextBlock, safeText, truncateMiddleDisplayText, } from "./terminal.js";
+export const DEFAULT_CONTEXT = { columns: 80, color: false };
+const SNAPSHOT_RULER = "────────────";
+const TIME_WIDTH = 5;
+const VERB_WIDTH = 6;
+function identity(id, alias) {
+    return `${id}${alias === undefined ? "" : ` (${alias})`}`;
+}
+function associatedContractId(contract) {
+    return contract.kind === "associated" ? contract.contractId : undefined;
+}
+export function associatedIdentity(id, alias, contract) {
+    const contractId = contract === undefined ? undefined : associatedContractId(contract);
+    return `${identity(id, alias)}${contractId === undefined ? "" : ` [${contractId}]`}`;
+}
+export function snapshotHeading(id, alias, contract) {
+    const contractId = contract === undefined ? undefined : associatedContractId(contract);
+    return [identity(id, alias), SNAPSHOT_RULER, ...(contractId === undefined ? [] : [`└─ ${contractId}`])];
+}
+function answeredHeading(id, alias) {
+    return [`✓ came back ${identity(id, alias)}`, SNAPSHOT_RULER].join("\n");
+}
+function contractFacts(contract) {
+    return contract.kind === "failed" ? [`! contract failed ${safeText(contract.diagnostic)}`] : [];
+}
+function unobservedText(id, diagnostic) {
+    return `! ${id} unobserved: ${safeText(diagnostic)}`;
+}
+function lifeLabel(life) {
+    if (life === "running")
+        return "● STILL RUNNING";
+    if (life === "asleep")
+        return "✓ came back";
+    if (life === "killed")
+        return "× killed";
+    return `? ${life}`;
+}
+function pendingWithoutLiveBody(status) {
+    if (status.life === "running")
+        return 0;
+    return status.timeline.entries.reduce((count, entry) => count + (entry.kind === "row" && entry.row.kind === "tell" && entry.row.state === "pending" ? 1 : 0), 0);
+}
+function clock(at) {
+    const date = new Date(at);
+    return Number.isFinite(date.getTime())
+        ? `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`
+        : "unknown";
+}
+function label(row) {
+    if (row.kind === "said")
+        return "say";
+    if (row.kind === "thought")
+        return "think";
+    if (row.kind === "note")
+        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" ? "✓" : "!";
+    }
+    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,
+        };
+    }
+    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 eventPrefix(glyph, verb, time) {
+    const gutter = time === undefined ? " ".repeat(TIME_WIDTH) : time.padEnd(TIME_WIDTH);
+    return `${gutter} ${glyph} ${verb.padEnd(VERB_WIDTH)} `;
+}
+function continuationPrefix() {
+    return eventPrefix("│", "");
+}
+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 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)];
+    }
+    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;
+    }
+    return lines;
+}
+function groupedRows(rows, context, history = false) {
+    return groupedEntries(rows.filter((row) => row.kind !== "turn").map((row) => ({ kind: "row", row })), context, history);
+}
+function taskDispositionMark(disposition) {
+    if (disposition === "done")
+        return "✓";
+    if (disposition === "drop")
+        return "×";
+    if (disposition === "on_hold")
+        return "⧗";
+    if (disposition === "in_progress")
+        return "●";
+    return disposition === "blocked" ? "‖" : "○";
+}
+function changeStat(group) {
+    let added = 0;
+    let removed = 0;
+    for (const change of group) {
+        if (change.diffstat === undefined)
+            return "+? -?";
+        added += change.diffstat.added;
+        removed += change.diffstat.removed;
+    }
+    return `+${added} -${removed}`;
+}
+function groupedChangeRows(changes) {
+    const groups = [];
+    const seen = new Map();
+    for (const change of changes) {
+        const index = seen.get(change.path);
+        if (index === undefined) {
+            seen.set(change.path, groups.length);
+            groups.push([change]);
+        }
+        else
+            groups[index].push(change);
+    }
+    return groups.map((group) => ({ path: group[0].path, stat: changeStat(group) }));
+}
+function renderReportedChangeLines(snapshot) {
+    const rows = groupedChangeRows(snapshot.reportedChanges);
+    const width = rows.reduce((max, row) => Math.max(max, row.stat.length), 0);
+    return [
+        `changes ${snapshot.reportedChanges.length + snapshot.reportedChangesOmitted}`,
+        ...rows.map((row) => `  ${row.stat.padEnd(width)}  ${safeText(row.path)}`),
+        ...(snapshot.reportedChangesOmitted > 0 ? [`  ⋮ ${snapshot.reportedChangesOmitted} earlier changes`] : []),
+    ];
+}
+function renderTaskRow(row, columns) {
+    const prefix = `  ${taskDispositionMark(row.disposition)} ${row.id} · `;
+    const body = `${safeText(row.title)} · ${row.disposition} · P${row.priority}`;
+    const inline = `${prefix}${body}`;
+    if (displayColumns(inline) <= columns)
+        return [inline];
+    return renderBoundedTextBlock(body, {
+        first: prefix,
+        continuation: "    ",
+        columns,
+        lines: Number.MAX_SAFE_INTEGER,
+    });
+}
+function renderTaskContextLines(created, columns) {
+    if (created === undefined)
+        return [];
+    if (created.kind === "failed")
+        return [`! tasks failed ${safeText(created.diagnostic)}`];
+    return [`tasks ${created.rows.length}`, ...created.rows.flatMap((row) => renderTaskRow(row, columns))];
+}
+function answerContextLines(observation, columns) {
+    return [
+        ...renderTaskContextLines(observation.createdTasks, columns),
+        ...renderReportedChangeLines(observation.status.timeline),
+    ];
+}
+function answeredBlock(observation, answer, alias, columns) {
+    const context = answerContextLines(observation, columns).join("\n");
+    if (context.length === 0)
+        return `${answeredHeading(observation.status.id, alias)}\n${answer}`;
+    const separator = answer.endsWith("\n") ? "\n" : "\n\n";
+    return `${answeredHeading(observation.status.id, alias)}\n${answer}${separator}${context}`;
+}
+function snapshotCore(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)}`] : []),
+        ...contractFacts(view.contract),
+        ...(options.facts ?? []),
+    ];
+    const pending = pendingWithoutLiveBody(view.status);
+    return {
+        activity,
+        lines: [
+            ...snapshotHeading(view.status.id, options.alias, view.contract),
+            ...facts,
+            ...activity,
+            ...(pending === 0 ? [] : [`pending ${pending} tells · no live body`]),
+        ],
+    };
+}
+export function snapshotText(view, context, options = {}) {
+    const core = snapshotCore(view, context, options);
+    const taskContext = renderTaskContextLines(view.createdTasks, context.columns);
+    return [
+        ...core.lines,
+        ...(core.activity.length > 0 && taskContext.length > 0 ? [""] : []),
+        ...taskContext,
+        ...renderReportedChangeLines(view.status.timeline),
+        "",
+        lifeLabel(view.status.life),
+    ].join("\n");
+}
+function mutationSnapshotText(view, context, options = {}) {
+    const core = snapshotCore(view, context, options);
+    return [...core.lines, ...(options.showLife === false ? [] : ["", lifeLabel(view.status.life)])].join("\n");
+}
+export function mutationObservationStageText(id, observation, context, options = {}) {
+    if (observation.kind === "unobserved")
+        return unobservedText(id, observation.diagnostic);
+    return mutationSnapshotText(observation, context, options);
+}
+export function statusAnswer(view) {
+    if (!defaultWaitComplete(view.status))
+        return undefined;
+    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;
+}
+function answerCallFailed(result) {
+    return result.dispatch.kind === "failed" || result.alias.kind === "failed" || result.readonly?.enforcement === "none";
+}
+export function akumaRawAnswer(result) {
+    if (result.action === "call") {
+        if (answerCallFailed(result.result) || result.result.observation.kind !== "observed")
+            return undefined;
+        return statusAnswer({ status: result.result.observation.status });
+    }
+    if (result.action === "wait" && result.result.observations.length === 1)
+        return statusAnswer(result.result.observations[0]);
+    return undefined;
+}
+export function waitText(result, context) {
+    const alias = result.alias;
+    const total = result.result.observations.length + result.result.unobserved.length;
+    const done = result.result.observations.filter((observation) => defaultWaitComplete(observation.status)).length;
+    const blocks = [
+        ...result.result.observations.map((observation) => {
+            const answer = statusAnswer(observation);
+            if (answer !== undefined)
+                return answeredBlock(observation, answer, alias, context.columns);
+            return snapshotText(observation, context, { ...(alias === undefined ? {} : { alias }) });
+        }),
+        ...result.result.unobserved.map((member) => unobservedText(member.id, member.diagnostic)),
+    ];
+    if (total <= 1)
+        return blocks.join("\n\n");
+    return [...blocks, `${done} of ${total} done`].join("\n\n");
+}
+export 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");
+    return [
+        ...snapshotHeading(result.akuma, result.alias, result.historyResult.contract),
+        ...groupedRows(result.history.rows, context, true),
+    ].join("\n");
+}
+export function tellText(result, context) {
+    const wake = result.result.tell.wake;
+    const facts = wake.kind === "failed"
+        ? [
+            `! wake failed · ${safeText(wake.diagnostic)}${wake.child === undefined ? "" : ` · log ${wake.child.log.path} ${wake.child.log.from}..${wake.child.log.to}`}`,
+        ]
+        : wake.kind === "pursuing"
+            ? []
+            : [`wake ${wake.kind}`];
+    return mutationObservationStageText(result.result.akuma, result.result.observation, context, {
+        ...(result.alias === undefined ? {} : { alias: result.alias }),
+        facts,
+        showLife: false,
+    });
+}

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

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