@bermudi/pi-delegate 0.1.13 → 0.1.15

package/render-result.ts

@@ -1,4 +1,4 @@
-import { Text } from "@earendil-works/pi-tui";
+import { Box, Text } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import {
   fmtDuration,
@@ -15,6 +15,7 @@ import {
   type RenderHelpers,
 } from "./render-branches.ts";
 import type { DelegateDetails, TaskProgress } from "./types.ts";
+import { sanitizeTerminalLine, sanitizeTerminalText } from "./utils.ts";
 
 /** Build the shared helpers bound to a theme, width, and the lines sink.
  *  Both render branches consume one bound set so warning/activity formatting
@@ -25,9 +26,11 @@ function makeRenderHelpers(
   lines: string[],
 ): RenderHelpers {
   const statJoin = (parts: string[]) =>
-    parts.length ? theme.fg("muted", ` · ${parts.join(" · ")}`) : "";
-  const modelLabel = (p: TaskProgress) =>
-    p.model ? ` ${theme.fg("accent", p.model)}` : "";
+    parts.length ? theme.fg("dim", ` · ${parts.join(" · ")}`) : "";
+  const modelLabel = (p: TaskProgress) => {
+    const model = p.model ? sanitizeTerminalLine(p.model) : "";
+    return model ? theme.fg("dim", ` · ${model}`) : "";
+  };
 
   // Push muted warning lines for a task under its status row. Rendered in
   // both partial and final views so a human watching the TUI sees that tools
@@ -35,11 +38,21 @@ function makeRenderHelpers(
   const pushWarnings = (p: TaskProgress, ind: string) => {
     if (!p.warnings?.length) return;
     for (const wn of p.warnings) {
-      lines.push(truncLine(`${ind}${theme.fg("warning", `⚠ ${wn}`)}`, w));
+      const warning = sanitizeTerminalLine(wn);
+      if (warning) {
+        lines.push(
+          truncLine(`${ind}${theme.fg("warning", `⚠ ${warning}`)}`, w),
+        );
+      }
     }
   };
 
-  return { statJoin, modelLabel, compactActivity, pushWarnings };
+  return {
+    statJoin,
+    modelLabel,
+    compactActivity: (p) => sanitizeTerminalLine(compactActivity(p)),
+    pushWarnings,
+  };
 }
 
 /** Minimal structural view of Pi's `ToolRenderContext` used by the delegate
@@ -50,6 +63,12 @@ interface RenderCtx {
   invalidate: () => void;
   executionStarted: boolean;
   isPartial: boolean;
+  /** Message renderers own their horizontal padding; tool renderers do not. */
+  outputPad?: number;
+  /** Width already consumed by an outer shell such as the async result box. */
+  widthInset?: number;
+  /** Standalone custom messages do not need the tool-result leading spacer. */
+  standalone?: boolean;
 }
 
 interface RenderResultOptions {
@@ -65,6 +84,15 @@ interface RenderResult {
   details?: DelegateDetails;
 }
 
+interface AsyncDelegateMessage {
+  content: string | Array<{ type: string; text?: string }>;
+  details?: DelegateDetails;
+}
+
+interface AsyncMessageRenderOptions {
+  expanded: boolean;
+}
+
 /** Custom rendering for the tool *call* display — minimal by design; the result
  *  renderer shows all detail. Only animates a spinner while still running. */
 export function renderDelegateCall(
@@ -75,7 +103,9 @@ export function renderDelegateCall(
   const state = ctx.state;
   const rawTasks = args.tasks;
   const tasks = Array.isArray(rawTasks) ? rawTasks : [];
-  const text = (ctx.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+  const text =
+    (ctx.lastComponent as Text | undefined) ??
+    new Text("", ctx.outputPad ?? 0, 0);
   if (typeof rawTasks === "string") {
     text.setText(theme.fg("toolTitle", theme.bold("delegate invalid tasks")));
     return text;
@@ -129,7 +159,9 @@ export function renderDelegateResult(
     clearInterval(state.interval);
     state.interval = undefined;
   }
-  const text = (ctx.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+  const text =
+    (ctx.lastComponent as Text | undefined) ??
+    new Text("", ctx.outputPad ?? 0, 0);
 
   const details = result.details;
   if (!details?.progress?.length) {
@@ -138,7 +170,10 @@ export function renderDelegateResult(
         ?.filter((c) => c.type === "text")
         .map((c) => c.text)
         .join("\n") ?? "";
-    text.setText(content ? `\n${content}` : "");
+    const safeContent = sanitizeTerminalText(content);
+    text.setText(
+      safeContent ? `${ctx.standalone ? "" : "\n"}${safeContent}` : "",
+    );
     return text;
   }
 
@@ -149,8 +184,11 @@ export function renderDelegateResult(
     status: ticketStatus,
   } = details;
   const total = progress.length;
-  const w = getTermWidth() - 4;
-  const lines: string[] = [""];
+  const widthInset =
+    ctx.widthInset ??
+    (ctx.outputPad === undefined ? 4 : Math.max(0, ctx.outputPad * 2));
+  const w = getTermWidth() - widthInset;
+  const lines: string[] = ctx.standalone ? [] : [""];
   const helpers = makeRenderHelpers(theme, w, lines);
 
   const branchCtx = {
@@ -164,19 +202,32 @@ export function renderDelegateResult(
     lines,
     ticketId,
     ticketStatus,
+    elapsedMs: details.elapsedMs,
   };
 
   // Surface batch-level warnings at the top of the TUI. The same text already
   // lives in textual content, but the progress renderer ignores content.
   if (details?.dispatchWarning) {
-    lines.push(
-      truncLine(theme.fg("warning", `⚠ ${details.dispatchWarning}`), w),
-      "",
-    );
+    const warning = sanitizeTerminalLine(details.dispatchWarning);
+    if (warning) {
+      lines.push(truncLine(theme.fg("warning", `⚠ ${warning}`), w), "");
+    }
   }
   if (details?.overlapWarning) {
+    const warning = sanitizeTerminalLine(details.overlapWarning);
+    if (warning) {
+      lines.push(truncLine(theme.fg("warning", `⚠ ${warning}`), w), "");
+    }
+  }
+  if (details?.crossLeafDelivery) {
     lines.push(
-      truncLine(theme.fg("warning", `⚠ ${details.overlapWarning}`), w),
+      truncLine(
+        theme.fg(
+          "warning",
+          "↳ Result delivered from another session-tree branch",
+        ),
+        w,
+      ),
       "",
     );
   }
@@ -195,3 +246,52 @@ export function renderDelegateResult(
   text.setText(budgeted.join("\n"));
   return text;
 }
+
+/**
+ * Render an automatically delivered async result with the same compact /
+ * expanded presentation as a synchronous tool result. The full message
+ * content remains untouched in model context; only its TUI presentation is
+ * replaced.
+ */
+export function renderAsyncDelegateMessage(
+  message: AsyncDelegateMessage,
+  options: AsyncMessageRenderOptions,
+  theme: Theme,
+): Box {
+  const content =
+    typeof message.content === "string"
+      ? [{ type: "text", text: message.content }]
+      : message.content;
+  const result = renderDelegateResult(
+    { content, details: message.details },
+    { isPartial: false, expanded: options.expanded },
+    theme,
+    {
+      state: {},
+      lastComponent: undefined,
+      invalidate: () => undefined,
+      executionStarted: false,
+      isPartial: false,
+      // The Box below owns the same one-column padding as Pi's tool shell.
+      outputPad: 0,
+      widthInset: 2,
+      standalone: true,
+    },
+  );
+  const status = message.details?.status;
+  const failed =
+    status === "failed" ||
+    status === "cancelled" ||
+    message.details?.progress?.some((task) => task.status === "failed");
+  const pending = status === "running" || status === "cancelling";
+  let background: "toolPendingBg" | "toolErrorBg" | "toolSuccessBg" =
+    "toolSuccessBg";
+  if (pending) {
+    background = "toolPendingBg";
+  } else if (failed) {
+    background = "toolErrorBg";
+  }
+  const box = new Box(1, 1, (text) => theme.bg(background, text));
+  box.addChild(result);
+  return box;
+}