ubume 0.1.0

package/src/ui/timeline/layoutListWindow.ts

@@ -0,0 +1,145 @@
+/**
+ * Shared utility for windowing large lists in limited terminal rows.
+ */
+
+export interface ListWindowOptions {
+  itemCount: number;
+  selectedIndex: number;
+  availableRows: number;
+  /** Fixed rows consumed by headers, borders, titles, etc. */
+  chromeRows: number;
+  /** Whether to show "↑ N more" and "↓ N more" indicators. */
+  showIndicators?: boolean;
+  /** Whether to show "Showing X-Y of N" range line. */
+  showRangeLine?: boolean;
+}
+
+export interface ListWindowResult {
+  start: number;
+  end: number;
+  visibleCount: number;
+  showAbove: boolean;
+  showBelow: boolean;
+  showRange: boolean;
+  hiddenAbove: number;
+  hiddenBelow: number;
+  /** Total rows consumed including chrome and indicators. */
+  totalRows: number;
+}
+
+/**
+ * Calculates a contiguous window of items that fits within available rows,
+ * ensuring the selected item is always visible.
+ */
+export function calculateListWindow({
+  itemCount,
+  selectedIndex,
+  availableRows,
+  chromeRows,
+  showIndicators = true,
+  showRangeLine = false,
+}: ListWindowOptions): ListWindowResult {
+  if (itemCount === 0) {
+    return {
+      start: 0,
+      end: 0,
+      visibleCount: 0,
+      showAbove: false,
+      showBelow: false,
+      showRange: false,
+      hiddenAbove: 0,
+      hiddenBelow: 0,
+      totalRows: chromeRows,
+    };
+  }
+
+  const rangeReserved = showRangeLine ? 1 : 0;
+  
+  // If everything fits including the range line, just show everything.
+  if (itemCount + chromeRows + rangeReserved <= availableRows) {
+    return {
+      start: 0,
+      end: itemCount,
+      visibleCount: itemCount,
+      showAbove: false,
+      showBelow: false,
+      showRange: showRangeLine,
+      hiddenAbove: 0,
+      hiddenBelow: 0,
+      totalRows: itemCount + chromeRows + rangeReserved,
+    };
+  }
+
+  // Otherwise we must window.
+  // We reserve space for indicators if requested.
+  // We MUST fit within availableRows.
+  const indicatorReserved = showIndicators ? 2 : 0;
+  const baseReserved = chromeRows + indicatorReserved + rangeReserved;
+  
+  let itemRows = Math.max(1, availableRows - baseReserved);
+  let start = 0;
+  let end = 0;
+
+  // Iteratively refine to account for dynamic indicators.
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const visibleCount = Math.max(1, Math.min(itemCount, itemRows));
+    
+    // Center selected item if possible
+    start = Math.max(0, selectedIndex - Math.floor(visibleCount / 2));
+    if (start + visibleCount > itemCount) {
+      start = Math.max(0, itemCount - visibleCount);
+    }
+    end = Math.min(itemCount, start + visibleCount);
+
+    const actualAbove = start > 0;
+    const actualBelow = end < itemCount;
+    const dynamicReserved = chromeRows 
+      + (showRangeLine ? 1 : 0)
+      + (showIndicators && actualAbove ? 1 : 0)
+      + (showIndicators && actualBelow ? 1 : 0);
+    
+    const nextItemRows = Math.max(1, availableRows - dynamicReserved);
+    if (nextItemRows === itemRows) break;
+    itemRows = nextItemRows;
+  }
+
+  // Final visibility check for selectedIndex
+  if (selectedIndex < start) {
+    start = selectedIndex;
+    end = Math.min(itemCount, start + itemRows);
+  } else if (selectedIndex >= end) {
+    end = selectedIndex + 1;
+    start = Math.max(0, end - itemRows);
+  }
+
+  // Final clamping to ensure we don't exceed availableRows if indicators are shown
+  let finalAbove = showIndicators && start > 0;
+  let finalBelow = showIndicators && end < itemCount;
+  
+  while (end - start + chromeRows + (showRangeLine ? 1 : 0) + (finalAbove ? 1 : 0) + (finalBelow ? 1 : 0) > availableRows && end - start > 1) {
+    // Shrink window from the side further from selectedIndex
+    if (selectedIndex - start > end - 1 - selectedIndex) {
+      start++;
+    } else {
+      end--;
+    }
+    finalAbove = showIndicators && start > 0;
+    finalBelow = showIndicators && end < itemCount;
+  }
+
+  return {
+    start,
+    end,
+    visibleCount: end - start,
+    showAbove: finalAbove,
+    showBelow: finalBelow,
+    showRange: showRangeLine,
+    hiddenAbove: start,
+    hiddenBelow: itemCount - end,
+    totalRows: (end - start) 
+      + chromeRows 
+      + (showRangeLine ? 1 : 0)
+      + (finalAbove ? 1 : 0)
+      + (finalBelow ? 1 : 0),
+  };
+}

