zidane-ui 9.0.4 → 9.1.3

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

@@ -1,382 +0,0 @@
-/**
- * Row passes that fold finished work: run receipts, exchange folds, worker
- * rows, message groups, and the status dot each row shows.
- */
-import type { FoldStats, RunReceipt } from 'zidane/chat/pure';
-import { foldsInCompactShape, foldSummary, planFold } from 'zidane/chat/pure';
-import type { Owned, Row, ExchangeFoldStats, DotVariant } from './rows';
-import { toolFailed } from './collapse';
-import { TOOL_GROUP_BOUNDARIES, FOLD_CACHE, sameMembers } from './batch';
-import { foldUnits } from './fold-actions';
-
-/**
- * Fold `run-summary` rows into the assistant row that closed the run: the
- * receipt renders as one line under that reply instead of a row (and a dot)
- * of its own.
- *
- * Docked by ORDER (the nearest preceding assistant row), not by turn id. Live,
- * the receipt lands while that row may still be streaming and before `run:end`
- * settles it; matching ids across the live and persisted paths is one more
- * thing that can disagree, and then the receipt would fall out as a
- * standalone block with its own dot, a "new step" the reload path never
- * produces. The transcript's own order is the authoritative fact: whatever
- * assistant prose came last IS the run's end.
- *
- * A receipt with no preceding assistant row IN ITS OWN RUN (a tool-only run,
- * or one that errored right after a tool) keeps a standalone row rather than
- * docking onto the row that closed the PREVIOUS run — which would both
- * mis-attribute it and overwrite that run's receipt. Hence the candidate is
- * cleared once consumed and at every user prompt: a receipt may only ever
- * dock onto prose that came after its own run's prompt.
- *
- * `show === false` (`Settings.showRunReceipt` off) drops the receipts
- * entirely — no standalone row, nothing docked. Receipts are synthesized both
- * live and on replay and never persisted, so this is the only gate.
- *
- * @param rows - The transcript rows, oldest first.
- * @param show - Whether to show run receipts. When false they are dropped.
- */
-export function dockRunReceipts(
-  rows: readonly Row[],
-  show: boolean,
-): { visibleRows: Row[]; receiptByRowId: Map<string, RunReceipt> } {
-  const receiptByRowId = new Map<string, RunReceipt>();
-  const visibleRows: Row[] = [];
-  let lastAssistantRowId: string | null = null;
-
-  for (const row of rows) {
-    if (row.kind === 'run-summary' && !show) {
-      continue;
-    }
-
-    if (row.kind === 'user-prompt') {
-      lastAssistantRowId = null;
-    }
-
-    // A run that failed ends on its failure row: the receipt goes under it.
-    if (row.kind === 'markdown' || (row.kind === 'error' && row.failure)) {
-      lastAssistantRowId = row.id;
-    }
-
-    if (row.kind === 'run-summary' && row.runSummary && lastAssistantRowId !== null) {
-      receiptByRowId.set(lastAssistantRowId, row.runSummary);
-      lastAssistantRowId = null;
-      continue;
-    }
-
-    visibleRows.push(row);
-  }
-
-  return { visibleRows, receiptByRowId };
-}
-
-/**
- * Rows that fold in compact density: core's rule (`foldsInCompactShape`),
- * shared with the TUI. Prose, the user's own rows, anything that demands
- * attention and structural rows stay in the transcript.
- */
-function foldsInCompact(row: Row): boolean {
-  const owned = row as Row & { childId?: string; depth?: number; notice?: unknown };
-  return foldsInCompactShape({
-    kind: row.kind,
-    notice: owned.notice,
-    childId: owned.childId,
-    depth: owned.depth,
-  });
-}
-
-/**
- * The id a fold keys off. A batch's own id changes as it forms (`t-5`
- * becomes `tg-t-5` once a second call joins), which would remount the
- * fold mid-exchange; the first underlying row's id never does.
- */
-function foldAnchorId(row: Row): string {
-  switch (row.kind) {
-    case 'tool-batch':
-      return row.tools[0]?.id ?? row.id;
-    case 'thinking-batch':
-      return row.thoughts[0]?.id ?? row.id;
-    default:
-      return row.id;
-  }
-}
-
-/** The fold row's counts, from core's plan: a worker's calls and thoughts count under the worker. */
-function rowStats(stats: FoldStats): ExchangeFoldStats {
-  return {
-    tools: stats.tools,
-    thoughts: stats.thoughts,
-    subagents: stats.workers,
-    failed: stats.failed,
-    ...(stats.durationMs !== undefined ? { durationMs: stats.durationMs } : {}),
-  };
-}
-
-/**
- * Compact density: fold every exchange's work behind one `exchange-fold`
- * row. An exchange is the span between two boundary rows (`user-prompt`,
- * `separator`, `compact-summary`); rows that {@link foldsInCompact} move
- * into the fold, which sits RIGHT UNDER the exchange's prompt, ahead of the
- * prose (prose written before the first call still reads after the work
- * indicator, never between the prompt and it).
- *
- * The exchange of a running run is `live` until the run ends (one working
- * indicator for the whole reply, however much prose streams in between).
- * It appears as soon as the prompt lands, before any action ("Working"),
- * so the indicator is always in place instead of jumping in later; a run
- * that ends without any action leaves no fold behind.
- *
- * Runs after batching and receipt docking (so batches are already folded
- * and receipts already docked on their prose) and before owner clustering
- * (the fold's rows are clustered again when it is expanded, so worker
- * blocks paint exactly as in full density).
- *
- * @param rows - The transcript rows after batching and receipt docking, oldest first.
- * @param isStreaming - A run is in flight, so the last exchange is live.
- */
-export function foldExchanges(rows: readonly Row[], isStreaming: boolean): Row[] {
-  const out: Row[] = [];
-  let boundary: Row | null = null;
-  let folded: Row[] = [];
-  let visible: Row[] = [];
-
-  const flush = (final: boolean) => {
-    const live = final && isStreaming;
-    // The indicator of a run that has not acted yet: only under a prompt.
-    const pending = live && folded.length === 0 && boundary?.kind === 'user-prompt';
-    if (folded.length > 0 || pending) {
-      const anchor = boundary ?? folded[0]!;
-      const owned: Owned = {};
-      const turnSource = folded[0] ?? boundary;
-      if (turnSource && turnSource.kind !== 'separator' && turnSource.kind !== 'compact-summary' && turnSource.turnId) {
-        owned.turnId = turnSource.turnId;
-      }
-      const id = `xf-${boundary ? boundary.id : foldAnchorId(anchor)}`;
-      // A settled fold keeps its identity while its rows do, so a streaming
-      // delta elsewhere re-renders only the live exchange, not every fold.
-      const key = boundary ?? folded[0]!;
-      const hit = FOLD_CACHE.get(key);
-      if (hit && hit.kind === 'exchange-fold' && hit.id === id && hit.live === live && sameMembers(hit.rows, folded)) {
-        out.push(hit);
-      } else {
-        const plan = planFold(foldUnits(folded));
-        const row: Row = {
-          ...owned,
-          kind: 'exchange-fold',
-          id,
-          rows: folded,
-          live,
-          stats: rowStats(plan.stats),
-          // The header ends on its calls' counts (`FoldOutcomes`), so it carries no +N.
-          summary: foldSummary(plan, { overflow: false }),
-        };
-        FOLD_CACHE.set(key, row);
-        out.push(row);
-      }
-    }
-    out.push(...groupMessages(visible, boundary, live));
-    folded = [];
-    visible = [];
-  };
-
-  for (const row of rows) {
-    if (TOOL_GROUP_BOUNDARIES.has(row.kind)) {
-      flush(false);
-      out.push(row);
-      boundary = row;
-      continue;
-    }
-    if (foldsInCompact(row)) folded.push(row);
-    else visible.push(row);
-  }
-  // Only the final exchange can be live, and only while the run streams.
-  flush(true);
-  return out;
-}
-
-const REBASED = new WeakMap<object, Row>();
-
-/**
- * A worker's (subagent's) own rows folded like an exchange of the main
- * transcript: its tool calls, thoughts and the workers it started behind one
- * "Working" row, its earlier messages behind one group, its last message in
- * full. Its own rows are re-based to depth 0 (same row objects per input, so
- * folds keep their identity across stream ticks); rows of workers it started
- * keep their lane and fold as worker lines. Its lifecycle markers are left
- * out: the line or header showing the worker already carries them.
- *
- * @param rows - The rows that include the worker's own rows and those of workers it started.
- * @param owner - The `childId` of the worker whose rows to fold.
- * @param live - The worker is still running, so its last exchange is live.
- */
-export function foldWorkerRows(rows: readonly Row[], owner: string, live: boolean): Row[] {
-  const own: Row[] = [];
-  for (const row of rows) {
-    const childId = 'childId' in row ? row.childId : undefined;
-    if (childId !== owner) {
-      own.push(row);
-      continue;
-    }
-    if (row.kind === 'spawn-start' || row.kind === 'spawn-end') continue;
-    let rebased = REBASED.get(row);
-    if (!rebased) {
-      const { childId: _childId, depth: _depth, ...rest } = row as Row & { childId?: string; depth?: number };
-      rebased = rest as Row;
-      REBASED.set(row, rebased);
-    }
-    own.push(rebased);
-  }
-  return foldExchanges(own, live);
-}
-
-const MESSAGE_GROUP_CACHE = new WeakMap<object, Row>();
-
-const isOwnMessage = (row: Row): boolean =>
-  row.kind === 'markdown' && !('childId' in row && row.childId) && !(('depth' in row ? row.depth : 0) ?? 0);
-
-/**
- * The exchange's own messages but the last fold into one `message-group`
- * row, placed where the first of them was; everything else keeps its place.
- * An exchange with one message is left as it is.
- */
-function groupMessages(visible: readonly Row[], boundary: Row | null, live: boolean): Row[] {
-  const messages = visible.filter(isOwnMessage);
-  // Every exchange's messages ride one group: the latest (`current`) in full
-  // as its last row, the earlier ones behind it. Same group live and settled,
-  // so a message moving from current to earlier animates in place and the
-  // run ending swaps nothing.
-  if (messages.length === 0) return [...visible];
-  const earlier = messages.slice(0, -1);
-  const current = messages[messages.length - 1]!;
-  const key = boundary ?? messages[0]!;
-  const id = `mg-${boundary ? boundary.id : messages[0]!.id}`;
-  const hit = MESSAGE_GROUP_CACHE.get(key);
-  let group: Row;
-  if (
-    hit &&
-    hit.kind === 'message-group' &&
-    hit.id === id &&
-    hit.live === live &&
-    hit.current === current &&
-    sameMembers(hit.messages, earlier)
-  ) {
-    group = hit;
-  } else {
-    const first = messages[0]!;
-    group = {
-      ...('turnId' in first && first.turnId ? { turnId: first.turnId } : {}),
-      kind: 'message-group',
-      id,
-      messages: earlier,
-      live,
-      current,
-    };
-    MESSAGE_GROUP_CACHE.set(key, group);
-  }
-  const inGroup = new Set(messages);
-  const out: Row[] = [];
-  for (const row of visible) {
-    if (row === messages[0]) out.push(group);
-    else if (!inGroup.has(row)) out.push(row);
-  }
-  return out;
-}
-
-/**
- * The streaming reply that carries the caret, looking inside message groups.
- *
- * @param rows - The transcript rows, oldest first.
- */
-export function findLastStreamingRow(rows: readonly Row[]): Row | null {
-  for (let i = rows.length - 1; i >= 0; i -= 1) {
-    const row = rows[i]!;
-    if (row.kind === 'markdown' && row.streaming) return row;
-    if (row.kind === 'message-group' && row.current.kind === 'markdown' && row.current.streaming) return row.current;
-  }
-  return null;
-}
-
-/**
- * Picks the status dot a row shows.
- *
- * @param row - The transcript row.
- */
-export function dotVariantFor(row: Row): DotVariant {
-  switch (row.kind) {
-    case 'thinking':
-    case 'thinking-batch':
-      return 'thinking';
-    case 'markdown':
-      return 'text';
-    case 'info':
-    case 'command-detail':
-    case 'run-summary':
-      return 'info';
-    case 'command-note':
-      return 'note';
-    // The worker's outcome IS the dot: the card carries no glyph of its own,
-    // so status reads from the timeline column like a tool's ok/err does.
-    case 'session-event':
-      return row.sessionEvent ? `session-${row.sessionEvent.status}` : 'info';
-    case 'error':
-      return row.failure?.cause === 'aborted' ? 'stopped' : 'error';
-    case 'spawn-start':
-      return 'spawn-start';
-    case 'spawn-end':
-      return 'spawn-end';
-    case 'compact-summary':
-      return 'compact';
-    case 'tool':
-      if (row.ok === null) {
-        return 'tool-running';
-      }
-
-      return row.ok ? 'tool-ok' : 'tool-err';
-    case 'user-bash':
-      if (row.running) {
-        return 'tool-running';
-      }
-
-      if (row.errored) {
-        return 'tool-err';
-      }
-
-      // No parsable exit meta (e.g. clipped success footer) reads as ok —
-      // failures always carry their `Exit code N` header at the head.
-      return row.exit === null || (row.exit.code === 0 && !row.exit.cancelled) ? 'tool-ok' : 'tool-err';
-    case 'tool-batch': {
-      // Surface the worst-case child status on the dot so a single
-      // failure in a batch still draws the eye.
-      let anyRunning = false;
-      let anyErr = false;
-
-      for (const t of row.tools) {
-        if (t.ok === null) {
-          anyRunning = true;
-        } else if (toolFailed(t)) {
-          anyErr = true;
-        }
-      }
-
-      if (anyErr) {
-        return 'tool-err';
-      }
-
-      if (anyRunning) {
-        return 'tool-running';
-      }
-
-      return 'tool-ok';
-    }
-    case 'exchange-fold':
-      // A few failed calls in a finished exchange are routine (a probe, a retry):
-      // the run's own failure has its row. Only an exchange whose calls all failed reads failed.
-      if (row.live) return 'tool-running';
-      return row.stats.tools > 0 && row.stats.failed === row.stats.tools ? 'tool-err' : 'tool-ok';
-    case 'message-group':
-      return row.messages.length === 0 ? 'text' : 'messages';
-    case 'user-prompt':
-    case 'separator':
-      return 'text';
-  }
-}

