@fitchmultz/pi-subagents 0.44.7 → 0.46.0

package/src/tui/compact-results.ts

@@ -0,0 +1,342 @@
+import { keyText } from "@earendil-works/pi-coding-agent";
+import { Container, Text, TruncatedText, type Component } from "@earendil-works/pi-tui";
+import { shortenPath } from "../shared/formatters.ts";
+import { getSingleResultOutput } from "../shared/utils.ts";
+import {
+  buildMultiProgressLabel,
+  renderEntries,
+  resultRowLabel,
+  type ChainRenderEntry,
+  type MultiProgressLabel,
+} from "./workflow-labels.ts";
+import { widgetStepGlyph, widgetStepStatus } from "./widget-status.ts";
+import {
+  totalProgress,
+  resultProgress,
+  workflowFacts,
+  type DetailsInput,
+  type ResultInput,
+} from "./result-facts.ts";
+import { hasText, nonemptyText } from "./text-values.ts";
+import {
+  statJoin,
+  formatProgressStats,
+  getTermWidth,
+  modelThinkingBadge,
+  modelStat,
+  resultGlyph,
+  compactCurrentActivity,
+  truncLine,
+  buildLiveStatusLine,
+  snapshotNowForProgress,
+  resultStatusLine,
+  firstOutputLine,
+  hasEmptyTextOutputWithoutOutputTarget,
+  runningGlyph,
+  runningSeed,
+  progressRunningSeed,
+  themeBold,
+  extractOutputTarget,
+  type Theme,
+} from "./display.ts";
+
+function resultOutput(d: DetailsInput, r: ResultInput): string {
+  return (
+    nonemptyText(r.truncation?.text) ??
+    nonemptyText(getSingleResultOutput(r)) ??
+    (d.intercomDelivery?.delivered === true ? d.intercomDelivery.summary : "")
+  );
+}
+function expandLabel(d: DetailsInput): string {
+  return `${keyText("app.tools.expand")} ${d.intercomDelivery?.delivered === true ? "receipt details" : "full response"}`;
+}
+function paths(r: ResultInput, theme: Theme): Container {
+  const c = new Container();
+  if (hasText(r.sessionFile)) {
+    c.addChild(new TruncatedText(theme.fg("dim", `  session: ${shortenPath(r.sessionFile)}`)));
+  }
+  if (r.artifactPaths) {
+    c.addChild(
+      new TruncatedText(theme.fg("dim", `  output: ${shortenPath(r.artifactPaths.outputPath)}`)),
+    );
+  }
+  if (hasText(r.truncation?.artifactPath)) {
+    c.addChild(
+      new TruncatedText(
+        theme.fg("dim", `  full output: ${shortenPath(r.truncation.artifactPath)}`),
+      ),
+    );
+  }
+  return c;
+}
+function singleHeadline(
+  d: DetailsInput,
+  r: ResultInput,
+  theme: Theme,
+  isError: boolean,
+): Component {
+  const progress = r.progress ?? r.progressSummary;
+  const running = !isError && r.progress?.status === "running";
+  const badge = d.context === "fork" ? theme.fg("warning", " [fork]") : "";
+  const turns = r.usage.turns > 0 ? `⟳ ${r.usage.turns}` : "";
+  const stats = statJoin(theme, [turns, formatProgressStats(theme, progress)]);
+  const glyph = isError
+    ? theme.fg("error", "✗")
+    : resultGlyph(r, resultOutput(d, r), theme, { running });
+  return new TruncatedText(
+    `${glyph} ${theme.fg("toolTitle", theme.bold(r.agent))}${modelThinkingBadge(theme, r.model)}${badge}${hasText(stats) ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
+  );
+}
+function compactLive(r: ResultInput, theme: Theme): Container {
+  const c = new Container(),
+    width = getTermWidth() - 4,
+    progress = r.progress;
+  if (!progress) {
+    return c;
+  }
+  const activity = compactCurrentActivity(progress),
+    live = buildLiveStatusLine(progress, snapshotNowForProgress(progress));
+  c.addChild(new Text(truncLine(theme.fg("dim", `  ⎿  ${activity}`), width), 0, 0));
+  if (hasText(live) && live !== activity) {
+    c.addChild(new Text(truncLine(theme.fg("dim", `     ${live}`), width), 0, 0));
+  }
+  const expand = keyText("app.tools.expand");
+  if (hasText(expand)) {
+    c.addChild(
+      new Text(truncLine(theme.fg("accent", `  Press ${expand} for live detail`), width), 0, 0),
+    );
+  }
+  if (r.artifactPaths) {
+    c.addChild(
+      new Text(
+        truncLine(theme.fg("dim", `  output: ${shortenPath(r.artifactPaths.outputPath)}`), width),
+        0,
+        0,
+      ),
+    );
+  }
+  return c;
+}
+export function renderSingleCompact(
+  d: DetailsInput,
+  r: ResultInput,
+  theme: Theme,
+  isError = false,
+): Component {
+  const c = new Container(),
+    output = nonemptyText(r.truncation?.text) ?? getSingleResultOutput(r);
+  c.addChild(singleHeadline(d, r, theme, isError));
+  if (!isError && r.progress?.status === "running") {
+    c.addChild(compactLive(r, theme));
+    return c;
+  }
+  c.addChild(new TruncatedText(theme.fg("dim", `  ⎿  ${resultStatusLine(r, resultOutput(d, r))}`)));
+  const preview = firstOutputLine(output);
+  if (
+    hasText(preview) &&
+    r.exitCode === 0 &&
+    !hasEmptyTextOutputWithoutOutputTarget(r.task, output)
+  ) {
+    c.addChild(new TruncatedText(theme.fg("dim", `     ${preview}`)));
+  }
+  c.addChild(paths(r, theme));
+  c.addChild(new TruncatedText(theme.fg("dim", `  ${expandLabel(d)}`)));
+  return c;
+}
+function compactMultiGlyph(d: DetailsInput, theme: Theme, isError: boolean): string {
+  const facts = workflowFacts(d, isError);
+  if (facts.running) {
+    return theme.fg(
+      "accent",
+      runningGlyph(runningSeed(progressRunningSeed(totalProgress(d)), d.currentStepIndex)),
+    );
+  }
+  if (facts.failed) {
+    return theme.fg("error", "✗");
+  }
+  return theme.fg(
+    facts.paused || facts.blocked ? "warning" : "success",
+    facts.paused || facts.blocked ? "■" : "✓",
+  );
+}
+function compactMultiHeading(
+  d: DetailsInput,
+  theme: Theme,
+  label: MultiProgressLabel,
+  isError: boolean,
+): Component {
+  const stats = statJoin(theme, [label.headerLabel, formatProgressStats(theme, totalProgress(d))]);
+  const badge = d.context === "fork" ? theme.fg("warning", " [fork]") : "";
+  return new TruncatedText(
+    `${compactMultiGlyph(d, theme, isError)} ${theme.fg("toolTitle", theme.bold(d.mode))}${badge}${hasText(stats) ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
+  );
+}
+function placeholder(
+  entry: Extract<ChainRenderEntry, { kind: "placeholder" }>,
+  theme: Theme,
+): Container {
+  const c = new Container();
+  c.addChild(
+    new TruncatedText(
+      `  ${widgetStepGlyph(entry.status, theme)} ${entry.stepLabel}: ${themeBold(theme, entry.agentName)} ${theme.fg("dim", "·")} ${widgetStepStatus(entry.status, theme)}`,
+    ),
+  );
+  if (hasText(entry.error)) {
+    c.addChild(new TruncatedText(theme.fg("error", `    ⎿  Error: ${entry.error}`)));
+  }
+  return c;
+}
+function needsOutcome(r: ResultInput, output: string): boolean {
+  return (
+    r.exitCode !== 0 ||
+    r.interrupted === true ||
+    r.detached === true ||
+    r.timedOut === true ||
+    r.acceptance?.status === "blocked" ||
+    hasEmptyTextOutputWithoutOutputTarget(r.task, output)
+  );
+}
+function rowPaths(r: ResultInput, theme: Theme): Container {
+  const c = new Container(),
+    target = extractOutputTarget(r.task);
+  if (hasText(target)) {
+    c.addChild(new TruncatedText(theme.fg("dim", `    output: ${target}`)));
+  }
+  if (r.artifactPaths) {
+    c.addChild(
+      new TruncatedText(theme.fg("dim", `    output: ${shortenPath(r.artifactPaths.outputPath)}`)),
+    );
+  }
+  return c;
+}
+function compactRow(
+  d: DetailsInput,
+  entry: Extract<ChainRenderEntry, { kind: "result" }>,
+  theme: Theme,
+  label: MultiProgressLabel,
+): { component: Component; live: boolean } {
+  const c = new Container(),
+    r = d.results.at(entry.resultIndex);
+  if (!r) {
+    const pending = label.hasParallelInChain
+      ? resultRowLabel(d, label, entry.resultIndex, entry.rowNumber)
+      : `${label.itemTitle} ${entry.rowNumber}`;
+    c.addChild(new TruncatedText(theme.fg("dim", `  ◦ ${pending}: ${entry.agentName} · pending`)));
+    return { component: c, live: false };
+  }
+  const progress = resultProgress(d, entry.resultIndex),
+    running = progress?.status === "running";
+  const output =
+    nonemptyText(getSingleResultOutput(r)) ??
+    (d.intercomDelivery?.delivered === true ? d.intercomDelivery.summary : "");
+  const number = progress?.index === undefined ? entry.resultIndex + 1 : progress.index + 1;
+  const step = resultRowLabel(d, label, entry.resultIndex, number);
+  c.addChild(compactRowHeading(r, theme, output, { progress, step, agentName: entry.agentName }));
+  c.addChild(compactRowActivity(r, theme, output, progress));
+  c.addChild(rowPaths(r, theme));
+  return { component: c, live: running };
+}
+
+function compactRowHeading(
+  r: ResultInput,
+  theme: Theme,
+  output: string,
+  row: {
+    readonly progress: ReturnType<typeof resultProgress>;
+    readonly step: string;
+    readonly agentName: string;
+  },
+): Component {
+  const progress = row.progress,
+    running = progress?.status === "running",
+    pending = progress?.status === "pending";
+  const stats = formatProgressStats(theme, progress),
+    glyph = pending
+      ? theme.fg("dim", "◦")
+      : resultGlyph(r, output, theme, { running, seed: progressRunningSeed(progress) });
+  return new TruncatedText(
+    `  ${glyph} ${row.step}: ${themeBold(theme, row.agentName)}${modelStat(theme, r.model)}${hasText(stats) ? ` ${theme.fg("dim", "·")} ${stats}` : ""}${pending ? ` ${theme.fg("dim", "· pending")}` : ""}`,
+  );
+}
+
+function compactRowActivity(
+  r: ResultInput,
+  theme: Theme,
+  output: string,
+  progress: ReturnType<typeof resultProgress>,
+): Container {
+  const c = new Container();
+  if (progress?.status === "running") {
+    c.addChild(
+      new Text(
+        truncLine(
+          theme.fg("dim", `    ⎿  ${compactCurrentActivity(progress)}`),
+          getTermWidth() - 4,
+        ),
+        0,
+        0,
+      ),
+    );
+  } else if (progress?.status !== "pending" && needsOutcome(r, output)) {
+    c.addChild(
+      new TruncatedText(
+        theme.fg(r.exitCode !== 0 ? "error" : "dim", `    ⎿  ${resultStatusLine(r, output)}`),
+      ),
+    );
+  }
+  return c;
+}
+function multiFooter(
+  d: DetailsInput,
+  theme: Theme,
+  input: { readonly hidden: number; readonly live: boolean; readonly running: boolean },
+): Container {
+  const c = new Container(),
+    expand = keyText("app.tools.expand");
+  if (input.hidden > 0) {
+    c.addChild(
+      new Text(
+        theme.fg("dim", `  +${input.hidden} more${hasText(expand) ? ` · ${expand} expands` : ""}`),
+        0,
+        0,
+      ),
+    );
+  }
+  if (input.live && hasText(expand)) {
+    c.addChild(new Text(theme.fg("accent", `  Press ${expand} for live detail`), 0, 0));
+  }
+  if (d.artifacts) {
+    c.addChild(new TruncatedText(theme.fg("dim", `  artifacts: ${shortenPath(d.artifacts.dir)}`)));
+  }
+  if (!input.running) {
+    c.addChild(new TruncatedText(theme.fg("dim", `  ${expandLabel(d)}`)));
+  }
+  return c;
+}
+export function renderMultiCompact(d: DetailsInput, theme: Theme, isError = false): Component {
+  const c = new Container(),
+    facts = workflowFacts(d, isError),
+    label = buildMultiProgressLabel(d, facts.running);
+  c.addChild(compactMultiHeading(d, theme, label, isError));
+  const entries = renderEntries(d, label, label.itemTitle.toLowerCase());
+  const visible =
+    facts.running || facts.failed || facts.paused || facts.blocked ? entries : entries.slice(0, 6);
+  let live = false;
+  for (const entry of visible) {
+    if (entry.kind === "placeholder") {
+      c.addChild(placeholder(entry, theme));
+      continue;
+    }
+    const row = compactRow(d, entry, theme, label);
+    c.addChild(row.component);
+    live ||= row.live;
+  }
+  c.addChild(
+    multiFooter(d, theme, {
+      hidden: entries.length - visible.length,
+      live,
+      running: facts.running,
+    }),
+  );
+  return c;
+}

package/src/tui/conversation-details.ts

@@ -0,0 +1,206 @@
+import { hasText, errorText } from "./text-values.ts";
+import type { TUI } from "@earendil-works/pi-tui";
+import { readableText, type AgentHistoryItem } from "./agent-history.ts";
+import type { AgentTask, AgentVisit, Anchor, Quote } from "./view-model.ts";
+function quote(item: AgentHistoryItem): Quote {
+  const parts =
+    item.call || item.result
+      ? [item.diff, item.details ?? item.text]
+      : [item.text, item.diff, item.details];
+  return { title: item.title, text: parts.filter(Boolean).join("\n\n") };
+}
+interface DetailEffects {
+  readonly task: () => AgentTask | undefined;
+  readonly visit: () => AgentVisit;
+  readonly selected: () => AgentHistoryItem | undefined;
+  readonly following: () => boolean;
+  readonly anchor: () => Anchor | undefined;
+  readonly compose: (value: boolean) => void;
+  readonly closeMenu: () => void;
+  readonly restore: (anchor: Anchor | undefined) => void;
+  readonly toStart: () => void;
+  readonly toEnd: () => void;
+  readonly changed: () => void;
+  readonly back: () => void;
+  readonly changes: () => Promise<AgentHistoryItem | undefined>;
+}
+export class ConversationDetails {
+  detail?: AgentHistoryItem;
+  detailError?: string;
+  loadingDetail = false;
+  pendingDetail = false;
+  detailRequest = 0;
+  conversationAnchor?: Anchor;
+  private closed = false;
+  private readonly tui: TUI;
+  private readonly effects: DetailEffects;
+  constructor(tui: TUI, effects: DetailEffects) {
+    this.tui = tui;
+    this.effects = effects;
+  }
+  private active(request: number): boolean {
+    return !this.closed && request === this.detailRequest;
+  }
+  private sameAttempt(request: number, runId: string | undefined): boolean {
+    return this.active(request) && this.effects.task()?.run.runId === runId;
+  }
+  private begin(item: AgentHistoryItem): void {
+    this.conversationAnchor = this.effects.following() ? undefined : this.effects.anchor();
+    this.loadingDetail = item.load !== undefined;
+    this.detailError = undefined;
+    this.detail = item.load
+      ? {
+          id: item.id,
+          kind: "notice",
+          title: "Loading selected details…",
+          text: "Native record validation is running in the history process.",
+          timestamp: item.timestamp,
+        }
+      : item;
+    this.effects.closeMenu();
+    this.effects.compose(false);
+    this.effects.toStart();
+    this.effects.restore({ id: item.id, line: 0 });
+    this.tui.requestRender();
+  }
+  async inspectSelected(): Promise<void> {
+    const item = this.effects.selected();
+    if (item) {
+      await this.inspect(item);
+    }
+  }
+  async inspect(item: AgentHistoryItem): Promise<void> {
+    const request = ++this.detailRequest,
+      runId = this.effects.task()?.run.runId;
+    this.begin(item);
+    try {
+      const detail = item.load ? await item.load() : item;
+      if (this.sameAttempt(request, runId)) {
+        this.detail = detail;
+      }
+    } catch (error) {
+      if (this.sameAttempt(request, runId)) {
+        this.detailError = readableText(errorText(error));
+        this.detail = {
+          id: item.id,
+          kind: "notice",
+          title: "Details unavailable",
+          text: this.detailError,
+          timestamp: item.timestamp,
+        };
+      }
+    }
+    if (this.active(request)) {
+      this.loadingDetail = false;
+      this.tui.requestRender();
+    }
+  }
+  private replyAnchor(): Anchor | undefined {
+    if (this.detail) {
+      return this.conversationAnchor;
+    }
+    return this.effects.following() ? undefined : this.effects.anchor();
+  }
+  private async quoteItem(item: AgentHistoryItem): Promise<AgentHistoryItem | undefined> {
+    if (!item.load || this.detail) {
+      return item;
+    }
+    const request = ++this.detailRequest,
+      runId = this.effects.task()?.run.runId;
+    this.loadingDetail = true;
+    this.effects.compose(true);
+    this.tui.requestRender();
+    try {
+      const full = await item.load();
+      return this.sameAttempt(request, runId) ? full : undefined;
+    } catch (error) {
+      if (this.active(request)) {
+        this.effects.visit().notice = `Quoted context unavailable; draft kept. ${readableText(errorText(error))}`;
+        this.effects.changed();
+      }
+      return;
+    } finally {
+      if (this.active(request)) {
+        this.loadingDetail = false;
+        this.tui.requestRender();
+      }
+    }
+  }
+  async reply(): Promise<void> {
+    if (this.loadingDetail) {
+      return;
+    }
+    if (this.detail && hasText(this.detailError)) {
+      this.effects.visit().notice = `Quoted context unavailable; draft kept. ${this.detailError}`;
+      this.effects.back();
+      this.effects.changed();
+      return;
+    }
+    const selected = this.effects.selected();
+    if (!selected) {
+      return;
+    }
+    const anchor = this.replyAnchor();
+    let item: AgentHistoryItem | undefined = selected;
+    if (selected.load && !this.detail) {
+      item = await this.quoteItem(selected);
+    }
+    if (!item) {
+      return;
+    }
+    this.effects.visit().quote = quote(item);
+    this.detailRequest++;
+    this.detail = undefined;
+    this.effects.closeMenu();
+    this.effects.compose(true);
+    this.effects.restore(anchor);
+    this.effects.changed();
+  }
+  async changes(): Promise<void> {
+    if (this.pendingDetail) {
+      return;
+    }
+    const request = ++this.detailRequest,
+      runId = this.effects.task()?.run.runId;
+    this.pendingDetail = true;
+    try {
+      const item = await this.effects.changes();
+      if (item && this.sameAttempt(request, runId)) {
+        await this.inspect(item);
+        this.tui.requestRender();
+      }
+    } catch (error) {
+      if (this.sameAttempt(request, runId)) {
+        this.effects.visit().notice = `Changes unavailable: ${errorText(error)}`;
+      }
+    } finally {
+      this.pendingDetail = false;
+    }
+  }
+  close(): boolean {
+    if (!this.detail) {
+      return false;
+    }
+    this.detailRequest++;
+    this.loadingDetail = false;
+    this.detail = undefined;
+    this.effects.compose(true);
+    this.effects.restore(this.conversationAnchor);
+    if (!this.conversationAnchor) {
+      this.effects.toEnd();
+    }
+    return true;
+  }
+  unquote(): void {
+    if (this.loadingDetail && !this.detail) {
+      this.detailRequest++;
+      this.loadingDetail = false;
+    }
+    this.effects.visit().quote = undefined;
+    this.effects.changed();
+  }
+  dispose(): void {
+    this.closed = true;
+    this.detailRequest++;
+  }
+}