@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/src/tui/history-cards.ts

@@ -1,298 +0,0 @@
-import type { AssistantMessage } from "@earendil-works/pi-ai";
-import { isDeepStrictEqual } from "node:util";
-import {
-  AssistantMessageComponent,
-  UserMessageComponent,
-  ToolExecutionComponent,
-  createBashToolDefinition,
-  createEditToolDefinition,
-  createFindToolDefinition,
-  createGrepToolDefinition,
-  createLsToolDefinition,
-  createPowerShellToolDefinition,
-  createReadToolDefinition,
-  createWriteToolDefinition,
-  getMarkdownTheme,
-  renderDiff,
-  type Theme,
-} from "@earendil-works/pi-coding-agent";
-import {
-  Container,
-  Spacer,
-  Text,
-  type Component,
-  type TUI,
-  type TuiMouseEvent,
-} from "@earendil-works/pi-tui";
-import { formatModelThinking } from "../shared/formatters.ts";
-import { stripAcceptanceReport } from "../runs/shared/acceptance-reports.ts";
-import { readableText, type AgentHistoryItem } from "./agent-history.ts";
-import { short } from "./view-model.ts";
-import { hasText } from "./text-values.ts";
-interface HistoryPresentation {
-  readonly selectedId?: string;
-  readonly editorFocus: boolean;
-  readonly detail: boolean;
-  readonly toolsExpanded: boolean;
-  readonly toolExpansion: Readonly<ReadonlyMap<string, boolean>>;
-}
-interface CachedCard {
-  readonly signature: string;
-  readonly item: AgentHistoryItem;
-  readonly component: Component;
-}
-interface CardLine {
-  readonly id: string;
-  readonly entryIds: readonly string[];
-  readonly start: number;
-  readonly contentStart: number;
-  readonly end: number;
-}
-function sameDisplay(left: AgentHistoryItem, right: AgentHistoryItem): boolean {
-  // Detail loaders stay fresh in contentItems; only the native display component is reused.
-  return isDeepStrictEqual({ ...left, load: undefined }, { ...right, load: undefined });
-}
-function previewStop(reason: string | undefined): AssistantMessage["stopReason"] {
-  if (reason === "error" || reason === "aborted" || reason === "length") {
-    return reason;
-  }
-  return "stop";
-}
-/** Bounded previews/live text are native display adapters only, never journal or completion evidence. */
-function assistantDisplay(item: AgentHistoryItem): AssistantMessage {
-  if (item.assistant) {
-    return item.assistant;
-  }
-  const preview = item.previewAssistant;
-  return {
-    role: "assistant",
-    content: preview ? [...preview.content] : [{ type: "text", text: item.text }],
-    timestamp: item.timestamp,
-    api: "",
-    provider: "",
-    model: "",
-    stopReason: previewStop(preview?.stopReason),
-    errorMessage: preview?.errorMessage,
-    usage: {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-      totalTokens: 0,
-      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-    },
-  };
-}
-function sanitizedMessage(message: AssistantMessage): AssistantMessage {
-  return {
-    ...message,
-    content: message.content.map((part) =>
-      part.type === "text"
-        ? { ...part, text: stripAcceptanceReport(readableText(part.text)) }
-        : part,
-    ),
-  };
-}
-
-/** Native cards and width-dependent line locations have one cache owner. */
-export class HistoryCards {
-  lines: CardLine[] = [];
-  contentItems: readonly AgentHistoryItem[] = [];
-  private readonly components = new Map<string, CachedCard>();
-  private readonly toolDefinitions: Map<
-    string,
-    ConstructorParameters<typeof ToolExecutionComponent>[4]
-  >;
-  private readonly tui: TUI;
-  private readonly theme: Theme;
-  private readonly cwd: () => string;
-  constructor(tui: TUI, theme: Theme, cwd: () => string) {
-    this.tui = tui;
-    this.theme = theme;
-    this.cwd = cwd;
-    this.toolDefinitions = new Map(
-      [
-        createReadToolDefinition,
-        createBashToolDefinition,
-        createEditToolDefinition,
-        createWriteToolDefinition,
-        createFindToolDefinition,
-        createGrepToolDefinition,
-        createLsToolDefinition,
-        createPowerShellToolDefinition,
-      ].map((create) => {
-        const definition = create(cwd());
-        return [definition.name, definition];
-      }),
-    );
-  }
-  clear(): void {
-    this.components.clear();
-  }
-  dispatch(id: string, event: Readonly<TuiMouseEvent>): void {
-    this.components.get(id)?.component.handleMouse?.(event);
-  }
-  private prune(items: readonly AgentHistoryItem[]): void {
-    const ids = new Set(items.map((item) => item.id));
-    for (const id of this.components.keys()) {
-      if (!ids.has(id)) {
-        this.components.delete(id);
-      }
-    }
-  }
-  render(
-    width: number,
-    items: readonly AgentHistoryItem[],
-    options: HistoryPresentation,
-  ): string[] {
-    this.contentItems = items;
-    this.prune(items);
-    this.lines = [];
-    const lines: string[] = [];
-    for (const item of items) {
-      const expanded =
-        options.detail || (options.toolExpansion.get(item.id) ?? options.toolsExpanded);
-      const component = this.card(item, expanded, options.detail),
-        start = lines.length;
-      if (item.id === options.selectedId && !options.editorFocus) {
-        lines.push(this.theme.fg("accent", short(`› ${item.title}`, width)));
-      }
-      const contentStart = lines.length;
-      lines.push(...component.render(width));
-      this.lines.push({
-        id: item.id,
-        entryIds: item.entryIds ?? [item.id],
-        start,
-        contentStart,
-        end: lines.length,
-      });
-    }
-    return lines;
-  }
-  private card(item: AgentHistoryItem, expanded: boolean, detail: boolean): Component {
-    const signature = `${expanded}:${detail}`,
-      cached = this.components.get(item.id);
-    if (cached?.signature === signature && cached.item === item) {
-      return cached.component;
-    }
-    if (cached?.signature === signature && sameDisplay(cached.item, item)) {
-      this.components.set(item.id, { ...cached, item });
-      return cached.component;
-    }
-    const component = this.create(item, { expanded, detail });
-    this.components.set(item.id, { signature, item, component });
-    return component;
-  }
-  private create(
-    item: AgentHistoryItem,
-    presentation: { readonly expanded: boolean; readonly detail: boolean },
-  ): Component {
-    const c = new Container();
-    if (presentation.detail && hasText(item.model)) {
-      c.addChild(
-        new Text(
-          this.theme.fg("muted", `Message model: ${readableText(formatModelThinking(item.model))}`),
-          0,
-          0,
-        ),
-      );
-    }
-    c.addChild(this.body(item, presentation));
-    if (presentation.detail && hasText(item.details)) {
-      c.addChild(new Text(item.details, 0, 1));
-    }
-    c.addChild(new Spacer(1));
-    return c;
-  }
-  private body(
-    item: AgentHistoryItem,
-    presentation: { readonly expanded: boolean; readonly detail: boolean },
-  ): Component {
-    if (item.call || item.result) {
-      return this.tool(item, presentation);
-    }
-    if (item.kind === "assistant" || item.kind === "thinking") {
-      const message = assistantDisplay(item);
-      return new AssistantMessageComponent(
-        presentation.detail ? message : sanitizedMessage(message),
-        !presentation.detail,
-        getMarkdownTheme(),
-        "Thinking · open details to read",
-      );
-    }
-    if (item.kind === "user") {
-      return this.user(item);
-    }
-    const c = new Container();
-    c.addChild(new Text(this.theme.fg("muted", readableText(item.title)), 0, 0));
-    c.addChild(new Text(item.text, 0, 0));
-    if (hasText(item.diff)) {
-      c.addChild(new Text(renderDiff(item.diff), 0, 0));
-    }
-    return c;
-  }
-  private user(item: AgentHistoryItem): Component {
-    const c = new Container();
-    if (item.id.startsWith("outgoing:") || hasText(item.messageId)) {
-      c.addChild(new Text(this.theme.fg("muted", item.title), 0, 0));
-    }
-    c.addChild(new UserMessageComponent(item.text, getMarkdownTheme(), 1));
-    return c;
-  }
-  private nativeTool(item: AgentHistoryItem): ToolExecutionComponent | undefined {
-    const fallback = {
-      renderCall: () =>
-        new Text(this.theme.fg("toolTitle", this.theme.bold(readableText(item.title))), 0, 0),
-    };
-    const options = { compactView: true, showImages: false };
-    if (item.call) {
-      const call = item.call;
-      return new ToolExecutionComponent(
-        call.name,
-        call.id,
-        call.arguments,
-        options,
-        this.toolDefinitions.get(call.name) ?? fallback,
-        this.tui,
-        this.cwd(),
-      );
-    }
-    if (item.result) {
-      const result = item.result;
-      return new ToolExecutionComponent(
-        result.toolName,
-        result.toolCallId,
-        {},
-        options,
-        fallback,
-        this.tui,
-        this.cwd(),
-      );
-    }
-    return;
-  }
-  private tool(
-    item: AgentHistoryItem,
-    presentation: { readonly expanded: boolean; readonly detail: boolean },
-  ): Component {
-    const c = new Container(),
-      result = item.result,
-      tool = this.nativeTool(item);
-    if (!tool) {
-      return c;
-    }
-    // Saved data only: execution/args-complete hooks would invent timing or re-read today's files.
-    if (result) {
-      tool.updateResult(result);
-    }
-    tool.setExpanded(presentation.expanded);
-    c.addChild(tool);
-    if (presentation.detail && hasText(item.diff) && item.call?.name !== "edit") {
-      c.addChild(new Text(renderDiff(item.diff), 0, 0));
-    }
-    if (!result) {
-      c.addChild(new Text(this.theme.fg("dim", "Result not recorded · exit unconfirmed"), 1, 0));
-    }
-    return c;
-  }
-}

