TUI: add mouse scroll and text selection support

Enable crossterm MouseCapture to handle scroll events (3 lines per
tick) and click-drag text selection with reversed-color highlighting.
Selected text is auto-copied to clipboard on mouse release using
platform commands (pbcopy/xclip/xsel). Selection clears on new
streaming content and clicks outside the chat panel.

Author: k29

tycode-cli/src/tui/app.rs

@@ -1,11 +1,16 @@
 use anyhow::Result;
 use crossterm::{
-    event::{EnableBracketedPaste, DisableBracketedPaste, Event as CrosstermEvent, EventStream, KeyboardEnhancementFlags, PushKeyboardEnhancementFlags, PopKeyboardEnhancementFlags},
+    event::{
+        DisableBracketedPaste, DisableMouseCapture, EnableBracketedPaste, EnableMouseCapture,
+        Event as CrosstermEvent, EventStream, KeyboardEnhancementFlags,
+        MouseButton, MouseEvent, MouseEventKind, PopKeyboardEnhancementFlags,
+        PushKeyboardEnhancementFlags,
+    },
     execute,
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
 };
 use futures::StreamExt;
-use ratatui::{backend::CrosstermBackend, Terminal};
+use ratatui::{backend::CrosstermBackend, layout::Position, Terminal};
 use std::io;
 use std::path::PathBuf;
 use std::time::Duration;
