feat(tui2): copy tui crate and normalize snapshots (#7833)

Introduce a full codex-tui source snapshot under the new codex-tui2
crate so viewport work can be replayed in isolation.

This change copies the entire codex-rs/tui/src tree into
codex-rs/tui2/src in one atomic step, rather than piecemeal, to keep
future diffs vs the original viewport bookmark easy to reason about.

The goal is for codex-tui2 to render identically to the existing TUI
behind the `features.tui2` flag while we gradually port the
viewport/history commits from the joshka/viewport bookmark onto this
forked tree.

While on this baseline change, we also ran the codex-tui2 snapshot test
suite and accepted all insta snapshots for the new crate, so the
snapshot files now use the codex-tui2 naming scheme and encode the
unmodified legacy TUI behavior. This keeps later viewport commits
focused on intentional behavior changes (and their snapshots) rather
than on mechanical snapshot renames.

codex-rs/tui2/src/streaming/controller.rs

@@ -0,0 +1,223 @@
+use crate::history_cell::HistoryCell;
+use crate::history_cell::{self};
+use ratatui::text::Line;
+
+use super::StreamState;
+
+/// Controller that manages newline-gated streaming, header emission, and
+/// commit animation across streams.
+pub(crate) struct StreamController {
+    state: StreamState,
+    finishing_after_drain: bool,
+    header_emitted: bool,
+}
+
+impl StreamController {
+    pub(crate) fn new(width: Option<usize>) -> Self {
+        Self {
+            state: StreamState::new(width),
+            finishing_after_drain: false,
+            header_emitted: false,
+        }
+    }
+
+    /// Push a delta; if it contains a newline, commit completed lines and start animation.
+    pub(crate) fn push(&mut self, delta: &str) -> bool {
+        let state = &mut self.state;
+        if !delta.is_empty() {
+            state.has_seen_delta = true;
+        }
+        state.collector.push_delta(delta);
+        if delta.contains('\n') {
+            let newly_completed = state.collector.commit_complete_lines();
+            if !newly_completed.is_empty() {
+                state.enqueue(newly_completed);
+                return true;
+            }
+        }
+        false
+    }
+
+    /// Finalize the active stream. Drain and emit now.
+    pub(crate) fn finalize(&mut self) -> Option<Box<dyn HistoryCell>> {
+        // Finalize collector first.
+        let remaining = {
+            let state = &mut self.state;
+            state.collector.finalize_and_drain()
+        };
+        // Collect all output first to avoid emitting headers when there is no content.
+        let mut out_lines = Vec::new();
+        {
+            let state = &mut self.state;
+            if !remaining.is_empty() {
+                state.enqueue(remaining);
+            }
+            let step = state.drain_all();
+            out_lines.extend(step);
+        }
+
+        // Cleanup
+        self.state.clear();
+        self.finishing_after_drain = false;
+        self.emit(out_lines)
+    }
+
+    /// Step animation: commit at most one queued line and handle end-of-drain cleanup.
+    pub(crate) fn on_commit_tick(&mut self) -> (Option<Box<dyn HistoryCell>>, bool) {
+        let step = self.state.step();
+        (self.emit(step), self.state.is_idle())
+    }
+
+    fn emit(&mut self, lines: Vec<Line<'static>>) -> Option<Box<dyn HistoryCell>> {
+        if lines.is_empty() {
+            return None;
+        }
+        Some(Box::new(history_cell::AgentMessageCell::new(lines, {
+            let header_emitted = self.header_emitted;
+            self.header_emitted = true;
+            !header_emitted
+        })))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn lines_to_plain_strings(lines: &[ratatui::text::Line<'_>]) -> Vec<String> {
+        lines
+            .iter()
+            .map(|l| {
+                l.spans
+                    .iter()
+                    .map(|s| s.content.clone())
+                    .collect::<Vec<_>>()
+                    .join("")
+            })
+            .collect()
+    }
+
+    #[tokio::test]
+    async fn controller_loose_vs_tight_with_commit_ticks_matches_full() {
+        let mut ctrl = StreamController::new(None);
+        let mut lines = Vec::new();
+
+        // Exact deltas from the session log (section: Loose vs. tight list items)
+        let deltas = vec![
+            "\n\n",
+            "Loose",
+            " vs",
+            ".",
+            " tight",
+            " list",
+            " items",
+            ":\n",
+            "1",
+            ".",
+            " Tight",
+            " item",
+            "\n",
+            "2",
+            ".",
+            " Another",
+            " tight",
+            " item",
+            "\n\n",
+            "1",
+            ".",
+            " Loose",
+            " item",
+            " with",
+            " its",
+            " own",
+            " paragraph",
+            ".\n\n",
+            "  ",
+            " This",
+            " paragraph",
+            " belongs",
+            " to",
+            " the",
+            " same",
+            " list",
+            " item",
+            ".\n\n",
+            "2",
+            ".",
+            " Second",
+            " loose",
+            " item",
+            " with",
+            " a",
+            " nested",
+            " list",
+            " after",
+            " a",
+            " blank",
+            " line",
+            ".\n\n",
+            "  ",
+            " -",
+            " Nested",
+            " bullet",
+            " under",
+            " a",
+            " loose",
+            " item",
+            "\n",
+            "  ",
+            " -",
+            " Another",
+            " nested",
+            " bullet",
+            "\n\n",
+        ];
+
+        // Simulate streaming with a commit tick attempt after each delta.
+        for d in deltas.iter() {
+            ctrl.push(d);
+            while let (Some(cell), idle) = ctrl.on_commit_tick() {
+                lines.extend(cell.transcript_lines(u16::MAX));
+                if idle {
+                    break;
+                }
+            }
+        }
+        // Finalize and flush remaining lines now.
+        if let Some(cell) = ctrl.finalize() {
+            lines.extend(cell.transcript_lines(u16::MAX));
+        }
+
+        let streamed: Vec<_> = lines_to_plain_strings(&lines)
+            .into_iter()
+            // skip • and 2-space indentation
+            .map(|s| s.chars().skip(2).collect::<String>())
+            .collect();
+
+        // Full render of the same source
+        let source: String = deltas.iter().copied().collect();
+        let mut rendered: Vec<ratatui::text::Line<'static>> = Vec::new();
+        crate::markdown::append_markdown(&source, None, &mut rendered);
+        let rendered_strs = lines_to_plain_strings(&rendered);
+
+        assert_eq!(streamed, rendered_strs);
+
+        // Also assert exact expected plain strings for clarity.
+        let expected = vec![
+            "Loose vs. tight list items:".to_string(),
+            "".to_string(),
+            "1. Tight item".to_string(),
+            "2. Another tight item".to_string(),
+            "3. Loose item with its own paragraph.".to_string(),
+            "".to_string(),
+            "   This paragraph belongs to the same list item.".to_string(),
+            "4. Second loose item with a nested list after a blank line.".to_string(),
+            "    - Nested bullet under a loose item".to_string(),
+            "    - Another nested bullet".to_string(),
+        ];
+        assert_eq!(
+            streamed, expected,
+            "expected exact rendered lines for loose/tight section"
+        );
+    }
+}

codex-rs/tui2/src/streaming/mod.rs

@@ -0,0 +1,39 @@
+use std::collections::VecDeque;
+
+use ratatui::text::Line;
+
+use crate::markdown_stream::MarkdownStreamCollector;
+pub(crate) mod controller;
+
+pub(crate) struct StreamState {
+    pub(crate) collector: MarkdownStreamCollector,
+    queued_lines: VecDeque<Line<'static>>,
+    pub(crate) has_seen_delta: bool,
+}
+
+impl StreamState {
+    pub(crate) fn new(width: Option<usize>) -> Self {
+        Self {
+            collector: MarkdownStreamCollector::new(width),
+            queued_lines: VecDeque::new(),
+            has_seen_delta: false,
+        }
+    }
+    pub(crate) fn clear(&mut self) {
+        self.collector.clear();
+        self.queued_lines.clear();
+        self.has_seen_delta = false;
+    }
+    pub(crate) fn step(&mut self) -> Vec<Line<'static>> {
+        self.queued_lines.pop_front().into_iter().collect()
+    }
+    pub(crate) fn drain_all(&mut self) -> Vec<Line<'static>> {
+        self.queued_lines.drain(..).collect()
+    }
+    pub(crate) fn is_idle(&self) -> bool {
+        self.queued_lines.is_empty()
+    }
+    pub(crate) fn enqueue(&mut self, lines: Vec<Line<'static>>) {
+        self.queued_lines.extend(lines);
+    }
+}