Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Preserve logical source text and styles across TUI wrapping (#46708)

Eric Trautfcaa035438e4
diff --git a/codex-rs/tui/src/chatwidget/realtime_split_flap.rs b/codex-rs/tui/src/chatwidget/realtime_split_flap.rs
index f9635c52cc..50f0b8c57e 100644
--- a/codex-rs/tui/src/chatwidget/realtime_split_flap.rs
+++ b/codex-rs/tui/src/chatwidget/realtime_split_flap.rs
@@ -164,6 +164,8 @@ impl SplitFlapTranscriptCell {
continue;
}
+ // Animated glyphs and board padding no longer map to authored source bytes.
+ line.source = None;
let original_spans = std::mem::take(&mut line.line.spans);
line.line.style = line.line.style.patch(board_style);
for span in original_spans {
diff --git a/codex-rs/tui/src/chatwidget/realtime_split_flap_tests.rs b/codex-rs/tui/src/chatwidget/realtime_split_flap_tests.rs
index bece1513be..5007f5382f 100644
--- a/codex-rs/tui/src/chatwidget/realtime_split_flap_tests.rs
+++ b/codex-rs/tui/src/chatwidget/realtime_split_flap_tests.rs
@@ -90,11 +90,12 @@ fn split_flap_frames_assemble_a_transcript_from_dark_tiles() {
#[test]
fn split_flap_paints_the_entire_transcript_row_black() {
let cell = cell("GATE", MotionMode::Animated);
- let lines = cell.animate_lines(
- cell.inner.display_hyperlink_lines(/*width*/ 12),
- /*width*/ 12,
- Duration::ZERO,
- );
+ let mut source_lines = cell.inner.display_hyperlink_lines(/*width*/ 12);
+ source_lines[0].source = Some(crate::terminal_hyperlinks::LogicalLineSource::from_line(
+ &source_lines[0].line,
+ ));
+ let lines = cell.animate_lines(source_lines, /*width*/ 12, Duration::ZERO);
+ assert!(lines[0].source.is_none());
let area = Rect::new(
/*x*/ 0, /*y*/ 0, /*width*/ 12, /*height*/ 1,
);
diff --git a/codex-rs/tui/src/history_cell/base.rs b/codex-rs/tui/src/history_cell/base.rs
index 44db928e47..15ab8638f5 100644
--- a/codex-rs/tui/src/history_cell/base.rs
+++ b/codex-rs/tui/src/history_cell/base.rs
@@ -80,13 +80,24 @@ impl PrefixedWrappedHistoryCell {
impl HistoryCell for PrefixedWrappedHistoryCell {
fn display_lines(&self, width: u16) -> Vec<Line<'static>> {
+ visible_lines(self.display_hyperlink_lines(width))
+ }
+
+ fn display_hyperlink_lines(&self, width: u16) -> Vec<HyperlinkLine> {
if width == 0 {
return Vec::new();
}
- let opts = RtOptions::new(width.max(1) as usize)
+ let opts = RtOptions::new(usize::from(width))
.initial_indent(self.initial_prefix.clone())
.subsequent_indent(self.subsequent_prefix.clone());
- adaptive_wrap_lines(&self.text, opts)
+ crate::terminal_hyperlinks::adaptive_wrap_hyperlink_lines(
+ &plain_hyperlink_lines(self.text.lines.clone()),
+ opts,
+ )
+ }
+
+ fn transcript_hyperlink_lines(&self, width: u16) -> Vec<HyperlinkLine> {
+ self.display_hyperlink_lines(width)
}
fn raw_lines(&self) -> Vec<Line<'static>> {
@@ -173,3 +184,7 @@ impl HistoryCell for CompositeHistoryCell {
false
}
}
+
+#[cfg(test)]
+#[path = "base_tests.rs"]
+mod tests;
diff --git a/codex-rs/tui/src/history_cell/base_tests.rs b/codex-rs/tui/src/history_cell/base_tests.rs
new file mode 100644
index 0000000000..fbcbb7cbad
--- /dev/null
+++ b/codex-rs/tui/src/history_cell/base_tests.rs
@@ -0,0 +1,95 @@
+//! Prefixed rows preserve authored whitespace and exclude display gutters from source text.
+
+use super::*;
+use pretty_assertions::assert_eq;
+use std::sync::Arc;
+
+#[test]
+fn prefixed_wrapping_retains_one_source_line_across_widths_and_gutters() {
+ let source = " let result = compute(alpha, beta, gamma); print(result);";
+ let styled = Line::from(vec![
+ " let result = ".into(),
+ "compute".red().bold(),
+ "(alpha, beta, gamma); print(result);".into(),
+ ])
+ .cyan()
+ .italic();
+ let cell = PrefixedWrappedHistoryCell::new(styled, "✔ ".green(), " ");
+ for width in [16, 24, 48] {
+ let lines = cell.transcript_hyperlink_lines(width);
+ let first = lines
+ .first()
+ .expect("wrapped source")
+ .source
+ .as_ref()
+ .expect("source range");
+ assert_eq!(first.text.as_ref(), source);
+ assert_eq!(
+ first.styled_range(0..source.len()),
+ Line::from(vec![
+ " let result = ".cyan().italic(),
+ "compute".red().bold().italic(),
+ "(alpha, beta, gamma); print(result);".cyan().italic(),
+ ])
+ );
+ assert_eq!(first.range.start, 0);
+ let restyled = lines[0].clone().style(Style::new().on_blue());
+ assert_eq!(
+ restyled
+ .source
+ .as_ref()
+ .unwrap()
+ .styled_range(0..source.len()),
+ Line::from(vec![
+ " let result = ".cyan().italic().on_blue(),
+ "compute".red().bold().italic().on_blue(),
+ "(alpha, beta, gamma); print(result);"
+ .cyan()
+ .italic()
+ .on_blue(),
+ ])
+ );
+ for line in &lines {
+ let origin = line.source.as_ref().expect("source range");
+ let visible = line.line.to_string();
+ assert!(Arc::ptr_eq(&origin.text, &first.text));
+ assert_eq!(
+ &visible[origin.prefix_bytes..origin.prefix_bytes + origin.range.len()],
+ &source[origin.range.clone()],
+ );
+ assert!(line.line.width() <= usize::from(width));
+ }
+ assert_eq!(
+ lines
+ .last()
+ .expect("last row")
+ .source
+ .as_ref()
+ .expect("source")
+ .range
+ .end,
+ source.len()
+ );
+ }
+}
+
+#[test]
+fn prefixed_wrapping_keeps_hard_lines_distinct_even_when_their_text_repeats() {
+ let cell = PrefixedWrappedHistoryCell::new(
+ Text::from(vec![
+ Line::from("repeated text"),
+ Line::from("repeated text"),
+ ]),
+ "✔ ",
+ " ",
+ );
+ let lines = cell.transcript_hyperlink_lines(/*width*/ 40);
+ let first = lines[0].source.as_ref().expect("first source");
+ let second = lines[1].source.as_ref().expect("second source");
+ assert_eq!(
+ (first.text.as_ref(), second.text.as_ref()),
+ ("repeated text", "repeated text")
+ );
+ assert!(!Arc::ptr_eq(&first.text, &second.text));
+ assert!(cell.display_hyperlink_lines(/*width*/ 0).is_empty());
+}
diff --git a/codex-rs/tui/src/history_cell/messages.rs b/codex-rs/tui/src/history_cell/messages.rs
index c5c3002c02..555aaf4929 100644
--- a/codex-rs/tui/src/history_cell/messages.rs
+++ b/codex-rs/tui/src/history_cell/messages.rs
@@ -4,10 +4,12 @@
use super::markdown_render_cache::MarkdownRenderCache;
use super::*;
use crate::style::accent_color_on;
+use crate::style::history_prompt_style;
use crate::terminal_hyperlinks::annotate_web_urls_in_line;
-use crate::terminal_hyperlinks::remap_wrapped_line;
+use crate::terminal_hyperlinks::lines_with_sources_eq;
+use crate::terminal_hyperlinks::remap_source_wrapped_line;
use crate::wrapping::url_preserving_wrap_options;
-use crate::wrapping::word_wrap_line;
+use crate::wrapping::word_wrap_line_with_source;
use std::borrow::Cow;
#[derive(Debug)]
@@ -185,9 +187,9 @@ impl HistoryCell for UserHistoryCell {
.saturating_sub(
LIVE_PREFIX_COLS + 1, /* keep a one-column right margin for wrapping */
)
- .max(1);
+ .max(/*other*/ 1);
- let style = user_message_style();
+ let style = history_prompt_style();
let element_style = style.fg(accent_color_on(style.bg));
let wrapped_remote_images = if self.remote_image_urls.is_empty() {
@@ -202,60 +204,7 @@ impl HistoryCell for UserHistoryCell {
}
.filter(|lines| !lines.is_empty());
- let wrapped_message = if message.is_empty() && text_elements.is_empty() {
- None
- } else {
- let wrap_options = RtOptions::new(usize::from(wrap_width))
- .wrap_algorithm(textwrap::WrapAlgorithm::FirstFit);
- let mut wrapped = if text_elements.is_empty() {
- let message_without_trailing_newlines = message.trim_end_matches(['\r', '\n']);
- adaptive_wrap_lines(
- message_without_trailing_newlines
- .split('\n')
- .map(|line| Line::from(line).style(style)),
- wrap_options,
- )
- } else {
- adaptive_wrap_lines(
- build_user_message_lines_with_elements(
- message,
- text_elements,
- style,
- element_style,
- ),
- wrap_options,
- )
- }
- .into_iter()
- .flat_map(|line| {
- if line.width() <= usize::from(wrap_width) {
- return vec![HyperlinkLine::new(line)];
- }
-
- // Terminal autowrap loses the message gutter and background. Explicitly split
- // oversized URL tokens while retaining their complete OSC-8 destination.
- let line = annotate_web_urls_in_line(line);
- let forced_lines = word_wrap_line(
- &line.line,
- url_preserving_wrap_options(RtOptions::new(usize::from(wrap_width)))
- .break_words(/*break_words*/ true),
- )
- .iter()
- .map(line_to_static)
- .collect();
- remap_wrapped_line(&line, forced_lines)
- })
- .collect::<Vec<_>>();
- while wrapped.last().is_some_and(|line| {
- line.line
- .spans
- .iter()
- .all(|span| span.content.trim().is_empty())
- }) {
- wrapped.pop();
- }
- (!wrapped.is_empty()).then_some(wrapped)
- };
+ let wrapped_message = wrap_user_message(message, text_elements, style, wrap_width);
if wrapped_remote_images.is_none() && wrapped_message.is_none() {
return Vec::new();
@@ -287,6 +236,9 @@ impl HistoryCell for UserHistoryCell {
}
lines.push(HyperlinkLine::new(Line::from("").style(style)));
+ for source in lines.iter_mut().filter_map(|line| line.source.as_mut()) {
+ source.right_reserve = 1;
+ }
lines
}
@@ -308,6 +260,61 @@ impl HistoryCell for UserHistoryCell {
}
}
+/// Wrap a prompt body before the user-message gutter and background padding are added.
+fn wrap_user_message(
+ message: &str,
+ text_elements: &[TextElement],
+ style: Style,
+ wrap_width: u16,
+) -> Option<Vec<HyperlinkLine>> {
+ let element_style = style.fg(accent_color_on(style.bg));
+ if message.is_empty() && text_elements.is_empty() {
+ return None;
+ }
+
+ let wrap_options =
+ RtOptions::new(usize::from(wrap_width)).wrap_algorithm(textwrap::WrapAlgorithm::FirstFit);
+ let logical_lines = if text_elements.is_empty() {
+ let message_without_trailing_newlines = message.trim_end_matches(['\r', '\n']);
+ message_without_trailing_newlines
+ .split('\n')
+ .map(|line| Line::from(line.to_owned()).style(style))
+ .collect()
+ } else {
+ build_user_message_lines_with_elements(message, text_elements, style, element_style)
+ };
+ let mut wrapped = crate::terminal_hyperlinks::adaptive_wrap_hyperlink_lines(
+ &plain_hyperlink_lines(logical_lines),
+ wrap_options,
+ )
+ .into_iter()
+ .flat_map(|mut line| {
+ if line.width() <= usize::from(wrap_width) {
+ return vec![line];
+ }
+
+ // Terminal autowrap loses the message gutter and background. Explicitly split
+ // oversized URL tokens while retaining their complete OSC-8 destination.
+ line.hyperlinks = annotate_web_urls_in_line(line.line.clone()).hyperlinks;
+ let forced_lines = word_wrap_line_with_source(
+ &line.line,
+ url_preserving_wrap_options(RtOptions::new(usize::from(wrap_width)))
+ .break_words(/*break_words*/ true),
+ );
+ remap_source_wrapped_line(&line, forced_lines)
+ })
+ .collect::<Vec<_>>();
+ while wrapped.last().is_some_and(|line| {
+ line.line
+ .spans
+ .iter()
+ .all(|span| span.content.trim().is_empty())
+ }) {
+ wrapped.pop();
+ }
+ (!wrapped.is_empty()).then_some(wrapped)
+}
+
#[derive(Debug)]
pub(crate) struct ReasoningSummaryCell {
_header: String,
@@ -522,6 +529,10 @@ fn normalize_whitespace_only_hyperlink_lines(mut lines: Vec<HyperlinkLine>) -> V
{
line.line = Line::default().style(line.line.style);
line.hyperlinks.clear();
+ if let Some(source) = &mut line.source {
+ source.prefix_bytes = 0;
+ source.range.end = source.range.start;
+ }
}
}
lines
@@ -594,13 +605,20 @@ mod tests;
///
/// During streaming, lines that have not yet been committed to scrollback because they belong to
/// an in-progress table are displayed via this cell in the `active_cell` slot. It is replaced on
-/// deltas that change the visible tail and cleared when the stream finalizes.
-#[derive(Debug, Eq, PartialEq)]
+/// deltas that change the visible tail or retained source, and cleared when the stream finalizes.
+#[derive(Debug, Eq)]
pub(crate) struct StreamingAgentTailCell {
lines: Vec<HyperlinkLine>,
is_first_line: bool,
}
+impl PartialEq for StreamingAgentTailCell {
+ fn eq(&self, other: &Self) -> bool {
+ self.is_first_line == other.is_first_line
+ && lines_with_sources_eq(&self.lines, &other.lines)
+ }
+}
+
impl StreamingAgentTailCell {
pub(crate) fn new(lines: Vec<HyperlinkLine>, is_first_line: bool) -> Self {
Self {
diff --git a/codex-rs/tui/src/history_cell/messages_tests.rs b/codex-rs/tui/src/history_cell/messages_tests.rs
index deabffe9ad..8db0126863 100644
--- a/codex-rs/tui/src/history_cell/messages_tests.rs
+++ b/codex-rs/tui/src/history_cell/messages_tests.rs
@@ -234,6 +234,21 @@ fn spoken_artifacts_link_only_real_workspace_files_and_preserve_existing_urls()
span.content == "src/lib.rs:42" && span.style.add_modifier.contains(Modifier::UNDERLINED)
}));
assert_eq!(spoken.raw_lines(), vec![Line::from(markdown)]);
+ for width in [90, 24] {
+ for line in spoken.display_hyperlink_lines(width) {
+ let source = line.source.expect("spoken source");
+ assert!(
+ source
+ .styled_range(0..source.text.len())
+ .spans
+ .iter()
+ .any(|span| {
+ span.content == "src/lib.rs:42"
+ && span.style.add_modifier.contains(Modifier::UNDERLINED)
+ })
+ );
+ }
+ }
insta::assert_snapshot!(
format!(
"{}\n{:?} -> <workspace>/src/lib.rs\n{:?} -> https://example.com",
diff --git a/codex-rs/tui/src/history_cell/mod.rs b/codex-rs/tui/src/history_cell/mod.rs
index be50cc6042..97b7a856d6 100644
--- a/codex-rs/tui/src/history_cell/mod.rs
+++ b/codex-rs/tui/src/history_cell/mod.rs
@@ -33,7 +33,6 @@ use crate::render::line_utils::push_owned_lines;
use crate::render::renderable::Renderable;
use crate::session_state::ThreadSessionState;
use crate::style::proposed_plan_style;
-use crate::style::user_message_style;
use crate::terminal_hyperlinks::HyperlinkLine;
use crate::terminal_hyperlinks::HyperlinkParagraph;
use crate::terminal_hyperlinks::plain_hyperlink_lines;
@@ -83,7 +82,6 @@ use codex_utils_absolute_path::AbsolutePathBuf;
#[cfg(test)]
use codex_utils_cli::format_env_display;
use ratatui::prelude::*;
-use ratatui::style::Color;
use ratatui::style::Modifier;
use ratatui::style::Style;
use ratatui::style::Styled;
diff --git a/codex-rs/tui/src/history_cell/plans.rs b/codex-rs/tui/src/history_cell/plans.rs
index 4847d30ca4..e7545b37a3 100644
--- a/codex-rs/tui/src/history_cell/plans.rs
+++ b/codex-rs/tui/src/history_cell/plans.rs
@@ -2,18 +2,26 @@
use super::markdown_render_cache::MarkdownRenderCache;
use super::*;
+use crate::terminal_hyperlinks::lines_with_sources_eq;
/// Transient active-cell representation of the mutable tail of a proposed-plan stream.
///
/// The controller prepares the full styled plan lines because plan tails need the same header,
/// padding, and background treatment as committed `ProposedPlanStreamCell`s while remaining
/// preview-only during streaming.
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Debug, Eq)]
pub(crate) struct StreamingPlanTailCell {
lines: Vec<HyperlinkLine>,
is_stream_continuation: bool,
}
+impl PartialEq for StreamingPlanTailCell {
+ fn eq(&self, other: &Self) -> bool {
+ self.is_stream_continuation == other.is_stream_continuation
+ && lines_with_sources_eq(&self.lines, &other.lines)
+ }
+}
+
impl StreamingPlanTailCell {
pub(crate) fn new(lines: Vec<HyperlinkLine>, is_stream_continuation: bool) -> Self {
Self {
diff --git a/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__tests__user_image_labels_follow_the_painted_prompt_surface.snap b/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__tests__user_image_labels_follow_the_painted_prompt_surface.snap
index ce43b56f63..2968505509 100644
--- a/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__tests__user_image_labels_follow_the_painted_prompt_surface.snap
+++ b/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__tests__user_image_labels_follow_the_painted_prompt_surface.snap
@@ -1,5 +1,6 @@
---
source: tui/src/history_cell/tests.rs
+assertion_line: 2425
expression: "snapshots.join(\"\\n\")"
---
(255, 255, 255): Buffer {
@@ -13,11 +14,11 @@ expression: "snapshots.join(\"\\n\")"
],
styles: [
x: 0, y: 0, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,
- x: 0, y: 1, fg: Rgb(28, 100, 200), bg: Rgb(244, 244, 244), underline: Reset, modifier: NONE,
+ x: 0, y: 1, fg: Rgb(28, 100, 200), bg: Rgb(249, 249, 249), underline: Reset, modifier: NONE,
x: 12, y: 1, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,
- x: 0, y: 3, fg: Reset, bg: Rgb(244, 244, 244), underline: Reset, modifier: BOLD | DIM,
- x: 2, y: 3, fg: Rgb(28, 100, 200), bg: Rgb(244, 244, 244), underline: Reset, modifier: NONE,
- x: 12, y: 3, fg: Reset, bg: Rgb(244, 244, 244), underline: Reset, modifier: NONE,
+ x: 0, y: 3, fg: Reset, bg: Rgb(249, 249, 249), underline: Reset, modifier: BOLD | DIM,
+ x: 2, y: 3, fg: Rgb(28, 100, 200), bg: Rgb(249, 249, 249), underline: Reset, modifier: NONE,
+ x: 12, y: 3, fg: Reset, bg: Rgb(249, 249, 249), underline: Reset, modifier: NONE,
x: 27, y: 3, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,
]
}
@@ -32,11 +33,11 @@ expression: "snapshots.join(\"\\n\")"
],
styles: [
x: 0, y: 0, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,
- x: 0, y: 1, fg: Rgb(99, 168, 248), bg: Rgb(46, 48, 57), underline: Reset, modifier: NONE,
+ x: 0, y: 1, fg: Rgb(99, 168, 248), bg: Rgb(55, 57, 66), underline: Reset, modifier: NONE,
x: 12, y: 1, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,
- x: 0, y: 3, fg: Reset, bg: Rgb(46, 48, 57), underline: Reset, modifier: BOLD | DIM,
- x: 2, y: 3, fg: Rgb(99, 168, 248), bg: Rgb(46, 48, 57), underline: Reset, modifier: NONE,
- x: 12, y: 3, fg: Reset, bg: Rgb(46, 48, 57), underline: Reset, modifier: NONE,
+ x: 0, y: 3, fg: Reset, bg: Rgb(55, 57, 66), underline: Reset, modifier: BOLD | DIM,
+ x: 2, y: 3, fg: Rgb(99, 168, 248), bg: Rgb(55, 57, 66), underline: Reset, modifier: NONE,
+ x: 12, y: 3, fg: Reset, bg: Rgb(55, 57, 66), underline: Reset, modifier: NONE,
x: 27, y: 3, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,
]
}
@@ -51,11 +52,11 @@ expression: "snapshots.join(\"\\n\")"
],
styles: [
x: 0, y: 0, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,
- x: 0, y: 1, fg: Rgb(243, 248, 254), bg: Rgb(114, 114, 114), underline: Reset, modifier: NONE,
+ x: 0, y: 1, fg: Rgb(5, 9, 14), bg: Rgb(120, 120, 120), underline: Reset, modifier: NONE,
x: 12, y: 1, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,
- x: 0, y: 3, fg: Reset, bg: Rgb(114, 114, 114), underline: Reset, modifier: BOLD | DIM,
- x: 2, y: 3, fg: Rgb(243, 248, 254), bg: Rgb(114, 114, 114), underline: Reset, modifier: NONE,
- x: 12, y: 3, fg: Reset, bg: Rgb(114, 114, 114), underline: Reset, modifier: NONE,
+ x: 0, y: 3, fg: Reset, bg: Rgb(120, 120, 120), underline: Reset, modifier: BOLD | DIM,
+ x: 2, y: 3, fg: Rgb(5, 9, 14), bg: Rgb(120, 120, 120), underline: Reset, modifier: NONE,
+ x: 12, y: 3, fg: Reset, bg: Rgb(120, 120, 120), underline: Reset, modifier: NONE,
x: 27, y: 3, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,
]
}
diff --git a/codex-rs/tui/src/history_cell/spoken_artifacts.rs b/codex-rs/tui/src/history_cell/spoken_artifacts.rs
index ae13971b9d..c44cb43c7f 100644
--- a/codex-rs/tui/src/history_cell/spoken_artifacts.rs
+++ b/codex-rs/tui/src/history_cell/spoken_artifacts.rs
@@ -7,12 +7,14 @@ use crate::width::display_width;
use ratatui::style::Modifier;
use ratatui::text::Span;
use std::path::Path;
+use std::sync::Arc;
const MAX_ARTIFACT_CANDIDATES: usize = 16;
pub(super) fn annotate_spoken_artifacts(lines: &mut [HyperlinkLine], cwd: &Path) {
let mut inspected = 0;
- for line in lines {
+ let mut source_patches = Vec::new();
+ 'lines: for line in &mut *lines {
let text = line
.line
.spans
@@ -46,7 +48,7 @@ pub(super) fn annotate_spoken_artifacts(lines: &mut [HyperlinkLine], cwd: &Path)
}
inspected += 1;
if inspected > MAX_ARTIFACT_CANDIDATES {
- return;
+ break 'lines;
}
let Some(file) = TrustedWorkspaceFile::validate(cwd, path) else {
continue;
@@ -61,6 +63,17 @@ pub(super) fn annotate_spoken_artifacts(lines: &mut [HyperlinkLine], cwd: &Path)
}
line.hyperlinks
.push(TerminalHyperlink::trusted_workspace_file(columns, file));
+ if let Some(source) = &line.source {
+ let start = byte_start.max(source.prefix_bytes);
+ let end = byte_end.min(source.prefix_bytes + source.range.len());
+ if start < end {
+ source_patches.push((
+ Arc::clone(&source.text),
+ source.range.start + start - source.prefix_bytes
+ ..source.range.start + end - source.prefix_bytes,
+ ));
+ }
+ }
let mut offset = 0;
for span in std::mem::take(&mut line.line.spans) {
@@ -91,4 +104,52 @@ pub(super) fn annotate_spoken_artifacts(lines: &mut [HyperlinkLine], cwd: &Path)
}
line.hyperlinks.sort_by_key(|link| link.columns.start);
}
+
+ // Every wrapped fragment must retain all annotations on its shared logical line.
+ while let Some((text, range)) = source_patches.pop() {
+ let mut ranges = vec![range];
+ source_patches.retain(|(other, range)| {
+ if Arc::ptr_eq(&text, other) {
+ ranges.push(range.clone());
+ false
+ } else {
+ true
+ }
+ });
+ let mut sources = lines
+ .iter_mut()
+ .filter_map(|line| line.source.as_mut())
+ .filter(|source| Arc::ptr_eq(&source.text, &text));
+ let Some(first) = sources.next() else {
+ continue;
+ };
+ let mut styles = Vec::new();
+ for (span, style) in first.styles.iter() {
+ let mut boundaries = vec![span.start, span.end];
+ boundaries.extend(
+ ranges
+ .iter()
+ .flat_map(|range| [range.start, range.end])
+ .filter(|offset| span.start < *offset && *offset < span.end),
+ );
+ boundaries.sort_unstable();
+ boundaries.dedup();
+ for pair in boundaries.windows(/*size*/ 2) {
+ let range = pair[0]..pair[1];
+ let style = if ranges
+ .iter()
+ .any(|patch| patch.start < range.end && range.start < patch.end)
+ {
+ style.add_modifier(Modifier::UNDERLINED)
+ } else {
+ *style
+ };
+ styles.push((range, style));
+ }
+ }
+ first.styles = styles.into();
+ for source in sources {
+ source.styles = Arc::clone(&first.styles);
+ }
+ }
}
diff --git a/codex-rs/tui/src/history_cell/tests.rs b/codex-rs/tui/src/history_cell/tests.rs
index 8f3958011b..5cdf6eb781 100644
--- a/codex-rs/tui/src/history_cell/tests.rs
+++ b/codex-rs/tui/src/history_cell/tests.rs
@@ -120,13 +120,17 @@ fn streaming_agent_tail_blank_line_uses_one_viewport_row() {
let cell = StreamingAgentTailCell::new(
vec![
HyperlinkLine::from("first"),
- HyperlinkLine::from(""),
+ HyperlinkLine::from(" "),
HyperlinkLine::from("second"),
],
/*is_first_line*/ false,
);
- let lines = cell.display_lines(/*width*/ 80);
+ let rendered = cell.display_hyperlink_lines(/*width*/ 80);
+ let source = rendered[1].source.as_ref().expect("blank row source");
+ assert_eq!((source.prefix_bytes, source.range.clone()), (0, 0..0));
+ assert_eq!(source.text.as_ref(), " ");
+ let lines = visible_lines(rendered);
insta::assert_snapshot!(render_lines(&lines).join("\n"), @" first
second");
diff --git a/codex-rs/tui/src/insert_history.rs b/codex-rs/tui/src/insert_history.rs
index 73027d7581..e5ad5a277a 100644
--- a/codex-rs/tui/src/insert_history.rs
+++ b/codex-rs/tui/src/insert_history.rs
@@ -332,6 +332,7 @@ fn write_history_line<W: Write>(
})
.collect();
let merged_line = HyperlinkLine {
+ source: None,
line: Line::from(merged_spans),
hyperlinks: line.hyperlinks.clone(),
};
diff --git a/codex-rs/tui/src/markdown_render.rs b/codex-rs/tui/src/markdown_render.rs
index 4cdd619a55..4decb1eb01 100644
--- a/codex-rs/tui/src/markdown_render.rs
+++ b/codex-rs/tui/src/markdown_render.rs
@@ -2001,6 +2001,11 @@ where
}
} else {
let mut spans = self.current_initial_indent.clone();
+ let mut source =
+ crate::terminal_hyperlinks::LogicalLineSource::from_line(&line.line);
+ source.prefix_bytes = spans.iter().map(|span| span.content.len()).sum();
+ source.continuation_indent = self.current_subsequent_indent.clone().into();
+ line.source = Some(source);
let shift = Self::spans_display_width(&spans);
spans.append(&mut line.line.spans);
for hyperlink in &mut line.hyperlinks {
@@ -2180,6 +2185,7 @@ mod markdown_render_tests {
mod tests {
use super::*;
use pretty_assertions::assert_eq;
+ use ratatui::style::Stylize;
use ratatui::text::Text;
fn lines_to_strings(text: &Text<'_>) -> Vec<String> {
@@ -2257,9 +2263,19 @@ mod tests {
#[test]
fn wraps_blockquotes() {
- let markdown = "> block quote with content that should wrap nicely";
- let rendered = render_markdown_text_with_width(markdown, Some(22));
- let lines = lines_to_strings(&rendered);
+ let markdown = "> block quote with **content** that should wrap nicely";
+ let rendered =
+ render_markdown_lines_with_width_and_cwd(markdown, Some(22), /*cwd*/ None);
+ let source = rendered[0].source.as_ref().expect("blockquote source");
+ assert_eq!(
+ source.styled_range(0..source.text.len()),
+ Line::from(vec![
+ "block quote with ".green(),
+ "content".green().bold(),
+ " that should wrap nicely".green(),
+ ])
+ );
+ let lines: Vec<_> = rendered.iter().map(|line| line.line.to_string()).collect();
assert_eq!(
lines,
vec![
diff --git a/codex-rs/tui/src/markdown_render/web_links_tests.rs b/codex-rs/tui/src/markdown_render/web_links_tests.rs
index d503f77417..608f77f406 100644
--- a/codex-rs/tui/src/markdown_render/web_links_tests.rs
+++ b/codex-rs/tui/src/markdown_render/web_links_tests.rs
@@ -79,6 +79,7 @@ fn supporting_terminals_render_only_the_styled_label_and_keep_its_target() {
assert_eq!(
render(markdown, /*width*/ 80, display),
vec![HyperlinkLine {
+ source: None,
line: Line::from(label),
hyperlinks: vec![TerminalHyperlink::web(
0..label_width,
diff --git a/codex-rs/tui/src/multi_agents.rs b/codex-rs/tui/src/multi_agents.rs
index cfa05f74dd..1604be9b29 100644
--- a/codex-rs/tui/src/multi_agents.rs
+++ b/codex-rs/tui/src/multi_agents.rs
@@ -318,6 +318,7 @@ pub(crate) fn sub_agent_activity_history_cell(item: &ThreadItem) -> Option<Plain
))
}
+#[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]
pub(crate) fn sub_agent_activity_summary(kind: SubAgentActivityKind, agent_path: &str) -> String {
match kind {
SubAgentActivityKind::Started => format!("Started `{agent_path}`"),
diff --git a/codex-rs/tui/src/streaming/controller_preview_tests.rs b/codex-rs/tui/src/streaming/controller_preview_tests.rs
index 60baca07e9..19d4820f94 100644
--- a/codex-rs/tui/src/streaming/controller_preview_tests.rs
+++ b/codex-rs/tui/src/streaming/controller_preview_tests.rs
@@ -2,6 +2,38 @@ use super::*;
use crate::terminal_hyperlinks::visible_lines;
use pretty_assertions::assert_eq;
+#[test]
+fn source_only_changes_refresh_the_preview_and_active_tail() {
+ let cwd = std::env::temp_dir();
+ let mut controller = StreamController::new(Some(5), &cwd, HistoryRenderMode::Rich);
+ controller.push("hello");
+ let before = controller.current_tail_lines();
+
+ // An entity preserves trailing whitespace that Markdown otherwise trims at EOF.
+ assert!(controller.push("&#32;"));
+ let after = controller.current_tail_lines();
+ assert_eq!(visible_lines(before.clone()), visible_lines(after.clone()));
+ assert_eq!(
+ after[0].source,
+ render_source(
+ "hello&#32;",
+ Some(5),
+ &cwd,
+ HistoryRenderMode::Rich,
+ /*inline_visualization_context*/ None,
+ )[0]
+ .source,
+ );
+ assert_ne!(
+ history_cell::StreamingAgentTailCell::new(before.clone(), /*is_first_line*/ true),
+ history_cell::StreamingAgentTailCell::new(after.clone(), /*is_first_line*/ true),
+ );
+ assert_ne!(
+ history_cell::StreamingPlanTailCell::new(before, /*is_stream_continuation*/ false),
+ history_cell::StreamingPlanTailCell::new(after, /*is_stream_continuation*/ false),
+ );
+}
+
#[test]
fn unterminated_prose_reflows_and_finishes_without_duplication() {
let cwd = std::env::temp_dir();
diff --git a/codex-rs/tui/src/streaming/prose_preview.rs b/codex-rs/tui/src/streaming/prose_preview.rs
index 94a848a330..b8b4cdc1cf 100644
--- a/codex-rs/tui/src/streaming/prose_preview.rs
+++ b/codex-rs/tui/src/streaming/prose_preview.rs
@@ -6,6 +6,7 @@ use super::render::render_source;
use crate::history_cell::HistoryRenderMode;
use crate::inline_visualization::InlineVisualizationContext;
use crate::terminal_hyperlinks::HyperlinkLine;
+use crate::terminal_hyperlinks::lines_with_sources_eq;
use ratatui::text::Line;
use std::path::Path;
@@ -67,7 +68,7 @@ impl ProsePreview {
if start > 0 {
lines.insert(0, HyperlinkLine::new(Line::from("…")));
}
- if self.lines == lines {
+ if lines_with_sources_eq(&self.lines, &lines) {
return false;
}
self.lines = lines;
diff --git a/codex-rs/tui/src/style.rs b/codex-rs/tui/src/style.rs
index 32e64ca6b8..dee9f16ed6 100644
--- a/codex-rs/tui/src/style.rs
+++ b/codex-rs/tui/src/style.rs
@@ -62,7 +62,6 @@ pub fn user_message_style() -> Style {
}
/// Submitted prompts use a lighter fill than the editable composer in either theme.
-#[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]
pub(crate) fn history_prompt_style() -> Style {
let Some(background) = default_bg() else {
return Style::default();
diff --git a/codex-rs/tui/src/terminal_hyperlinks.rs b/codex-rs/tui/src/terminal_hyperlinks.rs
index 390d50d309..7fa6a83045 100644
--- a/codex-rs/tui/src/terminal_hyperlinks.rs
+++ b/codex-rs/tui/src/terminal_hyperlinks.rs
@@ -4,8 +4,10 @@
//! when text reaches a terminal buffer or scrollback writer so OSC 8 bytes never affect geometry.
mod paragraph;
+mod source;
pub(crate) use paragraph::HyperlinkParagraph;
+pub(crate) use source::LogicalLineSource;
use std::num::NonZeroU16;
use std::ops::Range;
@@ -31,7 +33,6 @@ use crate::render::line_utils::line_to_borrowed;
use crate::render::line_utils::line_to_static;
use crate::width::display_width;
use crate::wrapping::RtOptions;
-use crate::wrapping::adaptive_wrap_line;
// Destinations are repeated in every linked buffer cell. Leave oversized URLs as plain text.
const MAX_HYPERLINK_DESTINATION_BYTES: usize = 8 * 1024;
@@ -120,7 +121,7 @@ impl TerminalHyperlink {
}
}
- fn with_columns(&self, columns: Range<usize>) -> Self {
+ pub(crate) fn with_columns(&self, columns: Range<usize>) -> Self {
Self {
columns,
destination: self.destination.clone(),
@@ -136,10 +137,40 @@ impl TerminalHyperlink {
}
}
-#[derive(Clone, Debug, Default, Eq, PartialEq)]
+#[derive(Clone, Default)]
pub(crate) struct HyperlinkLine {
pub(crate) line: Line<'static>,
pub(crate) hyperlinks: Vec<TerminalHyperlink>,
+ pub(crate) source: Option<LogicalLineSource>,
+}
+
+// Source provenance is shared layout metadata; omit it from visual diagnostics to avoid
+// repeating an entire logical line for every wrapped fragment.
+impl std::fmt::Debug for HyperlinkLine {
+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ formatter
+ .debug_struct("HyperlinkLine")
+ .field("line", &self.line)
+ .field("hyperlinks", &self.hyperlinks)
+ .finish()
+ }
+}
+
+impl PartialEq for HyperlinkLine {
+ fn eq(&self, other: &Self) -> bool {
+ self.line == other.line && self.hyperlinks == other.hyperlinks
+ }
+}
+
+impl Eq for HyperlinkLine {}
+
+/// Cache equality also tracks source whitespace hidden by display wrapping.
+pub(crate) fn lines_with_sources_eq(left: &[HyperlinkLine], right: &[HyperlinkLine]) -> bool {
+ left == right
+ && left
+ .iter()
+ .map(|line| &line.source)
+ .eq(right.iter().map(|line| &line.source))
}
impl HyperlinkLine {
@@ -147,6 +178,7 @@ impl HyperlinkLine {
Self {
line,
hyperlinks: Vec::new(),
+ source: None,
}
}
@@ -155,6 +187,7 @@ impl HyperlinkLine {
}
pub(crate) fn push_span(&mut self, span: Span<'static>, destination: Option<&str>) {
+ self.source = None;
let start = self.width();
let end = start + display_width(span.content.as_ref());
self.line.push_span(span);
@@ -168,6 +201,9 @@ impl HyperlinkLine {
pub(crate) fn style(mut self, style: ratatui::style::Style) -> Self {
self.line = self.line.style(style);
+ if let Some(source) = &mut self.source {
+ source.line_style = style;
+ }
self
}
}
@@ -220,6 +256,16 @@ pub(crate) fn prefix_hyperlink_lines(
subsequent_prefix.clone()
};
let shift = display_width(prefix.content.as_ref());
+ let mut source = line
+ .source
+ .take()
+ .unwrap_or_else(|| LogicalLineSource::from_line(&line.line));
+ source.prefix_bytes += prefix.content.len();
+ source
+ .continuation_indent
+ .spans
+ .insert(/*index*/ 0, subsequent_prefix.clone());
+ line.source = Some(source);
let mut spans = Vec::with_capacity(line.line.spans.len() + 1);
spans.push(prefix);
spans.extend(line.line.spans);
@@ -245,12 +291,14 @@ pub(crate) fn adaptive_wrap_hyperlink_lines(
.clone()
.initial_indent(options.subsequent_indent.clone())
};
- out.extend(remap_wrapped_line(
- line,
- adaptive_wrap_line(&line.line, options)
- .into_iter()
- .map(|wrapped| line_to_static(&wrapped))
- .collect(),
+ let mut source = line.clone();
+ source
+ .source
+ .get_or_insert_with(|| LogicalLineSource::from_line(&line.line))
+ .continuation_indent = options.subsequent_indent.clone();
+ out.extend(remap_source_wrapped_line(
+ &source,
+ crate::wrapping::adaptive_wrap_line_with_source(&line.line, options),
));
}
out
@@ -271,11 +319,67 @@ pub(crate) fn annotate_web_urls_in_line(line: Line<'static>) -> HyperlinkLine {
out
}
+/// Project annotations from the exact source slices used by the existing wrapping algorithm.
+pub(crate) fn remap_source_wrapped_line(
+ source: &HyperlinkLine,
+ wrapped: Vec<crate::wrapping::WrappedLine<'_>>,
+) -> Vec<HyperlinkLine> {
+ let text = line_text(&source.line);
+ let mut logical = source
+ .source
+ .clone()
+ .unwrap_or_else(|| LogicalLineSource::from_line(&source.line));
+ // Wrapping bakes the row style into each span; mirror it once for all source fragments.
+ if logical.line_style != ratatui::style::Style::default() {
+ logical.styles = logical
+ .styles
+ .iter()
+ .map(|(range, style)| (range.clone(), logical.line_style.patch(*style)))
+ .collect::<Vec<_>>()
+ .into();
+ }
+ let mut source_byte = 0;
+ let mut source_column = 0;
+ wrapped
+ .into_iter()
+ .map(|wrapped| {
+ let line = line_to_static(&wrapped.line);
+ let displayed = line_text(&line);
+ let prefix_columns = display_width(&displayed[..wrapped.prefix_bytes]);
+ source_column += display_width(&text[source_byte..wrapped.range.start]);
+ let start = source_column;
+ let end = start + display_width(&text[wrapped.range.clone()]);
+ source_byte = wrapped.range.end;
+ source_column = end;
+ let hyperlinks = source
+ .hyperlinks
+ .iter()
+ .filter_map(|link| {
+ let first = link.columns.start.max(start);
+ let last = link.columns.end.min(end);
+ (first < last).then(|| {
+ link.with_columns(
+ prefix_columns + first - start..prefix_columns + last - start,
+ )
+ })
+ })
+ .collect();
+ HyperlinkLine {
+ line,
+ hyperlinks,
+ source: Some(logical.wrapped(wrapped.range, wrapped.prefix_bytes)),
+ }
+ })
+ .collect()
+}
+
/// Re-attach source hyperlink ranges after visible-text wrapping has split a line.
///
/// Link text is matched in display order so a URL split across table rows retains the complete
/// destination on every rendered fragment. Whitespace inserted or removed at line boundaries is
/// ignored while matching; hyperlink destinations themselves are never reconstructed from output.
+/// This legacy projection does not infer logical source provenance. New wrapping callers should
+/// pass authoritative ranges to [`remap_source_wrapped_line`].
pub(crate) fn remap_wrapped_line(
source: &HyperlinkLine,
wrapped: Vec<Line<'static>>,
@@ -284,7 +388,6 @@ pub(crate) fn remap_wrapped_line(
if source.hyperlinks.is_empty() {
return out;
}
-
let source_text = line_text(&source.line);
let mut source_byte = 0usize;
let mut source_column = 0usize;
@@ -758,6 +861,7 @@ mod tests {
fn decorates_a_contiguous_web_link_with_one_osc8_pair() {
let destination = "https://example.com/a/very/long/path";
let line = HyperlinkLine {
+ source: None,
line: Line::from(destination),
hyperlinks: vec![TerminalHyperlink::web(
/*columns*/ 0..usize::from(destination.cell_width()),
@@ -823,6 +927,7 @@ mod tests {
wrapped,
vec![
HyperlinkLine {
+ source: None,
line: Line::from(" alpha 😀here"),
hyperlinks: vec![TerminalHyperlink::web(
/*columns*/ 10..14,
@@ -830,6 +935,7 @@ mod tests {
)],
},
HyperlinkLine {
+ source: None,
line: Line::from(" middle there end"),
hyperlinks: vec![TerminalHyperlink::web(
/*columns*/ 11..16,
@@ -1091,6 +1197,7 @@ mod tests {
);
link.retarget_to_trusted_file(&file_url);
let line = HyperlinkLine {
+ source: None,
line: Line::from("view"),
hyperlinks: vec![link],
};
diff --git a/codex-rs/tui/src/terminal_hyperlinks/source.rs b/codex-rs/tui/src/terminal_hyperlinks/source.rs
new file mode 100644
index 0000000000..cb1a343c52
--- /dev/null
+++ b/codex-rs/tui/src/terminal_hyperlinks/source.rs
@@ -0,0 +1,114 @@
+//! Logical text and margins retained when display wrapping removes whitespace or adds a gutter.
+
+use ratatui::style::Style;
+use ratatui::text::Line;
+use ratatui::text::Span;
+use std::ops::Range;
+use std::sync::Arc;
+
+/// Wrapping policy of an existing display renderer.
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) enum LineWrapPolicy {
+ #[default]
+ Word,
+}
+
+/// A displayed line's contiguous fragment of one original logical line.
+///
+/// Wrapped fragments share `text`. `prefix_bytes` counts synthetic display bytes before
+/// the fragment, so selection never has to infer whether a gutter belongs to the source.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct LogicalLineSource {
+ pub(crate) text: Arc<str>,
+ /// Span styles share the text's byte coordinates, including whitespace omitted by wrapping.
+ pub(crate) styles: Arc<[(Range<usize>, Style)]>,
+ /// Row style, applied beneath explicit span styles just like ratatui's `Line`.
+ pub(crate) line_style: Style,
+ /// A later uniform span-style patch, such as the dim/italic reasoning treatment.
+ pub(crate) span_style: Style,
+ pub(crate) range: Range<usize>,
+ pub(crate) prefix_bytes: usize,
+ pub(crate) wrap_policy: LineWrapPolicy,
+ pub(crate) continuation_indent: Line<'static>,
+ /// Blank columns after wrapped content; they remain outside the copied source text.
+ pub(crate) right_reserve: u16,
+}
+
+impl LogicalLineSource {
+ pub(crate) fn new(text: String) -> Self {
+ let end = text.len();
+ Self {
+ text: text.into(),
+ styles: vec![(0..end, Style::default())].into(),
+ line_style: Style::default(),
+ span_style: Style::default(),
+ range: 0..end,
+ prefix_bytes: 0,
+ wrap_policy: LineWrapPolicy::Word,
+ continuation_indent: Line::default(),
+ right_reserve: 0,
+ }
+ }
+
+ pub(crate) fn from_line(line: &Line<'_>) -> Self {
+ let mut source = Self::new(
+ line.spans
+ .iter()
+ .map(|span| span.content.as_ref())
+ .collect(),
+ );
+ let mut offset = 0;
+ source.line_style = line.style;
+ source.styles = line
+ .spans
+ .iter()
+ .map(|span| {
+ let start = offset;
+ offset += span.content.len();
+ (start..offset, span.style)
+ })
+ .collect::<Vec<_>>()
+ .into();
+ source
+ }
+
+ #[allow(
+ dead_code,
+ reason = "Used by the activity presentation layer of this stack."
+ )]
+ pub(crate) fn styled_range(&self, range: Range<usize>) -> Line<'static> {
+ Line::from(
+ self.styles
+ .iter()
+ .filter_map(|(style_range, style)| {
+ let start = style_range.start.max(range.start);
+ let end = style_range.end.min(range.end);
+ (start < end).then(|| {
+ Span::styled(
+ self.text[start..end].to_owned(),
+ self.line_style.patch(*style).patch(self.span_style),
+ )
+ })
+ })
+ .collect::<Vec<_>>(),
+ )
+ }
+
+ pub(super) fn wrapped(&self, displayed: Range<usize>, prefix_bytes: usize) -> Self {
+ let source_start = self.prefix_bytes;
+ let source_end = source_start + self.range.len();
+ let start = displayed.start.clamp(source_start, source_end);
+ let end = displayed.end.clamp(source_start, source_end);
+ Self {
+ text: Arc::clone(&self.text),
+ styles: Arc::clone(&self.styles),
+ line_style: self.line_style,
+ span_style: self.span_style,
+ range: self.range.start + start - source_start..self.range.start + end - source_start,
+ prefix_bytes: prefix_bytes + start.saturating_sub(displayed.start).min(displayed.len()),
+ wrap_policy: self.wrap_policy,
+ continuation_indent: self.continuation_indent.clone(),
+ right_reserve: self.right_reserve,
+ }
+ }
+}
diff --git a/codex-rs/tui/src/terminal_hyperlinks_tests.rs b/codex-rs/tui/src/terminal_hyperlinks_tests.rs
index 8648631cef..ead3f3662b 100644
--- a/codex-rs/tui/src/terminal_hyperlinks_tests.rs
+++ b/codex-rs/tui/src/terminal_hyperlinks_tests.rs
@@ -15,6 +15,7 @@ fn oversized_destinations_remain_plain_text() {
// Explicit Markdown links can reach the cell marker without bare-URL detection.
let line = HyperlinkLine {
+ source: None,
line: Line::from("visible"),
hyperlinks: vec![TerminalHyperlink::web(/*columns*/ 0..7, oversized)],
};
diff --git a/codex-rs/tui/src/wrapping.rs b/codex-rs/tui/src/wrapping.rs
index d65c6b88aa..a1d35ff5a4 100644
--- a/codex-rs/tui/src/wrapping.rs
+++ b/codex-rs/tui/src/wrapping.rs
@@ -46,12 +46,16 @@ struct ProjectedText {
grapheme_boundaries: Vec<usize>,
}
-/// Replaces halfwidth sound-mark graphemes with equally wide, textwrap-safe placeholders.
+/// Replaces compound graphemes with equally wide, textwrap-safe placeholders.
///
/// Source boundaries recover original byte offsets, while grapheme boundaries keep placeholders
/// indivisible and preserve leading whitespace as a wrapping opportunity.
-fn project_halfwidth_sound_marks(text: &str) -> Option<ProjectedText> {
- if !text.contains(['\u{FF9E}', '\u{FF9F}']) {
+fn project_complex_graphemes(text: &str) -> Option<ProjectedText> {
+ if !text.contains(['\u{FF9E}', '\u{FF9F}'])
+ && !text
+ .graphemes(/*is_extended*/ true)
+ .any(|grapheme| grapheme.chars().count() > 1)
+ {
return None;
}
@@ -59,7 +63,7 @@ fn project_halfwidth_sound_marks(text: &str) -> Option<ProjectedText> {
let mut source_boundaries = vec![(0, 0)];
let mut grapheme_boundaries = vec![0];
for (source_start, grapheme) in text.grapheme_indices(/*is_extended*/ true) {
- if grapheme.contains(['\u{FF9E}', '\u{FF9F}']) {
+ if grapheme.chars().count() > 1 || grapheme.contains(['\u{FF9E}', '\u{FF9F}']) {
let source_end = source_start + grapheme.len();
let content_start = grapheme
.find(|ch: char| !ch.is_whitespace())
@@ -72,6 +76,10 @@ fn project_halfwidth_sound_marks(text: &str) -> Option<ProjectedText> {
}
let width = display_width(content);
+ if width == 0 && !content.is_empty() {
+ projected.push_str(content);
+ source_boundaries.push((projected.len(), source_end));
+ }
let projected_start = projected.len();
for _ in 0..width / 2 {
if projected.len() > projected_start {
@@ -233,7 +241,7 @@ where
O: Into<Options<'a>>,
{
let opts = width_or_options.into();
- if let Some(projected) = project_halfwidth_sound_marks(text) {
+ if let Some(projected) = project_complex_graphemes(text) {
return wrap_projected_ranges(&projected, &opts, /*include_trailing_spaces*/ true);
}
let mut lines: Vec<Range<usize>> = Vec::new();
@@ -279,7 +287,7 @@ where
O: Into<Options<'a>>,
{
let opts = width_or_options.into();
- if let Some(projected) = project_halfwidth_sound_marks(text) {
+ if let Some(projected) = project_complex_graphemes(text) {
return wrap_projected_ranges(&projected, &opts, /*include_trailing_spaces*/ false);
}
let mut lines: Vec<Range<usize>> = Vec::new();
@@ -701,6 +709,24 @@ pub(crate) fn url_preserving_wrap_options<'a>(opts: RtOptions<'a>) -> RtOptions<
/// while a genuinely overlong non-URL token can still split if needed.
#[must_use]
pub(crate) fn adaptive_wrap_line<'a>(line: &'a Line<'a>, base: RtOptions<'a>) -> Vec<Line<'a>> {
+ adaptive_wrap_line_with_source(line, base)
+ .into_iter()
+ .map(|wrapped| wrapped.line)
+ .collect()
+}
+
+/// A display row and the exact source fragment used to build it.
+pub(crate) struct WrappedLine<'a> {
+ pub(crate) line: Line<'a>,
+ pub(crate) range: Range<usize>,
+ pub(crate) prefix_bytes: usize,
+}
+
+/// Preserve wrapping's source ranges for selection and hyperlink projection.
+pub(crate) fn adaptive_wrap_line_with_source<'a>(
+ line: &'a Line<'a>,
+ base: RtOptions<'a>,
+) -> Vec<WrappedLine<'a>> {
let (flat, span_bounds) = flatten_line(line);
let mut saw_url = false;
let mut saw_non_url = false;
@@ -854,6 +880,20 @@ impl<'a> RtOptions<'a> {
#[must_use]
pub(crate) fn word_wrap_line<'a, O>(line: &'a Line<'a>, width_or_options: O) -> Vec<Line<'a>>
+where
+ O: Into<RtOptions<'a>>,
+{
+ word_wrap_line_with_source(line, width_or_options)
+ .into_iter()
+ .map(|wrapped| wrapped.line)
+ .collect()
+}
+
+/// Standard wrapping with the same source ranges used to slice styled spans.
+pub(crate) fn word_wrap_line_with_source<'a, O>(
+ line: &'a Line<'a>,
+ width_or_options: O,
+) -> Vec<WrappedLine<'a>>
where
O: Into<RtOptions<'a>>,
{
@@ -866,7 +906,7 @@ fn word_wrap_flattened_line<'a>(
flat: &str,
span_bounds: &[(Range<usize>, ratatui::style::Style)],
rt_opts: RtOptions<'a>,
-) -> Vec<Line<'a>> {
+) -> Vec<WrappedLine<'a>> {
let opts = Options::new(rt_opts.width)
.line_ending(rt_opts.line_ending)
.break_words(rt_opts.break_words)
@@ -874,7 +914,7 @@ fn word_wrap_flattened_line<'a>(
.word_separator(rt_opts.word_separator)
.word_splitter(rt_opts.word_splitter);
- let mut out: Vec<Line<'a>> = Vec::new();
+ let mut out: Vec<WrappedLine<'a>> = Vec::new();
// Compute first line range with reduced width due to initial indent.
let initial_width_available = opts
@@ -883,7 +923,16 @@ fn word_wrap_flattened_line<'a>(
.max(1);
let initial_wrapped = wrap_ranges_trim(flat, opts.clone().width(initial_width_available));
let Some(first_line_range) = initial_wrapped.first() else {
- return vec![rt_opts.initial_indent.clone()];
+ return vec![WrappedLine {
+ line: rt_opts.initial_indent.clone().style(line.style),
+ range: 0..0,
+ prefix_bytes: rt_opts
+ .initial_indent
+ .spans
+ .iter()
+ .map(|span| span.content.len())
+ .sum(),
+ }];
};
// Build first wrapped line with initial indent.
@@ -895,14 +944,22 @@ fn word_wrap_flattened_line<'a>(
&mut sliced
.spans
.into_iter()
- .map(|s| s.patch_style(line.style))
+ .map(|span| Span::styled(span.content, line.style.patch(span.style)))
.collect(),
);
first_line.spans = spans;
- out.push(first_line);
+ out.push(WrappedLine {
+ line: first_line,
+ range: first_line_range.clone(),
+ prefix_bytes: rt_opts
+ .initial_indent
+ .spans
+ .iter()
+ .map(|span| span.content.len())
+ .sum(),
+ });
}
- // Wrap the remainder using subsequent indent width and map back to original indices.
let base = first_line_range.end;
let skip_leading_spaces = flat[base..].chars().take_while(|c| *c == ' ').count();
let base = base + skip_leading_spaces;
@@ -910,24 +967,55 @@ fn word_wrap_flattened_line<'a>(
.width
.saturating_sub(line_width(&rt_opts.subsequent_indent))
.max(1);
- let remaining_wrapped = wrap_ranges_trim(&flat[base..], opts.width(subsequent_width_available));
- for r in &remaining_wrapped {
- if r.is_empty() {
+ // First-fit decisions do not depend on later rows. Reuse the full first pass when
+ // both indents leave the same width and the remainder starts after a complete word.
+ // Splitting inside a word can change hyphenation when the remainder is tokenized again.
+ // Custom tokenizers can also repartition the remainder, so they retain the second pass.
+ let remaining_wrapped = if initial_width_available == subsequent_width_available
+ && matches!(rt_opts.wrap_algorithm, textwrap::WrapAlgorithm::FirstFit)
+ && matches!(
+ rt_opts.word_separator,
+ WordSeparator::AsciiSpace | WordSeparator::UnicodeBreakProperties
+ )
+ && (skip_leading_spaces > 0 || base == flat.len())
+ // The projected and plain text wrappers interpret control characters differently.
+ && !flat.as_bytes().iter().any(u8::is_ascii_control)
+ && initial_wrapped
+ .get(/*index*/ 1)
+ .map_or(base == flat.len(), |range| range.start == base)
+ {
+ initial_wrapped.into_iter().skip(/*n*/ 1).collect()
+ } else {
+ wrap_ranges_trim(&flat[base..], opts.width(subsequent_width_available))
+ .into_iter()
+ .map(|range| (range.start + base)..(range.end + base))
+ .collect::<Vec<_>>()
+ };
+ for offset_range in remaining_wrapped {
+ if offset_range.is_empty() {
continue;
}
let mut subsequent_line = rt_opts.subsequent_indent.clone().style(line.style);
- let offset_range = (r.start + base)..(r.end + base);
let sliced = slice_line_spans(line, span_bounds, &offset_range);
let mut spans = subsequent_line.spans;
spans.append(
&mut sliced
.spans
.into_iter()
- .map(|s| s.patch_style(line.style))
+ .map(|span| Span::styled(span.content, line.style.patch(span.style)))
.collect(),
);
subsequent_line.spans = spans;
- out.push(subsequent_line);
+ out.push(WrappedLine {
+ line: subsequent_line,
+ range: offset_range,
+ prefix_bytes: rt_opts
+ .subsequent_indent
+ .spans
+ .iter()
+ .map(|span| span.content.len())
+ .sum(),
+ });
}
out
@@ -950,7 +1038,7 @@ fn mixed_url_wrap_line<'a>(
flat: &str,
span_bounds: &[(Range<usize>, ratatui::style::Style)],
rt_opts: RtOptions<'a>,
-) -> Vec<Line<'a>> {
+) -> Vec<WrappedLine<'a>> {
let initial_width_available = rt_opts
.width
.saturating_sub(line_width(&rt_opts.initial_indent))
@@ -969,20 +1057,38 @@ fn mixed_url_wrap_line<'a>(
rt_opts.subsequent_indent.clone()
}
.style(line.style);
+ let prefix_bytes = wrapped_line
+ .spans
+ .iter()
+ .map(|span| span.content.len())
+ .sum();
let sliced = slice_line_spans(line, span_bounds, range);
let mut spans = wrapped_line.spans;
spans.extend(
sliced
.spans
.into_iter()
- .map(|span| span.patch_style(line.style)),
+ .map(|span| Span::styled(span.content, line.style.patch(span.style))),
);
wrapped_line.spans = spans;
- out.push(wrapped_line);
+ out.push(WrappedLine {
+ line: wrapped_line,
+ range: range.clone(),
+ prefix_bytes,
+ });
}
if out.is_empty() {
- vec![rt_opts.initial_indent.clone()]
+ vec![WrappedLine {
+ line: rt_opts.initial_indent.clone().style(line.style),
+ range: 0..0,
+ prefix_bytes: rt_opts
+ .initial_indent
+ .spans
+ .iter()
+ .map(|span| span.content.len())
+ .sum(),
+ }]
} else {
out
}
@@ -1269,6 +1375,10 @@ fn slice_line_spans<'a>(
}
}
+#[cfg(test)]
+#[path = "wrapping_reuse_tests.rs"]
+mod reuse_tests;
+
#[cfg(test)]
mod tests {
use super::*;
@@ -1293,6 +1403,24 @@ mod tests {
assert_eq!(concat_line(&out[0]), "hello");
}
+ #[test]
+ fn narrow_wrap_ranges_preserve_compound_graphemes() {
+ assert_eq!(
+ wrap_ranges_trim("👩‍💻e\u{301}x", /*width_or_options*/ 2),
+ vec![0..11, 11..15],
+ );
+ for text in ["\u{301}\u{302}", " \u{301}\u{302}"] {
+ assert_eq!(
+ wrap_ranges_trim(text, /*width_or_options*/ 2),
+ vec![0..text.len()]
+ );
+ }
+ assert_eq!(
+ wrap_ranges("\u{301}\u{302}", /*width_or_options*/ 2),
+ vec![0..5],
+ );
+ }
+
#[test]
fn simple_unstyled_wrap_narrow_width() {
let line = Line::from("hello world");
diff --git a/codex-rs/tui/src/wrapping_reuse_tests.rs b/codex-rs/tui/src/wrapping_reuse_tests.rs
new file mode 100644
index 0000000000..0dcd15c8a0
--- /dev/null
+++ b/codex-rs/tui/src/wrapping_reuse_tests.rs
@@ -0,0 +1,114 @@
+//! Compare reused first-fit rows with the generic wrapping path, including source provenance.
+
+use super::*;
+use pretty_assertions::assert_eq;
+use ratatui::style::Stylize;
+
+#[test]
+fn custom_word_separator_reprocesses_the_remainder() {
+ let separator = WordSeparator::Custom(|text| {
+ let Some(space) = text.find(' ') else {
+ return Box::new(std::iter::once(Word::from(text)));
+ };
+ Box::new([Word::from(&text[..=space]), Word::from(&text[space + 1..])].into_iter())
+ });
+ let line = Line::from("one two three");
+ let rows =
+ word_wrap_line_with_source(&line, RtOptions::new(/*width*/ 5).word_separator(separator))
+ .into_iter()
+ .map(|row| (row.line, row.range))
+ .collect::<Vec<_>>();
+ assert_eq!(
+ rows,
+ vec![
+ (Line::from("one"), 0..3),
+ (Line::from("two"), 4..7),
+ (Line::from("three"), 8..13),
+ ]
+ );
+}
+
+#[test]
+fn first_fit_reuse_preserves_styled_rows_and_source_ranges() {
+ // A custom first-fit function exercises the unchanged generic path without copying
+ // its implementation into the test. Compare complete rows, styles and byte ranges.
+ let generic_first_fit = textwrap::WrapAlgorithm::Custom(|words, widths| {
+ textwrap::WrapAlgorithm::FirstFit.wrap(words, widths)
+ });
+ // Cover distinct split, width, indentation and separator boundaries without a random matrix.
+ for (text, width, initial, subsequent, break_words, separator) in [
+ ("", 0, "", "", true, WordSeparator::AsciiSpace),
+ (
+ "hello world",
+ 0,
+ "> ",
+ " ",
+ true,
+ WordSeparator::AsciiSpace,
+ ),
+ (
+ "cafe\u{301} 中文 👩🏽‍💻 🇧🇷 ガ",
+ 2,
+ "",
+ "",
+ true,
+ WordSeparator::UnicodeBreakProperties,
+ ),
+ (
+ "a-very-long-hyphenated-word",
+ 5,
+ "界",
+ "ab",
+ true,
+ WordSeparator::AsciiSpace,
+ ),
+ (
+ "https://example.com/a/b tail",
+ 17,
+ "> ",
+ " ",
+ false,
+ WordSeparator::AsciiSpace,
+ ),
+ (
+ "alpha beta\u{a0}gamma\u{200b}delta",
+ 5,
+ "",
+ " ",
+ true,
+ WordSeparator::UnicodeBreakProperties,
+ ),
+ (
+ "one\n two\r\nthree\tfour",
+ 5,
+ "> ",
+ " ",
+ true,
+ WordSeparator::AsciiSpace,
+ ),
+ (
+ "\u{1b}[31mred\u{1b}[0m tail",
+ 80,
+ "",
+ "",
+ false,
+ WordSeparator::AsciiSpace,
+ ),
+ ] {
+ let line = Line::from(vec![text.bold(), " suffix".cyan()]).italic();
+ let options = RtOptions::new(width)
+ .initial_indent(Line::from(initial.red()))
+ .subsequent_indent(Line::from(subsequent.green()))
+ .break_words(break_words)
+ .word_separator(separator);
+ let actual = word_wrap_line_with_source(&line, options.clone())
+ .into_iter()
+ .map(|row| (row.line, row.range, row.prefix_bytes))
+ .collect::<Vec<_>>();
+ let expected = word_wrap_line_with_source(&line, options.wrap_algorithm(generic_first_fit))
+ .into_iter()
+ .map(|row| (row.line, row.range, row.prefix_bytes))
+ .collect::<Vec<_>>();
+ assert_eq!(actual, expected, "text={text:?}, width={width}");
+ }
+}