@@ -92,7 +97,7 @@ impl TuiApp {
         // Setup terminal
         enable_raw_mode()?;
         let mut stdout = io::stdout();
-        execute!(stdout, EnterAlternateScreen, EnableBracketedPaste)?;
+        execute!(stdout, EnterAlternateScreen, EnableBracketedPaste, EnableMouseCapture)?;
         // Try to enable keyboard enhancement (for Shift+Enter support).
         // This is only supported by some terminals (Kitty, WezTerm, foot, etc.)
         // so we ignore failures.
@@ -116,7 +121,7 @@ impl TuiApp {
         let original_hook = std::panic::take_hook();
         std::panic::set_hook(Box::new(move |panic_info| {
             let _ = disable_raw_mode();
-            let _ = execute!(io::stdout(), PopKeyboardEnhancementFlags, DisableBracketedPaste, LeaveAlternateScreen);
+            let _ = execute!(io::stdout(), PopKeyboardEnhancementFlags, DisableMouseCapture, DisableBracketedPaste, LeaveAlternateScreen);
             original_hook(panic_info);
         }));
 
@@ -151,23 +156,31 @@ impl TuiApp {
 
                 // Poll crossterm events (async)
                 Some(Ok(crossterm_event)) = crossterm_reader.next() => {
-                    if let CrosstermEvent::Key(key) = crossterm_event {
-                        match handle_key_event(key, &mut textarea, &mut self.state) {
-                            TuiAction::SendMessage(text) => {
-                                self.send_user_message(&text)?;
+                    match crossterm_event {
+                        CrosstermEvent::Key(key) => {
+                            match handle_key_event(key, &mut textarea, &mut self.state) {
+                                TuiAction::SendMessage(text) => {
+                                    self.send_user_message(&text)?;
+                                }
+                                TuiAction::Cancel => {
+                                    self.chat_actor.cancel()?;
+                                }
+                                TuiAction::Quit => {
+                                    self.state.should_quit = true;
+                                }
+                                TuiAction::None => {}
                             }
-                            TuiAction::Cancel => {
-                                self.chat_actor.cancel()?;
-                            }
-                            TuiAction::Quit => {
-                                self.state.should_quit = true;
-                            }
-                            TuiAction::None => {}
                         }
-                    } else if let CrosstermEvent::Paste(text) = crossterm_event {
-                        textarea.insert_str(&text);
-                    } else if let CrosstermEvent::Resize(_, _) = crossterm_event {
-                        // Terminal will re-render on next loop iteration
+                        CrosstermEvent::Mouse(mouse) => {
+                            self.handle_mouse_event(mouse);
+                        }
+                        CrosstermEvent::Paste(text) => {
+                            textarea.insert_str(&text);
+                        }
+                        CrosstermEvent::Resize(_, _) => {
+                            // Terminal will re-render on next loop iteration
+                        }
+                        _ => {}
                     }
                 }
 
@@ -242,11 +255,144 @@ impl TuiApp {
         Ok(())
     }
 
+    fn handle_mouse_event(&mut self, mouse: MouseEvent) {
+        let col = mouse.column;
+        let row = mouse.row;
+        let in_chat = self
+            .state
+            .chat_area
+            .contains(Position { x: col, y: row });
+
+        match mouse.kind {
+            MouseEventKind::ScrollUp if in_chat => {
+                self.state.scroll_up(3);
+            }
+            MouseEventKind::ScrollDown if in_chat => {
+                self.state.scroll_down(3);
+            }
+            MouseEventKind::Down(MouseButton::Left) => {
+                if in_chat {
+                    self.state.selection.start = (col, row);
+                    self.state.selection.end = (col, row);
+                    self.state.selection.is_dragging = true;
+                    self.state.selection.has_selection = false;
+                } else {
+                    self.state.selection.clear();
+                }
+            }
+            MouseEventKind::Drag(MouseButton::Left) if self.state.selection.is_dragging => {
+                // Clamp to chat area bounds
+                let clamped_col = col.clamp(self.state.chat_area.x, self.state.chat_area.right().saturating_sub(1));
+                let clamped_row = row.clamp(self.state.chat_area.y, self.state.chat_area.bottom().saturating_sub(1));
+                self.state.selection.end = (clamped_col, clamped_row);
+                self.state.selection.has_selection = true;
+            }
+            MouseEventKind::Up(MouseButton::Left) => {
+                if self.state.selection.has_selection {
+                    self.state.selection.is_dragging = false;
+                    let text = self.extract_selected_text();
+                    if !text.is_empty() {
+                        Self::copy_to_clipboard(&text);
+                    }
+                } else {
+                    self.state.selection.clear();
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn extract_selected_text(&self) -> String {
+        let ((sx, sy), (ex, ey)) = self.state.selection.normalized();
+        let area = self.state.chat_area;
+
+        // Convert terminal-absolute coords to chat-area-relative
+        let rel_sy = sy.saturating_sub(area.y) as usize;
+        let rel_ey = ey.saturating_sub(area.y) as usize;
+        let rel_sx = sx.saturating_sub(area.x) as usize;
+        let rel_ex = ex.saturating_sub(area.x) as usize;
+
+        let mut lines = Vec::new();
+        for row_idx in rel_sy..=rel_ey {
+            if row_idx >= self.state.screen_text.len() {
+                break;
+            }
+            let line = &self.state.screen_text[row_idx];
+            let start_col = if row_idx == rel_sy { rel_sx } else { 0 };
+            let end_col = if row_idx == rel_ey {
+                (rel_ex + 1).min(line.len())
+            } else {
+                line.len()
+            };
+
+            if start_col < line.len() {
+                let selected: String = line
+                    .chars()
+                    .skip(start_col)
+                    .take(end_col.saturating_sub(start_col))
+                    .collect();
+                lines.push(selected.trim_end().to_string());
+            } else {
+                lines.push(String::new());
+            }
+        }
+
+        // Remove trailing empty lines
+        while lines.last().map_or(false, |l| l.is_empty()) {
+            lines.pop();
+        }
+
+        lines.join("\n")
+    }
+
+    fn copy_to_clipboard(text: &str) {
+        #[cfg(target_os = "macos")]
+        {
+            use std::process::{Command, Stdio};
+            if let Ok(mut child) = Command::new("pbcopy")
+                .stdin(Stdio::piped())
+                .spawn()
+            {
+                if let Some(stdin) = child.stdin.as_mut() {
+                    use std::io::Write;
+                    let _ = stdin.write_all(text.as_bytes());
+                }
+                let _ = child.wait();
+            }
+        }
+        #[cfg(target_os = "linux")]
+        {
+            use std::process::{Command, Stdio};
+            use std::io::Write;
+            // Try xclip first, fall back to xsel
+            let result = Command::new("xclip")
+                .args(["-selection", "clipboard"])
+                .stdin(Stdio::piped())
+                .spawn();
+            if let Ok(mut child) = result {
+                if let Some(stdin) = child.stdin.as_mut() {
+                    let _ = stdin.write_all(text.as_bytes());
+                }
+                let _ = child.wait();
+            } else if let Ok(mut child) = Command::new("xsel")
+                .args(["--clipboard", "--input"])
+                .stdin(Stdio::piped())
+                .spawn()
+            {
+                if let Some(stdin) = child.stdin.as_mut() {
+                    let _ = stdin.write_all(text.as_bytes());
+                }
+                let _ = child.wait();
+            }
+        }
+    }
+
     fn restore_terminal(&mut self) -> Result<()> {
         disable_raw_mode()?;
         execute!(
             self.terminal.backend_mut(),
             PopKeyboardEnhancementFlags,
+            DisableMouseCapture,
             DisableBracketedPaste,
             LeaveAlternateScreen
         )?;
@@ -261,6 +407,7 @@ impl Drop for TuiApp {
         let _ = execute!(
             self.terminal.backend_mut(),
             PopKeyboardEnhancementFlags,
+            DisableMouseCapture,
             DisableBracketedPaste,
             LeaveAlternateScreen
         );

tycode-cli/src/tui/state.rs

@@ -1,8 +1,43 @@
+use ratatui::layout::Rect;
 use tycode_core::ai::types::TokenUsage;
 use tycode_core::modules::task_list::TaskList;
 
 use crate::state::State;
 
+/// Tracks mouse-based text selection in the chat panel.
+#[derive(Clone, Debug, Default)]
+pub struct SelectionState {
+    /// Starting position of the selection (terminal-absolute coordinates).
+    pub start: (u16, u16),
+    /// Ending position of the selection (terminal-absolute coordinates).
+    pub end: (u16, u16),
+    /// Whether the user is currently dragging (mouse button held).
+    pub is_dragging: bool,
+    /// Whether there is a valid selection (drag moved at least 1 cell).
+    pub has_selection: bool,
+}
+
+impl SelectionState {
+    /// Returns start and end in reading order (top-left to bottom-right).
+    pub fn normalized(&self) -> ((u16, u16), (u16, u16)) {
+        let (sx, sy) = self.start;
+        let (ex, ey) = self.end;
+        if sy < ey || (sy == ey && sx <= ex) {
+            ((sx, sy), (ex, ey))
+        } else {
+            ((ex, ey), (sx, sy))
+        }
+    }
+
+    /// Clear the selection state.
+    pub fn clear(&mut self) {
+        self.start = (0, 0);
+        self.end = (0, 0);
+        self.is_dragging = false;
+        self.has_selection = false;
+    }
+}
+
 /// A single entry in the chat history panel.
 #[derive(Clone, Debug)]
 #[allow(dead_code)]
@@ -102,6 +137,15 @@ pub struct TuiState {
 
     /// Banner info for initial display.
     pub banner_data: Option<BannerData>,
+
+    /// The chat panel area rect (stored from layout for mouse hit-testing).
+    pub chat_area: Rect,
+
+    /// Mouse-based text selection state.
+    pub selection: SelectionState,
+
+    /// Buffer snapshot of the chat panel text (one String per row).
+    pub screen_text: Vec<String>,
 }
 
 impl TuiState {
@@ -132,6 +176,9 @@ impl TuiState {
             should_quit: false,
             awaiting_response: false,
             banner_data,
+            chat_area: Rect::default(),
+            selection: SelectionState::default(),
+            screen_text: Vec::new(),
         }
     }
 
@@ -140,6 +187,7 @@ impl TuiState {
         self.chat_history.push(entry);
         if self.auto_scroll {
             self.scroll_offset = 0;
+            self.selection.clear();
         }
     }
 

tycode-cli/src/tui/ui.rs

@@ -1,5 +1,6 @@
 use ratatui::{
     layout::{Constraint, Direction, Layout, Margin},
+    style::Modifier,
     Frame,
 };
 use tui_textarea::TextArea;
@@ -32,4 +33,42 @@ pub fn draw_ui(frame: &mut Frame, state: &mut TuiState, textarea: &TextArea) {
     input_area::render(frame, chunks[1], textarea);
     // chunks[2] is the empty gap line - just leave it blank
     status_bar::render(frame, chunks[3], state);
+
+    // Store chat area rect for mouse hit-testing
+    state.chat_area = chunks[0];
+
+    // Snapshot the chat panel buffer text for text extraction
+    let area = chunks[0];
+    let buf = frame.buffer_mut();
+    let mut screen_text = Vec::with_capacity(area.height as usize);
+    for row in area.y..area.bottom() {
+        let mut line = String::with_capacity(area.width as usize);
+        for col in area.x..area.right() {
+            let cell = &buf[(col, row)];
+            line.push_str(cell.symbol());
+        }
+        screen_text.push(line);
+    }
+    state.screen_text = screen_text;
+
+    // Apply selection highlight (reversed video)
+    if state.selection.has_selection {
+        let ((sx, sy), (ex, ey)) = state.selection.normalized();
+        for row in sy..=ey {
+            if row < area.y || row >= area.bottom() {
+                continue;
+            }
+            let col_start = if row == sy { sx.max(area.x) } else { area.x };
+            let col_end = if row == ey {
+                (ex + 1).min(area.right())
+            } else {
+                area.right()
+            };
+            for col in col_start..col_end {
+                let cell = &mut buf[(col, row)];
+                let style = cell.style().add_modifier(Modifier::REVERSED);
+                cell.set_style(style);
+            }
+        }
+    }
 }