use crate::autocomplete::{AutoComplete, Suggestion, SuggestionKind}; use crate::persistence::PromptHistoryCache; use crate::push_toast; use crate::theme::{agent_color, contrast_text, ThemeColors}; use crate::toast::{Toast, ToastLevel}; use crate::ui::selection::EdgeScrollDirection; use crate::ui::textarea_keys::{ command_backspace_to_line_start as textarea_command_backspace_to_line_start, delete_to_line_start as textarea_delete_to_line_start, has_command_modifier, }; use crate::utils::image_attachment; use ratatui::buffer::Buffer; use ratatui::crossterm::event::{ KeyCode, KeyEvent, KeyModifiers, MouseButton, MouseEvent, MouseEventKind, }; use ratatui::prelude::{Rect, Style}; use ratatui::style::{Color, Modifier}; use ratatui::symbols::border; use ratatui::text::{Line, Span, Text}; use ratatui::widgets::{Block, Borders, Paragraph}; use std::ops::Range; use std::path::PathBuf; use std::time::{Duration, Instant}; use tui_textarea::{CursorMove, Input as TuiInput, TextArea}; use unicode_width::UnicodeWidthChar; use unicode_width::UnicodeWidthStr; /// Clamp a byte offset to the nearest valid UTF-8 character boundary in `s`. fn char_boundary_before(s: &str, byte_idx: usize) -> usize { let idx = byte_idx.min(s.len()); if s.is_char_boundary(idx) { idx } else { (0..idx).rev().find(|&i| s.is_char_boundary(i)).unwrap_or(0) } } /// Word category for word-delete logic (matching tui-textarea's CharKind). fn char_kind(c: char) -> u8 { if c.is_whitespace() { 0 // Space } else if c.is_ascii_punctuation() { 1 // Punct } else { 2 // Other (includes emoji, letters, etc.) } } const LARGE_PASTE_CHAR_THRESHOLD: usize = 1000; pub(crate) const MAX_TEXTAREA_HEIGHT: usize = 9; pub(crate) const INPUT_CHROME_HEIGHT: u16 = 4; pub(crate) const MIN_INPUT_HEIGHT: u16 = 5; const POST_KEY_SCROLL_SUPPRESSION: Duration = Duration::from_millis(160); #[derive(Clone, Debug, PartialEq, Eq)] struct VisualLine { source_row: usize, start_col: usize, end_col: usize, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] struct SelectionEdgeScroll { direction: EdgeScrollDirection, column: u16, } pub struct Input { textarea: TextArea<'static>, pub autocomplete: Option, textarea_area: Option, viewport_top: usize, manual_viewport_scroll: bool, suppress_scroll_until: Option, preferred_visual_col: Option, selection_drag_active: bool, selection_edge_scroll: Option, prompt_history: Option, draft_state: Option, local_images: Vec, pending_pastes: Vec, pending_file_action: Option, hovered_image_placeholder: Option, hovered_paste_placeholder: Option, } #[derive(Clone, Debug, PartialEq, Eq)] struct PendingPaste { placeholder: String, content: String, } #[derive(Clone, Debug, PartialEq, Eq)] struct DraftState { text: String, local_images: Vec, pending_pastes: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct LocalImageAttachment { pub placeholder: String, pub path: PathBuf, } #[derive(Clone, Debug, PartialEq, Eq)] struct CompletionToken { query: String, range: Range, } impl Input { pub fn new() -> Self { let mut textarea = TextArea::default(); textarea.set_cursor_line_style(Style::default()); // Default selection style (will be updated per-theme in render) textarea.set_selection_style( Style::default() .bg(ratatui::style::Color::Rgb(255, 140, 0)) .fg(ratatui::style::Color::Reset), ); let prompt_history = PromptHistoryCache::new().ok(); Self { textarea, autocomplete: None, textarea_area: None, viewport_top: 0, manual_viewport_scroll: false, suppress_scroll_until: None, preferred_visual_col: None, selection_drag_active: false, selection_edge_scroll: None, prompt_history, draft_state: None, local_images: Vec::new(), pending_pastes: Vec::new(), pending_file_action: None, hovered_image_placeholder: None, hovered_paste_placeholder: None, } } fn render_paste_hover_tooltip( &self, buffer: &mut Buffer, area: Rect, colors: &ThemeColors, visual_lines: &[VisualLine], ) { let Some(placeholder) = self.hovered_paste_placeholder.as_deref() else { return; }; if area.width == 0 || area.height == 0 { return; } let lines = self.textarea.lines(); let Some((screen_row, visual_line, start)) = visual_lines .iter() .skip(self.viewport_top) .take(area.height as usize) .enumerate() .find_map(|(screen_row, visual_line)| { let line = lines.get(visual_line.source_row)?; line.match_indices(placeholder).find_map(|(start, _)| { let start_col = line[..start].chars().count(); let end_col = start_col + placeholder.chars().count(); (start_col < visual_line.end_col && end_col > visual_line.start_col) .then_some((screen_row, visual_line, start)) }) }) else { return; }; let Some(line) = lines.get(visual_line.source_row) else { return; }; let start_col = line[..start].chars().count(); let prefix = Self::line_char_slice( line, visual_line.start_col, start_col.clamp(visual_line.start_col, visual_line.end_col), ); let anchor_x = area.x + UnicodeWidthStr::width(prefix).min(area.width as usize - 1) as u16; let anchor_y = area.y + screen_row as u16; let tooltip = " expand "; let width = tooltip.len().min(area.width as usize) as u16; let x = anchor_x.min(area.x + area.width.saturating_sub(width)); // Prefer the padding row above the hovered line. On the first textarea // row that is the 1-line pad between border and text (not row 2 inside // the textarea). Only fall below when there is no room above. let y = if anchor_y > 0 { anchor_y - 1 } else { (anchor_y + 1).min(area.y + area.height.saturating_sub(1)) }; let style = Style::default() .fg(colors.background_element) .bg(colors.markdown_image_text) .add_modifier(Modifier::BOLD); for (idx, ch) in tooltip.chars().take(width as usize).enumerate() { if let Some(cell) = buffer.cell_mut((x + idx as u16, y)) { cell.set_char(ch); cell.set_style(style); } } } fn move_to_line_start(&mut self, extend: bool) { self.reveal_cursor_after_key_input(); self.preferred_visual_col = None; self.begin_extend_or_cancel(extend); let (row, _) = self.textarea.cursor(); self.textarea.move_cursor(CursorMove::Jump(row as u16, 0)); self.cancel_empty_selection(); } fn line_end_col(&self, row: usize) -> usize { self.textarea .lines() .get(row) .map(|line| line.chars().count()) .unwrap_or(0) } fn move_to_line_end(&mut self, extend: bool) { self.reveal_cursor_after_key_input(); self.preferred_visual_col = None; self.begin_extend_or_cancel(extend); let (row, _) = self.textarea.cursor(); let col = self.line_end_col(row); self.textarea .move_cursor(CursorMove::Jump(row as u16, col as u16)); self.cancel_empty_selection(); } /// Selection plumbing shared by Cmd/Opt+Arrow jumps: with `extend` /// (Shift held) start/continue the selection, otherwise clear it. fn begin_extend_or_cancel(&mut self, extend: bool) { if extend { if !self.textarea.is_selecting() { self.textarea.start_selection(); } } else { self.textarea.cancel_selection(); } } /// Native collapse: with an active selection, plain Left/Right clears /// the highlight and jumps the caret to the selection edge (Left -> /// start, Right -> end) instead of moving one char from the cursor. /// Returns false when there is no selection to collapse. fn collapse_selection_to_edge(&mut self, to_start: bool) -> bool { let Some(((start_row, start_col), (end_row, end_col))) = self.textarea.selection_range() else { return false; }; if (start_row, start_col) == (end_row, end_col) { return false; } self.reveal_cursor_after_key_input(); self.preferred_visual_col = None; let (row, col) = if to_start { (start_row, start_col) } else { (end_row, end_col) }; self.textarea.cancel_selection(); self.clear_selection_drag_state(); self.textarea .move_cursor(CursorMove::Jump(row as u16, col as u16)); true } /// Option+Arrow word jump (mirrors tui-textarea's Ctrl+Arrow handling, /// which terminals don't send for macOS Option). With `extend`, behaves /// like Shift+Arrow: starts/continues the selection instead of clearing. fn move_word_with_selection(&mut self, forward: bool, extend: bool) { self.reveal_cursor_after_key_input(); self.preferred_visual_col = None; self.begin_extend_or_cancel(extend); self.textarea.move_cursor(if forward { CursorMove::WordForward } else { CursorMove::WordBack }); self.cancel_empty_selection(); } /// Option+Up/Down paragraph jump (mirrors Ctrl+Up/Down in tui-textarea). fn move_paragraph_with_selection(&mut self, forward: bool, extend: bool) { self.reveal_cursor_after_key_input(); self.preferred_visual_col = None; self.begin_extend_or_cancel(extend); self.textarea.move_cursor(if forward { CursorMove::ParagraphForward } else { CursorMove::ParagraphBack }); self.cancel_empty_selection(); } fn delete_to_line_start(&mut self) { self.reveal_cursor_after_key_input(); self.preferred_visual_col = None; textarea_delete_to_line_start(&mut self.textarea); } fn command_backspace_to_line_start(&mut self) { self.reveal_cursor_after_key_input(); self.preferred_visual_col = None; textarea_command_backspace_to_line_start(&mut self.textarea); } fn reveal_cursor_on_next_render(&mut self) { self.manual_viewport_scroll = false; } fn reveal_cursor_after_key_input(&mut self) { let should_suppress_scroll = self.manual_viewport_scroll || self .suppress_scroll_until .is_some_and(|until| Instant::now() < until); self.reveal_cursor_on_next_render(); if should_suppress_scroll { self.suppress_scroll_until = Some(Instant::now() + POST_KEY_SCROLL_SUPPRESSION); } } fn should_suppress_scroll(&mut self) -> bool { let Some(until) = self.suppress_scroll_until else { return false; }; let now = Instant::now(); if now < until { self.suppress_scroll_until = Some(now + POST_KEY_SCROLL_SUPPRESSION); true } else { self.suppress_scroll_until = None; false } } pub fn with_autocomplete(mut self, autocomplete: AutoComplete) -> Self { self.autocomplete = Some(autocomplete); self } pub fn take_file_action(&mut self) -> Option { self.pending_file_action.take() } pub fn contains_mouse(&self, mouse: MouseEvent) -> bool { let Some(area) = self.textarea_area else { return false; }; let point = ratatui::layout::Position::new(mouse.column, mouse.row); area.contains(point) } #[cfg(test)] pub(crate) fn cursor(&self) -> (usize, usize) { self.textarea.cursor() } pub fn clear_hover(&mut self) { self.hovered_image_placeholder = None; self.hovered_paste_placeholder = None; } pub fn has_active_selection_edge_scroll(&self) -> bool { self.selection_edge_scroll.is_some() } pub fn is_selection_dragging(&self) -> bool { self.selection_drag_active } pub fn finish_selection_drag(&mut self) { self.finalize_selection_drag(); } pub fn tick_selection_edge_scroll(&mut self) -> bool { let Some(edge_scroll) = self.selection_edge_scroll else { return false; }; if !self.selection_drag_active { self.selection_edge_scroll = None; return false; } self.preferred_visual_col = Some(edge_scroll.column as usize); let moved = match edge_scroll.direction { EdgeScrollDirection::Up => self.move_cursor_visual(-1, true), EdgeScrollDirection::Down => self.move_cursor_visual(1, true), }; if !moved { self.selection_edge_scroll = None; } moved } fn clear_selection_drag_state(&mut self) { self.selection_drag_active = false; self.selection_edge_scroll = None; self.preferred_visual_col = None; } fn cancel_empty_selection(&mut self) { if matches!(self.textarea.selection_range(), Some((start, end)) if start == end) { self.textarea.cancel_selection(); } } fn finalize_selection_drag(&mut self) { self.cancel_empty_selection(); self.clear_selection_drag_state(); } fn start_selection_drag_if_needed(&mut self) { if !self.textarea.is_selecting() { self.textarea.start_selection(); } } fn clamped_relative_x(area: Rect, column: u16) -> u16 { if area.width == 0 { return 0; } column .saturating_sub(area.x) .min(area.width.saturating_sub(1)) } fn clamped_relative_y(area: Rect, row: u16) -> u16 { if area.height == 0 { return 0; } row.saturating_sub(area.y) .min(area.height.saturating_sub(1)) } fn edge_scroll_direction(area: Rect, row: u16) -> Option { if area.height == 0 { return None; } let bottom = area.y.saturating_add(area.height.saturating_sub(1)); if row <= area.y { Some(EdgeScrollDirection::Up) } else if row >= bottom { Some(EdgeScrollDirection::Down) } else { None } } fn update_selection_edge_scroll(&mut self, area: Rect, mouse: MouseEvent) { if !self.selection_drag_active || area.width == 0 || area.height == 0 { self.selection_edge_scroll = None; return; } self.selection_edge_scroll = Self::edge_scroll_direction(area, mouse.row).map(|direction| SelectionEdgeScroll { direction, column: Self::clamped_relative_x(area, mouse.column), }); } fn move_selection_to_mouse_position(&mut self, area: Rect, mouse: MouseEvent) -> bool { let relative_x = Self::clamped_relative_x(area, mouse.column); let relative_y = Self::clamped_relative_y(area, mouse.row); let Some((target_row, target_col)) = self.cursor_for_screen_position(area, relative_x, relative_y) else { return false; }; self.textarea .move_cursor(CursorMove::Jump(target_row as u16, target_col as u16)); true } pub fn render( &mut self, frame: &mut ratatui::Frame, area: Rect, agent: &str, model: &str, provider_name: &str, reasoning_effort: Option<&str>, reasoning_effort_explicit: bool, colors: &ThemeColors, show_terminal_cursor: bool, ) { if area.width == 0 || area.height == 0 { return; } let agent_color = agent_color(agent, colors); let border_set = border::Set { vertical_left: "┃", ..border::PLAIN }; let border = Block::new() .borders(Borders::LEFT) .border_set(border_set) .border_style(Style::default().fg(agent_color)); let inner_area = border.inner(area); let bg_area = Rect { x: inner_area.x, y: inner_area.y, width: inner_area.width, height: inner_area.height.saturating_sub(1), }; let bg = Block::default().style(Style::default().bg(colors.background_element)); frame.render_widget(bg, bg_area); let h_chunks = ratatui::layout::Layout::default() .direction(ratatui::layout::Direction::Horizontal) .constraints([ ratatui::layout::Constraint::Length(2), ratatui::layout::Constraint::Min(0), ratatui::layout::Constraint::Length(2), ]) .split(inner_area); let wrap_width = h_chunks[1].width as usize; // Fit what's possible on short terminals: never request more rows // than the allocated area allows. let content_height = self.textarea_height(wrap_width) as u16; let textarea_height = if area.height <= INPUT_CHROME_HEIGHT { area.height } else { content_height.min(area.height - INPUT_CHROME_HEIGHT) }; let v_chunks = ratatui::layout::Layout::default() .direction(ratatui::layout::Direction::Vertical) .constraints([ ratatui::layout::Constraint::Length(1), ratatui::layout::Constraint::Length(textarea_height), ratatui::layout::Constraint::Length(1), ratatui::layout::Constraint::Length(1), ratatui::layout::Constraint::Length(1), ]) .split(h_chunks[1]); self.textarea_area = Some(v_chunks[1]); self.textarea .set_selection_style(Style::default().bg(colors.accent).fg(colors.text)); self.textarea .set_cursor_style(input_cursor_style(agent_color)); self.textarea .set_placeholder_style(Style::default().fg(colors.text_weak)); self.textarea.set_style( Style::default() .fg(colors.text) .bg(colors.background_element), ); let visible_lines = v_chunks[1].height as usize; self.update_viewport(visible_lines, wrap_width); self.render_wrapped_textarea(frame, v_chunks[1], colors, show_terminal_cursor); // Set the physical terminal cursor position to the textarea's cursor // location so that the IME candidate window appears at the correct position. // This is essential for CJK input methods. if show_terminal_cursor { if let Some(area) = self.textarea_area { self.set_terminal_cursor_position(frame, area); } } let mut info_spans = vec![ ratatui::text::Span::styled(agent.to_string(), Style::default().fg(agent_color)), ratatui::text::Span::raw(" "), ratatui::text::Span::styled(model.to_string(), Style::default().fg(colors.text)), ratatui::text::Span::raw(" "), ratatui::text::Span::styled( provider_name.to_string(), Style::default() .fg(colors.text_weak) .add_modifier(ratatui::style::Modifier::DIM), ), ]; if let Some(reasoning_effort) = reasoning_effort { info_spans.push(ratatui::text::Span::raw(" ")); let effort_style = if reasoning_effort_explicit { Style::default() .fg(colors.warning) .add_modifier(ratatui::style::Modifier::BOLD) } else { Style::default() .fg(colors.warning) .add_modifier(ratatui::style::Modifier::DIM) }; info_spans.push(ratatui::text::Span::styled( reasoning_effort.to_string(), effort_style, )); } let info_text = ratatui::text::Line::from(info_spans); let info_paragraph = Paragraph::new(info_text); frame.render_widget(info_paragraph, v_chunks[3]); frame.render_widget(border, area); let cap_fill_width = area.width.saturating_sub(1) as usize; let cap_fill = if colors.background_element == Color::Reset { ratatui::text::Span::raw(" ".repeat(cap_fill_width)) } else { ratatui::text::Span::styled( "▀".repeat(cap_fill_width), Style::default().fg(colors.background_element), ) }; let cap_row = Paragraph::new(ratatui::text::Line::from(vec![ ratatui::text::Span::styled("╹", Style::default().fg(agent_color)), cap_fill, ])); let cap_row_area = Rect::new(area.x, v_chunks[4].y, area.width, 1); frame.render_widget(cap_row, cap_row_area); } pub fn get_height(&self) -> u16 { // The exact wrap width is only known during render; keep the existing // compact default so layout can reserve space before the first draw. let line_count = self.textarea.lines().len().max(1); let textarea_height = line_count.min(MAX_TEXTAREA_HEIGHT) as u16; textarea_height + INPUT_CHROME_HEIGHT } pub fn get_height_for_width(&self, area_width: u16) -> u16 { let wrap_width = area_width.saturating_sub(5).max(1) as usize; self.textarea_height(wrap_width) as u16 + INPUT_CHROME_HEIGHT } /// Desired height clamped to `max_allowed` so short terminals still fit. /// Never forces the full 9-line height when there is no room. pub fn get_height_for_layout(&self, area_width: u16, max_allowed: u16) -> u16 { let desired = self.get_height_for_width(area_width); if max_allowed < MIN_INPUT_HEIGHT { desired.min(max_allowed) } else { desired.min(max_allowed.max(MIN_INPUT_HEIGHT)) } } pub fn handle_event(&mut self, event: KeyEvent) -> bool { let input = TuiInput::from(event); // push_toast(Toast::new( // format!("Input event: {:?} | {:?}", input.key, input.shift), // ToastLevel::Info, // None, // )); // Check for Shift+Enter (works in most terminals) if event.code == KeyCode::Enter && event.modifiers.contains(KeyModifiers::SHIFT) { self.reveal_cursor_after_key_input(); self.textarea.insert_newline(); self.sync_image_placeholders(); self.sync_pending_pastes(); return true; } // Fallback: Alt+Enter for terminals where Shift+Enter doesn't work if event.code == KeyCode::Enter && event.modifiers.contains(KeyModifiers::ALT) { self.reveal_cursor_after_key_input(); self.textarea.insert_newline(); self.sync_image_placeholders(); self.sync_pending_pastes(); return true; } // Regular Enter submits if event.code == KeyCode::Enter && event.modifiers == KeyModifiers::NONE { self.save_current_to_history(); return false; } // Handle Up arrow for prompt history navigation // Trigger when cursor is on first line if event.code == KeyCode::Up && event.modifiers == KeyModifiers::NONE { self.reveal_cursor_after_key_input(); if self.move_cursor_visual(-1, false) { return true; } if self.is_cursor_on_first_visual_line() { let current_text = self.get_text(); if let Some(ref mut history) = self.prompt_history { if let Some(prompt) = history.navigate_up(¤t_text) { if self.draft_state.is_none() { self.draft_state = Some(self.current_draft_state(current_text)); } self.set_text(&prompt); self.textarea.move_cursor(CursorMove::Head); return true; } } } } // Handle Down arrow for prompt history navigation if event.code == KeyCode::Down && event.modifiers == KeyModifiers::NONE { self.reveal_cursor_after_key_input(); if self.move_cursor_visual(1, false) { return true; } if self.is_cursor_on_last_visual_line() { let current_text = self.get_text(); let should_reset = if let Some(ref mut history) = self.prompt_history { if let Some(prompt) = history.navigate_down(¤t_text) { let is_empty = prompt.is_empty(); if is_empty { // Restore draft text when reaching the end of history if let Some(draft) = self.draft_state.take() { self.restore_draft_state(draft); } else { self.set_text(""); } } else { self.set_text(&prompt); } self.textarea.move_cursor(CursorMove::End); is_empty } else { false } } else { false }; if should_reset { if let Some(ref mut history) = self.prompt_history { history.reset_navigation(); } } if should_reset || self .prompt_history .as_ref() .map_or(false, |h| h.is_navigating()) { return true; } } } match event.code { KeyCode::Char('j') if event.modifiers == KeyModifiers::CONTROL => { self.reveal_cursor_after_key_input(); self.preferred_visual_col = None; self.textarea.insert_newline(); self.sync_image_placeholders(); self.sync_pending_pastes(); true } KeyCode::Char('c') if event.modifiers == KeyModifiers::CONTROL => false, KeyCode::Char('a') if event.modifiers == KeyModifiers::CONTROL => { self.move_to_line_start(false); true } KeyCode::Char('e') if event.modifiers == KeyModifiers::CONTROL => { self.move_to_line_end(false); true } KeyCode::Char('u') if event.modifiers == KeyModifiers::CONTROL => { self.delete_to_line_start(); self.sync_image_placeholders(); self.sync_pending_pastes(); true } KeyCode::Char('w') if event.modifiers == KeyModifiers::CONTROL => { self.reveal_cursor_after_key_input(); self.preferred_visual_col = None; self.delete_word_backward(); self.sync_image_placeholders(); self.sync_pending_pastes(); true } KeyCode::Left if has_command_modifier(event.modifiers) => { self.move_to_line_start(event.modifiers.contains(KeyModifiers::SHIFT)); true } KeyCode::Right if has_command_modifier(event.modifiers) => { self.move_to_line_end(event.modifiers.contains(KeyModifiers::SHIFT)); true } // macOS Option(+Shift)+Arrow: tui-textarea only word-jumps on // Ctrl+Arrow, while terminals report Option as ALT. Handle it // here so Opt+Left/Right moves by word and Opt+Shift extends // the selection by word (ditto paragraphs for Up/Down). KeyCode::Left if event.modifiers.contains(KeyModifiers::ALT) => { self.move_word_with_selection(false, event.modifiers.contains(KeyModifiers::SHIFT)); true } KeyCode::Right if event.modifiers.contains(KeyModifiers::ALT) => { self.move_word_with_selection(true, event.modifiers.contains(KeyModifiers::SHIFT)); true } // Ghostty (default macOS mode) sends Opt+Left/Right as Alt+b / Alt+f // instead of Alt+Arrow. Treat them identically, including // Opt+Shift variants (Alt+Shift+b/f, possibly as uppercase B/F). KeyCode::Char('b') | KeyCode::Char('B') if event.modifiers.contains(KeyModifiers::ALT) => { let extend = event.modifiers.contains(KeyModifiers::SHIFT) || event.code == KeyCode::Char('B'); self.move_word_with_selection(false, extend); true } KeyCode::Char('f') | KeyCode::Char('F') if event.modifiers.contains(KeyModifiers::ALT) => { let extend = event.modifiers.contains(KeyModifiers::SHIFT) || event.code == KeyCode::Char('F'); self.move_word_with_selection(true, extend); true } KeyCode::Up if event.modifiers.contains(KeyModifiers::ALT) => { self.move_paragraph_with_selection( false, event.modifiers.contains(KeyModifiers::SHIFT), ); true } KeyCode::Down if event.modifiers.contains(KeyModifiers::ALT) => { self.move_paragraph_with_selection( true, event.modifiers.contains(KeyModifiers::SHIFT), ); true } KeyCode::Tab => false, KeyCode::Esc => false, // Native behavior: plain Left/Right with an active selection // collapses to the selection edge (Left -> start, Right -> end). // Must come before the generic textarea.input() fallback, which // would otherwise move one char from the cursor. KeyCode::Left if event.modifiers == KeyModifiers::NONE && self.has_selection() => { self.collapse_selection_to_edge(true); true } KeyCode::Right if event.modifiers == KeyModifiers::NONE && self.has_selection() => { self.collapse_selection_to_edge(false); true } // Native behavior: Backspace/Delete with an active selection // erases the selection. These must come before the placeholder // fast-paths so a selection containing a placeholder deletes // the whole selection (with sync cleanup), not just the placeholder. KeyCode::Backspace if self.has_selection() => { self.reveal_cursor_after_key_input(); self.preferred_visual_col = None; self.textarea.delete_char(); self.sync_image_placeholders(); self.sync_pending_pastes(); true } KeyCode::Delete if self.has_selection() => { self.reveal_cursor_after_key_input(); self.preferred_visual_col = None; self.textarea.delete_next_char(); self.sync_image_placeholders(); self.sync_pending_pastes(); true } KeyCode::Backspace if self.remove_placeholder_at_cursor(false) => true, KeyCode::Backspace if has_command_modifier(event.modifiers) => { self.command_backspace_to_line_start(); self.sync_image_placeholders(); self.sync_pending_pastes(); true } KeyCode::Delete if self.remove_placeholder_at_cursor(true) => true, KeyCode::Backspace if event.modifiers.contains(KeyModifiers::ALT) => { self.reveal_cursor_after_key_input(); self.preferred_visual_col = None; // Handle Alt+Backspace (word-delete) ourselves to avoid // tui-textarea's buggy word boundary with multi-byte emoji self.delete_word_backward(); self.sync_image_placeholders(); self.sync_pending_pastes(); true } _ => { self.reveal_cursor_after_key_input(); self.preferred_visual_col = None; self.textarea.input(input); self.sync_image_placeholders(); self.sync_pending_pastes(); true } } } pub fn handle_mouse_event(&mut self, mouse: MouseEvent) -> bool { let textarea_area = match self.textarea_area { Some(area) => area, None => return false, }; let mouse_x = mouse.column; let mouse_y = mouse.row; // Check if mouse is within the textarea area let within_textarea = mouse_x >= textarea_area.x && mouse_x < textarea_area.x + textarea_area.width && mouse_y >= textarea_area.y && mouse_y < textarea_area.y + textarea_area.height; if !within_textarea { match mouse.kind { MouseEventKind::Drag(MouseButton::Left) if self.selection_drag_active => { self.preferred_visual_col = None; self.start_selection_drag_if_needed(); self.move_selection_to_mouse_position(textarea_area, mouse); self.update_selection_edge_scroll(textarea_area, mouse); let _ = self.tick_selection_edge_scroll(); return true; } MouseEventKind::Up(MouseButton::Left) if self.selection_drag_active => { self.finalize_selection_drag(); return false; } MouseEventKind::Moved => { self.hovered_image_placeholder = None; self.hovered_paste_placeholder = None; } _ => {} } return false; } match mouse.kind { MouseEventKind::Moved => { let previous_hover = self.hovered_image_placeholder.clone(); let previous_paste_hover = self.hovered_paste_placeholder.clone(); self.hovered_image_placeholder = self .image_at_mouse_position(textarea_area, mouse) .map(|image| image.placeholder); self.hovered_paste_placeholder = if self.hovered_image_placeholder.is_none() { self.paste_at_mouse_position(textarea_area, mouse) .map(|paste| paste.placeholder) } else { None }; previous_hover != self.hovered_image_placeholder || previous_paste_hover != self.hovered_paste_placeholder } MouseEventKind::ScrollDown => { if self.should_suppress_scroll() { return true; } self.scroll_viewport_visual(1); true } MouseEventKind::ScrollUp => { if self.should_suppress_scroll() { return true; } self.scroll_viewport_visual(-1); true } MouseEventKind::Down(MouseButton::Left) => { self.preferred_visual_col = None; let relative_x = mouse_x.saturating_sub(textarea_area.x); let relative_y = mouse_y.saturating_sub(textarea_area.y); if let Some((target_row, target_col)) = self.cursor_for_screen_position(textarea_area, relative_x, relative_y) { let offset = self.flat_offset_for_position(target_row, target_col); if let Some(image) = self.image_at_offset(offset) { self.pending_file_action = Some(image.path.clone()); return true; } if let Some((range, paste)) = self.paste_at_offset(offset) { let placeholder = paste.placeholder.clone(); self.expand_pending_paste(range, paste); push_toast(Toast::new( format!("Expanded {placeholder}"), ToastLevel::Info, None, )); return true; } // Position cursor; actual selection starts only if a drag follows. self.reveal_cursor_on_next_render(); self.textarea .move_cursor(CursorMove::Jump(target_row as u16, target_col as u16)); self.selection_drag_active = true; self.selection_edge_scroll = None; } else { let lines = self.textarea.lines(); let last_row = lines.len().saturating_sub(1); let last_col = lines[last_row].chars().count(); self.reveal_cursor_on_next_render(); self.textarea .move_cursor(CursorMove::Jump(last_row as u16, last_col as u16)); self.selection_drag_active = true; self.selection_edge_scroll = None; } true } MouseEventKind::Drag(MouseButton::Left) => { if !self.selection_drag_active { return false; } self.reveal_cursor_on_next_render(); self.preferred_visual_col = None; self.start_selection_drag_if_needed(); // Since selection is active, move_cursor extends it. self.move_selection_to_mouse_position(textarea_area, mouse); self.update_selection_edge_scroll(textarea_area, mouse); let _ = self.tick_selection_edge_scroll(); true } MouseEventKind::Up(MouseButton::Left) => { // Selection finalized (cursor was moved during drag) self.finalize_selection_drag(); true } MouseEventKind::Up(MouseButton::Right) => { // Right-click clears selection self.textarea.cancel_selection(); self.clear_selection_drag_state(); true } _ => false, } } pub fn has_selection(&self) -> bool { matches!(self.textarea.selection_range(), Some((start, end)) if start != end) } pub fn get_selected_text(&self) -> String { let range = match self.textarea.selection_range() { Some(r) => r, None => return String::new(), }; let ((start_row, start_col), (end_row, end_col)) = range; let lines = self.textarea.lines(); let mut parts = Vec::new(); for (i, line) in lines.iter().enumerate() { if i < start_row || i > end_row { continue; } let start = if i == start_row { Self::char_col_to_byte_offset(line, start_col) } else { 0 }; let end = if i == end_row { Self::char_col_to_byte_offset(line, end_col) } else { line.len() }; let start = start.min(line.len()); let end = end.min(line.len()).max(start); // Keep empty rows. They are typed blank lines, not visual wraps // (those stay inside a single logical row). parts.push(&line[start..end]); } parts.join("\n") } #[cfg(test)] pub(crate) fn set_textarea_area_for_test(&mut self, area: Rect) { self.textarea_area = Some(area); } pub fn clear_selection(&mut self) { self.textarea.cancel_selection(); self.clear_selection_drag_state(); } /// Erase the active selection, same as Backspace while text is highlighted. pub fn delete_selection(&mut self) -> bool { if !self.has_selection() { return false; } self.reveal_cursor_after_key_input(); self.preferred_visual_col = None; self.textarea.delete_char(); self.sync_image_placeholders(); self.sync_pending_pastes(); true } /// Screen Y of the first selected visual row inside the textarea, if any. pub fn selection_screen_row(&self) -> Option { let area = self.textarea_area?; if area.width == 0 || area.height == 0 { return None; } let (start, end) = self.textarea.selection_range()?; if start == end { return None; } let (sel_start, _) = if start <= end { (start, end) } else { (end, start) }; let visual_lines = self.visual_lines(area.width as usize); let visual_idx = visual_lines.iter().enumerate().find_map(|(idx, vl)| { if vl.source_row != sel_start.0 { return None; } let overlaps = sel_start.1 >= vl.start_col && (sel_start.1 < vl.end_col || (sel_start.1 == vl.end_col && vl.start_col == vl.end_col)); overlaps.then_some(idx) })?; if visual_idx < self.viewport_top || visual_idx >= self.viewport_top + area.height as usize { // Selection scrolled out of the textarea viewport — fall back to top row. return Some(area.y); } let screen_row = visual_idx - self.viewport_top; Some(area.y.saturating_add(screen_row as u16)) } /// Delete the word before the cursor. Handles multi-byte emoji correctly /// (works around a tui-textarea bug in find_word_start_backward). fn delete_word_backward(&mut self) { // Native behavior: word-delete with an active selection deletes the // selection instead of a word. Without this guard the loop below // would delete the selection AND extra characters, since the word // boundary is computed from the selection edge. if self.has_selection() { self.textarea.delete_char(); return; } let (row, cursor_col) = self.textarea.cursor(); let lines = self.textarea.lines(); let line = match lines.get(row) { Some(l) => l, None => return, }; // Find the word start by walking chars backwards from the cursor. // tui-textarea cursor columns are character indexes, not byte offsets. let cursor_col = cursor_col.min(line.chars().count()); if cursor_col == 0 { // At start of line: join with previous line if possible if row > 0 { self.textarea.move_cursor(CursorMove::Jump(row as u16, 0)); self.textarea.delete_char(); // deletes newline, joining lines } return; } // Walk backwards from the cursor to find the word boundary let chars: Vec = line.chars().collect(); let chars_rev = chars[..cursor_col].iter().enumerate().rev(); let mut chars_rev = chars_rev.peekable(); if chars_rev.peek().is_none() { return; } // Determine the category of the character just before the cursor let (_, first_char) = chars_rev.next().expect("non-empty cursor prefix"); let first_kind = char_kind(*first_char); // Scan backward to find where the word starts let mut word_start = cursor_col - 1; for (char_idx, c) in chars_rev { let kind = char_kind(*c); if kind != first_kind { // Boundary found at the character after this one. word_start = char_idx + 1; break; } word_start = char_idx; } // Delete from word_start to cursor_col if word_start < cursor_col { let char_count = cursor_col - word_start; self.textarea .move_cursor(CursorMove::Jump(row as u16, cursor_col as u16)); for _ in 0..char_count { self.textarea.delete_char(); } } } fn current_at_token(&self, allow_empty: bool) -> Option { let text = self.get_text(); let cursor = self.flat_cursor_offset().min(text.len()); if !text.is_char_boundary(cursor) { return None; } let before_cursor = &text[..cursor]; let at_index = before_cursor.rfind('@')?; if at_index > 0 { let before_at = &text[..at_index]; if !before_at .chars() .last() .map(char::is_whitespace) .unwrap_or(true) { return None; } } let query = &text[at_index + 1..cursor]; if (!allow_empty && query.is_empty()) || query.chars().any(char::is_whitespace) { return None; } let end = cursor + text[cursor..] .find(char::is_whitespace) .unwrap_or_else(|| text.len().saturating_sub(cursor)); Some(CompletionToken { query: query.to_string(), range: at_index..end, }) } fn command_query(&self) -> Option { let text = self.get_text(); if !text.starts_with('/') || text.chars().any(char::is_whitespace) { return None; } Some(text.trim_start_matches('/').to_string()) } fn char_col_to_byte_offset(line: &str, col: usize) -> usize { line.char_indices() .nth(col) .map(|(idx, _)| idx) .unwrap_or(line.len()) } fn line_char_slice(line: &str, start_col: usize, end_col: usize) -> &str { let start = Self::char_col_to_byte_offset(line, start_col); let end = Self::char_col_to_byte_offset(line, end_col); &line[start..end] } fn display_col_to_char_col( line: &str, start_col: usize, end_col: usize, display_col: usize, ) -> usize { let mut current_display = 0; for (offset, ch) in Self::line_char_slice(line, start_col, end_col) .chars() .enumerate() { let char_width = UnicodeWidthChar::width(ch).unwrap_or(1); if display_col < current_display + char_width { return start_col + offset; } current_display += char_width; } end_col } fn flat_cursor_offset(&self) -> usize { let (row, col) = self.textarea.cursor(); let lines = self.textarea.lines(); let mut offset = 0; for line in lines.iter().take(row) { offset += line.len() + 1; } offset + lines .get(row) .map(|line| Self::char_col_to_byte_offset(line, col)) .unwrap_or(0) } fn flat_offset_for_position(&self, row: usize, col: usize) -> usize { let lines = self.textarea.lines(); let mut offset = 0; for line in lines.iter().take(row) { offset += line.len() + 1; } offset + lines .get(row) .map(|line| Self::char_col_to_byte_offset(line, col)) .unwrap_or(0) } fn cursor_for_flat_offset(text: &str, mut offset: usize) -> (usize, usize) { offset = char_boundary_before(text, offset); let mut consumed = 0; for (row, line) in text.split('\n').enumerate() { let line_end = consumed + line.len(); if offset <= line_end { return (row, line[..offset - consumed].chars().count()); } consumed = line_end + 1; } let last_line = text.rsplit('\n').next().unwrap_or(""); ( text.lines().count().saturating_sub(1), last_line.chars().count(), ) } fn reset_textarea(&mut self) { self.textarea = TextArea::default(); self.textarea.set_cursor_line_style(Style::default()); self.textarea.set_selection_style( Style::default() .bg(ratatui::style::Color::Rgb(255, 140, 0)) .fg(ratatui::style::Color::Reset), ); self.clear_selection_drag_state(); } fn set_text_preserving_images(&mut self, text: &str, cursor_offset: usize) { self.reset_textarea(); self.textarea.insert_str(text); let cursor_offset = char_boundary_before(text, cursor_offset.min(text.len())); let (row, col) = Self::cursor_for_flat_offset(text, cursor_offset); self.textarea .move_cursor(CursorMove::Jump(row as u16, col as u16)); self.viewport_top = 0; self.manual_viewport_scroll = false; self.preferred_visual_col = None; self.hovered_image_placeholder = None; self.hovered_paste_placeholder = None; } fn current_draft_state(&self, text: String) -> DraftState { DraftState { text, local_images: self.local_images.clone(), pending_pastes: self.pending_pastes.clone(), } } fn restore_draft_state(&mut self, draft: DraftState) { self.reset_textarea(); self.textarea.insert_str(&draft.text); self.viewport_top = 0; self.manual_viewport_scroll = false; self.preferred_visual_col = None; self.local_images = draft.local_images; self.pending_pastes = draft.pending_pastes; self.hovered_image_placeholder = None; self.hovered_paste_placeholder = None; self.sync_image_placeholders(); self.sync_pending_pastes(); } fn expand_pending_paste(&mut self, range: Range, paste: PendingPaste) { self.pending_pastes .retain(|pending| pending.placeholder != paste.placeholder); self.replace_range(range, &paste.content); } fn image_placeholder(number: usize) -> String { format!("[Image #{}]", number) } fn next_scroll_offset(previous: usize, cursor: usize, visible_len: usize) -> usize { if visible_len == 0 { return 0; } if cursor < previous { cursor } else if previous + visible_len <= cursor { cursor + 1 - visible_len } else { previous } } fn textarea_height(&self, wrap_width: usize) -> usize { self.visual_lines(wrap_width) .len() .max(1) .min(MAX_TEXTAREA_HEIGHT) } fn visual_lines(&self, wrap_width: usize) -> Vec { let wrap_width = wrap_width.max(1); let mut visual_lines = Vec::new(); for (source_row, line) in self.textarea.lines().iter().enumerate() { let line_len = line.chars().count(); if line_len == 0 { visual_lines.push(VisualLine { source_row, start_col: 0, end_col: 0, }); continue; } let mut start_col = 0; while start_col < line_len { let mut end_col = start_col; let mut width = 0; for ch in line.chars().skip(start_col) { let ch_width = UnicodeWidthChar::width(ch).unwrap_or(0); if end_col > start_col && width + ch_width > wrap_width { break; } width += ch_width; end_col += 1; if width >= wrap_width { break; } } if end_col == start_col { end_col += 1; } visual_lines.push(VisualLine { source_row, start_col, end_col, }); start_col = end_col; } } visual_lines } fn cursor_visual_row(&self, visual_lines: &[VisualLine]) -> Option { let (cursor_row, cursor_col) = self.textarea.cursor(); let line_len = self .textarea .lines() .get(cursor_row) .map(|line| line.chars().count()) .unwrap_or(0); visual_lines .iter() .enumerate() .find_map(|(idx, visual_line)| { if visual_line.source_row != cursor_row { return None; } let contains_cursor = cursor_col >= visual_line.start_col && (cursor_col < visual_line.end_col || (cursor_col == visual_line.end_col && cursor_col == line_len)); contains_cursor.then_some(idx) }) } fn cursor_display_col(&self, visual_line: &VisualLine) -> usize { let (_, cursor_col) = self.textarea.cursor(); let Some(line) = self.textarea.lines().get(visual_line.source_row) else { return 0; }; let cursor_col = cursor_col.clamp(visual_line.start_col, visual_line.end_col); UnicodeWidthStr::width(Self::line_char_slice( line, visual_line.start_col, cursor_col, )) } fn move_cursor_visual(&mut self, direction: isize, extend_selection: bool) -> bool { let Some(area) = self.textarea_area else { return false; }; if area.width == 0 { return false; } let visual_lines = self.visual_lines(area.width as usize); let Some(current_idx) = self.cursor_visual_row(&visual_lines) else { return false; }; let target_idx = if direction < 0 { match current_idx.checked_sub(1) { Some(idx) => idx, None => return false, } } else { let idx = current_idx + 1; if idx >= visual_lines.len() { return false; } idx }; let preferred_col = self .preferred_visual_col .unwrap_or_else(|| self.cursor_display_col(&visual_lines[current_idx])); let target = &visual_lines[target_idx]; let Some(line) = self.textarea.lines().get(target.source_row) else { return false; }; let target_col = Self::display_col_to_char_col(line, target.start_col, target.end_col, preferred_col); if extend_selection { if !self.textarea.is_selecting() { self.textarea.start_selection(); } } else { self.textarea.cancel_selection(); } self.textarea.move_cursor(CursorMove::Jump( target.source_row as u16, target_col as u16, )); self.reveal_cursor_on_next_render(); self.preferred_visual_col = Some(preferred_col); true } fn scroll_viewport_visual(&mut self, direction: isize) -> bool { let Some(area) = self.textarea_area else { return false; }; if area.width == 0 || area.height == 0 { return false; } let visual_lines = self.visual_lines(area.width as usize); let max_viewport_top = visual_lines.len().saturating_sub(area.height as usize); self.viewport_top = self.viewport_top.min(max_viewport_top); if max_viewport_top == 0 { self.manual_viewport_scroll = false; return true; } self.viewport_top = if direction < 0 { self.viewport_top.saturating_sub(1) } else { self.viewport_top.saturating_add(1).min(max_viewport_top) }; self.manual_viewport_scroll = true; true } fn is_cursor_on_first_visual_line(&self) -> bool { let Some(area) = self.textarea_area else { return self.textarea.cursor().0 == 0; }; let visual_lines = self.visual_lines(area.width as usize); self.cursor_visual_row(&visual_lines) == Some(0) } fn is_cursor_on_last_visual_line(&self) -> bool { let Some(area) = self.textarea_area else { return self.textarea.cursor().0 == self.textarea.lines().len().saturating_sub(1); }; let visual_lines = self.visual_lines(area.width as usize); self.cursor_visual_row(&visual_lines) == visual_lines.len().checked_sub(1) } fn cursor_for_screen_position( &self, area: Rect, relative_x: u16, relative_y: u16, ) -> Option<(usize, usize)> { let visual_lines = self.visual_lines(area.width as usize); let visual_idx = self.viewport_top + relative_y as usize; let visual_line = visual_lines.get(visual_idx)?; let line = self.textarea.lines().get(visual_line.source_row)?; let target_col = Self::display_col_to_char_col( line, visual_line.start_col, visual_line.end_col, relative_x as usize, ); Some((visual_line.source_row, target_col)) } fn render_wrapped_textarea( &mut self, frame: &mut ratatui::Frame, area: Rect, colors: &ThemeColors, _show_cursor: bool, ) { if area.width == 0 || area.height == 0 { return; } let text_style = self.textarea.style(); // Single caret: the hardware terminal cursor is the source of truth // (Ghostty shaders, IME popups). The fake block highlight is // suppressed because on complex emoji (ZWJ sequences, VS16, flags) // the terminal's grapheme width can differ from unicode-width // tables by 1-2 cells, which otherwise shows as two split carets. let cursor_style = text_style; let selection_style = self.textarea.selection_style(); let selection_range = self.textarea.selection_range(); // Fake block cursor is always suppressed (see above); the // hardware cursor is positioned separately in `render`. let cursor = (usize::MAX, usize::MAX); let visual_lines = self.visual_lines(area.width as usize); let text = if self.is_empty() && !self.textarea.placeholder_text().is_empty() { let placeholder_style = self .textarea .placeholder_style() .unwrap_or_else(|| Style::default().fg(colors.text_weak)); Text::from(Line::from(vec![ Span::styled(" ", cursor_style), Span::styled( self.textarea.placeholder_text().to_string(), placeholder_style, ), ])) } else { let lines = self.textarea.lines(); let rendered = visual_lines .iter() .skip(self.viewport_top) .take(area.height as usize) .filter_map(|visual_line| { let line = lines.get(visual_line.source_row)?; Some(Self::render_visual_line( line, visual_line, text_style, cursor_style, selection_style, selection_range, cursor, )) }) .collect::>(); Text::from(rendered) }; frame.render_widget(Paragraph::new(text).style(text_style), area); self.style_placeholder_ranges(frame.buffer_mut(), area, colors, &visual_lines); self.style_agent_mention_ranges(frame.buffer_mut(), area, colors, &visual_lines); self.render_paste_hover_tooltip(frame.buffer_mut(), area, colors, &visual_lines); } fn set_terminal_cursor_position(&self, frame: &mut ratatui::Frame, area: Rect) { if area.width == 0 || area.height == 0 { return; } let visual_lines = self.visual_lines(area.width as usize); let Some(visual_idx) = self.cursor_visual_row(&visual_lines) else { return; }; if visual_idx < self.viewport_top || visual_idx >= self.viewport_top + area.height as usize { return; } let vl = &visual_lines[visual_idx]; let screen_row = visual_idx - self.viewport_top; // Width of chars from this visual line's start to the cursor. The // caret sits on the wrapped row, so only the suffix of the source // line matters — prefix_width - start_col mixes cell widths with // char indices and drifts right by start_col cells on CJK (width 2). let render_col = self.cursor_display_col(vl); let cursor_x = area.x + render_col.min(area.width.saturating_sub(1) as usize) as u16; let cursor_y = area.y + screen_row as u16; frame.set_cursor_position(ratatui::layout::Position { x: cursor_x, y: cursor_y, }); } fn render_visual_line( line: &str, visual_line: &VisualLine, text_style: Style, cursor_style: Style, selection_style: Style, selection_range: Option<((usize, usize), (usize, usize))>, cursor: (usize, usize), ) -> Line<'static> { let line_len = line.chars().count(); let mut spans = Vec::new(); if visual_line.start_col == visual_line.end_col { if cursor == (visual_line.source_row, visual_line.start_col) { spans.push(Span::styled(" ", cursor_style)); } return Line::from(spans); } for (idx, ch) in Self::line_char_slice(line, visual_line.start_col, visual_line.end_col) .chars() .enumerate() { let col = visual_line.start_col + idx; let mut style = text_style; if Self::position_in_selection(selection_range, visual_line.source_row, col) { style = selection_style; } if cursor == (visual_line.source_row, col) { style = cursor_style; } spans.push(Span::styled(ch.to_string(), style)); } if cursor == (visual_line.source_row, visual_line.end_col) && visual_line.end_col == line_len { spans.push(Span::styled(" ", cursor_style)); } Line::from(spans) } fn position_in_selection( selection_range: Option<((usize, usize), (usize, usize))>, row: usize, col: usize, ) -> bool { let Some((start, end)) = selection_range else { return false; }; (row, col) >= start && (row, col) < end } fn update_viewport(&mut self, visible_lines: usize, wrap_width: usize) { let visual_lines = self.visual_lines(wrap_width); let cursor_visual_row = self.cursor_visual_row(&visual_lines).unwrap_or(0); let max_viewport_top = visual_lines.len().saturating_sub(visible_lines); self.viewport_top = self.viewport_top.min(max_viewport_top); if self.manual_viewport_scroll { return; } self.viewport_top = Self::next_scroll_offset(self.viewport_top, cursor_visual_row, visible_lines) .min(max_viewport_top); } fn style_placeholder_ranges( &self, buffer: &mut Buffer, area: Rect, colors: &ThemeColors, visual_lines: &[VisualLine], ) { if area.width == 0 || area.height == 0 { return; } let lines = self.textarea.lines(); for (screen_row, visual_line) in visual_lines .iter() .skip(self.viewport_top) .take(area.height as usize) .enumerate() { let Some(line) = lines.get(visual_line.source_row) else { continue; }; let y = area.y + screen_row as u16; for image in &self.local_images { let placeholder_style = if self.hovered_image_placeholder.as_deref() == Some(image.placeholder.as_str()) { Style::default().fg(colors.markdown_image_text) } else { Style::default().fg(colors.markdown_image) }; for (start, _) in line.match_indices(&image.placeholder) { Self::style_line_byte_range( buffer, area, y, line, start..start + image.placeholder.len(), visual_line, placeholder_style, ); } } for paste in &self.pending_pastes { let placeholder_style = if self.hovered_paste_placeholder.as_deref() == Some(paste.placeholder.as_str()) { Style::default().fg(colors.markdown_image_text) } else { Style::default().fg(colors.markdown_image) }; for (start, _) in line.match_indices(&paste.placeholder) { Self::style_line_byte_range( buffer, area, y, line, start..start + paste.placeholder.len(), visual_line, placeholder_style, ); } } } } /// Agent names, then skill names that don't collide with an agent. /// Collisions keep the agent so `@explore` stays an agent mention. fn configured_mention_names(&self) -> Vec { let Some(autocomplete) = &self.autocomplete else { return Vec::new(); }; let mut names: Vec = autocomplete .agents .iter() .map(|agent| agent.name.clone()) .collect(); for skill in &autocomplete.skills { if names .iter() .any(|name| name.eq_ignore_ascii_case(&skill.name)) { continue; } names.push(skill.name.clone()); } names } fn style_agent_mention_ranges( &self, buffer: &mut Buffer, area: Rect, colors: &ThemeColors, visual_lines: &[VisualLine], ) { if area.width == 0 || area.height == 0 { return; } let agent_names = self.configured_mention_names(); if agent_names.is_empty() { return; } let lines = self.textarea.lines(); for (screen_row, visual_line) in visual_lines .iter() .skip(self.viewport_top) .take(area.height as usize) .enumerate() { let Some(line) = lines.get(visual_line.source_row) else { continue; }; let y = area.y + screen_row as u16; for (range, agent_name) in crate::agent::mention::agent_mention_ranges_in_line(line, &agent_names) { let style = Style::default().fg(agent_color(&agent_name, colors)); Self::style_line_byte_range(buffer, area, y, line, range, visual_line, style); } } } fn style_line_byte_range( buffer: &mut Buffer, area: Rect, y: u16, line: &str, range: Range, visual_line: &VisualLine, style: Style, ) { if range.start > range.end || range.end > line.len() || !line.is_char_boundary(range.start) || !line.is_char_boundary(range.end) { return; } let range_start_col = line[..range.start].chars().count(); let range_end_col = range_start_col + line[range].chars().count(); let visible_start = range_start_col.max(visual_line.start_col); let visible_end = range_end_col.min(visual_line.end_col); if visible_start >= visible_end { return; } let prefix = Self::line_char_slice(line, visual_line.start_col, visible_start); let mut x_offset = UnicodeWidthStr::width(prefix); for ch in Self::line_char_slice(line, visible_start, visible_end).chars() { if x_offset >= area.width as usize { break; } let x = area.x + x_offset as u16; if let Some(cell) = buffer.cell_mut((x, y)) { if let Some(fg) = style.fg { cell.set_fg(fg); } else { cell.set_style(style); } } x_offset += UnicodeWidthChar::width(ch).unwrap_or(0); } } fn next_large_paste_placeholder(&self, char_count: usize) -> String { let base = format!("[Pasted Content {char_count} chars]"); let prefix = format!("{base} #"); let mut max_suffix = 0usize; for paste in &self.pending_pastes { if paste.placeholder == base { max_suffix = max_suffix.max(1); continue; } if let Some(suffix) = paste.placeholder.strip_prefix(&prefix) { if let Ok(value) = suffix.parse::() { max_suffix = max_suffix.max(value); } } } if max_suffix == 0 { base } else { format!("{base} #{}", max_suffix + 1) } } fn pending_paste_indices_by_placeholder_len(&self) -> Vec { let mut indices = (0..self.pending_pastes.len()).collect::>(); indices.sort_by(|&left, &right| { self.pending_pastes[right] .placeholder .len() .cmp(&self.pending_pastes[left].placeholder.len()) .then_with(|| left.cmp(&right)) }); indices } fn pending_paste_match_at_offset( &self, text: &str, offset: usize, indices: &[usize], used_indices: &[usize], ) -> Option { indices.iter().copied().find(|idx| { !used_indices.contains(idx) && text[offset..].starts_with(&self.pending_pastes[*idx].placeholder) }) } fn pending_paste_indices_in_text(&self, text: &str) -> Vec { let indices = self.pending_paste_indices_by_placeholder_len(); let mut matched = Vec::new(); let mut offset = 0; while offset < text.len() { if let Some(idx) = self.pending_paste_match_at_offset(text, offset, &indices, &matched) { matched.push(idx); offset += self.pending_pastes[idx].placeholder.len(); } else if let Some(ch) = text[offset..].chars().next() { offset += ch.len_utf8(); } else { break; } } matched } fn sync_pending_pastes(&mut self) { if self.pending_pastes.is_empty() { return; } let text = self.get_text(); let matched = self.pending_paste_indices_in_text(&text); if matched.len() == self.pending_pastes.len() && matched.iter().copied().eq(0..self.pending_pastes.len()) { return; } self.pending_pastes = matched .into_iter() .map(|idx| self.pending_pastes[idx].clone()) .collect(); if let Some(hovered) = self.hovered_paste_placeholder.as_deref() { if !self .pending_pastes .iter() .any(|paste| paste.placeholder == hovered) { self.hovered_paste_placeholder = None; } } } fn replace_pending_pastes(&self, text: &str) -> String { let indices = self.pending_paste_indices_by_placeholder_len(); let mut expanded = String::with_capacity(text.len()); let mut used_indices = Vec::new(); let mut offset = 0; while offset < text.len() { if let Some(idx) = self.pending_paste_match_at_offset(text, offset, &indices, &used_indices) { let paste = &self.pending_pastes[idx]; expanded.push_str(&paste.content); used_indices.push(idx); offset += paste.placeholder.len(); } else if let Some(ch) = text[offset..].chars().next() { expanded.push(ch); offset += ch.len_utf8(); } else { break; } } expanded } fn replace_range(&mut self, range: Range, replacement: &str) { let text = self.get_text(); if range.start > range.end || range.end > text.len() { return; } let mut new_text = String::new(); new_text.push_str(&text[..range.start]); new_text.push_str(replacement); new_text.push_str(&text[range.end..]); let cursor_offset = range.start + replacement.len(); self.set_text_preserving_images(&new_text, cursor_offset); self.sync_image_placeholders(); self.sync_pending_pastes(); } fn quote_completion_path(path: &str) -> String { if path.chars().any(char::is_whitespace) { format!("\"{}\"", path.replace('\\', "\\\\").replace('"', "\\\"")) } else { path.to_string() } } fn remove_placeholder_at_cursor(&mut self, forward: bool) -> bool { let text = self.get_text(); let cursor = self.flat_cursor_offset().min(text.len()); let mut placeholders = self .local_images .iter() .map(|image| image.placeholder.as_str()) .chain( self.pending_pastes .iter() .map(|paste| paste.placeholder.as_str()), ) .collect::>(); placeholders.sort_by_key(|placeholder| std::cmp::Reverse(placeholder.len())); let target = placeholders.into_iter().find_map(|placeholder| { text.match_indices(placeholder).find_map(|(start, _)| { let end = start + placeholder.len(); let should_remove = if forward { cursor >= start && cursor < end } else { cursor > start && cursor <= end }; should_remove.then_some(start..end) }) }); if let Some(range) = target { self.replace_range(range, ""); true } else { false } } fn image_at_offset(&self, offset: usize) -> Option { let text = self.get_text(); self.local_images.iter().find_map(|image| { text.match_indices(&image.placeholder) .any(|(start, _)| offset >= start && offset < start + image.placeholder.len()) .then(|| image.clone()) }) } fn paste_at_offset(&self, offset: usize) -> Option<(Range, PendingPaste)> { let text = self.get_text(); self.pending_paste_indices_by_placeholder_len() .into_iter() .find_map(|idx| { let paste = &self.pending_pastes[idx]; text.match_indices(&paste.placeholder) .find_map(|(start, _)| { let end = start + paste.placeholder.len(); (offset >= start && offset < end).then(|| (start..end, paste.clone())) }) }) } fn image_at_mouse_position( &self, textarea_area: Rect, mouse: MouseEvent, ) -> Option { let relative_x = mouse.column.saturating_sub(textarea_area.x); let relative_y = mouse.row.saturating_sub(textarea_area.y); let (target_row, target_col) = self.cursor_for_screen_position(textarea_area, relative_x, relative_y)?; let offset = self.flat_offset_for_position(target_row, target_col); self.image_at_offset(offset) } fn paste_at_mouse_position( &self, textarea_area: Rect, mouse: MouseEvent, ) -> Option { let relative_x = mouse.column.saturating_sub(textarea_area.x); let relative_y = mouse.row.saturating_sub(textarea_area.y); let (target_row, target_col) = self.cursor_for_screen_position(textarea_area, relative_x, relative_y)?; let offset = self.flat_offset_for_position(target_row, target_col); self.paste_at_offset(offset).map(|(_, paste)| paste) } pub fn attach_image(&mut self, path: PathBuf) { let placeholder = Self::image_placeholder(self.local_images.len() + 1); self.reveal_cursor_on_next_render(); self.preferred_visual_col = None; self.textarea.insert_str(&placeholder); self.local_images .push(LocalImageAttachment { placeholder, path }); self.sync_image_placeholders(); } pub fn local_image_paths_for_submission(&mut self) -> Vec { self.sync_image_placeholders(); self.local_images .iter() .map(|image| image.path.clone()) .collect() } fn sync_image_placeholders(&mut self) { if self.local_images.is_empty() { return; } let mut text = self.get_text(); let mut kept = self .local_images .iter() .filter(|image| text.contains(&image.placeholder)) .cloned() .collect::>(); if kept.len() == self.local_images.len() && kept .iter() .enumerate() .all(|(idx, image)| image.placeholder == Self::image_placeholder(idx + 1)) { return; } let cursor = self.flat_cursor_offset().min(text.len()); for (idx, image) in kept.iter_mut().enumerate() { let next_placeholder = Self::image_placeholder(idx + 1); if image.placeholder != next_placeholder { text = text.replacen(&image.placeholder, &next_placeholder, 1); image.placeholder = next_placeholder; } } self.local_images = kept; if let Some(hovered) = self.hovered_image_placeholder.as_deref() { if !self .local_images .iter() .any(|image| image.placeholder == hovered) { self.hovered_image_placeholder = None; } } self.set_text_preserving_images(&text, cursor); } pub fn apply_suggestion(&mut self, suggestion: &Suggestion) { match suggestion.kind { SuggestionKind::Command => { // Trailing space so cursor sits after the command (OpenCode-style). let replacement = format!("/{} ", suggestion.replacement); let text = self.get_text(); self.replace_range(0..text.len(), &replacement); } SuggestionKind::Agent | SuggestionKind::Skill => { let Some(token) = self.current_at_token(true) else { return; }; let replacement = format!("@{} ", suggestion.replacement); self.replace_range(token.range, &replacement); } SuggestionKind::File => { let Some(token) = self.current_at_token(true) else { return; }; let path = PathBuf::from(&suggestion.replacement); if !suggestion.is_directory && image_attachment::is_supported_image_path(&path) { let placeholder = Self::image_placeholder(self.local_images.len() + 1); let replacement = format!("{placeholder} "); self.replace_range(token.range, &replacement); self.local_images .push(LocalImageAttachment { placeholder, path }); self.sync_image_placeholders(); } else { let replacement = format!("{} ", Self::quote_completion_path(&suggestion.replacement)); self.replace_range(token.range, &replacement); } } } } pub fn should_show_suggestions(&self) -> bool { self.command_query().is_some() || self.current_at_token(true).is_some() } pub fn is_slash_at_end(&self) -> bool { let text = self.get_text(); text.trim_end() == "/" } pub fn complete_selection(&mut self, is_chat: bool) { if self.autocomplete.is_some() { if let Some(selected) = self.get_autocomplete_suggestions(is_chat).first().cloned() { self.apply_suggestion(&selected); } } } pub fn get_autocomplete_selection(&self, is_chat: bool) -> Option { self.get_autocomplete_suggestions(is_chat) .first() .map(|suggestion| suggestion.name.clone()) } pub fn get_text(&self) -> String { self.textarea.lines().join("\n") } pub fn submission_text(&self) -> String { self.replace_pending_pastes(&self.get_text()) } pub fn is_empty(&self) -> bool { self.get_text().is_empty() } /// Non-mutating draft check for pending-recall refusal. /// Mirrors submit-time `!text.is_empty() || !images.is_empty()`: any /// textarea text (including image/paste placeholders) or tracked /// attachments counts as an existing draft that recall must not overwrite. pub fn has_draft_content(&self) -> bool { !self.get_text().is_empty() || !self.local_images.is_empty() || !self.pending_pastes.is_empty() } pub fn clear(&mut self) { self.reset_textarea(); self.viewport_top = 0; self.manual_viewport_scroll = false; self.preferred_visual_col = None; self.draft_state = None; self.local_images.clear(); self.pending_pastes.clear(); self.hovered_image_placeholder = None; self.hovered_paste_placeholder = None; if let Some(ref mut history) = self.prompt_history { history.reset_navigation(); } } pub fn save_current_to_history(&mut self) { let text = self.submission_text(); if !text.trim().is_empty() { if let Some(ref mut history) = self.prompt_history { let _ = history.add_prompt(&text); } } self.draft_state = None; if let Some(ref mut history) = self.prompt_history { history.reset_navigation(); } } pub fn set_placeholder(&mut self, placeholder: &'static str) { self.textarea.set_placeholder_text(placeholder); } pub fn set_text(&mut self, text: &str) { self.reset_textarea(); self.textarea.insert_str(text); self.viewport_top = 0; self.manual_viewport_scroll = false; self.preferred_visual_col = None; self.local_images.clear(); self.pending_pastes.clear(); self.hovered_image_placeholder = None; self.hovered_paste_placeholder = None; } pub fn set_text_with_local_images(&mut self, text: &str, image_paths: Vec) { let mut text = text.to_string(); let local_images = image_paths .into_iter() .enumerate() .map(|(idx, path)| { let placeholder = Self::image_placeholder(idx + 1); if !text.contains(&placeholder) { if !text.is_empty() && !text.chars().last().is_some_and(char::is_whitespace) { text.push(' '); } text.push_str(&placeholder); } LocalImageAttachment { placeholder, path } }) .collect::>(); self.reset_textarea(); self.textarea.insert_str(&text); self.viewport_top = 0; self.manual_viewport_scroll = false; self.preferred_visual_col = None; self.local_images = local_images; self.pending_pastes.clear(); self.hovered_image_placeholder = None; self.hovered_paste_placeholder = None; self.sync_image_placeholders(); } pub fn insert_char(&mut self, c: char) { self.reveal_cursor_on_next_render(); self.preferred_visual_col = None; self.textarea.insert_str(c.to_string().as_str()); self.sync_image_placeholders(); self.sync_pending_pastes(); } pub fn insert_str(&mut self, text: &str) { self.reveal_cursor_on_next_render(); self.preferred_visual_col = None; self.textarea.insert_str(text); self.sync_image_placeholders(); self.sync_pending_pastes(); } pub fn insert_paste(&mut self, text: &str) { let text = text.replace("\r\n", "\n").replace('\r', "\n"); let char_count = text.chars().count(); if char_count > LARGE_PASTE_CHAR_THRESHOLD { self.sync_pending_pastes(); let placeholder = self.next_large_paste_placeholder(char_count); self.reveal_cursor_on_next_render(); self.preferred_visual_col = None; self.textarea.insert_str(&placeholder); self.pending_pastes.push(PendingPaste { placeholder, content: text, }); self.sync_image_placeholders(); return; } self.insert_str(&text); } pub fn get_autocomplete_suggestions(&self, is_chat: bool) -> Vec { if let Some(autocomplete) = &self.autocomplete { if let Some(filter) = self.command_query() { return autocomplete.command_auto.get_suggestions(&filter, is_chat); } if let Some(token) = self.current_at_token(true) { return autocomplete.mention_suggestions(&token.query); } } Vec::new() } } fn input_cursor_style(color: Color) -> Style { if color == Color::Reset { Style::default().add_modifier(Modifier::REVERSED) } else { Style::default().bg(color).fg(contrast_text(color)) } } impl Default for Input { fn default() -> Self { Self::new() } } #[cfg(test)] mod tests { use super::*; use crate::persistence::PromptHistoryCache; use ratatui::crossterm::event::{KeyEventKind, KeyEventState}; use ratatui::style::Color; fn test_colors() -> ThemeColors { ThemeColors { primary: Color::Reset, secondary: Color::Reset, accent: Color::Yellow, interactive: Color::Reset, background: Color::Black, dialog_background: Color::Black, background_element: Color::Black, text: Color::White, text_weak: Color::Gray, text_strong: Color::White, border: Color::Gray, border_weak_focus: Color::Gray, border_focus: Color::Gray, border_strong_focus: Color::Gray, success: Color::Green, warning: Color::Yellow, error: Color::Red, info: Color::Cyan, markdown_text: Color::White, markdown_heading: Color::Yellow, markdown_link: Color::Yellow, markdown_link_text: Color::Cyan, markdown_code: Color::Green, markdown_block_quote: Color::Gray, markdown_emph: Color::Yellow, markdown_strong: Color::Yellow, markdown_horizontal_rule: Color::Gray, markdown_list_item: Color::Yellow, markdown_list_enumeration: Color::Cyan, markdown_image: Color::Red, markdown_image_text: Color::Blue, markdown_code_block: Color::White, diff_add: Color::Green, diff_add_bg: Color::Green, diff_remove: Color::Red, diff_remove_bg: Color::Red, diff_gutter: Color::Gray, } } fn backspace_event() -> KeyEvent { KeyEvent { code: KeyCode::Backspace, modifiers: KeyModifiers::empty(), kind: KeyEventKind::Press, state: KeyEventState::NONE, } } fn key_event(code: KeyCode) -> KeyEvent { KeyEvent { code, modifiers: KeyModifiers::empty(), kind: KeyEventKind::Press, state: KeyEventState::NONE, } } fn modified_key_event(code: KeyCode, modifiers: KeyModifiers) -> KeyEvent { KeyEvent { code, modifiers, kind: KeyEventKind::Press, state: KeyEventState::NONE, } } fn mouse_event(kind: MouseEventKind) -> MouseEvent { MouseEvent { kind, column: 0, row: 0, modifiers: KeyModifiers::empty(), } } fn mouse_event_at(kind: MouseEventKind, column: u16, row: u16) -> MouseEvent { MouseEvent { kind, column, row, modifiers: KeyModifiers::empty(), } } fn buffer_row_text(buffer: &ratatui::buffer::Buffer, width: u16, y: u16) -> String { (0..width) .filter_map(|x| buffer.cell((x, y)).map(|cell| cell.symbol().to_string())) .collect() } fn find_buffer_text( buffer: &ratatui::buffer::Buffer, width: u16, height: u16, needle: &str, ) -> Option<(u16, u16)> { (0..height).find_map(|y| { let row = buffer_row_text(buffer, width, y); row.find(needle).map(|x| (x as u16, y)) }) } #[test] fn test_input_creation() { let input = Input::new(); assert!(input.is_empty()); } #[test] fn test_input_default() { let input = Input::default(); assert!(input.is_empty()); } #[test] fn test_input_get_text() { let input = Input::new(); assert_eq!(input.get_text(), ""); } #[test] fn test_input_clear() { let mut input = Input::new(); input.set_placeholder("Test"); input.clear(); assert!(input.is_empty()); } #[test] fn test_input_handle_event_return_true() { let mut input = Input::new(); let event = KeyEvent { code: KeyCode::Char('a'), modifiers: KeyModifiers::empty(), kind: KeyEventKind::Press, state: KeyEventState::NONE, }; let handled = input.handle_event(event); assert!(handled); } #[test] fn test_input_handle_event_enter() { let mut input = Input::new(); let event = KeyEvent { code: KeyCode::Enter, modifiers: KeyModifiers::empty(), kind: KeyEventKind::Press, state: KeyEventState::NONE, }; let handled = input.handle_event(event); assert!(!handled); } #[test] fn test_input_handle_event_ctrl_c() { let mut input = Input::new(); let event = KeyEvent { code: KeyCode::Char('c'), modifiers: KeyModifiers::CONTROL, kind: KeyEventKind::Press, state: KeyEventState::NONE, }; let handled = input.handle_event(event); assert!(!handled); } #[test] fn test_attach_image_inserts_placeholder() { let mut input = Input::new(); let path = PathBuf::from("/tmp/example.png"); input.attach_image(path.clone()); assert_eq!(input.get_text(), "[Image #1]"); assert_eq!(input.local_image_paths_for_submission(), vec![path]); } #[test] fn test_set_text_with_local_images_restores_attachment_state() { let mut input = Input::new(); let paths = vec![ PathBuf::from("/tmp/example-1.png"), PathBuf::from("/tmp/example-2.png"), ]; input.set_text_with_local_images("see [Image #1] and [Image #2]", paths.clone()); assert_eq!(input.get_text(), "see [Image #1] and [Image #2]"); assert_eq!(input.local_image_paths_for_submission(), paths); } #[test] fn test_has_draft_content_refuses_text_and_attachments() { let mut input = Input::new(); assert!(!input.has_draft_content()); input.insert_str("draft"); assert!(input.has_draft_content()); input.clear(); assert!(!input.has_draft_content()); input.attach_image(PathBuf::from("/tmp/draft.png")); assert!(input.has_draft_content()); } #[test] fn test_history_navigation_restores_draft_image_attachment_state() { let mut input = Input::new(); input.prompt_history = Some(PromptHistoryCache::new_for_test(["previous prompt".to_string()]).unwrap()); let image_path = PathBuf::from("/tmp/example.png"); let paste = "a".repeat(LARGE_PASTE_CHAR_THRESHOLD + 1); input.insert_str("I pasted "); input.attach_image(image_path.clone()); input.insert_str(" "); input.insert_paste(&paste); assert!(input.handle_event(key_event(KeyCode::Up))); assert_eq!(input.get_text(), "previous prompt"); assert!(input.handle_event(key_event(KeyCode::Down))); assert_eq!( input.get_text(), format!( "I pasted [Image #1] [Pasted Content {} chars]", LARGE_PASTE_CHAR_THRESHOLD + 1 ) ); assert_eq!(input.local_image_paths_for_submission(), vec![image_path]); assert_eq!( input.submission_text(), format!("I pasted [Image #1] {paste}") ); } #[test] fn test_backspace_removes_image_placeholder() { let mut input = Input::new(); input.attach_image(PathBuf::from("/tmp/example.png")); let event = backspace_event(); let handled = input.handle_event(event); assert!(handled); assert_eq!(input.get_text(), ""); assert!(input.local_image_paths_for_submission().is_empty()); } #[test] fn test_large_paste_is_compacted_for_display() { let mut input = Input::new(); let paste = "a".repeat(LARGE_PASTE_CHAR_THRESHOLD + 1); input.insert_paste(&paste); assert_eq!( input.get_text(), format!("[Pasted Content {} chars]", LARGE_PASTE_CHAR_THRESHOLD + 1) ); assert_eq!(input.submission_text(), paste); } #[test] fn test_hovering_large_paste_placeholder_shows_expand_tooltip() { use ratatui::{backend::TestBackend, Terminal}; let mut input = Input::new(); let paste = "a".repeat(LARGE_PASTE_CHAR_THRESHOLD + 1); let placeholder = format!("[Pasted Content {} chars]", LARGE_PASTE_CHAR_THRESHOLD + 1); input.insert_paste(&paste); let colors = test_colors(); let backend = TestBackend::new(60, 8); let mut terminal = Terminal::new(backend).unwrap(); terminal .draw(|frame| { input.render( frame, Rect::new(0, 0, 60, 8), "Plan", "model", "provider", None, false, &colors, true, ); }) .unwrap(); let (x, y) = find_buffer_text(terminal.backend().buffer(), 60, 8, &placeholder) .expect("paste placeholder rendered"); assert!(input.handle_mouse_event(mouse_event_at(MouseEventKind::Moved, x, y))); assert_eq!( input.hovered_paste_placeholder.as_deref(), Some(placeholder.as_str()) ); terminal .draw(|frame| { input.render( frame, Rect::new(0, 0, 60, 8), "Plan", "model", "provider", None, false, &colors, true, ); }) .unwrap(); let expand = find_buffer_text(terminal.backend().buffer(), 60, 8, " expand ") .expect("expand tooltip rendered"); // Tooltip should sit in the padding row above the placeholder, not on // the second textarea row. assert_eq!(expand.1, y.saturating_sub(1)); } #[test] fn test_clicking_large_paste_placeholder_expands_irreversibly() { use ratatui::{backend::TestBackend, Terminal}; let mut input = Input::new(); let paste = "abc\ndef".repeat(150); input.insert_str("before "); input.insert_paste(&paste); input.insert_str(" after"); let placeholder = format!("[Pasted Content {} chars]", paste.chars().count()); let colors = test_colors(); let backend = TestBackend::new(80, 8); let mut terminal = Terminal::new(backend).unwrap(); terminal .draw(|frame| { input.render( frame, Rect::new(0, 0, 80, 8), "Plan", "model", "provider", None, false, &colors, true, ); }) .unwrap(); let (x, y) = find_buffer_text(terminal.backend().buffer(), 80, 8, &placeholder) .expect("paste placeholder rendered"); assert!(input.handle_mouse_event(mouse_event_at( MouseEventKind::Down(MouseButton::Left), x, y, ))); assert_eq!(input.get_text(), format!("before {paste} after")); assert!(input.pending_pastes.is_empty()); assert_eq!(input.submission_text(), input.get_text()); } #[test] fn test_clicking_duplicate_large_paste_placeholder_expands_matching_payload() { use ratatui::{backend::TestBackend, Terminal}; let mut input = Input::new(); let first = "a".repeat(LARGE_PASTE_CHAR_THRESHOLD + 1); let second = "b".repeat(LARGE_PASTE_CHAR_THRESHOLD + 1); input.insert_paste(&first); input.insert_str(" "); input.insert_paste(&second); let second_placeholder = format!( "[Pasted Content {} chars] #2", LARGE_PASTE_CHAR_THRESHOLD + 1 ); let colors = test_colors(); let backend = TestBackend::new(80, 8); let mut terminal = Terminal::new(backend).unwrap(); terminal .draw(|frame| { input.render( frame, Rect::new(0, 0, 80, 8), "Plan", "model", "provider", None, false, &colors, true, ); }) .unwrap(); let (x, y) = find_buffer_text(terminal.backend().buffer(), 80, 8, &second_placeholder) .expect("second paste placeholder rendered"); assert!(input.handle_mouse_event(mouse_event_at( MouseEventKind::Down(MouseButton::Left), x, y, ))); assert_eq!(input.pending_pastes.len(), 1); assert_eq!(input.pending_pastes[0].content, first); assert!(input.get_text().ends_with(&second)); } #[test] fn test_threshold_sized_paste_stays_inline() { let mut input = Input::new(); let paste = "a".repeat(LARGE_PASTE_CHAR_THRESHOLD); input.insert_paste(&paste); assert_eq!(input.get_text(), paste); assert_eq!(input.submission_text(), paste); } #[test] fn test_duplicate_large_paste_placeholders_are_unique() { let mut input = Input::new(); let paste = "a".repeat(LARGE_PASTE_CHAR_THRESHOLD + 1); input.insert_paste(&paste); input.insert_paste(&paste); assert_eq!( input.get_text(), format!( "[Pasted Content {} chars][Pasted Content {} chars] #2", LARGE_PASTE_CHAR_THRESHOLD + 1, LARGE_PASTE_CHAR_THRESHOLD + 1 ) ); assert_eq!(input.submission_text(), format!("{paste}{paste}")); } #[test] fn test_large_paste_payload_is_pruned_after_placeholder_erasure() { let mut input = Input::new(); let first = "a".repeat(LARGE_PASTE_CHAR_THRESHOLD + 1); let second = "b".repeat(LARGE_PASTE_CHAR_THRESHOLD + 1); input.insert_paste(&first); assert!(input.handle_event(backspace_event())); input.insert_paste(&second); assert_eq!( input.get_text(), format!("[Pasted Content {} chars]", LARGE_PASTE_CHAR_THRESHOLD + 1) ); assert_eq!(input.submission_text(), second); } #[test] fn test_large_paste_suffix_is_reused_after_latest_duplicate_erasure() { let mut input = Input::new(); let paste = "a".repeat(LARGE_PASTE_CHAR_THRESHOLD + 1); let base = format!("[Pasted Content {} chars]", LARGE_PASTE_CHAR_THRESHOLD + 1); let second = format!("{base} #2"); input.insert_paste(&paste); input.insert_paste(&paste); assert_eq!(input.get_text(), format!("{base}{second}")); assert!(input.handle_event(backspace_event())); assert_eq!(input.get_text(), base); input.insert_paste(&paste); assert_eq!(input.get_text(), format!("{base}{second}")); } #[test] fn test_backspace_removes_large_paste_placeholder() { let mut input = Input::new(); input.insert_paste(&"a".repeat(LARGE_PASTE_CHAR_THRESHOLD + 1)); let event = backspace_event(); let handled = input.handle_event(event); assert!(handled); assert_eq!(input.get_text(), ""); assert_eq!(input.submission_text(), ""); } #[test] fn test_command_backspace_at_line_start_moves_to_previous_line_end() { let mut input = Input::new(); input.insert_str("first\nsecond"); assert!(input.handle_event(modified_key_event(KeyCode::Backspace, KeyModifiers::SUPER))); assert_eq!(input.get_text(), "first\n"); assert_eq!(input.textarea.cursor(), (1, 0)); assert!(input.handle_event(modified_key_event(KeyCode::Backspace, KeyModifiers::SUPER))); assert_eq!(input.get_text(), "first\n"); assert_eq!(input.textarea.cursor(), (0, 5)); assert!(input.handle_event(modified_key_event(KeyCode::Backspace, KeyModifiers::SUPER))); assert_eq!(input.get_text(), "\n"); assert_eq!(input.textarea.cursor(), (0, 0)); } #[test] fn test_alt_backspace_deletes_single_character_words() { let mut input = Input::new(); let alt_backspace = modified_key_event(KeyCode::Backspace, KeyModifiers::ALT); input.insert_str("1. "); assert!(input.handle_event(alt_backspace)); assert_eq!(input.get_text(), "1."); assert_eq!(input.textarea.cursor(), (0, 2)); assert!(input.handle_event(alt_backspace)); assert_eq!(input.get_text(), "1"); assert_eq!(input.textarea.cursor(), (0, 1)); assert!(input.handle_event(alt_backspace)); assert_eq!(input.get_text(), ""); assert_eq!(input.textarea.cursor(), (0, 0)); } #[test] fn test_alt_backspace_deletes_single_multibyte_character() { let mut input = Input::new(); input.insert_str("🙂"); assert!(input.handle_event(modified_key_event(KeyCode::Backspace, KeyModifiers::ALT,))); assert_eq!(input.get_text(), ""); assert_eq!(input.textarea.cursor(), (0, 0)); } #[test] fn test_long_unbroken_input_wraps_instead_of_scrolling() { use ratatui::{backend::TestBackend, Terminal}; let mut input = Input::new(); input.insert_str("0123456789ABCDEF"); let colors = test_colors(); let backend = TestBackend::new(20, 10); let mut terminal = Terminal::new(backend).unwrap(); terminal .draw(|frame| { input.render( frame, Rect::new(0, 0, 20, 10), "Plan", "model", "provider", None, false, &colors, true, ); }) .unwrap(); let buffer = terminal.backend().buffer(); let first_input_row = buffer_row_text(buffer, 20, 1); let second_input_row = buffer_row_text(buffer, 20, 2); assert!(first_input_row.contains("0123456789ABCDE")); assert!(!first_input_row.contains('F')); assert!(second_input_row.contains('F')); } #[test] fn test_transparent_input_background_does_not_render_cap_strip() { use ratatui::{backend::TestBackend, Terminal}; let mut input = Input::new(); let mut colors = test_colors(); colors.background_element = Color::Reset; let backend = TestBackend::new(20, 6); let mut terminal = Terminal::new(backend).unwrap(); terminal .draw(|frame| { input.render( frame, Rect::new(0, 0, 20, 6), "Plan", "model", "provider", None, false, &colors, true, ); }) .unwrap(); let buffer = terminal.backend().buffer(); assert!(!buffer_row_text(buffer, 20, 4).contains('▀')); } #[test] fn test_input_cursor_uses_agent_color() { use ratatui::{backend::Backend, backend::TestBackend, Terminal}; let mut input = Input::new(); let mut colors = test_colors(); colors.secondary = Color::Rgb(238, 121, 72); let backend = TestBackend::new(20, 6); let mut terminal = Terminal::new(backend).unwrap(); terminal .draw(|frame| { input.render( frame, Rect::new(0, 0, 20, 6), "Build", "model", "provider", None, false, &colors, true, ); }) .unwrap(); // Agent color is still wired through the textarea cursor style. // The visible caret is the hardware terminal cursor (single-caret // design, see 99f3227); the buffer no longer carries a fake block. let expected = input_cursor_style(colors.secondary); assert_eq!(input.textarea.cursor_style(), expected); assert_eq!(expected.bg, Some(colors.secondary)); assert_eq!( expected.fg, Some(crate::theme::contrast_text(colors.secondary)) ); // Single caret: fake block highlight is suppressed so complex emoji // (ZWJ/VS16/flags) can't render two split carets. The buffer cell // keeps the text/background style instead of the agent color. let buffer = terminal.backend().buffer(); let cursor_cell = buffer.cell((3, 1)).expect("cursor cell").style(); assert_eq!(cursor_cell.bg, Some(colors.background_element)); assert_ne!(cursor_cell.bg, Some(colors.secondary)); // Hardware terminal cursor is the source of truth and sits on the // textarea caret. let pos = terminal .backend_mut() .get_cursor_position() .expect("hardware cursor"); assert_eq!((pos.x, pos.y), (3, 1)); } #[test] fn test_agent_autocomplete_is_available_outside_chat() { let mut input = Input::new().with_autocomplete( AutoComplete::new(crate::autocomplete::CommandAuto::default()).with_agents(vec![ Suggestion::agent("explore", "Explore code"), Suggestion::agent("general", "General task"), ]), ); input.insert_str("@"); let suggestions = input.get_autocomplete_suggestions(false); assert!(suggestions .iter() .any(|s| s.kind == SuggestionKind::Agent && s.name == "explore")); assert!(suggestions .iter() .any(|s| s.kind == SuggestionKind::Agent && s.name == "general")); } #[test] fn test_skill_autocomplete_is_discovered_with_mentions_not_slashes() { let root = tempfile::tempdir().unwrap(); let mut input = Input::new().with_autocomplete( AutoComplete::new_at_with_file_config( crate::autocomplete::CommandAuto::default(), root.path(), false, Vec::new(), ) .with_agents(vec![Suggestion::agent("explore", "Explore code")]) .with_skills(vec![ Suggestion::skill("ratatui", "Build terminal UIs"), Suggestion::skill("codebase-design", "Design deep modules"), ]), ); for is_chat in [false, true] { input.set_text("@"); let suggestions = input.get_autocomplete_suggestions(is_chat); assert_eq!(suggestions[0].name, "codebase-design"); assert_eq!(suggestions[0].kind, SuggestionKind::Skill); assert_eq!(suggestions[1].name, "ratatui"); assert_eq!(suggestions[2].kind, SuggestionKind::Agent); input.set_text("@CODE"); assert_eq!( input.get_autocomplete_suggestions(is_chat), vec![Suggestion::skill("codebase-design", "Design deep modules")] ); assert_eq!( input.get_autocomplete_selection(is_chat).as_deref(), Some("codebase-design") ); input.set_text("/code"); assert!(input.get_autocomplete_suggestions(is_chat).is_empty()); } } #[test] fn test_skill_completion_replaces_only_current_mention() { let mut input = Input::new(); input.set_text("Use @code and keep the rest"); input.textarea.move_cursor(CursorMove::Jump(0, 9)); input.apply_suggestion(&Suggestion::skill("codebase-design", "Design deep modules")); assert_eq!(input.get_text(), "Use @codebase-design and keep the rest"); assert_eq!(input.submission_text(), input.get_text()); assert!(!input.should_show_suggestions()); } #[test] fn test_skill_completion_inside_slash_command_arguments() { let root = tempfile::tempdir().unwrap(); let mut input = Input::new().with_autocomplete( AutoComplete::new_at_with_file_config( crate::autocomplete::CommandAuto::default(), root.path(), false, Vec::new(), ) .with_skills(vec![Suggestion::skill( "codebase-design", "Design deep modules", )]), ); input.set_text("/review @code"); input.complete_selection(true); assert_eq!(input.get_text(), "/review @codebase-design "); } #[test] fn test_wrapped_input_and_paste_increase_height_like_newlines() { let mut newline_input = Input::new(); newline_input.insert_str("a"); assert!(newline_input.handle_event(modified_key_event(KeyCode::Enter, KeyModifiers::SHIFT))); newline_input.insert_str("b"); let mut wrapped_input = Input::new(); wrapped_input.insert_str("0123456789ABCDEF"); let mut pasted_input = Input::new(); pasted_input.insert_paste("0123456789ABCDEF"); assert_eq!(newline_input.get_height_for_width(20), 6); assert_eq!(wrapped_input.get_height_for_width(20), 6); assert_eq!(pasted_input.get_height_for_width(20), 6); } #[test] fn test_up_down_move_across_wrapped_visual_lines() { let mut input = Input::new(); input.insert_str("0123456789ABCDEF"); input.textarea_area = Some(Rect::new(0, 0, 15, 6)); input.textarea.move_cursor(CursorMove::Jump(0, 0)); assert!(input.handle_event(key_event(KeyCode::Down))); assert_eq!(input.textarea.cursor(), (0, 15)); assert_eq!(input.get_text(), "0123456789ABCDEF"); assert!(input.handle_event(key_event(KeyCode::Up))); assert_eq!(input.textarea.cursor(), (0, 0)); assert_eq!(input.get_text(), "0123456789ABCDEF"); } #[test] fn test_click_then_up_down_does_not_select_wrapped_text() { let mut input = Input::new(); input.insert_str("0123456789ABCDEF"); input.textarea_area = Some(Rect::new(0, 0, 15, 6)); assert!(input.handle_mouse_event(mouse_event_at( MouseEventKind::Down(MouseButton::Left), 0, 0, ))); assert!(input.handle_mouse_event(mouse_event_at( MouseEventKind::Up(MouseButton::Left), 0, 0, ))); assert!(!input.has_selection()); assert!(input.handle_event(key_event(KeyCode::Down))); assert_eq!(input.textarea.cursor(), (0, 15)); assert!(!input.has_selection()); assert_eq!(input.get_selected_text(), ""); assert!(input.handle_event(key_event(KeyCode::Up))); assert_eq!(input.textarea.cursor(), (0, 0)); assert!(!input.has_selection()); assert_eq!(input.get_selected_text(), ""); } #[test] fn test_mouse_scroll_moves_viewport_without_moving_cursor() { let mut input = Input::new(); input.insert_str("line0\nline1\nline2\nline3\nline4\nline5\nline6"); input.textarea_area = Some(Rect::new(0, 0, 10, 3)); input.textarea.move_cursor(CursorMove::End); assert!(input.handle_mouse_event(mouse_event(MouseEventKind::ScrollDown))); assert_eq!(input.textarea.cursor(), (6, 5)); assert_eq!(input.viewport_top, 1); assert!(input.handle_mouse_event(mouse_event(MouseEventKind::ScrollUp))); assert_eq!(input.textarea.cursor(), (6, 5)); assert_eq!(input.viewport_top, 0); } #[test] fn test_typing_after_mouse_scroll_reveals_cursor() { let mut input = Input::new(); input.insert_str("line0\nline1\nline2\nline3\nline4\nline5\nline6"); input.textarea_area = Some(Rect::new(0, 0, 10, 3)); input.textarea.move_cursor(CursorMove::End); input.viewport_top = 4; assert!(input.handle_mouse_event(mouse_event(MouseEventKind::ScrollUp))); assert_eq!(input.viewport_top, 3); assert_eq!(input.textarea.cursor(), (6, 5)); assert!(input.handle_event(key_event(KeyCode::Char('!')))); input.update_viewport(3, 10); assert_eq!(input.textarea.cursor(), (6, 6)); assert_eq!(input.viewport_top, 4); } #[test] fn test_queued_scroll_after_typing_is_ignored() { let mut input = Input::new(); input.insert_str("line0\nline1\nline2\nline3\nline4\nline5\nline6"); input.textarea_area = Some(Rect::new(0, 0, 10, 3)); input.textarea.move_cursor(CursorMove::End); input.viewport_top = 2; input.manual_viewport_scroll = true; assert!(input.handle_event(key_event(KeyCode::Char('!')))); input.update_viewport(3, 10); assert_eq!(input.viewport_top, 4); assert!(input.handle_mouse_event(mouse_event(MouseEventKind::ScrollDown))); assert!(input.handle_mouse_event(mouse_event(MouseEventKind::ScrollDown))); assert_eq!(input.textarea.cursor(), (6, 6)); assert_eq!(input.viewport_top, 4); } #[test] fn test_mouse_drag_at_bottom_edge_scrolls_wrapped_input_selection() { let mut input = Input::new(); input.insert_str("0123456789ABCDEFGHIJ"); input.textarea_area = Some(Rect::new(0, 0, 5, 2)); assert!(input.handle_mouse_event(mouse_event_at( MouseEventKind::Down(MouseButton::Left), 0, 0, ))); assert!(input.handle_mouse_event(mouse_event_at( MouseEventKind::Drag(MouseButton::Left), 4, 1, ))); assert!(input.has_active_selection_edge_scroll()); assert_eq!(input.textarea.cursor(), (0, 14)); assert_eq!(input.get_selected_text(), "0123456789ABCD"); } #[test] fn image_click_requests_file_actions_without_opening() { use ratatui::{backend::TestBackend, Terminal}; let root = tempfile::tempdir().unwrap(); let path = root.path().join("screenshot.png"); std::fs::write(&path, [0, 255]).unwrap(); let mut input = Input::new(); input.attach_image(path.clone()); let colors = test_colors(); let mut terminal = Terminal::new(TestBackend::new(60, 8)).unwrap(); terminal .draw(|frame| { input.render( frame, Rect::new(0, 0, 60, 8), "Plan", "model", "provider", None, false, &colors, true, ); }) .unwrap(); let (x, y) = find_buffer_text(terminal.backend().buffer(), 60, 8, "[Image #1]") .expect("image placeholder rendered"); assert!(input.handle_mouse_event(mouse_event_at( MouseEventKind::Down(MouseButton::Left), x, y, ))); assert_eq!(input.take_file_action(), Some(path)); assert_eq!(input.take_file_action(), None); } #[test] fn test_image_and_large_paste_placeholders_render_with_same_color() { use ratatui::{backend::TestBackend, Terminal}; let mut input = Input::new(); input.attach_image(PathBuf::from("/tmp/example.png")); input.insert_str(" "); input.insert_paste(&"a".repeat(LARGE_PASTE_CHAR_THRESHOLD + 1)); let colors = test_colors(); let backend = TestBackend::new(80, 6); let mut terminal = Terminal::new(backend).unwrap(); terminal .draw(|frame| { input.render( frame, Rect::new(0, 0, 80, 6), "Plan", "model", "provider", None, false, &colors, true, ); }) .unwrap(); let buffer = terminal.backend().buffer(); let image_pos = find_buffer_text(buffer, 80, 6, "[Image #1]").expect("image placeholder"); let paste_pos = find_buffer_text(buffer, 80, 6, "[Pasted Content").expect("paste placeholder"); assert_eq!( buffer.cell(image_pos).expect("image cell").style().fg, Some(colors.markdown_image) ); assert_eq!( buffer.cell(paste_pos).expect("paste cell").style().fg, Some(colors.markdown_image) ); } #[test] fn test_hovered_image_placeholder_changes_foreground_only() { use ratatui::{backend::TestBackend, Terminal}; let mut input = Input::new(); input.attach_image(PathBuf::from("/tmp/example.png")); let colors = test_colors(); let backend = TestBackend::new(40, 6); let mut terminal = Terminal::new(backend).unwrap(); terminal .draw(|frame| { input.render( frame, Rect::new(0, 0, 40, 6), "Plan", "model", "provider", None, false, &colors, true, ); }) .unwrap(); let buffer = terminal.backend().buffer(); let image_pos = find_buffer_text(buffer, 40, 6, "[Image #1]").expect("image placeholder"); let before_style = buffer.cell(image_pos).expect("image cell").style(); assert_eq!(before_style.fg, Some(colors.markdown_image)); assert!(input.handle_mouse_event(mouse_event_at( MouseEventKind::Moved, image_pos.0, image_pos.1 ))); terminal .draw(|frame| { input.render( frame, Rect::new(0, 0, 40, 6), "Plan", "model", "provider", None, false, &colors, true, ); }) .unwrap(); let buffer = terminal.backend().buffer(); let after_style = buffer.cell(image_pos).expect("image cell").style(); assert_eq!(after_style.fg, Some(colors.markdown_image_text)); assert_eq!(after_style.bg, before_style.bg); } #[test] fn test_get_selected_text_english_ascii() { let mut input = Input::new(); input.insert_str("Hello World"); input.textarea.move_cursor(CursorMove::Jump(0, 6)); input.textarea.start_selection(); for _ in 0..5 { input.textarea.move_cursor(CursorMove::Forward); } assert!(input.has_selection()); assert_eq!(input.get_selected_text(), "World"); } #[test] fn test_get_selected_text_korean_multibyte() { let mut input = Input::new(); // "안녕하세요" = 5 Korean chars, each 3 bytes in UTF-8 (total 15 bytes) input.insert_str("안녕하세요"); // Move cursor to char position 2 (after "녕") input.textarea.move_cursor(CursorMove::Jump(0, 2)); input.textarea.start_selection(); // Move cursor forward 2 chars to select chars 2-3 ("하세") input.textarea.move_cursor(CursorMove::Forward); input.textarea.move_cursor(CursorMove::Forward); assert!(input.has_selection()); // Selection is from char 2 to char 4 (chars positions 2 and 3) // With the bug, this would produce incorrect bytes; with fix, it should be "하세" assert_eq!(input.get_selected_text(), "하세"); } #[test] fn test_get_selected_text_preserves_blank_lines() { let mut input = Input::new(); input.insert_str("Carlo is awesome\nbut yeah he's awesome\n\nSecondly, he's amazing"); let last_row = input.textarea.lines().len() - 1; let last_col = input.textarea.lines()[last_row].chars().count(); input.textarea.move_cursor(CursorMove::Jump(0, 0)); input.textarea.start_selection(); input .textarea .move_cursor(CursorMove::Jump(last_row as u16, last_col as u16)); assert_eq!( input.get_selected_text(), "Carlo is awesome\nbut yeah he's awesome\n\nSecondly, he's amazing" ); } #[test] fn test_get_selected_text_keeps_wrapped_logical_line_together() { let mut input = Input::new(); let text = "This is a very long sentence that was linebreaked because it's too long"; input.insert_str(text); let last_col = input.textarea.lines()[0].chars().count(); input.textarea.move_cursor(CursorMove::Jump(0, 0)); input.textarea.start_selection(); input .textarea .move_cursor(CursorMove::Jump(0, last_col as u16)); assert_eq!(input.get_selected_text(), text); assert!(!input.get_selected_text().contains('\n')); } #[test] fn test_cursor_position_for_ime_cjk_wrapped() { let mut input = Input::new(); // 16 CJK chars (width 2 each) = 32 cells; at wrap width 10 they wrap // every 5 chars: vl0 = chars 0..5, vl1 = chars 5..10, ... input.insert_str("你好世界你好世界你好世界你好世界"); // Cursor at char index 7 → second wrapped row input.textarea.move_cursor(CursorMove::Jump(0, 7)); let area = Rect::new(0, 0, 10, 5); // narrow input forces wrapping let (row, col) = input.textarea.cursor(); assert_eq!((row, col), (0, 7)); let visual_lines = input.visual_lines(area.width as usize); let visual_idx = input.cursor_visual_row(&visual_lines); assert!( visual_idx.is_some(), "Cursor should be found in visual lines" ); let visual_idx = visual_idx.unwrap(); assert!( visual_idx >= input.viewport_top && visual_idx < input.viewport_top + area.height as usize, "Cursor should be in the visible viewport" ); let vl = &visual_lines[visual_idx]; let screen_row = visual_idx - input.viewport_top; assert_eq!(vl.start_col, 5, "Second visual line starts at char 5"); assert_eq!(screen_row, 1, "Cursor should be on the second wrapped row"); // Width of chars 5..7 = two CJK chars = 4 cells. The buggy formula // (prefix_width - start_col = 14 - 5 = 9) would drift 5 cells right. let render_col = input.cursor_display_col(vl); assert_eq!(render_col, 4, "Suffix width from wrap start to cursor"); } #[test] fn test_cursor_position_at_visual_line_boundary() { let mut input = Input::new(); // 10 CJK chars (width 2 each) = 20 cells; at wrap width 10 they wrap // every 5 chars: vl0 = chars 0..5, vl1 = chars 5..10 input.insert_str("你好世界你好世界你好世界你好世界"); // Cursor at char index 5 — exactly at the vl0/vl1 boundary input.textarea.move_cursor(CursorMove::Jump(0, 5)); let area = Rect::new(0, 0, 10, 5); let visual_lines = input.visual_lines(area.width as usize); let visual_idx = input.cursor_visual_row(&visual_lines); assert!( visual_idx.is_some(), "Cursor should be found in visual lines" ); let visual_idx = visual_idx.unwrap(); let vl = &visual_lines[visual_idx]; // The old `cursor_col <= vl.end_col` condition would match vl0 // (end_col=5, 5 <= 5), placing the caret at cell 10 (clamped to 9) // on row 0. The correct behavior is vl1 (start_col=5, end_col=10). assert_eq!(vl.start_col, 5, "Cursor at char 5 belongs to vl1, not vl0"); // cursor_display_col should return 0 (width of chars 5..5 = empty) let render_col = input.cursor_display_col(vl); assert_eq!( render_col, 0, "Caret should be at cell 0 of the second visual line" ); // Simulate what set_terminal_cursor_position does: let screen_row = visual_idx - input.viewport_top; assert_eq!(screen_row, 1, "Cursor should be on the second wrapped row"); } #[test] fn test_cursor_position_for_ime_english() { let mut input = Input::new(); input.insert_str("Hello World"); // Cursor at position 6 (after "Hello ") input.textarea.move_cursor(CursorMove::Jump(0, 6)); let area = Rect::new(0, 0, 80, 5); let visual_lines = input.visual_lines(area.width as usize); let (_row, col) = input.textarea.cursor(); assert_eq!(col, 6); let visual_idx = input.cursor_visual_row(&visual_lines); assert!(visual_idx.is_some()); } #[test] fn test_agent_mention_ranges_match_configured_names() { let agents = vec![ "explore".to_string(), "general".to_string(), "executor".to_string(), ]; let ranges = crate::agent::mention::agent_mention_ranges_in_line( "use @explore and @General, ignore @unknown and email@explore.com", &agents, ); assert_eq!( ranges, vec![ (4..12, "explore".to_string()), (17..25, "general".to_string()), ] ); assert!( crate::agent::mention::agent_mention_ranges_in_line("no mentions", &agents).is_empty() ); } #[test] fn test_agent_mentions_render_with_agent_colors() { use crate::autocomplete::{AutoComplete, CommandAuto, Suggestion}; use crate::command::registry::Registry; use ratatui::{backend::TestBackend, Terminal}; let mut input = Input::new(); input.autocomplete = Some( AutoComplete::new(CommandAuto::new(&Registry::new())).with_agents(vec![ Suggestion::agent("explore", "Explore agent"), Suggestion::agent("general", "General agent"), ]), ); input.insert_str("@explore then @general"); let colors = test_colors(); let backend = TestBackend::new(40, 6); let mut terminal = Terminal::new(backend).unwrap(); terminal .draw(|frame| { input.render( frame, Rect::new(0, 0, 40, 6), "Plan", "model", "provider", None, false, &colors, true, ); }) .unwrap(); let buffer = terminal.backend().buffer(); let explore_pos = find_buffer_text(buffer, 40, 6, "@explore").expect("explore mention"); let general_pos = find_buffer_text(buffer, 40, 6, "@general").expect("general mention"); assert_eq!( buffer.cell(explore_pos).expect("explore cell").style().fg, Some(colors.warning) ); assert_eq!( buffer.cell(general_pos).expect("general cell").style().fg, Some(colors.success) ); } #[test] fn test_skill_mentions_render_with_the_same_mention_colors_as_agents() { use crate::autocomplete::{AutoComplete, CommandAuto, Suggestion}; use crate::command::registry::Registry; use crate::theme::agent_color; use ratatui::{backend::TestBackend, Terminal}; let mut input = Input::new(); input.autocomplete = Some( AutoComplete::new(CommandAuto::new(&Registry::new())) .with_agents(vec![Suggestion::agent("explore", "Explore agent")]) .with_skills(vec![ Suggestion::skill("explore", "Name collision stays an agent"), Suggestion::skill("codebase-design", "Design deep modules"), ]), ); input.insert_str("@explore and @codebase-design"); let colors = test_colors(); let mut terminal = Terminal::new(TestBackend::new(48, 6)).unwrap(); terminal .draw(|frame| { input.render( frame, Rect::new(0, 0, 48, 6), "Plan", "model", "provider", None, false, &colors, true, ); }) .unwrap(); let buffer = terminal.backend().buffer(); let explore_pos = find_buffer_text(buffer, 48, 6, "@explore").expect("explore mention"); let skill_pos = find_buffer_text(buffer, 48, 6, "@codebase-design").expect("skill mention"); assert_eq!( buffer.cell(explore_pos).expect("explore cell").style().fg, Some(colors.warning) ); assert_eq!( buffer.cell(skill_pos).expect("skill cell").style().fg, Some(agent_color("codebase-design", &colors)) ); } #[test] fn test_alt_shift_left_extends_selection_by_word() { let mut input = Input::new(); input.insert_str("hello world"); // Cursor at end; Opt+Shift+Left should select "world". assert!(input.handle_event(modified_key_event( KeyCode::Left, KeyModifiers::ALT | KeyModifiers::SHIFT, ))); assert!(input.has_selection()); assert_eq!(input.get_selected_text(), "world"); } #[test] fn test_alt_shift_right_extends_selection_by_word() { let mut input = Input::new(); input.insert_str("hello world"); input.textarea.move_cursor(CursorMove::Jump(0, 0)); assert!(input.handle_event(modified_key_event( KeyCode::Right, KeyModifiers::ALT | KeyModifiers::SHIFT, ))); assert!(input.has_selection()); assert_eq!(input.get_selected_text(), "hello "); } #[test] fn test_alt_left_without_shift_moves_by_word_without_selection() { let mut input = Input::new(); input.insert_str("hello world"); assert!(input.handle_event(modified_key_event(KeyCode::Left, KeyModifiers::ALT))); assert!(!input.has_selection()); assert_eq!(input.textarea.cursor(), (0, 6)); } #[test] fn test_cmd_shift_left_selects_to_line_start() { // Ghostty sends the real combo (SUPER+SHIFT); WezTerm remaps to // Shift+Home instead. Both must select to line start. let mut input = Input::new(); input.insert_str("hello world"); assert!(input.handle_event(modified_key_event( KeyCode::Left, KeyModifiers::SUPER | KeyModifiers::SHIFT, ))); assert!(input.has_selection()); assert_eq!(input.get_selected_text(), "hello world"); assert_eq!(input.textarea.cursor(), (0, 0)); } #[test] fn plain_arrows_collapse_multiline_unicode_selection() { for backwards in [false, true] { for arrow in [KeyCode::Left, KeyCode::Right] { let mut input = Input::new(); input.insert_str("aé🙂\n中xyz"); let (start, end) = ((0, 1), (1, 2)); let (anchor, edge) = if backwards { (end, start) } else { (start, end) }; input .textarea .move_cursor(CursorMove::Jump(anchor.0, anchor.1)); input.textarea.start_selection(); input.textarea.move_cursor(CursorMove::Jump(edge.0, edge.1)); assert!(input.handle_event(key_event(arrow))); assert!(!input.has_selection()); assert_eq!(input.get_text(), "aé🙂\n中xyz"); assert_eq!( input.textarea.cursor(), if arrow == KeyCode::Left { (0, 1) } else { (1, 2) } ); assert!(input.handle_event(key_event(arrow))); assert_eq!( input.textarea.cursor(), if arrow == KeyCode::Left { (0, 0) } else { (1, 3) } ); } } } #[test] fn backspace_deletes_shift_selection() { let mut input = Input::new(); input.insert_str("hello world"); for _ in 0..5 { assert!(input.handle_event(modified_key_event(KeyCode::Left, KeyModifiers::SHIFT,))); } assert!(input.has_selection(), "expected selection after shift-left"); assert_eq!(input.get_selected_text(), "world"); assert!(input.handle_event(key_event(KeyCode::Backspace))); assert_eq!(input.get_text(), "hello "); assert!(!input.has_selection()); } #[test] fn backspace_deletes_opt_shift_selection() { let mut input = Input::new(); input.insert_str("hello world"); assert!(input.handle_event(modified_key_event( KeyCode::Left, KeyModifiers::ALT | KeyModifiers::SHIFT, ))); assert!(input.has_selection()); assert_eq!(input.get_selected_text(), "world"); assert!(input.handle_event(key_event(KeyCode::Backspace))); assert_eq!(input.get_text(), "hello "); } #[test] fn alt_backspace_with_selection_deletes_only_selection() { let mut input = Input::new(); input.insert_str("hello world"); assert!(input.handle_event(modified_key_event( KeyCode::Left, KeyModifiers::ALT | KeyModifiers::SHIFT, ))); assert!(input.has_selection()); assert!(input.handle_event(modified_key_event(KeyCode::Backspace, KeyModifiers::ALT,))); assert_eq!(input.get_text(), "hello "); } }