@tt-a1i/openpi 0.1.0

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

@@ -0,0 +1,615 @@
+/**
+ * Takeover UI for subagents (ported from v1, rendering from the synchronous
+ * SubagentReadModel instead of live pi sessions):
+ * - SubagentDashboard: full popup (overlay) listing all subagents.
+ * - TakeoverView: full interactive view of one subagent with an input line
+ *   to steer/continue it.
+ */
+
+import type {
+  ExtensionContext,
+  KeybindingsManager,
+  Theme,
+} from "@earendil-works/pi-coding-agent";
+import type { Component, Focusable, TUI } from "@earendil-works/pi-tui";
+import { Input, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { sanitizeTerminalText } from "../../../shared/terminal-text.ts";
+import { formatElapsed, type SubagentSnapshot } from "../domain.ts";
+import { formatContextUtilization } from "../format.ts";
+import type { SubagentReadModel } from "../manager.ts";
+import { TranscriptRenderer, buildTranscriptLines } from "./transcript.ts";
+
+export function sanitizeSubagentDisplayLine(value: string) {
+  return sanitizeTerminalText(value).replace(/\s+/g, " ").trim();
+}
+
+function configuredKeys(
+  keybindings: KeybindingsManager,
+  binding: Parameters<KeybindingsManager["getKeys"]>[0],
+) {
+  return keybindings.getKeys(binding).join("/") || "unbound";
+}
+
+function statusGlyph(snap: SubagentSnapshot, theme: Theme): string {
+  switch (snap.status) {
+    case "running":
+      return theme.fg("warning", "■");
+    case "done":
+      return theme.fg("success", "■");
+    case "error":
+      return theme.fg("error", "■");
+  }
+}
+
+function statusWord(snap: SubagentSnapshot, theme: Theme): string {
+  switch (snap.status) {
+    case "running":
+      return theme.fg("warning", "running");
+    case "done":
+      return theme.fg("success", "done");
+    case "error":
+      return theme.fg("error", "failed");
+  }
+}
+
+// --- Entry points --------------------------------------------------------------
+
+export interface TakeoverOptions {
+  readonly badge?: string;
+}
+
+export async function openSubagentTakeover(
+  ctx: ExtensionContext,
+  view: SubagentReadModel,
+  id: string,
+  options?: TakeoverOptions,
+) {
+  if (!view.get(id)) return;
+  await ctx.ui.custom<null>(
+    (tui, theme, keybindings, done) =>
+      new TakeoverView(tui, theme, keybindings, id, view, done, options),
+    {
+      overlay: true,
+      overlayOptions: { anchor: "center", width: "100%", maxHeight: "100%" },
+    },
+  );
+}
+
+export async function openSubagentPicker(
+  ctx: ExtensionContext,
+  view: SubagentReadModel,
+  initialId?: string,
+) {
+  const selection: DashboardSelection = { id: initialId, index: 0 };
+
+  while (true) {
+    if (view.size() === 0) {
+      ctx.ui.notify("No subagents", "info");
+      return;
+    }
+
+    const picked = await ctx.ui.custom<string | null>(
+      (tui, theme, keybindings, done) =>
+        new SubagentDashboard(tui, theme, keybindings, view, selection, done),
+      {
+        overlay: true,
+        overlayOptions: { anchor: "center", width: "100%", maxHeight: "100%" },
+      },
+    );
+
+    if (!picked) return;
+    if (!view.get(picked)) continue;
+
+    await openSubagentTakeover(ctx, view, picked);
+    // After leaving the takeover view, fall back to the dashboard.
+  }
+}
+
+// --- Dashboard (fullscreen overlay) ----------------------------------------------
+
+export interface DashboardSelection {
+  id?: string;
+  index: number;
+}
+
+export function reconcileDashboardSelection(
+  selection: DashboardSelection,
+  subs: ReadonlyArray<Pick<SubagentSnapshot, "id">>,
+) {
+  const stableIndex = selection.id
+    ? subs.findIndex((snap) => snap.id === selection.id)
+    : -1;
+  selection.index =
+    stableIndex >= 0
+      ? stableIndex
+      : Math.min(Math.max(0, selection.index), Math.max(0, subs.length - 1));
+  selection.id = subs[selection.index]?.id;
+}
+
+class SubagentDashboard implements Component {
+  private tui: TUI;
+  private theme: Theme;
+  private keybindings: KeybindingsManager;
+  private view: SubagentReadModel;
+  private selection: DashboardSelection;
+  private done: (value: string | null) => void;
+
+  private closed = false;
+  private ticker: ReturnType<typeof setInterval>;
+  private unsubChange: () => void;
+
+  constructor(
+    tui: TUI,
+    theme: Theme,
+    keybindings: KeybindingsManager,
+    view: SubagentReadModel,
+    selection: DashboardSelection,
+    done: (value: string | null) => void,
+  ) {
+    this.tui = tui;
+    this.theme = theme;
+    this.keybindings = keybindings;
+    this.view = view;
+    this.selection = selection;
+    this.done = done;
+    // Elapsed times, token counts, and statuses tick along at 1Hz.
+    this.ticker = setInterval(() => this.tui.requestRender(), 1000);
+    this.unsubChange = view.subscribe(() => this.tui.requestRender());
+  }
+
+  private subs(): ReadonlyArray<SubagentSnapshot> {
+    return this.view.list();
+  }
+
+  private cleanup() {
+    if (this.closed) return false;
+    this.closed = true;
+    clearInterval(this.ticker);
+    this.unsubChange();
+    return true;
+  }
+
+  private close(result: string | null) {
+    if (this.cleanup()) this.done(result);
+  }
+
+  dispose(): void {
+    this.cleanup();
+  }
+
+  handleInput(data: string): void {
+    const subs = this.subs();
+    reconcileDashboardSelection(this.selection, subs);
+
+    if (this.keybindings.matches(data, "tui.select.cancel")) {
+      this.close(null);
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.select.confirm")) {
+      const snap = subs[this.selection.index];
+      if (snap) this.close(snap.id);
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.select.up") || data === "k") {
+      if (subs.length > 0) {
+        this.selection.index =
+          (this.selection.index - 1 + subs.length) % subs.length;
+        this.selection.id = subs[this.selection.index]?.id;
+        this.tui.requestRender();
+      }
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.select.down") || data === "j") {
+      if (subs.length > 0) {
+        this.selection.index = (this.selection.index + 1) % subs.length;
+        this.selection.id = subs[this.selection.index]?.id;
+        this.tui.requestRender();
+      }
+      return;
+    }
+    if (data === "x") {
+      const snap = subs[this.selection.index];
+      if (snap && snap.status === "running") this.view.requestAbort(snap.id);
+      return;
+    }
+  }
+
+  private pad(text: string, width: number): string {
+    const truncated = truncateToWidth(text, width);
+    return truncated + " ".repeat(Math.max(0, width - visibleWidth(truncated)));
+  }
+
+  private borderSegment(width: number, title: string): string {
+    const theme = this.theme;
+    const label = title
+      ? ` ${truncateToWidth(title, Math.max(0, width - 3))} `
+      : "";
+    const labelWidth = visibleWidth(label);
+    return (
+      theme.fg("border", "─") +
+      (label ? theme.fg("text", label) : "") +
+      theme.fg("border", "─".repeat(Math.max(0, width - 1 - labelWidth)))
+    );
+  }
+
+  render(width: number): string[] {
+    const theme = this.theme;
+    const subs = this.subs();
+    reconcileDashboardSelection(this.selection, subs);
+
+    const rows = this.tui.terminal.rows || 30;
+    // Render exactly terminal rows - 1 so the overlay covers the header,
+    // chat, editor, and extra footer lines while leaving pi's final footer
+    // row visible.
+    const bodyHeight = Math.max(6, rows - 5);
+    const innerWidth = width - 2;
+
+    const lines: string[] = [];
+
+    // Header: title left, count right
+    const headerLeft = theme.fg("accent", theme.bold("Subagents"));
+    const headerRight = theme.fg(
+      "muted",
+      `${subs.length} agent${subs.length === 1 ? "" : "s"}`,
+    );
+    const headerPad = Math.max(
+      1,
+      width - visibleWidth(headerLeft) - visibleWidth(headerRight) - 4,
+    );
+    lines.push(
+      truncateToWidth(
+        `  ${headerLeft}${" ".repeat(headerPad)}${headerRight}  `,
+        width,
+      ),
+    );
+
+    // Top border with panel title
+    const settled = subs.filter((s) => s.status !== "running").length;
+    lines.push(
+      theme.fg("border", "╭") +
+        this.borderSegment(innerWidth, `agents · ${settled}/${subs.length}`) +
+        theme.fg("border", "╮"),
+    );
+
+    // Rows
+    const divider = theme.fg("border", "│");
+    const rowLines = this.renderRows(subs, innerWidth, bodyHeight);
+    for (let i = 0; i < bodyHeight; i++) {
+      lines.push(divider + this.pad(rowLines[i] ?? "", innerWidth) + divider);
+    }
+
+    // Bottom border
+    lines.push(
+      theme.fg("border", "╰") +
+        theme.fg("border", "─".repeat(innerWidth)) +
+        theme.fg("border", "╯"),
+    );
+
+    // Hints
+    lines.push(
+      truncateToWidth(
+        theme.fg(
+          "dim",
+          `  ${configuredKeys(this.keybindings, "tui.select.up")}/${configuredKeys(this.keybindings, "tui.select.down")}/jk select · ${configuredKeys(this.keybindings, "tui.select.confirm")} take over · x abort · ${configuredKeys(this.keybindings, "tui.select.cancel")} close`,
+        ),
+        width,
+      ),
+    );
+
+    return lines;
+  }
+
+  private renderRows(
+    subs: ReadonlyArray<SubagentSnapshot>,
+    width: number,
+    height: number,
+  ): string[] {
+    const theme = this.theme;
+    const out: string[] = [];
+
+    // Scroll window around selection
+    let start = 0;
+    if (subs.length > height) {
+      start = Math.min(
+        Math.max(0, this.selection.index - Math.floor(height / 2)),
+        subs.length - height,
+      );
+    }
+    const visible = subs.slice(start, start + height);
+
+    for (let i = 0; i < visible.length; i++) {
+      const snap = visible[i];
+      const index = start + i;
+      const isSelected = index === this.selection.index;
+
+      // Left: marker, status square, title
+      const marker = isSelected ? theme.fg("accent", "❯") : " ";
+      const safeTitle = sanitizeSubagentDisplayLine(snap.title) || snap.id;
+      const title = isSelected
+        ? theme.fg("accent", safeTitle)
+        : theme.fg("text", safeTitle);
+      const left = ` ${marker} ${statusGlyph(snap, theme)} ${title}`;
+
+      // Right: backend · model · context utilization · elapsed · status
+      const utilization = formatContextUtilization(snap.usage);
+      const dot = theme.fg("dim", " · ");
+      const rightParts = [
+        theme.fg("muted", snap.backend),
+        theme.fg(
+          "muted",
+          sanitizeSubagentDisplayLine(snap.meta.modelLabel ?? "?") || "?",
+        ),
+        ...(utilization ? [theme.fg("muted", utilization)] : []),
+        theme.fg("muted", formatElapsed(snap)),
+        statusWord(snap, theme),
+      ];
+      const right = `${rightParts.join(dot)} `;
+
+      const rightWidth = visibleWidth(right);
+      const leftMax = Math.max(0, width - rightWidth - 2);
+      const leftTruncated = truncateToWidth(left, leftMax);
+      const gap = Math.max(2, width - visibleWidth(leftTruncated) - rightWidth);
+      out.push(truncateToWidth(leftTruncated + " ".repeat(gap) + right, width));
+    }
+
+    if (start > 0) {
+      out[0] = truncateToWidth(theme.fg("dim", `   ... ${start} more`), width);
+    }
+    if (start + height < subs.length) {
+      out[out.length - 1] = truncateToWidth(
+        theme.fg("dim", `   ... ${subs.length - start - height} more`),
+        width,
+      );
+    }
+    return out;
+  }
+
+  invalidate(): void {}
+}
+
+// --- Takeover view ------------------------------------------------------------
+
+const TRANSCRIPT_SCROLL_STEP = 6;
+
+class TakeoverView implements Component, Focusable {
+  private tui: TUI;
+  private theme: Theme;
+  private keybindings: KeybindingsManager;
+  private id: string;
+  private view: SubagentReadModel;
+  private done: (value: null) => void;
+  private options?: TakeoverOptions;
+
+  private input = new Input();
+  private transcriptRenderer = new TranscriptRenderer();
+  /** Scroll offset in lines from the bottom of the transcript. 0 = pinned to bottom. */
+  private scrollOffset = 0;
+  private unsubscribe: () => void;
+  private renderTimer?: ReturnType<typeof setTimeout>;
+  private ticker: ReturnType<typeof setInterval>;
+  private closed = false;
+
+  private _focused = false;
+  get focused(): boolean {
+    return this._focused;
+  }
+  set focused(value: boolean) {
+    this._focused = value;
+    this.input.focused = value;
+  }
+
+  constructor(
+    tui: TUI,
+    theme: Theme,
+    keybindings: KeybindingsManager,
+    id: string,
+    view: SubagentReadModel,
+    done: (value: null) => void,
+    options?: TakeoverOptions,
+  ) {
+    this.tui = tui;
+    this.theme = theme;
+    this.keybindings = keybindings;
+    this.id = id;
+    this.view = view;
+    this.done = done;
+    this.options = options;
+    this.unsubscribe = view.subscribeTo(id, () => this.scheduleRender());
+    // Elapsed time in the header ticks along at 1Hz.
+    this.ticker = setInterval(() => this.tui.requestRender(), 1000);
+    this.input.onSubmit = (value: string) => {
+      const text = value.trim();
+      if (!text) return;
+      this.input.setValue("");
+      this.view.requestSend(this.id, text);
+      this.scrollOffset = 0;
+      this.tui.requestRender();
+    };
+  }
+
+  private snap(): SubagentSnapshot | undefined {
+    return this.view.get(this.id);
+  }
+
+  private scheduleRender() {
+    if (this.renderTimer) return;
+    // Streaming can emit an event per token. Limit terminal repaints so this
+    // view cannot starve input handling or make the child look frozen.
+    this.renderTimer = setTimeout(() => {
+      this.renderTimer = undefined;
+      if (!this.closed) this.tui.requestRender();
+    }, 50);
+  }
+
+  private cleanup() {
+    if (this.closed) return false;
+    this.closed = true;
+    this.unsubscribe();
+    clearInterval(this.ticker);
+    if (this.renderTimer) clearTimeout(this.renderTimer);
+    this.renderTimer = undefined;
+    return true;
+  }
+
+  private close() {
+    if (this.cleanup()) this.done(null);
+  }
+
+  dispose(): void {
+    this.cleanup();
+  }
+
+  handleInput(data: string): void {
+    if (this.keybindings.matches(data, "app.clear")) {
+      const snap = this.snap();
+      if (snap?.status === "running") this.view.requestAbort(this.id);
+      return;
+    }
+    if (
+      this.keybindings.matches(data, "app.interrupt") ||
+      this.keybindings.matches(data, "tui.select.cancel")
+    ) {
+      this.close();
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.editor.cursorUp")) {
+      this.scrollOffset += TRANSCRIPT_SCROLL_STEP;
+      this.tui.requestRender();
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.editor.cursorDown")) {
+      this.scrollOffset = Math.max(
+        0,
+        this.scrollOffset - TRANSCRIPT_SCROLL_STEP,
+      );
+      this.tui.requestRender();
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.editor.pageUp")) {
+      this.scrollOffset += this.viewportHeight();
+      this.tui.requestRender();
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.editor.pageDown")) {
+      this.scrollOffset = Math.max(
+        0,
+        this.scrollOffset - this.viewportHeight(),
+      );
+      this.tui.requestRender();
+      return;
+    }
+    this.input.handleInput(data);
+    this.tui.requestRender();
+  }
+
+  private viewportHeight(): number {
+    const rows = this.tui.terminal.rows || 30;
+    // The complete view renders viewport + 7 chrome rows. Using rows - 8
+    // makes the overlay exactly terminal rows - 1.
+    return Math.max(6, rows - 8);
+  }
+
+  render(width: number): string[] {
+    const theme = this.theme;
+    const border = theme.fg("borderAccent", "─".repeat(Math.max(1, width)));
+    const lines: string[] = [];
+    const snap = this.snap();
+
+    if (!snap) {
+      lines.push(border);
+      lines.push(theme.fg("dim", `${this.id} is no longer tracked`));
+      lines.push(border);
+      return lines;
+    }
+
+    lines.push(border);
+    const utilization = formatContextUtilization(snap.usage);
+    const header =
+      `${statusGlyph(snap, theme)} ` +
+      theme.fg(
+        "accent",
+        theme.bold(sanitizeSubagentDisplayLine(snap.title) || snap.id),
+      ) +
+      theme.fg("muted", ` · ${snap.status} · ${formatElapsed(snap)}`) +
+      (this.options?.badge
+        ? theme.fg(
+            "muted",
+            ` · ${sanitizeSubagentDisplayLine(this.options.badge)}`,
+          )
+        : "") +
+      theme.fg(
+        "dim",
+        ` · ${snap.backend}: ${sanitizeSubagentDisplayLine(snap.meta.modelLabel ?? "?") || "?"}`,
+      ) +
+      (utilization ? theme.fg("dim", ` · ${utilization}`) : "");
+    lines.push(truncateToWidth(header, width));
+    lines.push(border);
+
+    // Fixed-height transcript viewport. Error and scroll status consume rows
+    // inside the viewport so streaming/scrolling never changes overlay height.
+    const transcript = buildTranscriptLines(
+      snap,
+      width,
+      theme,
+      this.transcriptRenderer,
+    );
+    const viewport = this.viewportHeight();
+    const errorRows = snap.errorText ? 1 : 0;
+    const scrollRows = this.scrollOffset > 0 ? 1 : 0;
+    const transcriptCapacity = Math.max(1, viewport - errorRows - scrollRows);
+    const maxOffset = Math.max(0, transcript.length - transcriptCapacity);
+    if (this.scrollOffset > maxOffset) this.scrollOffset = maxOffset;
+
+    const body: string[] = [];
+    if (snap.errorText) {
+      body.push(
+        truncateToWidth(
+          theme.fg(
+            "error",
+            `error: ${sanitizeSubagentDisplayLine(snap.errorText)}`,
+          ),
+          width,
+        ),
+      );
+    }
+
+    const capacity = Math.max(
+      1,
+      viewport - body.length - (this.scrollOffset > 0 ? 1 : 0),
+    );
+    const end = transcript.length - this.scrollOffset;
+    const visible = transcript.slice(Math.max(0, end - capacity), end);
+    if (visible.length === 0) body.push(theme.fg("dim", "(no output yet)"));
+    else body.push(...visible);
+
+    if (this.scrollOffset > 0) {
+      body.push(
+        truncateToWidth(
+          theme.fg("dim", `... ${this.scrollOffset} lines below · ↓/pgdn`),
+          width,
+        ),
+      );
+    }
+    while (body.length < viewport) body.push("");
+    lines.push(...body.slice(0, viewport));
+
+    lines.push(border);
+    lines.push(...this.input.render(width));
+    lines.push(
+      truncateToWidth(
+        theme.fg(
+          "dim",
+          `${configuredKeys(this.keybindings, "tui.input.submit")} send · ${configuredKeys(this.keybindings, "app.interrupt")} back · ${configuredKeys(this.keybindings, "app.clear")} abort run · ${configuredKeys(this.keybindings, "tui.editor.cursorUp")}/${configuredKeys(this.keybindings, "tui.editor.cursorDown")} scroll · ${configuredKeys(this.keybindings, "tui.editor.pageUp")}/${configuredKeys(this.keybindings, "tui.editor.pageDown")} page`,
+        ),
+        width,
+      ),
+    );
+    lines.push(border);
+    return lines;
+  }
+
+  invalidate(): void {
+    this.input.invalidate();
+    this.transcriptRenderer.invalidate();
+  }
+}