package/src/chat/headless/transcript/index.ts

@@ -1,41 +0,0 @@
-/**
- * The headless transcript pipeline: zidane stream events in, the rows a
- * transcript paints out. Pure functions over `ChatEvent[]`; the styled
- * Transcript and any other renderer run the same passes:
- *
- *   collapseEvents     events → rows (pairs tool calls, merges text, edits, spawns)
- *   dockRunReceipts    run receipts onto their reply
- *   markRunFailures    a run that ended early → one row that can continue or retry
- *   batchToolRuns      consecutive tool calls → one batch row
- *   batchThinkingRuns  thinking chains across tool calls
- *   foldExchanges      finished exchanges → one fold row
- *   clusterByOwner     subagent rows → blocks per spawn
- *
- * Every pass keeps row identity for unchanged input (memoised rows rely on it).
- *
- * @module
- */
-export { firstRowId, parseBashExitMeta } from './rows';
-export type {
-  Owned,
-  Row,
-  ToolRowModel,
-  ExchangeFoldStats,
-  SpawnMeta,
-  Cluster,
-  GroupCluster,
-  BashExitMeta,
-  DotVariant,
-} from './rows';
-export { toolFailed, refusedSpawn, collapseEvents, inheritRowIdentity } from './collapse';
-export { clusterByOwner, batchToolRuns, batchThinkingRuns } from './batch';
-export { dockRunReceipts, foldExchanges, foldWorkerRows, findLastStreamingRow, dotVariantFor } from './fold';
-export { nestToolCalls, nestedCallVisible } from './nesting';
-export { pairToolEvents } from './pairing';
-export type { ToolPairing, PairingResult } from './pairing';
-export { toolAction, foldActionItems } from './fold-actions';
-export type { FoldActionState, FoldActionItem } from './fold-actions';
-export { failureTooltip, markRunFailures } from './run-failures';
-export type { RunFailure } from './run-failures';
-export { rowTurnIds, computeSelectStops, stopForRow } from './select-stops';
-export type { SelectStops } from './select-stops';

