@visual-z/xeno 0.1.0

package/src/apps/render.ts

@@ -0,0 +1,207 @@
+/**
+ * Loop events become lines. The shell prints them; this file does not
+ * touch a terminal, so "what a tool call looks like" can be asserted
+ * without starting one.
+ *
+ * Colour is a parameter, not a global. Piped and CI runs have no tty,
+ * and a CSI 2026 (or even a dim code) in `-p` output is a parse error
+ * waiting for a script.
+ */
+
+import { assertNever } from "../core/exhaustive.ts";
+import type { LoopEvent } from "../runtime/loop.ts";
+import { renderMarkdown } from "../tui/markdown.ts";
+import { ANSI as ANSI_STYLE, IDENTITY, type Style } from "../tui/style.ts";
+import { renderToolView, type ToolViewEvent } from "../tui/toolview.ts";
+
+export interface Palette {
+  dim: (s: string) => string;
+  bold: (s: string) => string;
+  red: (s: string) => string;
+  green: (s: string) => string;
+  yellow: (s: string) => string;
+  cyan: (s: string) => string;
+}
+
+const identity = (s: string): string => s;
+
+const ANSI: Palette = {
+  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+};
+
+const PLAIN: Palette = {
+  dim: identity,
+  bold: identity,
+  red: identity,
+  green: identity,
+  yellow: identity,
+  cyan: identity,
+};
+
+export function createPalette(color: boolean): Palette {
+  return color ? ANSI : PLAIN;
+}
+
+/**
+ * Colour is a tty AND not NO_COLOR. A theme that still emits ESC in a pipe
+ * or under NO_COLOR is the same class of bug as createPalette(true) on a
+ * redirected stdout.
+ */
+export function colorEnabled(): boolean {
+  const noColor = process.env["NO_COLOR"];
+  if (noColor !== undefined && noColor !== "") return false;
+  return stdoutIsTty();
+}
+
+/** True only for a real tty. `undefined` (piped, CI) must not count. */
+export function stdoutIsTty(): boolean {
+  return process.stdout.isTTY === true;
+}
+
+export function stdinIsTty(): boolean {
+  return process.stdin.isTTY === true;
+}
+
+/**
+ * One readable line from whatever was thrown.
+ *
+ * Never a stack. A stack is for whoever wrote the harness; the person running
+ * it needs the status and the provider's own sentence, which is the part that
+ * says whether this is their key, their quota, or the provider being down.
+ */
+export function describeError(error: unknown): string {
+  if (error instanceof Error) {
+    const status = (error as { status?: unknown }).status;
+    const prefix = typeof status === "number" ? `HTTP ${status}: ` : "";
+    return error.message.startsWith("HTTP ") ? error.message : prefix + error.message;
+  }
+  return String(error);
+}
+
+export function indent(text: string, pad: string): string {
+  return text.split("\n").map((l) => pad + l).join("\n");
+}
+
+export function wrap(text: string, width: number): string {
+  const out: string[] = [];
+  let line = "";
+  for (const word of text.split(/\s+/)) {
+    if (line && line.length + word.length + 1 > width) { out.push(line); line = word; }
+    else line = line ? `${line} ${word}` : word;
+  }
+  if (line) out.push(line);
+  return out.join("\n");
+}
+
+export function firstLine(text: string, width: number): string {
+  const line = text.split("\n")[0] ?? "";
+  return line.length > width ? line.slice(0, width - 1) + "…" : line;
+}
+
+/**
+ * Zero or more lines that the shell will print, matching the previous
+ * inline switch one-for-one -- including the leading newline on
+ * stop_and_ask, which is a blank line in the transcript.
+ *
+ * Kinds the old CLI ignored stay silent so this extraction cannot change
+ * what a piped run prints.
+ */
+function markdownStyle(C: Palette, style?: Style): Style {
+  if (style !== undefined) return style;
+  // Palette has no colour flag; identity wrappers are how -p and pipes
+  // already opt out of CSI. A sentinel that round-trips is that same gate.
+  return C.bold("\0") === "\0" ? IDENTITY : ANSI_STYLE;
+}
+
+export interface FormatFlags {
+  readonly toolsExpanded?: boolean;
+  readonly thinkingExpanded?: boolean;
+}
+
+export function toToolView(e: LoopEvent): ToolViewEvent | null {
+  switch (e.kind) {
+    case "thinking":
+      return { kind: "thinking", text: e.text ?? "" };
+    case "tool_call":
+      return { kind: "tool_call", tool: e.tool ?? { name: "", input: {} } };
+    case "tool_result":
+      return {
+        kind: "tool_result",
+        text: e.text ?? "",
+        ok: e.ok !== false,
+        ...(e.tool !== undefined ? { tool: e.tool } : {}),
+      };
+    default:
+      return null;
+  }
+}
+
+export function formatEvent(
+  e: LoopEvent,
+  C: Palette,
+  width = 80,
+  flags: FormatFlags = {},
+  style?: Style,
+): string[] {
+  const md = markdownStyle(C, style);
+  switch (e.kind) {
+    case "thinking":
+      return renderToolView(
+        { kind: "thinking", text: e.text ?? "" },
+        flags.thinkingExpanded === true,
+        width,
+        md,
+      );
+    case "assistant_text":
+      return renderMarkdown(e.text ?? "", width, md);
+    case "tool_call":
+      return renderToolView(
+        { kind: "tool_call", tool: e.tool ?? { name: "", input: {} } },
+        flags.toolsExpanded === true,
+        width,
+        md,
+      );
+    case "tool_result":
+      return renderToolView(
+        {
+          kind: "tool_result",
+          text: e.text ?? "",
+          ok: e.ok !== false,
+          ...(e.tool !== undefined ? { tool: e.tool } : {}),
+        },
+        flags.toolsExpanded === true,
+        width,
+        md,
+      );
+    case "usage": {
+      const u = e.usage!;
+      const line =
+        `    ${u.input_tokens} new  ${u.cache_read_input_tokens} cached  ` +
+        `${u.cache_creation_input_tokens} written  ${u.output_tokens} out  ${u.ms}ms`;
+      return [e.ok ? C.dim(line) : C.yellow(line + `  ⚠ ${e.prefix}`)];
+    }
+    case "cut":
+      return [C.yellow(`  ── node ${e.node} closed (${e.reason}); handoff written`)];
+    case "stop_and_ask":
+      return [C.red(`\n  stopping: ${e.reason}`)];
+    case "done":
+      if (e.reason && e.reason !== "end_turn") return [C.dim(`  [${e.reason}]`)];
+      return [];
+    case "turn_start":
+    case "branch_start":
+    case "branch_done":
+    case "snapshot_failed":
+    case "undeclared_change":
+    case "text_delta":
+    case "thinking_delta":
+    case "discard":
+      return [];
+    default:
+      return assertNever(e.kind, "formatEvent");
+  }
+}