package/src/ui/timeline/liveViewportWindow.ts

@@ -0,0 +1,68 @@
+import type { TimelineRow } from "./timelineMeasure.js";
+import { buildFrameElisionRow } from "./timelineMeasure.js";
+
+/**
+ * Rows kept free below the live window to absorb composer-measurement drift.
+ * Ink erases the scrollback (`\x1b[2J\x1b[3J\x1b[H`) on every frame whose live
+ * output is taller than the terminal, which drops the user to the bottom while
+ * they are reading scrollback. The window must therefore stay strictly inside
+ * the viewport even when the composer is one row taller than measured.
+ */
+export const LIVE_WINDOW_SAFETY_ROWS = 1;
+
+/** Rows a re-capped card costs: its own top border plus the elision notice. */
+const FRAME_RECAP_ROWS = 2;
+
+/**
+ * Walk back from `start` to the top row of the card `start` sits inside.
+ * Returns null when the slice does not cut a card open — either the row carries
+ * no frame at all, or it already is a card's top row.
+ */
+function findOpenFrameTop(
+  rows: TimelineRow[],
+  start: number,
+): { topRow: TimelineRow; topIndex: number } | null {
+  const frame = rows[start]?.frame;
+  if (!frame || frame.role === "top") return null;
+
+  for (let index = start - 1; index >= 0; index -= 1) {
+    const candidate = rows[index];
+    const candidateFrame = candidate?.frame;
+    if (!candidateFrame || candidateFrame.id !== frame.id) return null;
+    if (candidateFrame.role === "top") return { topRow: candidate!, topIndex: index };
+  }
+
+  return null;
+}
+
+/**
+ * Keep only the last `maxRows` live rows. Returns the input array itself when
+ * it already fits so memoized consumers keep their identity.
+ *
+ * The window may only ever shrink — growing past `maxRows` is what makes Ink
+ * wipe the scrollback. So when the cut lands inside a bordered card, the card is
+ * re-capped rather than extended: two rows of tail are traded for the card's own
+ * top border plus an `⋯ N rows hidden` notice, which keeps the box complete
+ * instead of leaving a headless frame that starts mid-sentence.
+ */
+export function windowLiveRows(rows: TimelineRow[], maxRows: number): TimelineRow[] {
+  const limit = Math.max(0, Math.floor(maxRows));
+  if (rows.length <= limit) return rows;
+  if (limit === 0) return [];
+
+  const plainStart = rows.length - limit;
+  if (limit <= FRAME_RECAP_ROWS + 1 || !findOpenFrameTop(rows, plainStart)) {
+    return rows.slice(plainStart);
+  }
+
+  const recapStart = rows.length - (limit - FRAME_RECAP_ROWS);
+  const frame = findOpenFrameTop(rows, recapStart);
+  if (!frame) return rows.slice(plainStart);
+
+  const hiddenRows = recapStart - frame.topIndex - 1;
+  return [
+    frame.topRow,
+    buildFrameElisionRow(frame.topRow, hiddenRows),
+    ...rows.slice(recapStart),
+  ];
+}