package/src/tui/history-display.ts

@@ -1,334 +0,0 @@
-import type { AssistantMessage, ToolCall, ToolResultMessage } from "@earendil-works/pi-ai";
-import type { DisplayEntry, HistoryAssistantPreview } from "./history-record.ts";
-import { hasText } from "./text-values.ts";
-import { readableText, contentText, isRecord } from "./history-text.ts";
-import { stripAcceptanceReport } from "../runs/shared/acceptance-reports.ts";
-import { extractToolArgsPreview } from "../shared/utils.ts";
-
-/** Fixed native SDK default payload, retained as a mutable native rendering handle. */
-export type RecordedToolResult = ToolResultMessage;
-export interface AgentHistoryItem {
-  readonly id: string;
-  readonly entryIds?: readonly string[];
-  readonly kind: "user" | "assistant" | "thinking" | "tool" | "result" | "change" | "notice";
-  readonly title: string;
-  readonly text: string;
-  readonly details?: string;
-  readonly diff?: string;
-  readonly assistant?: AssistantMessage;
-  readonly previewAssistant?: HistoryAssistantPreview;
-  readonly model?: string;
-  readonly call?: ToolCall;
-  readonly result?: RecordedToolResult;
-  readonly messageId?: string;
-  readonly timestamp: number;
-  readonly load?: () => Promise<AgentHistoryItem>;
-}
-export interface AgentHistory {
-  readonly items: readonly AgentHistoryItem[];
-  readonly entryIds: readonly string[];
-  readonly finalId?: string;
-  readonly findFinalResult?: (text: string) => string | undefined;
-  readonly deliveredMessages?: Readonly<ReadonlyMap<string, boolean>>;
-  readonly configuration?: {
-    readonly model?: string;
-    readonly thinking?: string;
-    readonly modelRecordedAt?: number;
-  };
-  readonly unavailable?: string;
-}
-function inlineAssistantError(message: AssistantMessage | HistoryAssistantPreview): boolean {
-  return (
-    !message.content.some((part) => part.type === "toolCall") &&
-    ["error", "aborted"].includes(message.stopReason ?? "")
-  );
-}
-function messageModel(message: AssistantMessage | HistoryAssistantPreview): string | undefined {
-  if (!hasText(message.model)) {
-    return;
-  }
-  return hasText(message.provider) ? `${message.provider}/${message.model}` : message.model;
-}
-function customTitle(human: boolean, from: unknown, customType: string): string {
-  if (human) {
-    return "User · delivered to conversation";
-  }
-  return typeof from === "string" && from.length > 0 ? `From ${from}` : customType;
-}
-function resultDisplay(
-  result: RecordedToolResult,
-  call?: ToolCall,
-): Pick<AgentHistoryItem, "text" | "diff" | "details"> {
-  const details: unknown = result.details;
-  return {
-    text: contentText(result.content),
-    diff:
-      isRecord(details) && typeof details.diff === "string"
-        ? readableText(details.diff)
-        : undefined,
-    details: readableText({ ...(call ? { call } : {}), result }),
-  };
-}
-function lazyItem(
-  facts: Omit<AgentHistoryItem, "text" | "title">,
-  format: () => Pick<AgentHistoryItem, "text" | "title" | "details" | "diff">,
-  resultReader?: () => RecordedToolResult | undefined,
-): AgentHistoryItem {
-  let display: ReturnType<typeof format> | undefined;
-  const get = () => {
-    display ??= format();
-    return display;
-  };
-  return {
-    ...facts,
-    get result() {
-      return resultReader?.() ?? facts.result;
-    },
-    get title() {
-      return get().title;
-    },
-    get text() {
-      return get().text;
-    },
-    get details() {
-      return get().details;
-    },
-    get diff() {
-      return get().diff;
-    },
-  };
-}
-
-/** The builder owns pairing; public cards expose getters, not mutable shared snapshots. */
-class NativeHistoryBuilder {
-  readonly items: AgentHistoryItem[] = [];
-  readonly entryIds: string[] = [];
-  private readonly calls = new Map<string, { result?: RecordedToolResult; entryIds: string[] }>();
-  append(item: AgentHistoryItem): void {
-    this.items.push(item);
-    this.entryIds.push(item.id);
-  }
-  add(entry: DisplayEntry): void {
-    const base = { id: entry.id, timestamp: Date.parse(entry.timestamp) };
-    switch (entry.type) {
-      case "custom_message": {
-        const details: unknown = entry.details,
-          human = entry.customType === "subagent-human-message";
-        const body = isRecord(details) ? details.bodyText : undefined;
-        const from = isRecord(details) && isRecord(details.from) ? details.from.name : undefined;
-        const message =
-          isRecord(details) && isRecord(details.message) ? details.message.id : undefined;
-        this.append(
-          lazyItem(
-            {
-              ...base,
-              kind: human ? "user" : "notice",
-              messageId: human && typeof message === "string" ? message : undefined,
-            },
-            () => ({
-              title: customTitle(human, from, entry.customType),
-              text: contentText(body ?? entry.content),
-            }),
-          ),
-        );
-        break;
-      }
-      case "compaction":
-        this.append(
-          lazyItem({ ...base, kind: "notice" }, () => ({
-            title: "Context summary · earlier history retained above",
-            text: readableText(entry.summary),
-          })),
-        );
-        break;
-      case "branch_summary":
-        this.append(
-          lazyItem({ ...base, kind: "notice" }, () => ({
-            title: "Branch summary",
-            text: readableText(entry.summary),
-          })),
-        );
-        break;
-      case "message":
-        this.message(entry);
-        break;
-    }
-  }
-  private message(entry: Extract<DisplayEntry, { type: "message" }>): void {
-    const message = entry.message,
-      base = { id: entry.id, timestamp: Date.parse(entry.timestamp) };
-    switch (message.role) {
-      case "assistant":
-        this.assistant(
-          entry.id,
-          base.timestamp,
-          message,
-          entry.native?.role === "assistant" ? entry.native : undefined,
-        );
-        break;
-      case "user":
-        this.append(
-          lazyItem({ ...base, kind: "user" }, () => ({
-            title: "User / assignment",
-            text: contentText(message.content),
-          })),
-        );
-        break;
-      case "toolResult": {
-        const pair = this.calls.get(message.toolCallId);
-        if (pair) {
-          pair.result = message;
-          pair.entryIds.push(entry.id);
-          this.entryIds.push(entry.id);
-        } else {
-          this.append(
-            lazyItem({ ...base, result: message, kind: "result" }, () => ({
-              title: `${message.toolName} · call not recorded`,
-              ...resultDisplay(message),
-            })),
-          );
-        }
-        break;
-      }
-      case "bashExecution":
-        this.append(
-          lazyItem({ ...base, kind: "tool" }, () => ({
-            title: `Shell: ${readableText(message.command)}`,
-            text: `${readableText(message.output)}\n${typeof message.exitCode === "number" ? `Shell exit code: ${message.exitCode}` : "Shell exit code not recorded"}${message.cancelled ? " · cancelled" : ""}`,
-            details: readableText({
-              command: message.command,
-              exitCode: message.exitCode,
-              cancelled: message.cancelled,
-            }),
-          })),
-        );
-        break;
-      case "custom":
-      case "branchSummary":
-      case "compactionSummary":
-      case "system":
-        break;
-    }
-  }
-  private assistant(
-    entryId: string,
-    timestamp: number,
-    message: AssistantMessage | HistoryAssistantPreview,
-    native?: AssistantMessage,
-  ): void {
-    const model = messageModel(message);
-    const ids = message.content.flatMap((part, index) =>
-      (part.type === "text" && part.text.length > 0) ||
-      (part.type === "thinking" && part.thinking.length > 0)
-        ? [`${entryId}:${index}`]
-        : [],
-    );
-    const first = ids.at(0);
-    if (first !== undefined) {
-      this.items.push(
-        assistantGroup(message, { id: first, timestamp, entryIds: ids, model, native }),
-      );
-    }
-    for (const [index, part] of message.content.entries()) {
-      const id = `${entryId}:${index}`;
-      if (part.type === "toolCall") {
-        this.tool(id, timestamp, part, model);
-      } else if (ids.includes(id)) {
-        this.entryIds.push(id);
-      }
-    }
-    if (message.errorMessage !== undefined && message.errorMessage.length > 0) {
-      const id = `${entryId}:error`;
-      if (ids.length > 0 && inlineAssistantError(message)) {
-        ids.push(id);
-        this.entryIds.push(id);
-      } else {
-        this.append(
-          lazyItem({ id, timestamp, kind: "notice", model }, () => ({
-            title: "Agent error",
-            text: readableText(message.errorMessage),
-          })),
-        );
-      }
-    }
-  }
-  private tool(id: string, timestamp: number, call: ToolCall, model?: string): void {
-    const pair: { result?: RecordedToolResult; entryIds: string[] } = { entryIds: [id] };
-    const display = () => ({
-      title:
-        `${call.name} ${extractToolArgsPreview(call.arguments)}`.trim() +
-        (pair.result
-          ? ` · ${pair.result.isError ? "failed" : "result recorded"}`
-          : " · result not recorded"),
-      ...(pair.result
-        ? resultDisplay(pair.result, call)
-        : {
-            text: readableText(call.arguments),
-            details: `${readableText(call)}\n\nCommand result not recorded; exit is unconfirmed. An agent pause or exit does not prove that a command or its descendants exited.`,
-          }),
-    });
-    this.append(
-      lazyItem(
-        { id, timestamp, entryIds: pair.entryIds, kind: "tool", call, model },
-        display,
-        () => pair.result,
-      ),
-    );
-    this.calls.set(call.id, pair);
-  }
-}
-function assistantGroup(
-  message: AssistantMessage | HistoryAssistantPreview,
-  facts: {
-    readonly id: string;
-    readonly timestamp: number;
-    readonly entryIds: readonly string[];
-    readonly model?: string;
-    readonly native?: AssistantMessage;
-  },
-): AgentHistoryItem {
-  return lazyItem(
-    {
-      id: facts.id,
-      timestamp: facts.timestamp,
-      entryIds: facts.entryIds,
-      kind: message.content.some((part) => part.type === "text" && part.text.length > 0)
-        ? "assistant"
-        : "thinking",
-      assistant: facts.native,
-      previewAssistant: facts.native ? undefined : message,
-      model: facts.model,
-    },
-    () => ({ title: "Agent", text: contentText(message.content) }),
-  );
-}
-function finalResultMap(items: readonly AgentHistoryItem[]): Map<string, string> {
-  const results = new Map<string, string>();
-  for (const item of items) {
-    if (item.kind !== "assistant") {
-      continue;
-    }
-    results.set(stripAcceptanceReport(item.text).trim(), item.id);
-    for (const part of item.assistant?.content ?? []) {
-      if (part.type === "text") {
-        results.set(stripAcceptanceReport(readableText(part.text)).trim(), item.id);
-      }
-    }
-  }
-  return results;
-}
-export function displayHistory(entries: readonly DisplayEntry[]): AgentHistory {
-  const builder = new NativeHistoryBuilder();
-  for (const entry of entries) {
-    builder.add(entry);
-  }
-  let finalResults: Map<string, string> | undefined;
-  return {
-    items: builder.items,
-    entryIds: builder.entryIds,
-    findFinalResult(text) {
-      finalResults ??= finalResultMap(builder.items);
-      return finalResults.get(text);
-    },
-  };
-}

package/src/tui/history-json.ts

@@ -1,17 +0,0 @@
-import type { JsonObject, JsonValue } from "@earendil-works/pi-ai";
-import { isRecord } from "./history-text.ts";
-export function isJson(value: unknown): value is JsonValue {
-  if (value === null || typeof value === "string" || typeof value === "boolean") {
-    return true;
-  }
-  if (typeof value === "number") {
-    return Number.isFinite(value);
-  }
-  if (Array.isArray(value)) {
-    return value.every((part: unknown) => isJson(part));
-  }
-  return isJsonObject(value);
-}
-export function isJsonObject(value: unknown): value is JsonObject {
-  return isRecord(value) && Object.values(value).every(isJson);
-}