@rigkit/cli 0.2.7 → 0.2.8

package/src/run-presenter.ts

@@ -1,7 +1,8 @@
-import chalk from "chalk";
-import { createLogUpdate } from "log-update";
-import logSymbols from "log-symbols";
-import ora from "ora";
+// Append-only run presenter. Each runtime event prints zero or one line to
+// stderr. No spinners, no re-renders. Looks the same in a TTY, a CI log, and an
+// LLM transcript — and it pipes cleanly.
+
+import { accent, bold, clip, dim, err, ok, sym, termWidth, warn } from "./ui.ts";
 
 export type RunPresenter = {
   render(event: { type: string; [key: string]: unknown }): void;
@@ -10,346 +11,209 @@ export type RunPresenter = {
   close(): void;
 };
 
-type StepStatus = "running" | "done" | "cached" | "failed";
-
-type RunStep = {
-  index: number;
-  path: string;
-  status: StepStatus;
-  detail: string;
-  logs: string[];
-};
-
 export function createRunPresenter(operation: string): RunPresenter | undefined {
-  if (!canUsePresenter()) return undefined;
+  if (process.env.RIGKIT_RENDER === "0") return undefined;
 
-  const log = createLogUpdate(normalizedStderr(), {
-    defaultHeight: 24,
-    defaultWidth: 80,
-  });
-  const spinner = ora({
-    color: "cyan",
-    discardStdin: false,
-    isEnabled: true,
-    spinner: "dots",
-    stream: process.stderr,
-  });
-  const steps: RunStep[] = [];
-  const stepsByPath = new Map<string, RunStep>();
-  let totalSteps = 0;
   let workflow = "";
-  let phase = "Starting runtime operation";
-  let activePath: string | undefined;
-  let finalStatus: "running" | "completed" | "failed" = "running";
+  let totalNodes = 0;
+  let cachedNodes = 0;
+  const seenNodes = new Set<string>();
+  const completedNodes = new Set<string>();
+  let lastNodePath: string | undefined;
   let closed = false;
-  let paused = false;
-  let timer: ReturnType<typeof setInterval> | undefined;
 
-  const refresh = () => {
-    if (closed || paused) return;
-    log(renderTimeline({
-      activePath,
-      finalStatus,
-      operation,
-      phase,
-      spinnerFrame: spinner.frame().trimEnd(),
-      steps,
-      totalSteps,
-      workflow,
-    }));
+  const write = (line: string): void => {
+    process.stderr.write(`${line}\n`);
   };
 
-  const startTimer = () => {
-    timer ??= setInterval(refresh, spinner.interval);
-    timer.unref?.();
-  };
-  const stopTimer = () => {
-    if (!timer) return;
-    clearInterval(timer);
-    timer = undefined;
+  const indent = (line: string): string => `  ${line}`;
+
+  const trim = (value: string): string => clip(value, Math.max(40, termWidth() - 4));
+
+  const headerLine = (): string => {
+    const left = workflow ? `${bold(operation)} ${dim(workflow)}` : bold(operation);
+    return `${accent(sym.active)} ${left}`;
   };
-  startTimer();
-  refresh();
 
   return {
     render(event) {
       if (closed) return;
       switch (event.type) {
-        case "definition.loaded":
-          workflow = String(event.workflow ?? "workflow");
-          phase = `Loaded ${workflow}`;
+        case "definition.loaded": {
+          workflow = stringField(event.workflow) ?? workflow;
           break;
-        case "plan.created":
-          workflow = String(event.workflow ?? (workflow || "workflow"));
-          totalSteps = numberField(event.nodeCount) ?? totalSteps;
-          phase = `Planned ${workflow}`;
+        }
+        case "plan.created": {
+          workflow = stringField(event.workflow) ?? workflow;
+          totalNodes = numberField(event.nodeCount) ?? totalNodes;
+          cachedNodes = numberField(event.cachedNodeCount) ?? cachedNodes;
+          write(headerLine());
+          write(indent(dim(planSummary(totalNodes, cachedNodes))));
           break;
-        case "node.cached":
-          markStep(stepFor(steps, stepsByPath, event.nodePath), "cached", compactId(event.runId));
+        }
+        case "workflow.apply.started": {
+          workflow = stringField(event.workflow) ?? workflow;
+          write(`${accent(sym.active)} workflow ${bold(workflow || operation)}`);
           break;
-        case "node.started":
-          activePath = stringField(event.nodePath);
-          markStep(stepFor(steps, stepsByPath, event.nodePath), "running", "loading");
-          phase = `Running ${activePath ?? "step"}`;
+        }
+        case "workflow.apply.completed": {
+          const name = stringField(event.workflow) ?? workflow;
+          totalNodes = numberField(event.nodeCount) ?? totalNodes;
+          cachedNodes = numberField(event.cachedNodeCount) ?? cachedNodes;
+          const summary = totalNodes > 0 ? `  ${dim(planSummary(totalNodes, cachedNodes))}` : "";
+          write(`${ok(sym.ok)} ${bold(name || "workflow")} ${dim("prepared")}${summary}`);
+          break;
+        }
+        case "node.cached": {
+          const path = stringField(event.nodePath);
+          if (!path || completedNodes.has(path)) break;
+          completedNodes.add(path);
+          seenNodes.add(path);
+          write(indent(`${dim(sym.ok)} ${dim(path)}  ${dim("cached")}`));
+          break;
+        }
+        case "node.started": {
+          const path = stringField(event.nodePath);
+          if (!path || seenNodes.has(path)) break;
+          seenNodes.add(path);
+          lastNodePath = path;
+          write(indent(`${accent(sym.active)} ${bold(path)}`));
           break;
+        }
         case "node.completed": {
-          const step = stepFor(steps, stepsByPath, event.nodePath);
-          markStep(step, "done", compactId(event.runId));
-          if (activePath === step.path) activePath = undefined;
-          phase = `Completed ${step.path}`;
+          const path = stringField(event.nodePath);
+          if (!path || completedNodes.has(path)) break;
+          completedNodes.add(path);
+          if (lastNodePath === path) lastNodePath = undefined;
+          const detail = compactId(event.runId);
+          const tail = detail ? `  ${dim(detail)}` : "";
+          write(indent(`${ok(sym.ok)} ${path}${tail}`));
           break;
         }
-        case "vm.created":
-          setActiveDetail(stepsByPath, activePath, event.fromSnapshotId
-            ? `VM ${String(event.vmId ?? "")} from ${String(event.fromSnapshotId)}`
-            : `VM ${String(event.vmId ?? "")} created`);
+        case "vm.created": {
+          const vmId = stringField(event.vmId);
+          const from = stringField(event.fromSnapshotId);
+          const label = from ? `vm ${vmId ?? ""} from ${from}` : `vm ${vmId ?? "ready"}`;
+          write(indent(`  ${dim(label)}`));
           break;
+        }
         case "command.started": {
-          const step = stepFor(steps, stepsByPath, event.nodePath ?? activePath);
-          step.status = "running";
-          activePath = step.path;
-          step.detail = String(event.command ?? event.commandName ?? "command");
-          phase = `Command ${String(event.commandName ?? "command")}`;
+          const command = stringField(event.command) ?? stringField(event.commandName);
+          if (command) write(indent(`  ${dim(`$ ${trim(command)}`)}`));
           break;
         }
         case "command.output": {
-          const step = stepFor(steps, stepsByPath, event.nodePath ?? activePath);
-          activePath = step.path;
-          appendLog(step.logs, `[${String(event.stream ?? "log")}] ${String(event.data ?? "")}`);
+          const data = stringField(event.data);
+          if (!data) break;
+          for (const line of data.replace(/\r/g, "").split("\n")) {
+            if (!line) continue;
+            write(indent(`  ${dim(trim(line))}`));
+          }
           break;
         }
-        case "command.completed":
-          setActiveDetail(
-            stepsByPath,
-            stringField(event.nodePath) ?? activePath,
-            `Command ${String(event.commandName ?? "")} exited ${String(event.exitCode ?? 0)}`,
-          );
+        case "command.completed": {
+          const exitCode = numberField(event.exitCode) ?? 0;
+          if (exitCode !== 0) {
+            const name = stringField(event.commandName) ?? "command";
+            write(indent(`  ${err(`${name} exited ${exitCode}`)}`));
+          }
           break;
+        }
         case "log.output": {
-          const step = stepFor(steps, stepsByPath, event.nodePath ?? activePath);
-          activePath = step.status === "running" ? step.path : activePath;
-          appendLog(step.logs, `[${String(event.label ?? event.stream ?? "log")}] ${String(event.data ?? "")}`);
+          const data = stringField(event.data);
+          if (!data) break;
+          const stream = stringField(event.stream);
+          // console.debug is intentionally silent at the terminal — it lives
+          // in the run log file only. Surface it live with RIGKIT_DEBUG=1.
+          if (stream === "debug" && process.env.RIGKIT_DEBUG !== "1") break;
+          const label = stringField(event.label);
+          const { icon, style } = logStreamPresentation(stream);
+          for (const line of data.replace(/\r/g, "").split("\n")) {
+            if (!line) continue;
+            const prefix = label ? `${dim(`[${label}]`)} ` : "";
+            write(indent(`  ${icon} ${prefix}${style(trim(line))}`));
+          }
           break;
         }
-        case "interaction.awaiting_user":
-          phase = `Waiting for ${String(event.title ?? "user interaction")}`;
-          setActiveDetail(stepsByPath, stringField(event.nodePath) ?? activePath, String(event.url ?? ""));
+        case "interaction.awaiting_user": {
+          const label = stringField(event.title) ?? stringField(event.label) ?? "user interaction";
+          const url = stringField(event.url);
+          write(indent(`${accent(sym.arrow)} waiting on ${bold(label)}`));
+          if (url) write(indent(`  ${dim(url)}`));
           break;
-        case "interaction.completed":
-          phase = `Completed ${String(event.title ?? "interaction")}`;
+        }
+        case "interaction.completed": {
+          const label = stringField(event.title) ?? stringField(event.label) ?? "interaction";
+          write(indent(`${ok(sym.ok)} ${dim(`${label} completed`)}`));
           break;
-        case "artifact.created":
-          setActiveDetail(
-            stepsByPath,
-            stringField(event.nodePath) ?? activePath,
-            `Created ${String(event.kind ?? "artifact")}`,
-          );
+        }
+        case "artifact.created": {
+          const kind = stringField(event.kind) ?? "artifact";
+          const provider = stringField(event.providerId);
+          const label = provider ? `${provider}:${kind}` : kind;
+          write(indent(`  ${dim(`+ ${label}`)}`));
           break;
-        case "workspace.ready":
-          phase = `Workspace ${String(event.workspaceId ?? "ready")} ready`;
+        }
+        case "workspace.create.started": {
+          const name = stringField(event.workspaceName) ?? "workspace";
+          write(`${accent(sym.active)} creating workspace ${bold(name)}`);
           break;
-        case "run.completed":
-          finalStatus = "completed";
-          phase = "Completed";
-          collapseActiveStep(stepsByPath, activePath);
-          activePath = undefined;
+        }
+        case "workspace.ready": {
+          const id = stringField(event.workspaceId) ?? "workspace";
+          write(`${ok(sym.ok)} ${bold(id)} ${dim("ready")}`);
           break;
-        case "run.failed":
-          finalStatus = "failed";
-          phase = isRecord(event.error) && typeof event.error.message === "string"
-            ? event.error.message
-            : "Run failed";
-          activePath = failActiveStep(steps, stepsByPath, activePath, phase);
+        }
+        case "workspace.remove.started": {
+          const name = stringField(event.workspaceName) ?? "workspace";
+          write(`${accent(sym.active)} removing workspace ${bold(name)}`);
+          break;
+        }
+        case "workspace.remove.completed": {
+          const name = stringField(event.workspaceName) ?? "workspace";
+          write(`${ok(sym.ok)} removed ${bold(name)}`);
           break;
+        }
+        case "workspace.operation.started": {
+          const name = stringField(event.workspaceName) ?? "workspace";
+          const op = stringField(event.operationId) ?? "operation";
+          write(`${accent(sym.active)} running ${bold(op)} on ${bold(name)}`);
+          break;
+        }
+        case "workspace.operation.completed": {
+          const name = stringField(event.workspaceName) ?? "workspace";
+          const op = stringField(event.operationId) ?? "operation";
+          write(`${ok(sym.ok)} ran ${bold(op)} on ${bold(name)}`);
+          break;
+        }
+        case "run.completed":
+        case "run.failed": {
+          // Run terminal events are owned by the CLI's failure renderer so the
+          // structured failure block stays in one place.
+          break;
+        }
       }
-      refresh();
     },
     pause() {
-      if (closed || paused) return;
-      log(renderTimeline({
-        activePath,
-        finalStatus,
-        operation,
-        phase,
-        spinnerFrame: spinner.frame().trimEnd(),
-        steps,
-        totalSteps,
-        workflow,
-      }));
-      paused = true;
-      stopTimer();
-      log.done();
+      // No-op — output is already append-only.
     },
     resume() {
-      if (closed || !paused) return;
-      paused = false;
-      startTimer();
-      refresh();
+      // No-op — output is already append-only.
     },
     close() {
-      if (closed) return;
-      if (paused) {
-        paused = false;
-      }
-      refresh();
       closed = true;
-      stopTimer();
-      log.done();
     },
   };
 }
 
-function normalizedStderr(): NodeJS.WriteStream {
-  const stream = Object.create(process.stderr) as NodeJS.WriteStream;
-  Object.defineProperty(stream, "columns", {
-    get: () => process.stderr.columns || 80,
-  });
-  Object.defineProperty(stream, "rows", {
-    get: () => process.stderr.rows || 24,
-  });
-  stream.write = process.stderr.write.bind(process.stderr) as typeof process.stderr.write;
-  return stream;
-}
-
-function canUsePresenter(): boolean {
-  return Boolean(
-    process.env.RIGKIT_RENDER !== "0" &&
-      process.stderr.isTTY,
-  );
-}
-
-function renderTimeline(input: {
-  activePath: string | undefined;
-  finalStatus: "running" | "completed" | "failed";
-  operation: string;
-  phase: string;
-  spinnerFrame: string;
-  steps: RunStep[];
-  totalSteps: number;
-  workflow: string;
-}): string {
-  const done = input.steps.filter((step) => step.status === "done" || step.status === "cached").length;
-  const total = input.totalSteps || input.steps.length;
-  const progress = total > 0 ? `${done}/${total} steps` : `${input.steps.length} steps`;
-  const title = input.workflow ? `${input.operation} ${input.workflow}` : input.operation;
-  const lines = [
-    `${statusPrefix(input.finalStatus, input.spinnerFrame)} ${chalk.bold(title)} ${chalk.dim(input.phase)} ${chalk.dim(`(${progress})`)}`,
-    "",
-    ...timelineLines(input),
-  ];
-  return lines.join("\n");
-}
-
-function timelineLines(input: {
-  activePath: string | undefined;
-  spinnerFrame: string;
-  steps: RunStep[];
-}): string[] {
-  const visible = input.steps.length > 8 ? input.steps.slice(-8) : input.steps;
-  const lines: string[] = [];
-  if (visible.length < input.steps.length) {
-    lines.push(chalk.dim(`... ${input.steps.length - visible.length} earlier steps`));
-  }
-
-  const active = input.activePath ? input.steps.find((step) => step.path === input.activePath) : undefined;
-  for (const step of visible) {
-    lines.push(stepLine(step, input.spinnerFrame));
-    if (step.path === active?.path && (step.status === "running" || step.status === "failed")) {
-      if (step.detail) lines.push(chalk.dim(`     ${clip(step.detail, 100)}`));
-      for (const line of step.logs.slice(-4)) lines.push(chalk.dim(`     ${clip(line, 100)}`));
-    }
-  }
-
-  return lines.length > 0 ? lines : [chalk.dim("waiting for runtime events")];
-}
-
-function stepLine(step: RunStep, spinnerFrame: string): string {
-  const index = String(step.index).padStart(2, " ");
-  switch (step.status) {
-    case "running":
-      return `${chalk.dim(index)} ${spinnerFrame} ${chalk.bold(step.path)}`;
-    case "cached":
-      return `${chalk.dim(index)} ${logSymbols.success} ${chalk.dim(step.path)}${step.detail ? chalk.dim(` cached ${step.detail}`) : ""}`;
-    case "done":
-      return `${chalk.dim(index)} ${logSymbols.success} ${chalk.dim(step.path)}${step.detail ? chalk.dim(` ${step.detail}`) : ""}`;
-    case "failed":
-      return `${chalk.dim(index)} ${logSymbols.error} ${chalk.bold(step.path)}`;
-  }
-}
-
-function statusPrefix(status: "running" | "completed" | "failed", spinnerFrame: string): string {
-  if (status === "completed") return logSymbols.success;
-  if (status === "failed") return logSymbols.error;
-  return spinnerFrame;
-}
-
-function stepFor(
-  steps: RunStep[],
-  stepsByPath: Map<string, RunStep>,
-  rawPath: unknown,
-): RunStep {
-  const path = typeof rawPath === "string" && rawPath.length > 0 ? rawPath : "runtime";
-  const existing = stepsByPath.get(path);
-  if (existing) return existing;
-  const step: RunStep = {
-    index: steps.length + 1,
-    path,
-    status: "running",
-    detail: "loading",
-    logs: [],
-  };
-  steps.push(step);
-  stepsByPath.set(path, step);
-  return step;
-}
-
-function markStep(step: RunStep, status: StepStatus, detail: string): void {
-  step.status = status;
-  step.detail = detail;
-  if (status === "done" || status === "cached") {
-    step.logs = [];
-  }
-}
-
-function setActiveDetail(stepsByPath: Map<string, RunStep>, path: string | undefined, detail: string): void {
-  if (!path) return;
-  const step = stepsByPath.get(path);
-  if (!step) return;
-  step.detail = detail;
-}
-
-function collapseActiveStep(stepsByPath: Map<string, RunStep>, path: string | undefined): void {
-  if (!path) return;
-  const step = stepsByPath.get(path);
-  if (step?.status === "running") markStep(step, "done", "completed");
+function planSummary(total: number, cached: number): string {
+  if (total === 0) return "no nodes";
+  if (cached === 0) return `${total} ${noun("node", total)}`;
+  return `${cached}/${total} cached`;
 }
 
-function failActiveStep(
-  steps: RunStep[],
-  stepsByPath: Map<string, RunStep>,
-  path: string | undefined,
-  message: string,
-): string | undefined {
-  const step = path ? stepsByPath.get(path) : lastStepToFail(steps);
-  if (!step) return undefined;
-  markStep(step, "failed", message);
-  return step.path;
-}
-
-function lastStepToFail(steps: RunStep[]): RunStep | undefined {
-  for (let index = steps.length - 1; index >= 0; index -= 1) {
-    const step = steps[index]!;
-    if (step.status === "running") return step;
-  }
-  return steps[steps.length - 1];
-}
-
-function appendLog(lines: string[], value: string): void {
-  for (const line of value.replace(/\r/g, "").split("\n")) {
-    if (line.length === 0) continue;
-    lines.push(line);
-  }
-  if (lines.length > 200) lines.splice(0, lines.length - 200);
+function noun(singular: string, count: number): string {
+  return count === 1 ? singular : `${singular}s`;
 }
 
 function compactId(value: unknown): string {
@@ -357,17 +221,30 @@ function compactId(value: unknown): string {
 }
 
 function stringField(value: unknown): string | undefined {
-  return typeof value === "string" ? value : undefined;
+  return typeof value === "string" && value.length > 0 ? value : undefined;
 }
 
 function numberField(value: unknown): number | undefined {
   return typeof value === "number" ? value : undefined;
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+function logStreamPresentation(stream: string | undefined): {
+  icon: string;
+  style: (text: string) => string;
+} {
+  switch (stream) {
+    case "warn":
+      return { icon: warn("!"), style: warn };
+    case "stderr":
+    case "error":
+      return { icon: err(sym.err), style: err };
+    case "debug":
+      return { icon: dim("·"), style: (text: string) => dim(`${dim("debug")} ${text}`) };
+    case "stdout":
+    case "info":
+    case "log":
+    default:
+      return { icon: dim(sym.dot), style: dim };
+  }
 }
 
-function clip(value: string, max: number): string {
-  return value.length > max ? `${value.slice(0, Math.max(0, max - 3))}...` : value;
-}