package/src/ui/timeline/progressEntries.ts

@@ -0,0 +1,156 @@
+import type { RunProgressBlock, RunProgressEntry, RunProgressSource } from "../../session/types.js";
+import { sanitizeTerminalOutput } from "../../core/terminal/terminalSanitize.js";
+import { wrapPlainText } from "../render/textLayout.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface VisibleProgressBlock {
+  id: string;
+  key: string;
+  label: string;
+  headline: string;
+  text: string;
+  source: RunProgressSource;
+  entryId: string;
+  entrySequence: number;
+  blockSequence: number;
+  status: RunProgressBlock["status"];
+  isLatest: boolean;
+  isActive: boolean;
+}
+
+export interface VisibleProgressBlocks {
+  hiddenCount: number;
+  totalCount: number;
+  blocks: VisibleProgressBlock[];
+  latestBlock: VisibleProgressBlock | null;
+  latestActiveBlock: VisibleProgressBlock | null;
+}
+
+// ─── Block selection ─────────────────────────────────────────────────────────
+
+function sourceLabel(source: RunProgressSource): string {
+  switch (source) {
+    case "reasoning":
+      return "Reasoning";
+    case "todo":
+      return "Todo";
+    case "tool":
+      return "Tool";
+    case "activity":
+      return "Activity";
+    case "stderr":
+      return "Process";
+    case "transcript":
+      return "Progress";
+    default:
+      return "Update";
+  }
+}
+
+function firstMeaningfulLine(text: string): string {
+  return sanitizeTerminalOutput(text)
+    .replace(/\r\n/g, "\n")
+    .replace(/\r/g, "\n")
+    .split("\n")
+    .map((line) => line.trim())
+    .find(Boolean) ?? "";
+}
+
+function buildProgressHeadline(source: RunProgressSource, text: string, status: RunProgressBlock["status"]): string {
+  const label = status === "active" ? "Current" : sourceLabel(source);
+  const firstLine = firstMeaningfulLine(text);
+  return firstLine ? `${label}: ${firstLine}` : label;
+}
+
+function toVisibleProgressBlocks(entries: RunProgressEntry[]): VisibleProgressBlock[] {
+  const blocks: VisibleProgressBlock[] = [];
+  let visibleSequence = 0;
+
+  for (const entry of entries) {
+    for (const block of entry.blocks) {
+      if (!block.text.trim()) continue;
+      visibleSequence += 1;
+      blocks.push({
+        id: block.id,
+        key: block.id,
+        label: `Update ${visibleSequence}`,
+        headline: buildProgressHeadline(entry.source, block.text, block.status),
+        text: block.text,
+        source: entry.source,
+        entryId: entry.id,
+        entrySequence: entry.sequence,
+        blockSequence: block.sequence,
+        status: block.status,
+        isLatest: false,
+        isActive: block.status === "active",
+      });
+    }
+  }
+
+  return blocks.map((block, index) => ({
+    ...block,
+    isLatest: index === blocks.length - 1,
+  }));
+}
+
+export function getProgressUpdateCount(entries: RunProgressEntry[]): number {
+  return toVisibleProgressBlocks(entries).length;
+}
+
+export function selectVisibleProgressBlocks(entries: RunProgressEntry[], maxVisible: number): VisibleProgressBlocks {
+  const blocks = toVisibleProgressBlocks(entries);
+  const safeMax = Math.max(0, maxVisible);
+  const findLatestActiveBlock = (candidates: VisibleProgressBlock[]): VisibleProgressBlock | null => {
+    for (let index = candidates.length - 1; index >= 0; index -= 1) {
+      if (candidates[index]?.isActive) {
+        return candidates[index]!;
+      }
+    }
+    return null;
+  };
+
+  if (blocks.length <= safeMax) {
+    return {
+      hiddenCount: 0,
+      totalCount: blocks.length,
+      blocks,
+      latestBlock: blocks[blocks.length - 1] ?? null,
+      latestActiveBlock: findLatestActiveBlock(blocks),
+    };
+  }
+
+  const visible = blocks.slice(-safeMax);
+  return {
+    hiddenCount: blocks.length - safeMax,
+    totalCount: blocks.length,
+    blocks: visible,
+    latestBlock: visible[visible.length - 1] ?? null,
+    latestActiveBlock: findLatestActiveBlock(visible),
+  };
+}
+
+export function formatProgressBlockBodyLines(text: string, width: number): string[] {
+  const contentWidth = Math.max(1, width);
+  const normalized = sanitizeTerminalOutput(text)
+    .replace(/\r\n/g, "\n")
+    .replace(/\r/g, "\n")
+    .replace(/[ \t]+\n/g, "\n");
+
+  if (!normalized.trim()) {
+    return [" "];
+  }
+
+  const rows: string[] = [];
+  for (const rawLine of normalized.split("\n")) {
+    if (!rawLine.trim()) {
+      rows.push("");
+      continue;
+    }
+
+    const wrapped = wrapPlainText(rawLine, contentWidth);
+    rows.push(...(wrapped.length > 0 ? wrapped : [" "]));
+  }
+
+  return rows.length > 0 ? rows : [" "];
+}

