@bastani/atomic 0.8.31-alpha.4 → 0.9.0-alpha.1

package/dist/builtin/workflows/src/tui/stage-chat-view-archive-history.ts

@@ -0,0 +1,315 @@
+import { Box, Text } from "@earendil-works/pi-tui";
+import type { PendingPrompt, StageSnapshot } from "../shared/store-types.js";
+import { renderPromptCard } from "./prompt-card.js";
+import { renderRoundedBoxLines } from "./chat-surface.js";
+import { bannerLines, embedOrchestratorReturnHintInWidget } from "./stage-chat-view-footer-status.js";
+import {
+  blankLine,
+  paint,
+  renderHintsForPrompt,
+  setEditorBorderColor,
+  setEditorFocused,
+} from "./stage-chat-view-render-helpers.js";
+import type { StageChatViewContext } from "./stage-chat-view-types.js";
+import { hexToAnsi, RESET } from "./color-utils.js";
+
+export function renderReadOnlyArchiveBody(
+  ctx: StageChatViewContext,
+  width: number,
+  budget: number,
+  stage: StageSnapshot | undefined,
+): string[] {
+  if (stage?.promptFootprint) {
+    return renderReadOnlyPromptArchiveBody(ctx, width, budget, stage);
+  }
+
+  const t = ctx.theme;
+  const calloutRows = 6;
+  const transcriptBudget = Math.max(1, budget - calloutRows);
+  const lines = ctx.chatHost.renderBody(width, transcriptBudget);
+  const callout: string[] = [];
+  callout.push(blankLine(width));
+  callout.push(
+    ...bannerLines(
+      ctx,
+      width,
+      "info",
+      "◌",
+      "READ-ONLY SESSION",
+      stage?.sessionFile ? "archived transcript" : "no live chat session",
+    ),
+  );
+  callout.push(
+    ...new Text(
+      paint("This node is no longer attached to a live chat session.", t.textMuted),
+      2,
+      0,
+    ).render(width),
+  );
+  callout.push(
+    ...new Text(
+      paint("esc", t.accent, { bold: true }) +
+        paint(" close", t.textMuted) +
+        paint("  ·  ", t.dim) +
+        paint("ctrl+d", t.accent, { bold: true }) +
+        paint(" return to graph", t.textMuted),
+      2,
+      0,
+    ).render(width),
+  );
+  lines.push(...callout);
+  while (lines.length < budget) lines.push(blankLine(width));
+  if (lines.length > budget) lines.length = budget;
+  return lines;
+}
+
+function renderReadOnlyPromptArchiveBody(
+  ctx: StageChatViewContext,
+  width: number,
+  budget: number,
+  stage: StageSnapshot,
+): string[] {
+  const t = ctx.theme;
+  const prompt = stage.promptFootprint;
+  if (!prompt) return fitBodyLines(width, budget, []);
+
+  const innerWidth = Math.max(2, width - 2);
+  const bodyLines: string[] = [];
+  const messageBox = new Box(2, 1);
+  messageBox.addChild(new Text(paint(prompt.message, t.text), 0, 0));
+  bodyLines.push(...messageBox.render(innerWidth));
+  bodyLines.push(
+    ...new Text(
+      paint("prompt type", t.textMuted, { bold: true }) + paint(`  ${prompt.kind}`, t.text),
+      2,
+      0,
+    ).render(innerWidth),
+  );
+
+  if (prompt.kind === "select" && prompt.choices && prompt.choices.length > 0) {
+    bodyLines.push(...new Text(paint("choices", t.textMuted, { bold: true }), 2, 0).render(innerWidth));
+    for (const choice of prompt.choices) {
+      bodyLines.push(...new Text(paint("• ", t.dim) + paint(choice, t.text), 4, 0).render(innerWidth));
+    }
+  } else if (prompt.kind === "confirm") {
+    bodyLines.push(
+      ...new Text(
+        paint("choices", t.textMuted, { bold: true }) + paint("  yes / no", t.text),
+        2,
+        0,
+      ).render(innerWidth),
+    );
+  }
+
+  if ((prompt.kind === "input" || prompt.kind === "editor") && prompt.initial && prompt.initial.length > 0) {
+    bodyLines.push(...new Text(paint("initial value shown", t.textMuted, { bold: true }), 2, 0).render(innerWidth));
+    bodyLines.push(...new Text(paint(prompt.initial, t.dim), 4, 0).render(innerWidth));
+  }
+
+  const answer = readOnlyPromptAnswer(ctx, stage, prompt);
+  bodyLines.push("");
+  bodyLines.push(...new Text(paint("your response", t.textMuted, { bold: true }), 2, 0).render(innerWidth));
+  bodyLines.push(...new Text(paint(answer, answer.startsWith("(") ? t.dim : t.text), 4, 0).render(innerWidth));
+  bodyLines.push("");
+  bodyLines.push(
+    ...new Text(
+      paint("esc", t.accent, { bold: true }) +
+        paint(" close", t.textMuted) +
+        paint("  ·  ", t.dim) +
+        paint("ctrl+d", t.accent, { bold: true }) +
+        paint(" return to graph", t.textMuted),
+      2,
+      0,
+    ).render(innerWidth),
+  );
+
+  const title = stage.status === "skipped" ? "QUESTION SKIPPED" : "QUESTION ASKED";
+  const cardLines = renderRoundedBoxLines({
+    title,
+    bodyLines,
+    width,
+    theme: t,
+    accent: t.border,
+  });
+  return fitPromptBodyLines(ctx, cardLines, width, budget);
+}
+
+function readOnlyPromptAnswer(
+  ctx: StageChatViewContext,
+  stage: StageSnapshot,
+  prompt: PendingPrompt,
+): string {
+  const answer = ctx.store.getStagePromptAnswer(ctx.runId, stage.id);
+  if (answer && answer.promptId === prompt.id) {
+    return formatReadOnlyPromptAnswer(answer.value, prompt.kind);
+  }
+  switch (stage.promptAnswerState) {
+    case "ambiguous":
+      return "(response replay is ambiguous)";
+    case "unavailable":
+      return "(response unavailable)";
+    case "available":
+      return "(response no longer in live memory)";
+    default:
+      return "(no response saved)";
+  }
+}
+
+function formatReadOnlyPromptAnswer(value: unknown, kind: PendingPrompt["kind"]): string {
+  if (kind === "confirm") return value === true ? "yes" : "no";
+  if (typeof value === "string") return value.length > 0 ? value : "(empty response)";
+  if (typeof value === "number" || typeof value === "boolean" || value === null) {
+    return String(value);
+  }
+  try {
+    const encoded = JSON.stringify(value);
+    return encoded ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+
+export function renderPausedBody(
+  ctx: StageChatViewContext,
+  width: number,
+  budget: number,
+): string[] {
+  const t = ctx.theme;
+  const callout: string[] = [];
+  callout.push(blankLine(width));
+  callout.push(
+    ...bannerLines(ctx, width, "warning", "❚❚", "PAUSED", "enter resumes · ctrl+d graph"),
+  );
+  callout.push(
+    ...new Text(
+      paint(
+        "This workflow stage is paused. Type a message below and press Enter to resume.",
+        t.textMuted,
+      ),
+      2,
+      0,
+    ).render(width),
+  );
+
+  const calloutRows = Math.min(callout.length, Math.max(0, budget - 1));
+  const transcriptBudget = Math.max(1, budget - calloutRows);
+  const lines = ctx.chatHost.renderBody(width, transcriptBudget);
+  lines.push(...callout.slice(0, calloutRows));
+  while (lines.length < budget) lines.push(blankLine(width));
+  if (lines.length > budget) lines.length = budget;
+  return lines;
+}
+
+export function renderBlockedBody(
+  ctx: StageChatViewContext,
+  width: number,
+  budget: number,
+  stage: StageSnapshot | undefined,
+): string[] {
+  const t = ctx.theme;
+  const upstream = stage?.blockedByStageId ?? "upstream stage";
+  const lines: string[] = [];
+  lines.push(...bannerLines(ctx, width, "warning", "↑", "BLOCKED", `waiting on ${upstream}`));
+  lines.push(blankLine(width));
+  lines.push(
+    ...new Text(
+      paint("This stage is waiting for the upstream stage to resume.", t.textMuted),
+      2,
+      0,
+    ).render(width),
+  );
+  lines.push(
+    ...new Text(
+      paint("ctrl+d", t.accent, { bold: true }) + paint(" return to graph", t.textMuted),
+      2,
+      0,
+    ).render(width),
+  );
+  while (lines.length < budget) lines.push(blankLine(width));
+  if (lines.length > budget) lines.length = budget;
+  return lines;
+}
+
+export function renderPromptBody(
+  ctx: StageChatViewContext,
+  width: number,
+  budget: number,
+): string[] {
+  const primitiveLines = renderPrimitivePromptBody(ctx, width);
+  if (primitiveLines) {
+    return fitPromptBodyLines(
+      ctx,
+      embedOrchestratorReturnHintInWidget(ctx, primitiveLines, width),
+      width,
+      budget,
+    );
+  }
+
+  const state = ctx.promptState;
+  const lines = state
+    ? renderPromptCard({
+      state,
+      theme: ctx.theme,
+      width,
+      cursorOn: ctx.focused,
+    })
+    : [];
+  return fitPromptBodyLines(
+    ctx,
+    embedOrchestratorReturnHintInWidget(ctx, lines, width),
+    width,
+    budget,
+  );
+}
+
+function renderPrimitivePromptBody(
+  ctx: StageChatViewContext,
+  width: number,
+): string[] | null {
+  const state = ctx.promptState;
+  const editor = ctx.promptEditor;
+  if (!state || !editor) return null;
+  setEditorFocused(editor, ctx.focused);
+  setEditorBorderColor(editor, (text) => hexToAnsi(ctx.theme.accent) + text + RESET);
+
+  const innerWidth = Math.max(2, width - 2);
+  const bodyLines: string[] = [];
+  const messageBox = new Box(2, 1);
+  messageBox.addChild(new Text(paint(state.prompt.message, ctx.theme.text), 0, 0));
+  bodyLines.push(...messageBox.render(innerWidth));
+  bodyLines.push(
+    ...new Text(paint("response", ctx.theme.textMuted, { bold: true }), 2, 0).render(innerWidth),
+  );
+  for (const line of editor.render(Math.max(20, innerWidth - 4))) {
+    bodyLines.push("  " + line);
+  }
+  bodyLines.push("");
+  bodyLines.push(...new Text(renderHintsForPrompt(state.prompt.kind, ctx.theme), 2, 0).render(innerWidth));
+
+  return renderRoundedBoxLines({
+    title: "AWAITING INPUT",
+    bodyLines,
+    width,
+    theme: ctx.theme,
+    accent: ctx.theme.border,
+  });
+}
+
+export function fitPromptBodyLines(
+  ctx: StageChatViewContext,
+  lines: readonly string[],
+  width: number,
+  budget: number,
+): string[] {
+  ctx.promptMaxScroll = Math.max(0, lines.length - budget);
+  ctx.promptScrollOffset = Math.max(0, Math.min(ctx.promptScrollOffset, ctx.promptMaxScroll));
+  const framed = lines.slice(ctx.promptScrollOffset, ctx.promptScrollOffset + budget);
+  while (framed.length < budget) framed.push(blankLine(width));
+  return framed;
+}
+
+function fitBodyLines(width: number, budget: number, lines: readonly string[]): string[] {
+  const framed = lines.slice(0, budget);
+  while (framed.length < budget) framed.push(blankLine(width));
+  return framed;
+}

package/dist/builtin/workflows/src/tui/stage-chat-view-custom-ui.ts

@@ -0,0 +1,127 @@
+import {
+  mountStageCustomUi,
+  type StageCustomUiRequest,
+} from "../shared/stage-ui-broker.js";
+import { embedOrchestratorReturnHintInWidget } from "./stage-chat-view-footer-status.js";
+import { setComponentFocused } from "./stage-chat-view-render-helpers.js";
+import type { StageChatViewContext } from "./stage-chat-view-types.js";
+
+export async function showCustomUi(
+  ctx: StageChatViewContext,
+  request: StageCustomUiRequest,
+): Promise<void> {
+  ctx.mountedCustomUi?.component.dispose?.();
+  ctx.mountedCustomUi = null;
+  // Track the request currently being mounted. `mountStageCustomUi` is async,
+  // so the broker can resolve/reject/abort the request (clearing it via
+  // `hideMountedCustomUi`) before we finish awaiting. Without this guard the
+  // post-await assignment below would strand a settled gate as a permanent
+  // `mountedCustomUi`, hiding the transcript and crashing on the next
+  // keystroke routed into the dead component (readiness gate #1099).
+  ctx.mountingRequestId = request.id;
+  if (!ctx.piTui || ctx.piTheme === undefined || ctx.piKeybindings === undefined) {
+    ctx.mountingRequestId = null;
+    ctx.stageUiBroker.reject(
+      request,
+      new Error("atomic-workflows: stage custom UI cannot mount without attached TUI host"),
+    );
+    return;
+  }
+  if (request.options?.overlay === true) {
+    ctx.mountingRequestId = null;
+    ctx.stageUiBroker.reject(
+      request,
+      new Error(
+        "atomic-workflows: ctx.ui.custom overlay mode is unavailable in the workflow graph viewer",
+      ),
+    );
+    return;
+  }
+  try {
+    const mounted = await mountStageCustomUi(
+      request,
+      ctx.piTui,
+      ctx.piTheme,
+      ctx.piKeybindings,
+      ctx.stageUiBroker,
+      () => {
+        if (ctx.mountedCustomUi?.request.id !== request.id) return;
+        ctx.mountedCustomUi.component.dispose?.();
+        ctx.mountedCustomUi = null;
+        ctx.chatHost.focused = ctx.focused;
+        ctx.chatHost.scrollToBottom();
+        ctx.requestRender?.();
+      },
+      () => canSubmitPrompt(ctx, request.id),
+    );
+    // Settled or superseded while mounting: drop the freshly-built component
+    // instead of showing a gate the broker has already torn down.
+    if (ctx.mountingRequestId !== request.id) {
+      mounted.component.dispose?.();
+      return;
+    }
+    ctx.mountingRequestId = null;
+    ctx.mountedCustomUi = mounted;
+    // A freshly-shown custom UI (ask_user_question / readiness gate) must own
+    // keyboard focus to be answerable — including a question mounted mid-turn
+    // while the agent is "streaming" (it is blocked on this very question, and
+    // host focus may have drifted off the overlay during the turn, e.g. after a
+    // stay-loop composer submit). requestFocus is idempotent (a no-op when the
+    // overlay already owns focus), so this never re-runs a redundant focus
+    // transition that would stall the stream (#1120).
+    ctx.requestFocus?.();
+    ctx.requestRender?.();
+  } catch (error) {
+    if (ctx.mountingRequestId === request.id) ctx.mountingRequestId = null;
+    ctx.stageUiBroker.reject(request, error);
+  }
+}
+
+export function renderCustomUi(ctx: StageChatViewContext, width: number): string[] {
+  const component = ctx.mountedCustomUi?.component;
+  if (!component) return [];
+  setComponentFocused(component, ctx.focused);
+  return embedOrchestratorReturnHintInWidget(ctx, component.render(width), width);
+}
+
+export function hideMountedCustomUi(
+  ctx: StageChatViewContext,
+  request: StageCustomUiRequest,
+): void {
+  // Signal any in-flight `showCustomUi` mount for this request to drop its
+  // component when it finishes — the broker is already tearing it down.
+  if (ctx.mountingRequestId === request.id) ctx.mountingRequestId = null;
+  const mounted = ctx.mountedCustomUi;
+  if (!mounted || mounted.request.id !== request.id) return;
+  ctx.mountedCustomUi = null;
+  mounted.component.dispose?.();
+  ctx.chatHost.focused = ctx.focused;
+  ctx.chatHost.scrollToBottom();
+  // Returning to the composer after a custom UI resolves (e.g. the readiness
+  // gate -> "stay") must re-assert overlay focus so the composer accepts
+  // input. Guarded for streaming so an answered mid-turn ask_user_question
+  // does not refocus during the agent's continuation (would stall it).
+  if (!ctx.chatHost.isStreaming()) ctx.requestFocus?.();
+  ctx.requestRender?.();
+}
+
+/**
+ * Stop displaying the mounted stage custom UI locally, WITHOUT settling its
+ * broker request. Detaching / closing / disposing the attached chat stops
+ * viewing the stage; it never cancels a pending human-input request. The
+ * request stays pending (the stage remains awaiting_input) so re-attaching
+ * re-displays it. The request is settled only by the user answering (broker
+ * resolve) or the run aborting (its AbortSignal -> broker reject) — those are
+ * the single chokepoints for ending a human-input request.
+ */
+export function releaseMountedCustomUi(ctx: StageChatViewContext): void {
+  ctx.mountingRequestId = null;
+  const mounted = ctx.mountedCustomUi;
+  if (!mounted) return;
+  ctx.mountedCustomUi = null;
+  mounted.component.dispose?.();
+}
+
+function canSubmitPrompt(ctx: StageChatViewContext, promptId: string): boolean {
+  return ctx.canSubmitPrompt?.(ctx.runId, ctx.stageId, promptId) ?? true;
+}

package/dist/builtin/workflows/src/tui/stage-chat-view-footer-status.ts

@@ -0,0 +1,187 @@
+import type { AgentSession } from "@bastani/atomic";
+import { Box, Text } from "@earendil-works/pi-tui";
+import { RESET, hexToAnsi } from "./color-utils.js";
+import {
+  bgFn,
+  blendBg,
+  paint,
+  paintOnFill,
+  stripAnsi,
+  trailingWidgetBorderChar,
+  widgetHintTargetLineIndex,
+} from "./stage-chat-view-render-helpers.js";
+import type { StageChatViewContext } from "./stage-chat-view-types.js";
+import type { StageSnapshot } from "../shared/store-types.js";
+import { truncateToWidth, visibleWidth } from "./text-helpers.js";
+
+export function renderHeader(
+  ctx: StageChatViewContext,
+  width: number,
+  stage: StageSnapshot | undefined,
+): string[] {
+  const t = ctx.theme;
+  const stageName = stage?.name ?? "stage";
+  const left =
+    paint("   ", t.mauve, { bold: true }) +
+    paint("STAGE", t.textMuted, { bold: true }) +
+    "  " +
+    paint(ctx.workflowName, t.textMuted) +
+    paint(" / ", t.dim) +
+    paint(stageName, t.text, { bold: true });
+  const meta = headerMeta(ctx, stage);
+  const right = meta ? paint(meta, t.dim) + " " : "";
+  const leftW =
+    visibleWidth(ctx.workflowName) +
+    visibleWidth(stageName) +
+    visibleWidth("  STAGE   /  ") +
+    1;
+  const rightW = visibleWidth(meta) + (meta ? 1 : 0);
+  const gap = Math.max(1, width - leftW - rightW);
+  return [left + " ".repeat(gap) + right];
+}
+
+function headerMeta(
+  ctx: StageChatViewContext,
+  stage: StageSnapshot | undefined,
+): string {
+  const parts: string[] = [];
+  const sid = ctx.handle?.sessionId ?? stage?.sessionId;
+  if (sid) parts.push(`session ${shortenId(sid)}`);
+  return parts.join(" · ");
+}
+
+function shortenId(id: string): string {
+  return id.length > 10 ? id.slice(0, 8) : id;
+}
+
+export function sepRule(ctx: StageChatViewContext, width: number): string {
+  return hexToAnsi(ctx.theme.borderDim) + "─".repeat(width) + RESET;
+}
+
+export function renderFooterWithOrchestratorReturnHint(
+  ctx: StageChatViewContext,
+  width: number,
+  footerLines: readonly string[],
+): string[] {
+  if (footerLines.length === 0) {
+    return [mergeOrchestratorReturnHintIntoLine(ctx, "", width)];
+  }
+  const lines = [...footerLines];
+  const lastIndex = lines.length - 1;
+  lines[lastIndex] = mergeOrchestratorReturnHintIntoLine(
+    ctx,
+    lines[lastIndex] ?? "",
+    width,
+  );
+  return lines;
+}
+
+export function embedOrchestratorReturnHintInWidget(
+  ctx: StageChatViewContext,
+  widgetLines: readonly string[],
+  width: number,
+): string[] {
+  if (widgetLines.length === 0) {
+    return [mergeOrchestratorReturnHintIntoLine(ctx, "", width)];
+  }
+  const lines = [...widgetLines];
+  const targetIndex = widgetHintTargetLineIndex(lines);
+  lines[targetIndex] = mergeOrchestratorReturnHintIntoLine(
+    ctx,
+    lines[targetIndex] ?? "",
+    width,
+    { preserveTrailingBorder: true, rightMargin: 2 },
+  );
+  return lines;
+}
+
+function mergeOrchestratorReturnHintIntoLine(
+  ctx: StageChatViewContext,
+  line: string,
+  width: number,
+  options: { preserveTrailingBorder?: boolean; rightMargin?: number } = {},
+): string {
+  const plain = "ctrl+d returns to orchestrator panel";
+  const styled =
+    paint("ctrl+d", ctx.theme.text, { bold: true }) +
+    paint(" returns to orchestrator panel", ctx.theme.textMuted);
+  const trailingBorder = options.preserveTrailingBorder === true
+    ? trailingWidgetBorderChar(line)
+    : "";
+  const suffixWidth = visibleWidth(trailingBorder);
+  const hintWidth = visibleWidth(plain);
+  const requestedRightMargin = Math.max(0, Math.floor(options.rightMargin ?? 0));
+  const rightMargin = Math.min(
+    requestedRightMargin,
+    Math.max(0, width - suffixWidth - hintWidth),
+  );
+  const hintStart = Math.max(0, width - suffixWidth - rightMargin - hintWidth);
+  const prefix = truncateToWidth(line, hintStart, "", true);
+  const gap = Math.max(0, hintStart - visibleWidth(prefix));
+  return prefix + " ".repeat(gap) + styled + " ".repeat(rightMargin) + trailingBorder;
+}
+
+export function banner(
+  ctx: StageChatViewContext,
+  kind: "warning" | "success" | "error" | "info",
+  glyph: string,
+  label: string,
+  meta: string,
+): Box {
+  const t = ctx.theme;
+  const fg =
+    kind === "warning"
+      ? t.warning
+      : kind === "success"
+        ? t.success
+        : kind === "info"
+          ? t.info
+          : t.error;
+  const bg = blendBg(t.bg, fg, 0.1);
+  const head =
+    paintOnFill(glyph, fg, { bold: true }) +
+    "  " +
+    paintOnFill(label, fg, { bold: true }) +
+    "  " +
+    paintOnFill(stripAnsi(meta), t.dim);
+  const box = new Box(2, 0, bgFn(bg));
+  box.addChild(new Text(head, 0, 0));
+  return box;
+}
+
+export function bannerLines(
+  ctx: StageChatViewContext,
+  width: number,
+  kind: "warning" | "success" | "error" | "info",
+  glyph: string,
+  label: string,
+  meta: string,
+): string[] {
+  return banner(ctx, kind, glyph, label, meta).render(width);
+}
+
+export function editorRuleColor(
+  ctx: StageChatViewContext,
+  disabled: boolean,
+  agentSession: AgentSession | undefined,
+  state?: { isBashMode: boolean },
+): string {
+  if (disabled) return ctx.theme.borderDim;
+  if (state?.isBashMode) return ctx.theme.warning;
+  const level = agentSession?.state.thinkingLevel ?? "off";
+  switch (level) {
+    case "minimal":
+      return ctx.theme.borderDim;
+    case "low":
+      return ctx.theme.info;
+    case "medium":
+      return ctx.theme.accent;
+    case "high":
+      return ctx.theme.mauve;
+    case "xhigh":
+      return ctx.theme.error;
+    case "off":
+    default:
+      return ctx.theme.border;
+  }
+}