zidane-ui 9.1.1 → 9.1.4

package/src/chat/headless/transcript/fold-actions.ts

@@ -1,269 +0,0 @@
-/**
- * The compact fold's action list: one overview line per thing the agent
- * did, in order, for both the live stack and the expanded list.
- *
- * An overview says WHAT happened, not the payload: `Ran bun test`, not the
- * 40-line heredoc behind it; `Edited Timeline.tsx +12 −3`, not the diff.
- * The words are shared with the TUI (`toolOverview`), and so are the steps
- * (`planFold`); the payload stays one click away (the line's details) and in
- * the tooltip.
- * Consecutive thoughts are one line, a worker is one line (its own rows are
- * its details), batches are seen through.
- */
-import { type FoldStep, type FoldUnit, noteLabel, planFold, thoughtLabel, toolOverview } from 'zidane/chat/pure';
-
-import { toolFailed } from './collapse';
-import type { Row } from './rows';
-
-type ToolRow = Extract<Row, { kind: 'tool' }>;
-type ThinkingRow = Extract<Row, { kind: 'thinking' }>;
-
-/** `waiting`: a `spawn` call that has not started yet, every slot being taken. */
-export type FoldActionState = 'waiting' | 'running' | 'ok' | 'err';
-
-/** One overview line of a folded exchange: a tool call, a run of thoughts, a worker, or a note. */
-export interface FoldActionItem {
-  /** Stable per action (its first row's id), so lists animate entries, not text changes. */
-  id: string;
-  /** What the line stands for: a `tool` call, consecutive `thought` segments, a `worker` (subagent), or a `note`. */
-  kind: 'tool' | 'thought' | 'worker' | 'note';
-  /** The overview: "Ran bun test", "Read select-stops.ts", "Thought". */
-  label: string;
-  /** Quiet context after the label: a file's directory, "+2" chained commands. */
-  hint?: string;
-  /** A worker's model, shown as a badge on its line. */
-  model?: string;
-  /** Edit line counts, shown after the label. */
-  added?: number;
-  /** Number of lines an edit removed, shown after the label. */
-  removed?: number;
-  /** Full payload for the tooltip (the whole command, the full path). */
-  title?: string;
-  /** Progress of the action, shown as the line's status. */
-  state: FoldActionState;
-  /** How long the action took, in milliseconds, when known. */
-  durationMs?: number;
-  /** While running: when it started, for a live elapsed counter. */
-  startedAt?: number;
-  /** While waiting: the slots taken and the cap. */
-  waitingFor?: { active: number; max: number };
-  /** While running: a call of a batch a durable run resumed after a process death. */
-  resuming?: true;
-  /** What the details show. */
-  tool?: ToolRow;
-  /** The thinking rows a `thought` line stands for. Shown in the details. */
-  thoughts?: ThinkingRow[];
-  /** A worker's own rows (its lifecycle markers and everything it produced). */
-  workerRows?: Row[];
-  /** The calls this tool call made (its row's `children`), shown one step in under its line. */
-  children?: FoldActionItem[];
-}
-
-function stringInput(input: Record<string, unknown> | undefined, key: string): string | undefined {
-  const v = input?.[key];
-  return typeof v === 'string' ? v : undefined;
-}
-
-function toolState(tool: ToolRow): FoldActionState {
-  if (tool.waitingFor) return 'waiting';
-  return tool.ok === null ? 'running' : toolFailed(tool) ? 'err' : 'ok';
-}
-
-/** Overview words per tool row: rows keep their identity, and the gist parse is the costly part. */
-const OVERVIEW_CACHE = new WeakMap<ToolRow, ReturnType<typeof toolOverview>>();
-
-/**
- * The overview item for one tool call: the shared words, plus what the details show.
- *
- * @param tool - The tool call's row.
- */
-export function toolAction(tool: ToolRow): FoldActionItem {
-  const overview =
-    OVERVIEW_CACHE.get(tool) ??
-    toolOverview({
-      name: tool.name,
-      displayName: tool.displayName,
-      ...(tool.rawInput ? { input: tool.rawInput } : {}),
-      ...(tool.formatted?.target ? { target: tool.formatted.target } : {}),
-      result: typeof tool.result === 'string' ? tool.result : null,
-      ok: tool.ok,
-      ...(tool.edit ? { edit: tool.edit } : {}),
-    });
-  OVERVIEW_CACHE.set(tool, overview);
-  return {
-    id: tool.id,
-    kind: 'tool' as const,
-    state: toolState(tool),
-    tool,
-    ...(tool.durationMs !== undefined ? { durationMs: tool.durationMs } : {}),
-    ...(tool.ok === null && !tool.waitingFor && tool.startedAt !== undefined ? { startedAt: tool.startedAt } : {}),
-    ...(tool.waitingFor ? { waitingFor: tool.waitingFor } : {}),
-    ...(tool.ok === null && tool.resuming ? { resuming: true as const } : {}),
-    ...overview,
-  };
-}
-
-function thoughtAction(thoughts: ThinkingRow[], live: boolean): FoldActionItem {
-  const known = thoughts.filter((t) => t.thinkingMs !== undefined);
-  const ms = known.reduce((n, t) => n + (t.thinkingMs ?? 0), 0);
-  return {
-    id: thoughts[0]!.id,
-    kind: 'thought',
-    label: thoughtLabel(live),
-    state: live ? 'running' : 'ok',
-    ...(known.length > 0 && ms > 0 ? { durationMs: ms } : {}),
-    thoughts,
-  };
-}
-
-const isWorkerRow = (row: Row): boolean =>
-  ('childId' in row && row.childId !== undefined) || ('depth' in row && (row.depth ?? 0) > 0);
-
-/**
- * An exchange's folded rows as core's planner reads them (`planFold`):
- * batches seen through, a call's nested calls after it, a worker's rows one
- * unit each (they are its details as they are).
- *
- * @param rows - The rows of one exchange, oldest first.
- */
-export function foldUnits(rows: readonly Row[]): FoldUnit<Row>[] {
-  const units: FoldUnit<Row>[] = [];
-  const pushTool = (tool: ToolRow) => {
-    const task = stringInput(tool.rawInput, 'task');
-    units.push({
-      item: tool,
-      kind: 'call',
-      name: tool.name,
-      displayName: tool.displayName,
-      state: toolState(tool),
-      ...(tool.callId !== undefined ? { callId: tool.callId } : {}),
-      ...(tool.parentId !== undefined ? { parentId: tool.parentId } : {}),
-      ...(tool.waitingFor ? { waitingFor: tool.waitingFor } : {}),
-      ...(task !== undefined ? { task } : {}),
-      ...(tool.durationMs !== undefined ? { ms: tool.durationMs } : {}),
-    });
-    for (const child of tool.children ?? []) pushTool(child);
-  };
-  const pushThought = (t: ThinkingRow) =>
-    units.push({
-      item: t,
-      kind: 'thought',
-      live: t.live === true,
-      ...(t.thinkingMs !== undefined ? { ms: t.thinkingMs } : {}),
-    });
-  for (const row of rows) {
-    if (isWorkerRow(row)) {
-      const owner = row as Row & { childId?: string; depth?: number };
-      const base = {
-        item: row,
-        ...(owner.childId !== undefined ? { childId: owner.childId } : {}),
-        ...(owner.depth !== undefined ? { depth: owner.depth } : {}),
-      };
-      if (row.kind === 'spawn-start' || row.kind === 'spawn-end')
-        units.push({ ...base, kind: row.kind, text: row.text, ...(row.spawn ? { spawn: row.spawn } : {}) });
-      else units.push({ ...base, kind: 'other' });
-      continue;
-    }
-    switch (row.kind) {
-      case 'tool':
-        pushTool(row);
-        break;
-      case 'tool-batch':
-        for (const t of row.tools) pushTool(t);
-        break;
-      case 'thinking':
-        pushThought(row);
-        break;
-      case 'thinking-batch':
-        for (const t of row.thoughts) pushThought(t);
-        break;
-      case 'command-detail':
-        units.push({ item: row, kind: 'note' });
-        break;
-      default:
-        units.push({ item: row, kind: 'other' });
-        break;
-    }
-  }
-  return units;
-}
-
-/** A tool step's line: the call's words, and a `spawn` call's model as its badge. */
-function callItem(tool: ToolRow): FoldActionItem {
-  const item = toolAction(tool);
-  const model = tool.name === 'spawn' ? stringInput(tool.rawInput, 'model') : undefined;
-  if (model) item.model = model;
-  return item;
-}
-
-function workerItem(step: FoldStep<Row>): FoldActionItem {
-  const call = step.call as ToolRow | undefined;
-  let item: FoldActionItem;
-  if (call) {
-    item = callItem(call);
-    item.kind = 'worker';
-    delete item.waitingFor;
-  } else {
-    const task = step.task;
-    item = {
-      id: step.items[0]!.id,
-      kind: 'worker',
-      label: 'Agent',
-      ...(task ? { hint: task.length > 80 ? `${task.slice(0, 79)}…` : task, title: task } : {}),
-      state: 'running',
-    };
-  }
-  item.state = step.state;
-  if (step.state !== 'running') delete item.startedAt;
-  item.workerRows = step.items;
-  // The worker's own model: a nested worker's markers ride along without speaking for it.
-  if (!item.model) {
-    const own = step.items.find(
-      (row) => 'childId' in row && row.childId === step.lane && 'model' in row && row.model,
-    ) as { model?: string } | undefined;
-    if (own?.model) item.model = own.model;
-  }
-  return item;
-}
-
-function actionItem(step: FoldStep<Row>): FoldActionItem {
-  switch (step.kind) {
-    case 'thought':
-      return thoughtAction(step.items as ThinkingRow[], step.live === true);
-    case 'note': {
-      const row = step.items[0] as Extract<Row, { kind: 'command-detail' }>;
-      return { id: row.id, kind: 'note', label: noteLabel(row.label), state: 'ok' };
-    }
-    case 'worker':
-      return workerItem(step);
-    case 'tool':
-      return callItem(step.call as ToolRow);
-  }
-}
-
-/**
- * Every action of an exchange, in order (core `planFold`, shared with the
- * TUI): tool calls (batches seen through, the calls a call made nested under
- * it), consecutive thoughts merged, each worker one item holding its rows
- * and merged with the `spawn` call that started it. Rows that say nothing on
- * their own (plain notes) are skipped.
- *
- * @param rows - The rows of one exchange, oldest first.
- */
-export function foldActionItems(rows: readonly Row[]): FoldActionItem[] {
-  return nestActions(planFold(foldUnits(rows)).steps);
-}
-
-/** Lines in plan order, each call's own calls moved under it as `children`. */
-function nestActions(steps: readonly FoldStep<Row>[]): FoldActionItem[] {
-  const out: FoldActionItem[] = [];
-  const byCallId = new Map<string, FoldActionItem>();
-  for (const step of steps) {
-    const item = actionItem(step);
-    if (step.callId !== undefined) byCallId.set(step.callId, item);
-    const parent = step.parentId !== undefined ? byCallId.get(step.parentId) : undefined;
-    if (parent) (parent.children ??= []).push(item);
-    else out.push(item);
-  }
-  return out;
-}