package/src/ui/timeline/runActivityView.ts

@@ -0,0 +1,37 @@
+import type { RunEvent } from "../../session/types.js";
+
+const MAX_VISIBLE_ACTIVE_ACTIVITY = 6;
+const MAX_VISIBLE_SUMMARY_ACTIVITY = 4;
+export function selectVisibleRunActivity(event: RunEvent) {
+  const source = event.status === "running"
+    ? event.activity
+    : event.activitySummary?.recent ?? event.activity;
+  const limit = event.status === "running" ? MAX_VISIBLE_ACTIVE_ACTIVITY : MAX_VISIBLE_SUMMARY_ACTIVITY;
+  const visible = source.slice(-limit);
+  return {
+    visible,
+    hiddenCount: Math.max(0, source.length - visible.length),
+  };
+}
+
+export function shouldShowRawOutputFallback(event: RunEvent): boolean {
+  void event;
+  return false;
+}
+
+export function getVisibleRawOutputLines(event: RunEvent): string[] {
+  void event;
+  return [];
+}
+
+export function formatRunActivityStats(event: RunEvent): string | null {
+  const summary = event.activitySummary;
+  if (!summary || event.touchedFileCount === 0) return null;
+
+  return [
+    `${event.touchedFileCount} file${event.touchedFileCount === 1 ? "" : "s"} touched`,
+    `+${summary.created}`,
+    `~${summary.modified}`,
+    `-${summary.deleted}`,
+  ].join("  ");
+}

package/src/ui/timeline/staticTranscriptCache.ts