package/src/chat/headless/transcript/nesting.ts

@@ -1,73 +0,0 @@
-/**
- * Calls a tool made (a codemode script's `tools.*`, recorded with
- * `parentToolCallId`) as children of the calling row: one grouping step
- * keyed on the parent's call id, never on position, so a live run (nested
- * events between the parent's call and result) and a reload (nested pairs
- * right before the parent's result) give the same rows.
- */
-import type { ChatEvent } from '../host';
-import { sameMembers } from './batch';
-import type { Row, ToolRowModel } from './rows';
-
-/**
- * Whether a nested call's events show: a call that runs a subagent always
- * does (its worker attaches to it), the others only with
- * `Settings.codemodeShowCalls`. Core's `isVisible` applies the same rule.
- *
- * @param event - The transcript event.
- * @param codemodeShowCalls - The user's `codemodeShowCalls` setting.
- */
-export function nestedCallVisible(event: ChatEvent, codemodeShowCalls: boolean): boolean {
-  return event.parentToolCallId === undefined || event.runsNestedAgent === true || codemodeShowCalls;
-}
-
-/** The row with children, per source row: kept while the children are the same rows. */
-const NESTED_CACHE = new WeakMap<ToolRowModel, ToolRowModel>();
-
-const callKey = (owner: string | undefined, callId: string) => `${owner ?? ''}\u0000${callId}`;
-
-/**
- * Moves every tool row whose `parentId` names a call in `rows` (same owner)
- * into that call's `children`. A nested row whose parent is absent stays
- * where it is. Returns `rows` itself when nothing nests.
- *
- * @param rows - Rows from {@link collapseEvents}, oldest first.
- */
-export function nestToolCalls(rows: readonly Row[]): readonly Row[] {
-  const calls = new Map<string, ToolRowModel>();
-  for (const row of rows) if (row.kind === 'tool' && row.callId) calls.set(callKey(row.childId, row.callId), row);
-
-  const childrenOf = new Map<ToolRowModel, ToolRowModel[]>();
-  const nested = new Set<Row>();
-  for (const row of rows) {
-    if (row.kind !== 'tool' || row.parentId === undefined) continue;
-    const parent = calls.get(callKey(row.childId, row.parentId));
-    if (!parent || parent === row) continue;
-    const list = childrenOf.get(parent);
-    if (list) list.push(row);
-    else childrenOf.set(parent, [row]);
-    nested.add(row);
-  }
-  if (nested.size === 0) return rows;
-
-  const visiting = new Set<ToolRowModel>();
-  const build = (row: ToolRowModel): ToolRowModel => {
-    const kids = childrenOf.get(row);
-    if (!kids || visiting.has(row)) return row;
-    visiting.add(row);
-    const children = kids.map(build);
-    visiting.delete(row);
-    const hit = NESTED_CACHE.get(row);
-    if (hit?.children && sameMembers(hit.children, children)) return hit;
-    const next: ToolRowModel = { ...row, children };
-    NESTED_CACHE.set(row, next);
-    return next;
-  };
-
-  const out: Row[] = [];
-  for (const row of rows) {
-    if (nested.has(row)) continue;
-    out.push(row.kind === 'tool' ? build(row) : row);
-  }
-  return out;
-}

