@tt-a1i/openpi 0.1.0

package/extensions/subagents/src/ui/transcript.ts

@@ -0,0 +1,293 @@
+/**
+ * Transcript rendering for the takeover view: turns a SubagentSnapshot's
+ * normalized transcript + live state into width-bounded TUI lines. The domain
+ * stream stays normalized and bounded; this renderer only formats its previews.
+ */
+
+import { getMarkdownTheme, type Theme } from "@earendil-works/pi-coding-agent";
+import {
+  Markdown,
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi,
+  type DefaultTextStyle,
+  type MarkdownOptions,
+} from "@earendil-works/pi-tui";
+import { sanitizeTerminalText } from "../../../shared/terminal-text.ts";
+import type { SubagentSnapshot, TranscriptItem } from "../domain.ts";
+
+const MAX_CACHED_WIDTHS_PER_ITEM = 2;
+
+/**
+ * Strip raw ANSI codes, expand tabs, and drop control chars. Terminal-expanded
+ * tabs (and stray escapes) make lines wider than the width we declare to the
+ * TUI, which desyncs the renderer and smears the overlay.
+ */
+export function sanitizeText(text: string): string {
+  return sanitizeTerminalText(text);
+}
+
+function singleLinePreview(text: string) {
+  // Keep meaningful whitespace inside parsed commands and paths; only fold
+  // physical line breaks so a preview remains one terminal row.
+  return sanitizeText(text).replace(/\r?\n/g, " ↵ ");
+}
+
+function compactPreview(text: string) {
+  return singleLinePreview(text).trim();
+}
+
+function stringField(value: Record<string, unknown>, field: string) {
+  const candidate = value[field];
+  return typeof candidate === "string" && candidate.length > 0
+    ? singleLinePreview(candidate)
+    : undefined;
+}
+
+function parsedArgs(preview: string) {
+  try {
+    const value: unknown = JSON.parse(preview);
+    return value && typeof value === "object" && !Array.isArray(value)
+      ? (value as Record<string, unknown>)
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Turn common tool arguments into a useful, bounded summary without retaining raw args. */
+export function summarizeToolArgs(name: string, argsPreview?: string) {
+  if (!argsPreview) return undefined;
+
+  const fallback = compactPreview(argsPreview);
+  if (!fallback || fallback === "{}") return undefined;
+
+  const args = parsedArgs(fallback);
+  if (!args) return fallback;
+
+  const tool = name.toLowerCase();
+  if (tool === "bash") return stringField(args, "command") ?? fallback;
+  if (tool === "read" || tool === "write" || tool === "edit") {
+    return stringField(args, "path") ?? fallback;
+  }
+  if (tool === "rg" || tool === "fd") {
+    const pattern = stringField(args, "pattern");
+    const path = stringField(args, "path");
+    if (pattern && path) return `${pattern} · ${path}`;
+    return pattern ?? path ?? fallback;
+  }
+  return fallback;
+}
+
+function transcriptMarkdownTheme() {
+  const theme = getMarkdownTheme();
+  return {
+    ...theme,
+    // Markdown normalizes unordered lists to "- "; use a display bullet so
+    // transcript list syntax is never confused with unrendered source.
+    listBullet: (text: string) =>
+      theme.listBullet(text.replace(/^(?:[-+*]) /, "• ")),
+  };
+}
+
+function renderMarkdown(
+  text: string,
+  width: number,
+  defaultTextStyle?: DefaultTextStyle,
+  options?: MarkdownOptions,
+) {
+  const clean = sanitizeText(text).trim();
+  if (!clean) return [];
+  const markdown = new Markdown(
+    clean,
+    0,
+    0,
+    transcriptMarkdownTheme(),
+    defaultTextStyle,
+    options,
+  );
+  return markdown
+    .render(Math.max(1, width))
+    .map((line) => truncateToWidth(line, width));
+}
+
+function renderUserText(theme: Theme, text: string, width: number) {
+  const lines = renderMarkdown(
+    text,
+    Math.max(1, width - 2),
+    { color: (content: string) => theme.fg("userMessageText", content) },
+    { preserveOrderedListMarkers: true, preserveBackslashEscapes: true },
+  );
+  return lines.map((line, index) =>
+    truncateToWidth(
+      (index === 0 ? theme.fg("accent", "> ") : "  ") + line,
+      width,
+    ),
+  );
+}
+
+function renderThinking(theme: Theme, text: string, width: number) {
+  const reasoning = sanitizeText(text).trim();
+  if (!reasoning) return [];
+  const out: string[] = [];
+  const prefix = theme.fg("dim", "~ ");
+  const defaultTextStyle = {
+    color: (content: string) => theme.fg("muted", content),
+    italic: true,
+  } satisfies DefaultTextStyle;
+  const lines = renderMarkdown(
+    reasoning,
+    Math.max(1, width - 2),
+    defaultTextStyle,
+  );
+  for (let i = 0; i < lines.length; i++) {
+    out.push(truncateToWidth((i === 0 ? prefix : "  ") + lines[i], width));
+  }
+  return out;
+}
+
+function renderAssistantItem(
+  theme: Theme,
+  item: Extract<TranscriptItem, { kind: "assistant" }>,
+  width: number,
+) {
+  const out: string[] = [];
+  for (const part of item.parts) {
+    if (part.type === "text") {
+      out.push(...renderMarkdown(part.text, width));
+    } else if (part.type === "thinking") {
+      out.push(
+        ...renderThinking(
+          theme,
+          part.redacted ? "[redacted reasoning]" : part.text,
+          width,
+        ),
+      );
+    } else if (part.type === "toolCall") {
+      const preview = summarizeToolArgs(part.name, part.argsPreview);
+      const line =
+        theme.fg("muted", "→ ") +
+        theme.fg("toolTitle", part.name) +
+        (preview ? theme.fg("dim", ` ${preview}`) : "");
+      out.push(truncateToWidth(line, width));
+    }
+  }
+  return out;
+}
+
+function renderToolResultItem(
+  theme: Theme,
+  item: Extract<TranscriptItem, { kind: "toolResult" }>,
+  width: number,
+) {
+  const firstLine =
+    sanitizeText(item.outputPreview ?? "")
+      .split("\n")
+      .find((line) => line.trim()) ?? "";
+  const label = item.isError
+    ? theme.fg("error", "  error: ")
+    : theme.fg("dim", "  output: ");
+  return [
+    truncateToWidth(label + theme.fg("dim", firstLine || "(no output)"), width),
+  ];
+}
+
+function renderTranscriptItem(
+  theme: Theme,
+  item: TranscriptItem,
+  width: number,
+) {
+  if (item.kind === "user") return renderUserText(theme, item.text, width);
+  if (item.kind === "assistant") return renderAssistantItem(theme, item, width);
+  return renderToolResultItem(theme, item, width);
+}
+
+/**
+ * Caches finalized transcript items by identity and width. Live state remains
+ * uncached because it changes on every stream tick; callers clear this cache
+ * from their component's invalidate() when Pi changes theme.
+ */
+export class TranscriptRenderer {
+  private itemCache = new WeakMap<TranscriptItem, Map<number, string[]>>();
+
+  render(snap: SubagentSnapshot, width: number, theme: Theme) {
+    const out: string[] = [];
+
+    for (const item of snap.transcript) {
+      const cached = this.itemCache.get(item)?.get(width);
+      const lines = cached ?? renderTranscriptItem(theme, item, width);
+      if (!cached) {
+        const widths = this.itemCache.get(item) ?? new Map<number, string[]>();
+        if (widths.size >= MAX_CACHED_WIDTHS_PER_ITEM) {
+          const oldestWidth = widths.keys().next().value;
+          if (oldestWidth !== undefined) widths.delete(oldestWidth);
+        }
+        widths.set(width, lines);
+        this.itemCache.set(item, widths);
+      }
+      if (lines.length > 0) out.push(...lines, "");
+    }
+    while (out.length > 0 && out[out.length - 1] === "") out.pop();
+
+    // Live streaming assistant buffers (cleared when the finalized message lands).
+    if (snap.liveAssistant) {
+      const { thinking, text } = snap.liveAssistant;
+      const before = out.length;
+      if (out.length > 0) out.push("");
+      if (thinking.trim()) out.push(...renderThinking(theme, thinking, width));
+      if (text.trim()) out.push(...renderMarkdown(text, width));
+      if (out.length === before + 1) out.pop();
+    }
+
+    // Live tool executions (present until the ToolEnd lands in the transcript).
+    for (const tool of snap.liveTools) {
+      if (out.length > 0) out.push("");
+      const marker = tool.done
+        ? tool.isError
+          ? theme.fg("error", "error")
+          : theme.fg("success", "done")
+        : theme.fg("warning", "running");
+      const args = summarizeToolArgs(tool.name, tool.argsPreview);
+      let line = `${theme.fg("toolTitle", tool.name)}${args ? theme.fg("dim", ` ${args}`) : ""} · ${marker}`;
+      const preview = tool.outputPreview && compactPreview(tool.outputPreview);
+      if (preview) line += theme.fg("dim", ` · ${preview}`);
+      out.push(truncateToWidth(line, width));
+    }
+
+    // Queued steering/follow-up messages: show them immediately so Enter
+    // visibly acknowledges the user's input instead of appearing to do nothing.
+    for (const message of snap.queued) {
+      if (out.length > 0) out.push("");
+      const prefix = theme.fg("warning", `> [queued ${message.kind}] `);
+      const wrapped = wrapTextWithAnsi(
+        sanitizeText(message.text),
+        Math.max(1, width - visibleWidth(prefix)),
+      );
+      for (let i = 0; i < wrapped.length; i++) {
+        out.push(
+          truncateToWidth(
+            (i === 0 ? prefix : " ".repeat(visibleWidth(prefix))) +
+              theme.fg("muted", wrapped[i]),
+            width,
+          ),
+        );
+      }
+    }
+
+    return out;
+  }
+
+  invalidate() {
+    this.itemCache = new WeakMap();
+  }
+}
+
+/** Render a subagent's conversation as width-bounded lines. */
+export function buildTranscriptLines(
+  snap: SubagentSnapshot,
+  width: number,
+  theme: Theme,
+  renderer?: TranscriptRenderer,
+) {
+  return (renderer ?? new TranscriptRenderer()).render(snap, width, theme);
+}

package/extensions/subagents/src/ui/wait-result.ts

@@ -0,0 +1,89 @@
+import {
+  getMarkdownTheme,
+  keyHint,
+  type Theme,
+} from "@earendil-works/pi-coding-agent";
+import { Markdown, Text } from "@earendil-works/pi-tui";
+import { sanitizeText } from "./transcript.ts";
+
+const COLLAPSED_MAX_LINES = 12;
+const MAX_STATUS_ROWS = 4;
+
+export interface WaitResultItem {
+  id: string;
+  title?: string;
+  status?: string;
+}
+
+export interface WaitResultDetails {
+  results?: WaitResultItem[];
+}
+
+export function buildWaitResultPreview(
+  content: string,
+  details: WaitResultDetails | undefined,
+  theme: Theme,
+) {
+  const results = details?.results ?? [];
+  const failed = results.filter((result) => result.status === "error").length;
+  const header =
+    theme.fg(failed > 0 ? "warning" : "success", "■") +
+    ` ${theme.fg("accent", theme.bold(`${results.length} subagent${results.length === 1 ? "" : "s"} settled`))}` +
+    (failed > 0 ? theme.fg("error", ` · ${failed} failed`) : "");
+  const lines = [header];
+
+  for (const result of results.slice(0, MAX_STATUS_ROWS)) {
+    const isFailure = result.status === "error";
+    const icon = theme.fg(
+      isFailure ? "error" : "success",
+      isFailure ? "x" : "✓",
+    );
+    lines.push(
+      `  ${icon} ${theme.fg("accent", result.id)}${result.title ? theme.fg("muted", ` · ${result.title}`) : ""}${theme.fg("dim", ` · ${result.status ?? "settled"}`)}`,
+    );
+  }
+  if (results.length > MAX_STATUS_ROWS) {
+    lines.push(theme.fg("dim", `  … ${results.length - MAX_STATUS_ROWS} more`));
+  }
+
+  const cleanLines = sanitizeText(content)
+    .split("\n")
+    .map((line) => line.trimEnd())
+    .filter((line) => line.trim() && line.trim() !== "---");
+  const leadingHeader = cleanLines[0]?.startsWith("## ") ? 1 : 0;
+  const body = cleanLines.slice(leadingHeader);
+  const available = Math.max(1, COLLAPSED_MAX_LINES - lines.length - 1);
+  for (const line of body.slice(0, available)) {
+    lines.push(theme.fg("toolOutput", line));
+  }
+
+  const hidden = Math.max(0, body.length - available);
+  if (hidden > 0) {
+    lines.push(
+      theme.fg(
+        "dim",
+        `… ${hidden} more line${hidden === 1 ? "" : "s"} · ${keyHint("app.tools.expand", "to expand")}`,
+      ),
+    );
+  }
+  return lines.join("\n");
+}
+
+export function renderWaitResult(
+  content: string,
+  details: WaitResultDetails | undefined,
+  expanded: boolean,
+  theme: Theme,
+) {
+  if (!expanded) {
+    return new Text(buildWaitResultPreview(content, details, theme), 0, 0);
+  }
+
+  const markdown = new Markdown(
+    sanitizeText(content),
+    0,
+    0,
+    getMarkdownTheme(),
+  );
+  return markdown;
+}

package/extensions/suggestions/index.ts

@@ -0,0 +1,172 @@
+import {
+  CustomEditor,
+  type ExtensionAPI,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+  loadSetupConfig,
+  SETUP_CONFIG_CHANGED_CHANNEL,
+} from "../shared/setup-config.ts";
+import { predictNextAction } from "./src/predictor.ts";
+import {
+  createRunBoundary,
+  getRunEntries,
+  serializeRunTranscript,
+} from "./src/transcript.ts";
+import {
+  NextActionSuggestionEditor,
+  NextActionSuggestionState,
+} from "./src/ui.ts";
+
+const STATUS_KEY = "suggestions";
+const SHUTDOWN_WAIT_MS = 1_000;
+
+async function waitForCancellation(
+  task: Promise<void> | undefined,
+  timeoutMs: number,
+) {
+  if (!task) return;
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    await Promise.race([
+      task.catch(() => undefined),
+      new Promise<void>((resolve) => {
+        timeout = setTimeout(resolve, timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
+interface ActivePrediction {
+  readonly controller: AbortController;
+  readonly task: Promise<void>;
+}
+
+export default function (pi: ExtensionAPI) {
+  const runBoundary = createRunBoundary();
+  const suggestionState = new NextActionSuggestionState();
+  let activePrediction: ActivePrediction | undefined;
+  let sessionActive = false;
+  let statusContext: ExtensionContext | undefined;
+  let requestEditorRender: (() => void) | undefined;
+
+  const updateStatus = () => {
+    statusContext?.ui.setStatus(
+      STATUS_KEY,
+      activePrediction
+        ? statusContext.ui.theme.fg("muted", "✦ predicting next input…")
+        : undefined,
+    );
+  };
+
+  const cancelPrediction = () => {
+    const current = activePrediction;
+    activePrediction = undefined;
+    suggestionState.cancel();
+    current?.controller.abort();
+    updateStatus();
+    requestEditorRender?.();
+  };
+
+  const installSuggestionEditor = (ctx: ExtensionContext) => {
+    if (ctx.mode !== "tui") return;
+    const previous = ctx.ui.getEditorComponent();
+    ctx.ui.setEditorComponent((tui, theme, keybindings) => {
+      const base =
+        previous?.(tui, theme, keybindings) ??
+        new CustomEditor(tui, theme, keybindings);
+      requestEditorRender = () => tui.requestRender();
+      return new NextActionSuggestionEditor(
+        base,
+        keybindings,
+        suggestionState,
+        cancelPrediction,
+        requestEditorRender,
+        (text) => ctx.ui.theme.fg("dim", text),
+      );
+    });
+  };
+
+  pi.on("session_start", (_event, ctx) => {
+    sessionActive = ctx.mode === "tui";
+    statusContext = ctx;
+    runBoundary.reset();
+    cancelPrediction();
+    installSuggestionEditor(ctx);
+  });
+
+  pi.on("input", () => {
+    cancelPrediction();
+    return { action: "continue" };
+  });
+
+  pi.on("before_agent_start", (_event, ctx) => {
+    if (ctx.mode !== "tui") return;
+    cancelPrediction();
+    runBoundary.begin(ctx.sessionManager.getLeafId());
+  });
+
+  pi.on("agent_settled", (_event, ctx) => {
+    const run = runBoundary.settle();
+    if (!run || ctx.mode !== "tui" || !sessionActive) return;
+
+    const entries = getRunEntries(
+      ctx.sessionManager.getBranch(),
+      run.baselineLeafId,
+    );
+    if (entries.length === 0) return;
+
+    const setup = loadSetupConfig();
+    if (!setup.suggestions.enabled || !setup.suggestions.model) return;
+
+    cancelPrediction();
+    const token = suggestionState.begin();
+    const controller = new AbortController();
+    statusContext = ctx;
+    const task = (async () => {
+      try {
+        const suggestion = await predictNextAction({
+          modelRegistry: ctx.modelRegistry,
+          config: setup.suggestions.model!,
+          transcript: serializeRunTranscript(entries),
+          signal: controller.signal,
+        });
+        if (!sessionActive || controller.signal.aborted) return;
+        suggestionState.offer(
+          token,
+          suggestion,
+          ctx.ui.getEditorText().length === 0,
+        );
+        requestEditorRender?.();
+      } catch {
+        if (!controller.signal.aborted) {
+          suggestionState.offer(token, undefined, true);
+        }
+      }
+    })().finally(() => {
+      if (activePrediction?.controller === controller) {
+        activePrediction = undefined;
+        updateStatus();
+      }
+    });
+
+    activePrediction = { controller, task };
+    updateStatus();
+    void task;
+  });
+
+  pi.events.on(SETUP_CONFIG_CHANGED_CHANNEL, cancelPrediction);
+
+  pi.on("session_shutdown", async () => {
+    sessionActive = false;
+    runBoundary.reset();
+    const task = activePrediction?.task;
+    cancelPrediction();
+    await waitForCancellation(task, SHUTDOWN_WAIT_MS);
+    statusContext?.ui.setStatus(STATUS_KEY, undefined);
+    statusContext = undefined;
+    requestEditorRender = undefined;
+  });
+}

package/extensions/suggestions/src/config.ts

@@ -0,0 +1,12 @@
+import {
+  loadSetupConfig,
+  type ReasoningLevel,
+  type SuggestionModelConfig,
+} from "../../shared/setup-config.ts";
+
+export type SuggestionConfig = SuggestionModelConfig;
+export type { ReasoningLevel };
+
+export function loadSuggestionConfig() {
+  return loadSetupConfig().suggestions.model;
+}