@@ -0,0 +1,174 @@
+import type { AssistantEvent, ErrorEvent, RunEvent, ShellEvent, SystemEvent, UserPromptEvent } from "../../session/types.js";
+import type { RenderTimelineItem } from "./Timeline.js";
+import type { TurnOpacity } from "./TurnGroup.js";
+import { buildNativeTranscriptParts, type NativeTranscriptRowItem, type TimelineRow } from "./timelineMeasure.js";
+
+/**
+ * Incremental row builder for the finalized (static) half of the transcript.
+ *
+ * Ink's <Static> prints each item once and never re-renders it, and finalized
+ * timeline events are immutable, so rebuilding every past turn's rows on each
+ * React commit (every keystroke, every streaming flush) is pure waste that
+ * grows with session length. This cache keys rows by the render item's key
+ * and revalidates by event identity plus the derived opacity, so a commit
+ * that changes nothing in the static half costs one Map lookup per item.
+ *
+ * Retention: only the newest MAX_RETAINED_STATIC_TURNS turns keep row objects.
+ * Older turns still emit placeholder items (with no rows) so the <Static> item
+ * count stays monotonic — Ink advances its printed index by items.length, so a
+ * shrinking list would swallow the next newly finalized turn. A turn that
+ * leaves the window keeps exactly the item keys it had while retained; those
+ * keys survive generation changes so the count never drops. Their rows are
+ * already in the terminal's scrollback; the only visible effect is that a
+ * width resize (which re-flushes <Static> from these items) redraws just the
+ * retained window.
+ */
+export const MAX_RETAINED_STATIC_TURNS = 200;
+
+const EMPTY_ROWS: TimelineRow[] = Object.freeze([]) as unknown as TimelineRow[];
+
+interface CachedTurnEntry {
+  kind: "turn";
+  user: UserPromptEvent | null;
+  run: RunEvent | null;
+  assistant: AssistantEvent | null;
+  opacity: TurnOpacity;
+  items: NativeTranscriptRowItem[];
+}
+
+interface CachedEventEntry {
+  kind: "event";
+  event: SystemEvent | ErrorEvent | ShellEvent;
+  items: NativeTranscriptRowItem[];
+}
+
+type CachedEntry = CachedTurnEntry | CachedEventEntry;
+
+export interface StaticTranscriptBuildOptions {
+  totalWidth: number;
+  verboseMode: boolean;
+  workspaceRoot: string | null;
+}
+
+export interface StaticTranscriptCache {
+  generation: string;
+  entries: Map<string, CachedEntry>;
+  /** Item keys of turns outside the retention window; kept across generations. */
+  placeholders: Map<string, string[]>;
+}
+
+export function createStaticTranscriptCache(): StaticTranscriptCache {
+  return { generation: "", entries: new Map(), placeholders: new Map() };
+}
+
+export function staticTranscriptGeneration(options: StaticTranscriptBuildOptions): string {
+  return `${options.totalWidth}|${options.verboseMode ? 1 : 0}|${options.workspaceRoot ?? ""}`;
+}
+
+function isCacheHit(cached: CachedEntry, item: RenderTimelineItem): boolean {
+  if (item.type === "event") return cached.kind === "event" && cached.event === item.event;
+  if (item.type !== "turn" || cached.kind !== "turn") return false;
+  return cached.user === item.item.user
+    && cached.run === item.item.run
+    && cached.assistant === item.item.assistant
+    && cached.opacity === item.renderState.opacity;
+}
+
+function isCacheable(item: RenderTimelineItem, liveRowCount: number): boolean {
+  if (item.type === "event") return true;
+  if (item.type !== "turn") return false;
+  return item.item.run?.status !== "running" && item.renderState.question === null && liveRowCount === 0;
+}
+
+/**
+ * Build native row items for the given render items, reusing cached rows for
+ * every item whose inputs are unchanged. Output is identical to a single
+ * batched buildNativeTranscriptParts call over the same items, except that
+ * turns outside the retention window carry empty rows.
+ */
+export function buildStaticTranscript(
+  cache: StaticTranscriptCache,
+  renderItems: RenderTimelineItem[],
+  options: StaticTranscriptBuildOptions,
+): { staticItems: NativeTranscriptRowItem[]; liveRows: TimelineRow[] } {
+  const generation = staticTranscriptGeneration(options);
+  if (cache.generation !== generation) {
+    cache.generation = generation;
+    cache.entries.clear();
+  }
+
+  const buildOptions = {
+    totalWidth: options.totalWidth,
+    verboseMode: options.verboseMode,
+    workspaceRoot: options.workspaceRoot,
+    debugLabel: "transcript-shell-static",
+  };
+  const staticItems: NativeTranscriptRowItem[] = [];
+  const liveRows: TimelineRow[] = [];
+  const seen = new Set<string>();
+
+  let turnCount = 0;
+  for (const item of renderItems) if (item.type === "turn") turnCount += 1;
+  const firstRetainedTurnOrdinal = Math.max(0, turnCount - MAX_RETAINED_STATIC_TURNS);
+  let turnOrdinal = 0;
+
+  for (const item of renderItems) {
+    if (item.type === "intro") {
+      staticItems.push(...buildNativeTranscriptParts([item], buildOptions).staticItems);
+      continue;
+    }
+
+    if (item.type === "turn") {
+      const ordinal = turnOrdinal;
+      turnOrdinal += 1;
+      if (ordinal < firstRetainedTurnOrdinal) {
+        let keys = cache.placeholders.get(item.key);
+        if (!keys) {
+          // Leaving the window: keep this turn's item keys so the count stays
+          // exactly what Ink already printed. A turn first seen outside the
+          // window was never printed by this <Static>, so one item suffices.
+          keys = cache.entries.get(item.key)?.items.map((entry) => entry.key) ?? [item.key];
+          cache.placeholders.set(item.key, keys);
+          cache.entries.delete(item.key);
+        }
+        for (const key of keys) staticItems.push({ key, rows: EMPTY_ROWS });
+        continue;
+      }
+    }
+
+    const cached = cache.entries.get(item.key);
+    if (cached && isCacheHit(cached, item)) {
+      staticItems.push(...cached.items);
+      seen.add(item.key);
+      continue;
+    }
+
+    const parts = buildNativeTranscriptParts([item], buildOptions);
+    staticItems.push(...parts.staticItems);
+    liveRows.push(...parts.liveRows);
+    if (!isCacheable(item, parts.liveRows.length)) continue;
+
+    cache.entries.set(
+      item.key,
+      item.type === "event"
+        ? { kind: "event", event: item.event, items: parts.staticItems }
+        : {
+          kind: "turn",
+          user: item.item.user,
+          run: item.item.run,
+          assistant: item.item.assistant,
+          opacity: item.renderState.opacity,
+          items: parts.staticItems,
+        },
+    );
+    seen.add(item.key);
+  }
+
+  if (cache.entries.size > seen.size) {
+    for (const key of cache.entries.keys()) {
+      if (!seen.has(key)) cache.entries.delete(key);
+    }
+  }
+
+  return { staticItems, liveRows };
+}