package/src/chat/headless/transcript/pairing.ts

@@ -1,124 +0,0 @@
-/**
- * Pure tool-event pairing, kept free of React so it can be unit-tested
- * without a render. Matches `tool` events with their
- * `tool-result` / `error` counterparts. A `tool-result` flagged `isError`
- * (the host marks a failed call's one result row) pairs as `error`.
- *
- * Two-pass design: bucket call + result indices by callId / (turnId,
- * toolName), then zip them. Phase 1 pairs by canonical `callId`
- * (zidane ≥ 5.1.21); Phase 2 falls back to positional pairing within
- * `(turnId, toolName)` for events without a `callId`.
- */
-import type { ChatEvent } from '../host';
-
-/** The result paired with one tool call. */
-export interface ToolPairing {
-  /** Index in the events array of the paired `tool-result` or `error` event. */
-  resultIndex: number;
-  /** Kind of the paired event. A `tool-result` flagged `isError` counts as `error`. */
-  resultKind: 'tool-result' | 'error';
-}
-
-/** The outcome of {@link pairToolEvents}. */
-export interface PairingResult {
-  /** Pairings keyed by the index of the `tool` event that made the call. */
-  pairings: ReadonlyMap<number, ToolPairing>;
-  /** Indices of result events that were paired, so a renderer does not show them again on their own. */
-  consumedResultIndices: ReadonlySet<number>;
-}
-
-/**
- * Matches each `tool` event with its `tool-result` or `error` event. Pairs by `callId` when events carry one, and by position within the turn and tool name otherwise.
- *
- * @param events - The transcript events, oldest first.
- */
-export function pairToolEvents(events: readonly ChatEvent[]): PairingResult {
-  const pairings = new Map<number, ToolPairing>();
-  const consumedResultIndices = new Set<number>();
-
-  const callsByCallId = new Map<string, number>();
-  const resultsByCallId = new Map<string, { idx: number; kind: 'tool-result' | 'error' }[]>();
-
-  const positionalCalls = new Map<string, number[]>();
-  const positionalResults = new Map<string, { idx: number; kind: 'tool-result' | 'error' }[]>();
-
-  for (let i = 0; i < events.length; i++) {
-    const event = events[i];
-    const toolName = event.tool;
-
-    if (!toolName) {
-      continue;
-    }
-
-    const callId = event.callId;
-    const turnId = event.turnId ?? '';
-    const positionalKey = `${turnId}::${toolName}`;
-
-    if (event.kind === 'tool') {
-      if (callId) {
-        callsByCallId.set(callId, i);
-      } else {
-        const arr = positionalCalls.get(positionalKey) ?? [];
-        arr.push(i);
-        positionalCalls.set(positionalKey, arr);
-      }
-
-      continue;
-    }
-
-    if (event.kind === 'tool-result' || event.kind === 'error') {
-      const kind = event.kind === 'tool-result' && event.isError ? 'error' : event.kind;
-      if (callId) {
-        const arr = resultsByCallId.get(callId) ?? [];
-        arr.push({ idx: i, kind });
-        resultsByCallId.set(callId, arr);
-      } else {
-        const arr = positionalResults.get(positionalKey) ?? [];
-        arr.push({ idx: i, kind });
-        positionalResults.set(positionalKey, arr);
-      }
-    }
-  }
-
-  /*
-   * Phase 1: pair by callId — unconditionally correct. A callId can carry
-   * SEVERAL results: the `!` shell mode streams its rolling tail as
-   * repeated `tool-result` events (the store is append-only, so each
-   * throttled paint is a new event). The call pairs with the LAST result;
-   * every earlier intermediate is consumed so it never leaks into the
-   * timeline as a stray info row.
-   */
-  for (const [callId, callIdx] of callsByCallId) {
-    const results = resultsByCallId.get(callId);
-
-    if (!results || results.length === 0) {
-      continue;
-    }
-
-    const last = results[results.length - 1];
-    pairings.set(callIdx, { resultIndex: last.idx, resultKind: last.kind });
-
-    for (const r of results) {
-      consumedResultIndices.add(r.idx);
-    }
-  }
-
-  // Phase 2: positional fallback for events without callId.
-  for (const [key, callIndices] of positionalCalls) {
-    const results = positionalResults.get(key) ?? [];
-
-    for (let k = 0; k < callIndices.length; k++) {
-      const callIdx = callIndices[k];
-      const result = results[k];
-
-      if (!result || result.idx <= callIdx) {
-        continue;
-      }
-
-      pairings.set(callIdx, { resultIndex: result.idx, resultKind: result.kind });
-      consumedResultIndices.add(result.idx);
-    }
-  }
-
-  return { pairings, consumedResultIndices };
-}