package/src/chat/headless/transcript/fold-attachments.ts

@@ -1,78 +0,0 @@
-/**
- * The images an exchange's tool calls returned, for the strip under compact
- * density's "Working" row: every call of the fold, nested calls and workers'
- * calls included, oldest first.
- */
-import { toolAction } from './fold-actions';
-import type { Row, ToolRowModel as ToolRow } from './rows';
-import { parseToolMedia } from './tool-media';
-
-/** One image a tool call returned. */
-export interface FoldAttachment {
-  /** Stable across renders: the call and the image's position in its result. */
-  key: string;
-  /** The call that returned it, which addresses it with `index` (`TranscriptActions.toolMediaUrl`). */
-  callId: string;
-  /** Position among the result's media blocks. */
-  index: number;
-  /** The call's overview line ("Screenshot localhost:5173"): the image's name in the lightbox. */
-  label: string;
-}
-
-const NONE: readonly FoldAttachment[] = [];
-
-/** Per tool row: rows keep their identity until their result changes, so a stream tick parses nothing again. */
-const CACHE = new WeakMap<ToolRow, readonly FoldAttachment[]>();
-
-function callImages(tool: ToolRow): readonly FoldAttachment[] {
-  const cached = CACHE.get(tool);
-  if (cached) return cached;
-  const result = tool.result;
-  const callId = tool.callId;
-  let images = NONE;
-  if (callId && typeof result === 'string' && result.includes('[image:')) {
-    const label = toolAction(tool).label;
-    images = parseToolMedia(result)
-      .media.filter((m) => m.kind === 'image')
-      .map((m) => ({ key: `${callId}:${m.index}`, callId, index: m.index, label }));
-  }
-  CACHE.set(tool, images);
-  return images;
-}
-
-/**
- * Whether two lists show the same images under the same names, in the same
- * order: a fold keeps the list it has when a stream tick answers an equal one,
- * so the strip (memoized on it) skips the render.
- *
- * @param a - One list.
- * @param b - The other.
- */
-export function sameAttachments(a: readonly FoldAttachment[], b: readonly FoldAttachment[]): boolean {
-  if (a === b) return true;
-  return a.length === b.length && a.every((item, i) => item.key === b[i]!.key && item.label === b[i]!.label);
-}
-
-/**
- * The images the tool calls among `rows` returned, oldest first: each call's,
- * then its nested calls'. A worker's calls are rows of the exchange too.
- *
- * @param rows - The rows of one exchange fold (`row.rows`).
- */
-export function foldAttachments(rows: readonly Row[]): readonly FoldAttachment[] {
-  const out: FoldAttachment[] = [];
-  const seen = new Set<string>();
-  const visit = (tool: ToolRow) => {
-    for (const image of callImages(tool)) {
-      if (seen.has(image.key)) continue;
-      seen.add(image.key);
-      out.push(image);
-    }
-    for (const child of tool.children ?? []) visit(child);
-  };
-  for (const row of rows) {
-    if (row.kind === 'tool') visit(row);
-    else if (row.kind === 'tool-batch') for (const tool of row.tools) visit(tool);
-  }
-  return out.length > 0 ? out : NONE;
-}