@signalridge/pi-workflows 1.8.0 → 1.9.0

package/src/ui.ts

@@ -1,276 +1,54 @@
-import type { ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
-import { DynamicBorder } from "@earendil-works/pi-coding-agent";
-import { Key, matchesKey, type SelectItem, SelectList, Text } from "@earendil-works/pi-tui";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { WorkflowEngine } from "./engine.js";
-import type { ScriptRun } from "./journal.js";
 import { sanitizeDisplayText } from "./safe-text.js";
-
-/** Bounds, in code points, for untrusted strings rendered into the navigator. */
-const MAX_NAME_CHARS = 200;
-const MAX_ID_CHARS = 128;
-const MAX_RESULT_CHARS = 300;
-const MAX_RUN_ERROR_CHARS = 500;
-const MAX_DESCRIPTION_CHARS = 120;
-
-/**
- * Pure snapshot render layer shared by the navigator, the live widget, and any
- * inline render site. All child-agent output passes through sanitizeDisplayText
- * BEFORE truncation so a live escape introducer is never cut mid-sequence.
- */
-export function snapshotRunLine(run: ScriptRun): string {
-  return formatWorkflowRunLabel(run);
-}
-
-/** Live-widget lines for all non-terminal runs (A10). */
-export function liveWidgetLines(
-  runs: readonly ScriptRun[],
-  mode: "compact" | "detailed" = "compact",
-  maxAgentsShown = 6,
-): string[] {
-  const active = runs.filter((run) => !isTerminal(run.status));
-  if (active.length === 0) return [];
-  const boundedMax = Math.max(1, Math.min(32, Math.floor(maxAgentsShown)));
-  const lines = ["Workflows"];
-  for (const run of active.slice(0, boundedMax)) {
-    lines.push(`  ${snapshotRunLine(run)}`);
-    if (mode === "detailed") {
-      for (const [nodeId, status] of Object.entries(run.callStatus).slice(0, boundedMax)) {
-        lines.push(`    ${nodeId}: ${status}`);
-      }
-    }
-  }
-  return lines.slice(0, 1 + boundedMax * (mode === "detailed" ? boundedMax + 1 : 1));
-}
-
-export type RunStatus = ScriptRun["status"];
-
-function elapsed(ms: number): string {
-  const seconds = Math.floor(ms / 1_000);
-  if (seconds < 60) return `${seconds}s`;
-  const minutes = Math.floor(seconds / 60);
-  return `${minutes}m ${seconds % 60}s`;
-}
-
-function isTerminal(status: RunStatus): boolean {
-  return status === "completed" || status === "failed" || status === "stopped";
-}
-
-export function formatWorkflowRunLabel(run: ScriptRun): string {
-  const phases = run.meta.phases && run.meta.phases.length > 0 ? ` · phases ${run.meta.phases.length}` : "";
-  const calls = Object.keys(run.callResults).length;
-  const name = sanitizeDisplayText(run.meta.name, MAX_NAME_CHARS);
-  return `${name} · ${run.status}${phases} · ${calls} calls · ${elapsed(Math.max(0, (isTerminal(run.status) ? run.updatedAt : Date.now()) - run.startedAt))}`;
-}
-
-function resultText(value: unknown): string {
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value) ?? "(no preview)";
-  } catch {
-    return "(unavailable preview)";
-  }
-}
-
-export function formatWorkflowDetail(engine: WorkflowEngine, runId: string): string {
-  const state = engine.getState(runId);
-  if (!state) return "Workflow run is no longer available.";
-  const run = state.run;
-  const tokenValues = Object.values(run.callResults)
-    .map((result) => result.tokenCount)
-    .filter((value): value is number => value !== undefined);
-  const tokenCount = tokenValues.length > 0 ? tokenValues.reduce((total, value) => total + value, 0) : undefined;
-  const lines = [
-    `${sanitizeDisplayText(run.meta.name, MAX_NAME_CHARS)} [${run.status}]`,
-    `run: ${sanitizeDisplayText(run.runId, MAX_ID_CHARS)}`,
-    `elapsed: ${elapsed(Math.max(0, (isTerminal(run.status) ? run.updatedAt : Date.now()) - run.startedAt))}`,
-    "",
-    ...(tokenCount === undefined ? [] : [`tokens: ${tokenCount}`]),
-  ];
-  for (const phase of run.meta.phases ?? []) {
-    lines.push(`Phase: ${sanitizeDisplayText(phase.title, MAX_NAME_CHARS)}`);
-  }
-  const calls = Object.entries(run.callStatus)
-    .sort(([a], [b]) => Number(a) - Number(b))
-    .map(([nodeId, status]) => {
-      const result = run.callResults[nodeId];
-      const agent = run.agentIds[nodeId] ? ` agent=${sanitizeDisplayText(run.agentIds[nodeId], MAX_ID_CHARS)}` : "";
-      const compact = run.compactions[nodeId] ? ` compactions=${run.compactions[nodeId]}` : "";
-      const parts = [`  ${status.padEnd(11)} call ${sanitizeDisplayText(nodeId, MAX_ID_CHARS)}${agent}${compact}`];
-      if (result?.error) parts.push(`    error: ${sanitizeDisplayText(result.error, MAX_RESULT_CHARS)}`);
-      if (result?.result !== undefined && result.status === "completed") {
-        parts.push(`    result: ${sanitizeDisplayText(resultText(result.result), MAX_RESULT_CHARS)}`);
-      }
-      return parts.join("\n");
-    });
-  if (calls.length > 0) {
-    lines.push("Calls:");
-    lines.push(...calls);
-  }
-  lines.push("", "Live agent conversations remain available through pi-subagents FleetView.");
-  if (run.error) lines.push(`Error: ${sanitizeDisplayText(run.error, MAX_RUN_ERROR_CHARS)}`);
-  return lines.join("\n");
-}
-
-/** Actions the `/workflows` detail menu can offer, in display order. */
-export type WorkflowAction = "refresh" | "pause" | "resume" | "stop" | "back";
-
-export interface WorkflowActionItem {
-  value: WorkflowAction;
-  label: string;
-}
-
-const REFRESH: WorkflowActionItem = { value: "refresh", label: "Refresh" };
-const PAUSE: WorkflowActionItem = { value: "pause", label: "Pause" };
-const RESUME: WorkflowActionItem = { value: "resume", label: "Resume" };
-const STOP: WorkflowActionItem = { value: "stop", label: "Stop" };
-const BACK: WorkflowActionItem = { value: "back", label: "Back" };
-
-/**
- * Menu actions legal for a run in `status`. Exhaustive by construction.
- */
-export function workflowActionsFor(status: RunStatus): readonly WorkflowActionItem[] {
-  switch (status) {
-    case "pending":
-    case "pausing":
-    case "stopping":
-      return [REFRESH, STOP, BACK];
-    case "running":
-      return [REFRESH, PAUSE, STOP, BACK];
-    case "paused":
-    case "interrupted":
-      return [REFRESH, RESUME, STOP, BACK];
-    case "completed":
-    case "failed":
-    case "stopped":
-      return [REFRESH, BACK];
-  }
-  const unreachable: never = status;
-  return unreachable;
-}
-
-async function selectList<T>(
-  ctx: ExtensionCommandContext,
-  title: string,
-  items: SelectItem[],
-  renderExtra: (theme: Pick<Theme, "fg">) => string,
-): Promise<T | undefined> {
-  if (ctx.mode !== "tui" || !ctx.hasUI) return undefined;
-  return ctx.ui.custom<T | undefined>((tui, theme, _keybindings, done) => {
-    const border = new DynamicBorder((s: string) => theme.fg("borderAccent", s));
-    const heading = new Text(theme.fg("accent", theme.bold(title)), 1, 0);
-    const detail = new Text(theme.fg("dim", renderExtra(theme)), 1, 0);
-    let offset = 0;
-    let pageSize = 1;
-    const list = new SelectList(items, Math.min(12, Math.max(1, items.length)), {
-      selectedPrefix: (text) => theme.fg("accent", text),
-      selectedText: (text) => theme.fg("accent", text),
-      description: (text) => theme.fg("muted", text),
-      scrollInfo: (text) => theme.fg("dim", text),
-      noMatch: (text) => theme.fg("warning", text),
-    });
-    list.onSelect = (item) => done(item.value as T);
-    list.onCancel = () => done(undefined);
-    const hint = new Text(theme.fg("dim", "↑↓ select · enter confirm · esc back · PgUp/PgDn details"), 1, 0);
-    return {
-      render: (width) => {
-        const top = [...border.render(width), ...heading.render(width).slice(0, 2)];
-        const bottom = [...list.render(width), ...hint.render(width), ...border.render(width)];
-        pageSize = Math.max(1, tui.terminal.rows - top.length - bottom.length - 1);
-        const lines = detail.render(width);
-        offset = Math.max(0, Math.min(offset, lines.length - pageSize));
-        return [...top, ...lines.slice(offset, offset + pageSize), ...bottom];
-      },
-      invalidate: () => {
-        heading.invalidate();
-        detail.invalidate();
-        list.invalidate();
-      },
-      handleInput: (data) => {
-        if (matchesKey(data, Key.pageDown)) offset += pageSize;
-        else if (matchesKey(data, Key.pageUp)) offset = Math.max(0, offset - pageSize);
-        else list.handleInput(data);
-        tui.requestRender();
-      },
-    };
-  });
-}
-
-/** Interactive `/workflows` navigator. TUI-only by design. */
+import { WorkflowCommandCenter, type WorkflowNavigatorOptions } from "./ui-command-center.js";
+
+export type { WorkflowNavigatorOptions } from "./ui-command-center.js";
+export {
+  formatWorkflowDetail,
+  formatWorkflowRunLabel,
+  liveWidgetLines,
+  type RunStatus,
+  snapshotRunLine,
+  type WorkflowAction,
+  type WorkflowActionItem,
+  workflowActionsFor,
+} from "./ui-presentation.js";
+
+/** Live, explicitly opened `/workflows` command center. No headless TUI mounts. */
 export async function showWorkflowNavigator(
-  ctx: ExtensionCommandContext,
+  ctx: ExtensionContext,
   engineSource: WorkflowEngine | (() => WorkflowEngine),
+  options: WorkflowNavigatorOptions = {},
 ): Promise<void> {
-  if (ctx.mode !== "tui") {
+  if (ctx.mode !== "tui" || !ctx.hasUI) {
     ctx.ui.notify("/workflows requires TUI mode; use workflow_control for machine-readable access.", "warning");
     return;
   }
-  const resolveEngine = typeof engineSource === "function" ? engineSource : () => engineSource;
-  let inactiveNotified = false;
-  const currentEngine = (): WorkflowEngine | undefined => {
-    try {
-      return resolveEngine();
-    } catch (error: unknown) {
-      if (!inactiveNotified) {
-        inactiveNotified = true;
-        ctx.ui.notify(error instanceof Error ? error.message : String(error), "warning");
-      }
-      return undefined;
-    }
-  };
-  while (true) {
-    const engine = currentEngine();
-    if (!engine) return;
-    const states = engine
-      .list()
-      .map((summary) => engine.getRun(String(summary.runId)))
-      .filter((run): run is ScriptRun => run !== undefined)
-      .sort((a, b) => b.startedAt - a.startedAt);
-    const selected = await selectList<string>(
-      ctx,
-      "Workflow runs",
-      states.map((run) => ({
-        value: run.runId,
-        label: formatWorkflowRunLabel(run),
-        description: run.error === undefined ? undefined : sanitizeDisplayText(run.error, MAX_DESCRIPTION_CHARS),
-      })),
-      (theme) =>
-        states.length > 0
-          ? theme.fg("dim", "Select a run to inspect.")
-          : theme.fg("muted", "No workflow runs in this session."),
+  const source = typeof engineSource === "function" ? engineSource : () => engineSource;
+  let component: WorkflowCommandCenter | undefined;
+  try {
+    const sessionId = ctx.sessionManager.getSessionId();
+    await ctx.ui.custom<void>(
+      (tui, theme, keys, done) => {
+        component = new WorkflowCommandCenter(
+          tui,
+          theme,
+          keys,
+          source,
+          () => ctx.sessionManager.getSessionId() === sessionId,
+          done,
+          (message) => ctx.ui.notify(message, "error"),
+          options,
+        );
+        return component;
+      },
+      { overlay: true, overlayOptions: { anchor: "center", width: "100%", maxHeight: "100%", margin: 0 } },
     );
-    if (!selected) return;
-    while (true) {
-      const latest = currentEngine();
-      if (!latest) return;
-      const run = latest.getRun(selected);
-      if (!run) break;
-      const name = sanitizeDisplayText(run.meta.name, MAX_NAME_CHARS);
-      const action = await selectList<WorkflowAction>(
-        ctx,
-        `${name} · ${run.status}`,
-        workflowActionsFor(run.status).map((item) => ({
-          value: item.value,
-          label: item.label,
-        })),
-        () => {
-          const current = currentEngine();
-          return current ? formatWorkflowDetail(current, selected) : "Workflow surface is no longer active.";
-        },
-      );
-      if (action === undefined || action === "back") break;
-      if (action === "refresh") continue;
-      if (action === "stop") {
-        const confirmed = await ctx.ui.confirm("Stop workflow", `Stop ${name}? The run will be non-resumable.`);
-        if (!confirmed) continue;
-      }
-      try {
-        const current = currentEngine();
-        if (!current) return;
-        await current.control(action, selected);
-        ctx.ui.notify(`Workflow ${action} requested.`, "info");
-      } catch (error: unknown) {
-        ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
-      }
-    }
+  } catch (error: unknown) {
+    ctx.ui.notify(sanitizeDisplayText(error instanceof Error ? error.message : String(error), 500), "error");
+  } finally {
+    // Also covers external cancellation or custom() rejection before TUI disposal.
+    component?.dispose();
   }
 }