Lightweight coding agent that runs in your terminal
Rust
Add keyboard selection support to the transcript view (#53693)
Felipe Coury31434401fa3c
diff --git a/codex-rs/tui/src/transcript_view.rs b/codex-rs/tui/src/transcript_view.rsindex 9a5d1a62e4..4a2b803537 100644--- a/codex-rs/tui/src/transcript_view.rs+++ b/codex-rs/tui/src/transcript_view.rs@@ -17,6 +17,7 @@ mod layout;mod mutations;mod prompt_header;mod search;+mod select_mode;mod selection;mod snapshot;mod text;@@ -38,6 +39,7 @@ use ratatui::widgets::Widget;use layout::LayoutCache;use search::Search;+use select_mode::SelectMode;use selection::Selection;use snapshot::ViewSnapshot;use text::TextLayout;@@ -126,6 +128,7 @@ pub(crate) struct TranscriptView {suppressed_prompt_header: Option<prompt_header::SuppressedHeader>,visible: Vec<VisibleRow>,selection: Option<Selection>,+ select_mode: Option<SelectMode>,copy_mode: Option<copy_mode::CopyMode>,held_reading: Option<ViewSnapshot>,search: Search,@@ -164,6 +167,7 @@ impl Default for TranscriptView {suppressed_prompt_header: None,visible: Vec::new(),selection: None,+ select_mode: None,copy_mode: None,held_reading: None,search: Search::default(),@@ -313,6 +317,7 @@ impl TranscriptView {self.unseen_activity = false;}self.render_selection(buf);+ self.render_select_cursor(buf);if self.history == TranscriptHistoryState::LoadingBeginning && self.is_following() {self.scroll(current_cells, /*rows*/ 0);}@@ -380,6 +385,7 @@ impl TranscriptView {return;}self.selection = None;+ self.select_mode = None;self.copy_mode = None;self.release_live_reading();self.cache.clear();@@ -397,7 +403,10 @@ impl TranscriptView {}pub(crate) fn has_active_interaction(&self) -> bool {- self.selection.is_some() || self.search.is_active() || self.is_activity_focused()+ self.select_mode.is_some()+ || self.selection.is_some()+ || self.search.is_active()+ || self.is_activity_focused()}pub(crate) fn is_detailed(&self) -> bool {@@ -405,7 +414,7 @@ impl TranscriptView {}pub(crate) fn is_following(&self) -> bool {- self.selection.is_none() && self.position == Position::Latest+ self.select_mode.is_none() && self.selection.is_none() && self.position == Position::Latest}/// Hold the current reading position until every older page has arrived.@@ -426,6 +435,7 @@ impl TranscriptView {self.cancel_beginning();self.position = Position::Latest;self.selection = None;+ self.select_mode = None;self.copy_mode = None;self.release_live_reading();self.unseen_activity = false;diff --git a/codex-rs/tui/src/transcript_view/input.rs b/codex-rs/tui/src/transcript_view/input.rsindex bf3a479bb1..f5bf119402 100644--- a/codex-rs/tui/src/transcript_view/input.rs+++ b/codex-rs/tui/src/transcript_view/input.rs@@ -20,6 +20,7 @@ use super::*;pub(crate) enum ViewAction {Changed,+ ExitSelectMode,Copy(String),CopyOnSelect(String),PrimarySelection(String),@@ -96,6 +97,7 @@ impl TranscriptView {clear_selection: self.copy_on_select_clear_selection,},ViewAction::Changed+ | ViewAction::ExitSelectMode| ViewAction::PrimarySelection(_)| ViewAction::Copy(_)| ViewAction::CopyAndFollow(_)@@ -159,6 +161,9 @@ impl TranscriptView {if self.copy_mode.is_some() {return true;}+ if self.select_mode.is_some() {+ return true;+ }if self.selection.is_some() {return crate::text_selection::is_copy_key(key)|| code == KeyCode::Esc@@ -192,6 +197,11 @@ impl TranscriptView {if let Some(action) = self.handle_copy_mode_key(key, cells) {return Some(action);}+ if self.select_mode.is_some() {+ return self+ .handle_select_mode_key(key, cells)+ .or(Some(ViewAction::Changed));+ }if let Some(action) = self.handle_disclosure_key(key, cells) {return Some(action);}@@ -221,6 +231,9 @@ impl TranscriptView {event: MouseEvent,cells: &[Arc<dyn HistoryCell>],) -> Option<ViewAction> {+ if self.select_mode.is_some() {+ return self.handle_selection_mouse(event, cells);+ }self.handle_mouse_with_mode(event, cells, MouseMode::Interactive)}diff --git a/codex-rs/tui/src/transcript_view/select_mode.rs b/codex-rs/tui/src/transcript_view/select_mode.rsnew file mode 100644index 0000000000..562a812b3b--- /dev/null+++ b/codex-rs/tui/src/transcript_view/select_mode.rs@@ -0,0 +1,266 @@+//! Keyboard-owned transcript cursor and mark state over the existing selection snapshot.+//!+//! An empty `Selection` is the caret. Marking only records its fixed and active anchors here;+//! copying, retained revisions, serialization, and asynchronous completion remain owned by+//! `Selection`.++use super::*;+use crate::text_selection::SelectionUnit;+use crossterm::event::KeyCode;+use crossterm::event::KeyEvent;+use crossterm::event::KeyEventKind;+use crossterm::event::KeyModifiers;+use ratatui::buffer::Buffer;+use ratatui::layout::Rect;++mod motion;++#[derive(Clone, Copy, Default)]+pub(super) struct SelectMode {+ pub(super) mark: Option<Mark>,+ pub(super) preferred_column: Option<u16>,+}++#[derive(Clone, Copy)]+pub(super) struct Mark {+ anchor: Anchor,+ active: Anchor,+}++#[derive(Clone, Copy)]+enum CursorMotion {+ Character(KeyCode),+ Rows(isize),+}++impl SelectMode {+ pub(super) fn cursor(self, selection: &Selection) -> Anchor {+ self.mark.map_or(selection.end, |mark| mark.active)+ }+}++impl TranscriptView {+ /// Enter at the bottommost visible selectable position.+ #[cfg_attr(not(test), expect(dead_code, reason = "used by a later stack layer"))]+ pub(crate) fn begin_select_mode(&mut self, cells: &[Arc<dyn HistoryCell>]) -> bool {+ if self.select_mode.is_some() {+ return true;+ }+ self.copy_mode = None;+ self.cancel_beginning();+ if self.selection.is_none() {+ let cursor = self+ .visible+ .iter()+ .rev()+ .find_map(|visible| {+ let offset = visible.layout.first_cursor_position(visible.row)?;+ Some(Anchor {+ key: visible.key,+ index: visible.index,+ offset,+ row_bias: visible.layout.row_for_offset(offset) as isize+ - visible.row as isize,+ })+ })+ .or_else(|| self.select_boundary(cells, /*end*/ true));+ let Some(cursor) = cursor else {+ return false;+ };+ let snapshot = self.capture_snapshot(cells);+ self.selection = Some(Selection::keyboard(snapshot, cursor));+ }+ if self.position == Position::Latest {+ self.hold_position();+ }+ self.select_mode = Some(SelectMode::default());+ self.reveal_select_cursor(cells);+ true+ }++ /// Leave the mode while retaining its displayed revision at the paused reading position.+ pub(crate) fn end_select_mode(&mut self) {+ if self.select_mode.take().is_none() {+ return;+ }+ self.cancel_beginning();+ if self.position == Position::Latest {+ self.hold_position();+ }+ if let Some(selection) = self.selection.take() {+ self.held_reading = Some(selection.snapshot);+ }+ }++ pub(crate) fn handle_select_mode_key(+ &mut self,+ key: KeyEvent,+ cells: &[Arc<dyn HistoryCell>],+ ) -> Option<ViewAction> {+ if self.select_mode.is_none() || key.kind == KeyEventKind::Release {+ return None;+ }+ let (code, modifiers) = crate::key_hint::normalize_key_parts(key.code, key.modifiers);+ let pressed = key.kind == KeyEventKind::Press;+ if crate::text_selection::is_copy_key(key)+ || (code == KeyCode::Char('y') && modifiers == KeyModifiers::NONE)+ || (code == KeyCode::Enter+ && modifiers == KeyModifiers::NONE+ && key.kind == KeyEventKind::Press)+ {+ let Some(text) = self.selected_text(cells).filter(|text| !text.is_empty()) else {+ if code == KeyCode::Enter {+ return Some(self.exit_select_mode());+ }+ return Some(ViewAction::Changed);+ };+ return Some(if code == KeyCode::Enter {+ ViewAction::CopyAndFollow(text)+ } else {+ ViewAction::Copy(text)+ });+ }+ if pressed && code == KeyCode::Esc && modifiers == KeyModifiers::NONE {+ if self.select_mode.is_some_and(|mode| mode.mark.is_some()) {+ self.clear_select_mark();+ return Some(ViewAction::Changed);+ }+ return Some(self.exit_select_mode());+ }+ if pressed && code == KeyCode::Char('q') && modifiers == KeyModifiers::NONE {+ return Some(self.exit_select_mode());+ }+ if pressed+ && matches!(code, KeyCode::Char('v') | KeyCode::Char(' '))+ && modifiers == KeyModifiers::NONE+ {+ self.start_select_mark(cells);+ return Some(ViewAction::Changed);+ }++ let shift_arrow = modifiers == KeyModifiers::SHIFT+ && matches!(+ code,+ KeyCode::Left | KeyCode::Right | KeyCode::Up | KeyCode::Down+ );+ if shift_arrow && self.select_mode.is_some_and(|mode| mode.mark.is_none()) {+ self.start_select_mark(cells);+ }+ let motion = match (code, modifiers) {+ (+ KeyCode::Left | KeyCode::Right | KeyCode::Up | KeyCode::Down,+ KeyModifiers::NONE | KeyModifiers::SHIFT,+ ) => {+ if matches!(code, KeyCode::Up | KeyCode::Down) {+ CursorMotion::Rows(if code == KeyCode::Up { -1 } else { 1 })+ } else {+ CursorMotion::Character(code)+ }+ }+ (KeyCode::Char('h'), KeyModifiers::NONE) => CursorMotion::Character(KeyCode::Left),+ (KeyCode::Char('l'), KeyModifiers::NONE) => CursorMotion::Character(KeyCode::Right),+ (KeyCode::Char('k'), KeyModifiers::NONE) => CursorMotion::Rows(-1),+ (KeyCode::Char('j'), KeyModifiers::NONE) => CursorMotion::Rows(1),+ _ => return None,+ };+ self.move_select_cursor(cells, motion);+ Some(ViewAction::Changed)+ }++ fn exit_select_mode(&mut self) -> ViewAction {+ self.end_select_mode();+ ViewAction::ExitSelectMode+ }++ fn start_select_mark(&mut self, cells: &[Arc<dyn HistoryCell>]) {+ let Some(mut mode) = self.select_mode else {+ return;+ };+ let Some(selection) = self.selection.as_ref() else {+ return;+ };+ let cursor = mode.cursor(selection);+ mode.mark = match mode.mark {+ Some(_) => {+ self.clear_select_mark();+ return;+ }+ None => Some(Mark {+ anchor: cursor,+ active: cursor,+ }),+ };+ mode.preferred_column = None;+ self.select_mode = Some(mode);+ self.sync_select_range(cells);+ }++ fn clear_select_mark(&mut self) {+ let Some(mode) = &mut self.select_mode else {+ return;+ };+ let Some(selection) = &mut self.selection else {+ return;+ };+ let cursor = mode.cursor(selection);+ mode.mark = None;+ mode.preferred_column = None;+ selection.set_keyboard_range(cursor, cursor);+ }++ fn reveal_select_cursor(&mut self, cells: &[Arc<dyn HistoryCell>]) {+ let Some(mode) = self.select_mode else {+ return;+ };+ let Some(selection) = self.selection.as_ref() else {+ return;+ };+ let cursor = mode.cursor(selection);+ let index = self.resolve(cells, cursor);+ let row = self.layout(cells, index).map_or(/*default*/ 0, |layout| {+ layout+ .row_for_offset(cursor.offset)+ .saturating_add_signed(cursor.row_bias.saturating_neg())+ });+ if !self+ .visible+ .iter()+ .any(|visible| visible.index == index && visible.row == row)+ {+ self.position = Position::Reading(Anchor { index, ..cursor });+ }+ }++ pub(super) fn render_select_cursor(&self, buf: &mut Buffer) {+ let (Some(mode), Some(selection)) = (self.select_mode, self.selection.as_ref()) else {+ return;+ };+ let cursor = mode.cursor(selection);+ let Some((y, visible)) = self.visible.iter().enumerate().find(|(_, visible)| {+ visible.key == cursor.key+ && visible.row+ == visible+ .layout+ .row_for_offset(cursor.offset)+ .saturating_add_signed(cursor.row_bias.saturating_neg())+ }) else {+ return;+ };+ let column = visible+ .layout+ .column_for_offset_on_row(visible.row, cursor.offset);+ if column < self.area.width {+ let area = Rect::new(+ self.area.x + column,+ self.area.y + y as u16,+ /*width*/ 1,+ /*height*/ 1,+ );+ buf.set_style(area, crate::style::selection_style().underlined());+ }+ }+}++#[cfg(test)]+#[path = "select_mode_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/transcript_view/select_mode/motion.rs b/codex-rs/tui/src/transcript_view/select_mode/motion.rsnew file mode 100644index 0000000000..d9198b9348--- /dev/null+++ b/codex-rs/tui/src/transcript_view/select_mode/motion.rs@@ -0,0 +1,235 @@+//! Basic cursor motions and marked-range derivation for keyboard transcript selection.++use super::*;+use crossterm::event::KeyCode;+use unicode_segmentation::UnicodeSegmentation;++impl TranscriptView {+ pub(super) fn move_select_cursor(+ &mut self,+ cells: &[Arc<dyn HistoryCell>],+ motion: CursorMotion,+ ) {+ let Some(mut mode) = self.select_mode else {+ return;+ };+ self.cancel_beginning();+ let Some(selection) = self.selection.as_ref() else {+ return;+ };+ let cursor = mode.cursor(selection);+ let snapshot = self.snapshot_cells();+ let cells = snapshot.as_deref().unwrap_or(cells);+ let next = match motion {+ CursorMotion::Character(code) => {+ mode.preferred_column = None;+ self.move_select_character(cells, cursor, code)+ }+ CursorMotion::Rows(rows) => {+ let index = self.resolve(cells, cursor);+ let layout = self.layout(cells, index);+ let column = mode.preferred_column.or_else(|| {+ layout.as_ref().map(|layout| {+ let row = layout+ .row_for_offset(cursor.offset)+ .saturating_add_signed(cursor.row_bias.saturating_neg());+ layout.column_for_offset_on_row(row, cursor.offset)+ })+ });+ mode.preferred_column = column;+ self.move_select_rows(cells, cursor, rows, column)+ }+ };+ let Some(next) = next else {+ self.select_mode = Some(mode);+ return;+ };+ if let Some(mark) = &mut mode.mark {+ mark.active = next;+ } else if let Some(selection) = &mut self.selection {+ selection.set_keyboard_range(next, next);+ }+ self.select_mode = Some(mode);+ self.sync_select_range(cells);+ self.reveal_select_cursor(cells);+ }++ fn move_select_character(+ &mut self,+ cells: &[Arc<dyn HistoryCell>],+ cursor: Anchor,+ code: KeyCode,+ ) -> Option<Anchor> {+ let mut index = self.resolve(cells, cursor);+ let layout = self.layout(cells, index)?;+ let offset = layout+ .text()+ .floor_char_boundary(cursor.offset.min(layout.text().len()));+ let local = match code {+ KeyCode::Left if offset > 0 => selectable_graphemes(&layout.text()[..offset])+ .rfind(|(offset, _)| layout.is_cursor_position(*offset))+ .map(|(offset, _)| offset),+ KeyCode::Right if offset < layout.text().len() => {+ selectable_graphemes(&layout.text()[offset..])+ .filter(|(next, _)| layout.is_cursor_position(offset + *next))+ .find(|(next, _)| cursor.row_bias != 0 || *next > 0)+ .map(|(next, _)| offset + next)+ }+ _ => None,+ };+ if let Some(offset) = local {+ return Some(Anchor {+ key: self.entry_key(cells, index),+ index,+ offset,+ row_bias: 0,+ });+ }+ loop {+ index = match code {+ KeyCode::Left => index.checked_sub(1)?,+ KeyCode::Right => index + 1,+ _ => return None,+ };+ let next = self.layout(cells, index)?;+ let offset = match code {+ KeyCode::Left => selectable_graphemes(next.text())+ .rfind(|(offset, _)| next.is_cursor_position(*offset))+ .map(|(offset, _)| offset),+ KeyCode::Right => selectable_graphemes(next.text())+ .find(|(offset, _)| next.is_cursor_position(*offset))+ .map(|(offset, _)| offset),+ _ => None,+ };+ if let Some(offset) = offset {+ return Some(Anchor {+ key: self.entry_key(cells, index),+ index,+ offset,+ row_bias: 0,+ });+ }+ }+ }++ fn move_select_rows(+ &mut self,+ cells: &[Arc<dyn HistoryCell>],+ mut cursor: Anchor,+ rows: isize,+ column: Option<u16>,+ ) -> Option<Anchor> {+ let code = if rows < 0 { KeyCode::Up } else { KeyCode::Down };+ for _ in 0..rows.unsigned_abs() {+ let Some(mut next) = self.move_selection_endpoint(cells, cursor, code, column) else {+ break;+ };+ let index = self.resolve(cells, next);+ if let Some(layout) = self.layout(cells, index) {+ let row = layout+ .row_for_offset(next.offset)+ .saturating_add_signed(next.row_bias.saturating_neg());+ next.offset = layout.cursor_position_at(row, column.unwrap_or_default());+ next.row_bias = layout.row_for_offset(next.offset) as isize - row as isize;+ }+ if next == cursor {+ break;+ }+ cursor = next;+ }+ Some(cursor)+ }++ pub(super) fn select_boundary(+ &mut self,+ cells: &[Arc<dyn HistoryCell>],+ end: bool,+ ) -> Option<Anchor> {+ let count = cells.len() + usize::from(self.layout(cells, cells.len()).is_some());+ let mut index = if end { count.checked_sub(1)? } else { 0 };+ loop {+ let layout = self.layout(cells, index)?;+ let offset = if end {+ selectable_graphemes(layout.text())+ .rfind(|(offset, _)| layout.is_cursor_position(*offset))+ .map(|(offset, _)| offset)+ } else {+ selectable_graphemes(layout.text())+ .find(|(offset, _)| layout.is_cursor_position(*offset))+ .map(|(offset, _)| offset)+ };+ if let Some(offset) = offset {+ return Some(Anchor {+ key: self.entry_key(cells, index),+ index,+ offset,+ row_bias: 0,+ });+ }+ if end {+ index = index.checked_sub(1)?;+ } else {+ index += 1;+ if index >= count {+ return None;+ }+ }+ }+ }++ pub(super) fn sync_select_range(&mut self, cells: &[Arc<dyn HistoryCell>]) {+ let Some(mark) = self.select_mode.and_then(|mode| mode.mark) else {+ return;+ };+ let snapshot = self.snapshot_cells();+ let cells = snapshot.as_deref().unwrap_or(cells);+ let after_anchor = self.after_grapheme(cells, mark.anchor);+ let after_active = self.after_grapheme(cells, mark.active);+ let Some(mut selection) = self.selection.take() else {+ return;+ };+ let (start, end) =+ if self.anchor_order(cells, mark.anchor) <= self.anchor_order(cells, mark.active) {+ (mark.anchor, after_active)+ } else {+ (after_anchor, mark.active)+ };+ selection.set_keyboard_marked_range(+ start,+ end,+ (mark.anchor, after_anchor),+ SelectionUnit::Character,+ );+ self.pin_selection_range(cells, &mut selection);+ self.selection = Some(selection);+ }++ fn after_grapheme(&mut self, cells: &[Arc<dyn HistoryCell>], anchor: Anchor) -> Anchor {+ let index = self.resolve(cells, anchor);+ let Some(layout) = self.layout(cells, index) else {+ return anchor;+ };+ let offset = layout+ .text()+ .floor_char_boundary(anchor.offset.min(layout.text().len()));+ let row = layout+ .row_for_offset(offset)+ .saturating_add_signed(anchor.row_bias.saturating_neg());+ let offset = layout.after_cursor_grapheme(row, offset);+ Anchor {+ key: self.entry_key(cells, index),+ index,+ offset,+ row_bias: 0,+ }+ }++ fn anchor_order(&self, cells: &[Arc<dyn HistoryCell>], anchor: Anchor) -> (usize, usize) {+ (self.resolve(cells, anchor), anchor.offset)+ }+}++fn selectable_graphemes(text: &str) -> impl DoubleEndedIterator<Item = (usize, &str)> {+ text.grapheme_indices(/*is_extended*/ true)+ .filter(|(_, grapheme)| !grapheme.contains('\n'))+}diff --git a/codex-rs/tui/src/transcript_view/select_mode_tests.rs b/codex-rs/tui/src/transcript_view/select_mode_tests.rsnew file mode 100644index 0000000000..61eed90e33--- /dev/null+++ b/codex-rs/tui/src/transcript_view/select_mode_tests.rs@@ -0,0 +1,148 @@+use super::*;+use crate::history_cell::PlainHistoryCell;+use pretty_assertions::assert_eq;+use ratatui::text::Line;++fn cell(lines: &[&str]) -> Arc<dyn HistoryCell> {+ Arc::new(PlainHistoryCell::new(+ lines+ .iter()+ .map(|line| Line::from((*line).to_owned()))+ .collect(),+ ))+}++fn render(view: &mut TranscriptView, cells: &[Arc<dyn HistoryCell>]) -> Buffer {+ let area = Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 32, /*height*/ 6,+ );+ let mut buffer = Buffer::empty(area);+ view.render(area, &mut buffer, cells);+ buffer+}++fn press(view: &mut TranscriptView, cells: &[Arc<dyn HistoryCell>], code: KeyCode) {+ assert!(matches!(+ view.handle_key(KeyEvent::new(code, KeyModifiers::NONE), cells),+ Some(ViewAction::Changed)+ ));+}++#[test]+fn entry_starts_on_the_last_selectable_visible_line() {+ for (cells, expected) in [+ (vec![cell(&["top"]), cell(&["bottom"])], "b"),+ (vec![cell(&["text"]), cell(&[""])], "t"),+ (vec![cell(&["abc", "", "", "", "", "", ""])], "c"),+ ] {+ let mut view = TranscriptView::default();+ render(&mut view, &cells);+ assert!(view.begin_select_mode(&cells));+ press(&mut view, &cells, KeyCode::Char('v'));+ assert_eq!(view.selected_text(&cells).as_deref(), Some(expected));+ }++ let cells = vec![cell(&["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])];+ let mut view = TranscriptView::default();+ render(&mut view, &cells);+ view.scroll(&cells, /*rows*/ -2);+ render(&mut view, &cells);+ assert!(view.begin_select_mode(&cells));+ press(&mut view, &cells, KeyCode::Char('v'));+ assert_eq!(view.selected_text(&cells).as_deref(), Some("h"));++ let cells = vec![cell(&["a", "", "", "", "", "", "", "", "", ""])];+ let mut view = TranscriptView::default();+ render(&mut view, &cells);+ assert!(view.begin_select_mode(&cells));+ assert!(matches!(view.position, Position::Reading(_)));++ let cells = vec![cell(&[""])];+ let mut view = TranscriptView::default();+ render(&mut view, &cells);+ assert!(!view.begin_select_mode(&cells));+}++#[test]+fn character_motion_crosses_line_and_entry_boundaries_without_invisible_stops() {+ let cells = vec![cell(&["a", ""]), cell(&[""]), cell(&["", "b"])];+ let mut view = TranscriptView::default();+ render(&mut view, &cells);+ assert!(view.begin_select_mode(&cells));+ press(&mut view, &cells, KeyCode::Left);+ press(&mut view, &cells, KeyCode::Char('v'));+ assert_eq!(view.selected_text(&cells).as_deref(), Some("a"));++ press(&mut view, &cells, KeyCode::Esc);+ press(&mut view, &cells, KeyCode::Right);+ press(&mut view, &cells, KeyCode::Char('v'));+ assert_eq!(view.selected_text(&cells).as_deref(), Some("b"));++ let cells = vec![cell(&["ab"])];+ let mut view = TranscriptView::default();+ render(&mut view, &cells);+ assert!(view.begin_select_mode(&cells));+ let separator = Anchor {+ key: EntryKey::cell(&cells[0]),+ index: 0,+ offset: 0,+ row_bias: 1,+ };+ view.selection+ .as_mut()+ .expect("selection")+ .set_keyboard_range(separator, separator);+ press(&mut view, &cells, KeyCode::Right);+ press(&mut view, &cells, KeyCode::Char('v'));+ assert_eq!(view.selected_text(&cells).as_deref(), Some("a"));++ let wrapped = format!("{} one", "1234567890".repeat(3));+ let cells = vec![cell(&[&wrapped])];+ let mut view = TranscriptView::default();+ render(&mut view, &cells);+ assert!(view.begin_select_mode(&cells));+ press(&mut view, &cells, KeyCode::Left);+ press(&mut view, &cells, KeyCode::Char('v'));+ assert_eq!(view.selected_text(&cells).as_deref(), Some("0"));+}++#[test]+fn vertical_motion_keeps_the_preferred_display_column() {+ let cells = vec![cell(&["abcdef", "x", "abcdef"])];+ let mut view = TranscriptView::default();+ render(&mut view, &cells);+ assert!(view.begin_select_mode(&cells));+ for _ in 0..3 {+ press(&mut view, &cells, KeyCode::Right);+ }+ press(&mut view, &cells, KeyCode::Up);+ press(&mut view, &cells, KeyCode::Up);+ press(&mut view, &cells, KeyCode::Char('v'));+ assert_eq!(view.selected_text(&cells).as_deref(), Some("d"));+}++#[test]+fn enter_without_a_mark_exits_but_enter_with_a_mark_copies_and_follows() {+ let cells = vec![cell(&["copy me"])];+ let mut view = TranscriptView::default();+ render(&mut view, &cells);+ assert!(view.begin_select_mode(&cells));+ assert!(matches!(+ view.handle_key(KeyCode::Enter.into(), &cells),+ Some(ViewAction::ExitSelectMode)+ ));++ assert!(view.begin_select_mode(&cells));+ press(&mut view, &cells, KeyCode::Char('v'));+ assert!(matches!(+ view.handle_key(+ KeyEvent::new_with_kind(KeyCode::Char('v'), KeyModifiers::NONE, KeyEventKind::Repeat,),+ &cells,+ ),+ Some(ViewAction::Changed)+ ));+ assert!(matches!(+ view.handle_key(KeyCode::Enter.into(), &cells),+ Some(ViewAction::CopyAndFollow(text)) if text == "c"+ ));+}diff --git a/codex-rs/tui/src/transcript_view/selection.rs b/codex-rs/tui/src/transcript_view/selection.rsindex 9d3c9d4852..b6cae02895 100644--- a/codex-rs/tui/src/transcript_view/selection.rs+++ b/codex-rs/tui/src/transcript_view/selection.rs@@ -41,6 +41,51 @@ pub(super) struct Selection {preferred_column: Option<u16>,}+impl Selection {+ pub(super) fn keyboard(snapshot: ViewSnapshot, cursor: Anchor) -> Self {+ Self {+ pending_copy: None,+ primary_owner: None,+ snapshot,+ start: cursor,+ end: cursor,+ dragging: false,+ moved: true,+ moved_vertically: false,+ pointer_origin_row: 0,+ resume_on_empty: false,+ pointer: None,+ pressed_link: None,+ origin: (cursor, cursor),+ unit: SelectionUnit::Character,+ preferred_column: None,+ }+ }++ pub(super) fn set_keyboard_range(&mut self, start: Anchor, end: Anchor) {+ if (self.start, self.end) != (start, end) {+ self.primary_owner = None;+ self.pending_copy = None;+ }+ self.start = start;+ self.end = end;+ self.origin = (start, end);+ self.preferred_column = None;+ }++ pub(super) fn set_keyboard_marked_range(+ &mut self,+ start: Anchor,+ end: Anchor,+ origin: (Anchor, Anchor),+ unit: SelectionUnit,+ ) {+ self.set_keyboard_range(start, end);+ self.origin = origin;+ self.unit = unit;+ }+}+impl TranscriptView {pub(super) fn select_copy_range(&mut self,@@ -139,6 +184,14 @@ impl TranscriptView {let Some(selection) = self.selection.take() else {return;};+ if let Some(mode) = &mut self.select_mode {+ let cursor = mode.cursor(&selection);+ mode.mark = None;+ let mut selection = selection;+ selection.set_keyboard_range(cursor, cursor);+ self.selection = Some(selection);+ return;+ }let empty = (selection.start.key, selection.start.offset)== (selection.end.key, selection.end.offset);if empty && selection.resume_on_empty {@@ -394,7 +447,9 @@ impl TranscriptView {self.publish_primary(tui, text);return None;}- ViewAction::Changed | ViewAction::OpenLink(_) => return None,+ ViewAction::Changed | ViewAction::ExitSelectMode | ViewAction::OpenLink(_) => {+ return None;+ }};let selection_copy = self.selection_copy(action);let clear_selection = selection_copy.clear_selection();@@ -695,7 +750,11 @@ impl TranscriptView {}}- fn pin_selection_range(&mut self, cells: &[Arc<dyn HistoryCell>], selection: &mut Selection) {+ pub(super) fn pin_selection_range(+ &mut self,+ cells: &[Arc<dyn HistoryCell>],+ selection: &mut Selection,+ ) {selection.start.index = self.resolve(cells, selection.start);selection.end.index = self.resolve(cells, selection.end);for index in selection.start.index.min(selection.end.index)@@ -710,7 +769,7 @@ impl TranscriptView {}}- fn move_selection_endpoint(+ pub(super) fn move_selection_endpoint(&mut self,cells: &[Arc<dyn HistoryCell>],end: Anchor,diff --git a/codex-rs/tui/src/transcript_view/text.rs b/codex-rs/tui/src/transcript_view/text.rsindex 282925dfd4..4aac01ddda 100644--- a/codex-rs/tui/src/transcript_view/text.rs+++ b/codex-rs/tui/src/transcript_view/text.rs@@ -314,6 +314,53 @@ impl TextLayout {row.source.end}+ /// Resolve a keyboard caret to a grapheme start while leaving truly empty rows blank.+ pub(super) fn cursor_position_at(&self, row: usize, column: u16) -> usize {+ let offset = self.position_at(row, column);+ let Some(row) = self.rows.get(row) else {+ return offset;+ };+ if row.source.start == row.source.end || offset < row.source.end {+ return offset;+ }+ self.text[row.source.clone()]+ .grapheme_indices(/*is_extended*/ true)+ .next_back()+ .map_or(row.source.start, |(offset, _)| row.source.start + offset)+ }++ /// Return the first selectable source grapheme on a display row, excluding synthetic rows.+ pub(super) fn first_cursor_position(&self, row: usize) -> Option<usize> {+ let row = self.rows.get(row)?;+ self.text[row.source.clone()]+ .grapheme_indices(/*is_extended*/ true)+ .next()+ .map(|(offset, _)| row.source.start + offset)+ }++ /// Whether a source grapheme is actually painted on a display row.+ pub(super) fn is_cursor_position(&self, offset: usize) -> bool {+ self.rows.iter().any(|row| row.source.contains(&offset))+ }++ /// Advance one grapheme inside the caret's display row without crossing an empty row.+ pub(super) fn after_cursor_grapheme(&self, row: usize, offset: usize) -> usize {+ let Some(row) = self.rows.get(row) else {+ return offset;+ };+ if row.source.start == row.source.end {+ return offset;+ }+ let offset = self+ .text+ .floor_char_boundary(offset.clamp(row.source.start, row.source.end));+ offset+ + self.text[offset..row.source.end]+ .graphemes(/*is_extended*/ true)+ .next()+ .map_or(/*default*/ 0, str::len)+ }+/// Find the display row containing a source position, including omitted wrapping whitespace.pub(super) fn row_for_offset(&self, offset: usize) -> usize {let before_control = if let Some(control_row) = self.disclosure_row() {@@ -332,7 +379,12 @@ impl TextLayout {}pub(super) fn column_for_offset(&self, offset: usize) -> u16 {- let Some(row) = self.rows.get(self.row_for_offset(offset)) else {+ self.column_for_offset_on_row(self.row_for_offset(offset), offset)+ }++ /// Resolve a source position within a specific display row when offsets are shared.+ pub(super) fn column_for_offset_on_row(&self, row: usize, offset: usize) -> u16 {+ let Some(row) = self.rows.get(row) else {return 0;};let offset = self