package/src/ui/timeline/streamCoalesce.ts

@@ -0,0 +1,53 @@
+import type { RunProgressBlock } from "../../session/types.js";
+
+interface ThinkingLikeEvent {
+  kind: string;
+  streamSeq: number;
+  block: RunProgressBlock;
+}
+
+/**
+ * Merge each run of consecutive `kind === "thinking"` events into a single
+ * event so contiguous chain-of-thought renders under one header. Local models
+ * emit every reasoning paragraph as its own progress item, which otherwise
+ * stacks one labeled block per sentence. Thoughts separated by a tool call or
+ * response segment stay separate — only uninterrupted runs merge.
+ */
+export function coalesceConsecutiveThinking<T extends { kind: string; streamSeq: number }>(events: T[]): T[] {
+  const result: T[] = [];
+  let index = 0;
+  while (index < events.length) {
+    const event = events[index]!;
+    if (event.kind !== "thinking") {
+      result.push(event);
+      index += 1;
+      continue;
+    }
+
+    let end = index + 1;
+    while (end < events.length && events[end]!.kind === "thinking") {
+      end += 1;
+    }
+    if (end - index === 1) {
+      result.push(event);
+      index = end;
+      continue;
+    }
+
+    const members = events.slice(index, end) as unknown as ThinkingLikeEvent[];
+    const first = members[0]!;
+    const last = members[members.length - 1]!;
+    const mergedBlock: RunProgressBlock = {
+      ...first.block,
+      text: members
+        .map((member) => member.block.text)
+        .filter((text) => text.trim().length > 0)
+        .join("\n\n"),
+      updatedAt: Math.max(...members.map((member) => member.block.updatedAt)),
+      status: last.block.status,
+    };
+    result.push({ ...event, block: mergedBlock });
+    index = end;
+  }
+  return result;
+}