Add Rust CLI suggestion functionality

  - Implement canned prompt suggestions similar to TypeScript CLI
  - Add suggestion detection and rendering in chat_composer.rs
  - Use Option<usize> for type-safe selection indexing
  - Auto-hide suggestions when user starts typing
  - Add test coverage

Author: dallonasnes

codex-rs/tui/src/bottom_pane/chat_composer.rs

@@ -30,24 +30,33 @@ pub enum InputResult {
     None,
 }
 
+const SUGGESTIONS: &[&str] = &[
+    "explain this codebase to me",
+    "fix any build errors",
+    "are there any bugs in my code?",
+];
+
 pub(crate) struct ChatComposer<'a> {
     textarea: TextArea<'a>,
     command_popup: Option<CommandPopup>,
     app_event_tx: AppEventSender,
     history: ChatComposerHistory,
+    selected_suggestion: Option<usize>,
+    has_user_typed: bool,
 }
 
 impl ChatComposer<'_> {
     pub fn new(has_input_focus: bool, app_event_tx: AppEventSender) -> Self {
         let mut textarea = TextArea::default();
-        textarea.set_placeholder_text("send a message");
         textarea.set_cursor_line_style(ratatui::style::Style::default());
 
         let mut this = Self {
             textarea,
             command_popup: None,
             app_event_tx,
             history: ChatComposerHistory::new(),
+            selected_suggestion: None,
+            has_user_typed: false,
         };
         this.update_border(has_input_focus);
         this
@@ -154,6 +163,43 @@ impl ChatComposer<'_> {
     /// Handle key event when no popup is visible.
     fn handle_key_event_without_popup(&mut self, key_event: KeyEvent) -> (InputResult, bool) {
         let input: Input = key_event.into();
+
+        // Handle suggested prompts when input is empty
+        if !self.has_user_typed && self.is_input_empty() {
+            match input {
+                Input { key: Key::Right, shift: false, .. } => {
+                    // Cycle forward through suggestions
+                    self.selected_suggestion = match self.selected_suggestion {
+                        None => Some(0),
+                        Some(i) if i >= SUGGESTIONS.len() - 1 => None,
+                        Some(i) => Some(i + 1),
+                    };
+                    return (InputResult::None, true);
+                }
+                Input { key: Key::Left, shift: false, .. } => {
+                    // Cycle backward through suggestions
+                    self.selected_suggestion = match self.selected_suggestion {
+                        None => Some(SUGGESTIONS.len() - 1),
+                        Some(0) => None,
+                        Some(i) => Some(i - 1),
+                    };
+                    return (InputResult::None, true);
+                }
+                Input {
+                    key: Key::Enter,
+                    shift: false,
+                    alt: false,
+                    ctrl: false,
+                } if self.selected_suggestion.is_some() => {
+                    if let Some(index) = self.selected_suggestion.take() {
+                        let suggestion = SUGGESTIONS[index];
+                        return (InputResult::Submitted(suggestion.to_string()), true);
+                    }
+                }
+                _ => {}
+            }
+        }
+
         match input {
             // -------------------------------------------------------------
             // History navigation (Up / Down) – only when the composer is not
@@ -191,6 +237,7 @@ impl ChatComposer<'_> {
                 let text = self.textarea.lines().join("\n");
                 self.textarea.select_all();
                 self.textarea.cut();
+                self.has_user_typed = false;
 
                 if text.is_empty() {
                     (InputResult::None, true)
@@ -218,6 +265,9 @@ impl ChatComposer<'_> {
     /// Handle generic Input events that modify the textarea content.
     fn handle_input_basic(&mut self, input: Input) -> (InputResult, bool) {
         self.textarea.input(input);
+        self.selected_suggestion = None;
+        // Mark that user has typed, but reset if input becomes empty
+        self.has_user_typed = !self.is_input_empty();
         (InputResult::None, true)
     }
 
@@ -290,6 +340,71 @@ impl ChatComposer<'_> {
     pub(crate) fn is_command_popup_visible(&self) -> bool {
         self.command_popup.is_some()
     }
+
+    pub(crate) fn is_input_empty(&self) -> bool {
+        self.textarea.lines().iter().all(|line| line.trim().is_empty())
+    }
+
+    pub(crate) fn should_show_suggestions(&self) -> bool {
+        !self.has_user_typed && self.is_input_empty()
+    }
+
+    pub(crate) fn get_suggestion_state(&self) -> (Option<usize>, &'static [&'static str]) {
+        (self.selected_suggestion, SUGGESTIONS)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #![expect(clippy::expect_used)]
+    use super::*;
+    use crate::app_event_sender::AppEventSender;
+    use std::sync::mpsc::channel;
+
+    #[test]
+    fn test_is_input_empty_with_empty_textarea() {
+        let (tx, _rx) = channel();
+        let tx = AppEventSender::new(tx);
+        let composer = ChatComposer::new(false, tx);
+        
+        assert!(composer.is_input_empty());
+    }
+
+    #[test]
+    fn test_is_input_empty_with_whitespace_only() {
+        let (tx, _rx) = channel();
+        let tx = AppEventSender::new(tx);
+        let mut composer = ChatComposer::new(false, tx);
+        
+        // Add whitespace-only content
+        composer.textarea.insert_str("   \t  \n  ");
+        
+        assert!(composer.is_input_empty());
+    }
+
+    #[test]
+    fn test_is_input_empty_with_actual_content() {
+        let (tx, _rx) = channel();
+        let tx = AppEventSender::new(tx);
+        let mut composer = ChatComposer::new(false, tx);
+        
+        // Add actual content
+        composer.textarea.insert_str("hello world");
+        
+        assert!(!composer.is_input_empty());
+    }
+
+    #[test]
+    fn test_is_input_empty_with_mixed_content() {
+        let (tx, _rx) = channel();
+        let tx = AppEventSender::new(tx);
+        let mut composer = ChatComposer::new(false, tx);
+        
+        // Add mixed whitespace and content
+        composer.textarea.insert_str("  \n  hello  \n  ");
+        
+        assert!(!composer.is_input_empty());
+    }
 }
 
 impl WidgetRef for &ChatComposer<'_> {

codex-rs/tui/src/bottom_pane/mod.rs

@@ -167,6 +167,16 @@ impl BottomPane<'_> {
         self.active_view.is_none() && self.composer.is_command_popup_visible()
     }
 
+    /// Get suggestion state for rendering (selected_index, suggestions_array, should_show)
+    pub(crate) fn get_suggestion_info(&self, is_conversation_new: bool) -> Option<(Option<usize>, &'static [&'static str])> {
+        if self.active_view.is_none() && is_conversation_new && self.composer.should_show_suggestions() {
+            let (selected, suggestions) = self.composer.get_suggestion_state();
+            Some((selected, suggestions))
+        } else {
+            None
+        }
+    }
+
     // --- History helpers ---
 
     pub(crate) fn set_history_metadata(&mut self, log_id: u64, entry_count: usize) {

codex-rs/tui/src/chatwidget.rs

@@ -24,8 +24,12 @@ use ratatui::layout::Constraint;
 use ratatui::layout::Direction;
 use ratatui::layout::Layout;
 use ratatui::layout::Rect;
+use ratatui::style::{Color, Style};
+use ratatui::text::{Line, Span};
+use ratatui::widgets::Paragraph;
 use ratatui::widgets::Widget;
 use ratatui::widgets::WidgetRef;
+use ratatui::widgets::Wrap;
 use tokio::sync::mpsc::UnboundedSender;
 use tokio::sync::mpsc::unbounded_channel;
 
@@ -395,18 +399,70 @@ impl ChatWidget<'_> {
             tracing::error!("failed to submit op: {e}");
         }
     }
+
+    fn render_suggestions(&self, area: Rect, buf: &mut Buffer, selected_suggestion: Option<usize>, suggestions: &[&str]) {
+
+        // Pre-allocate spans vector to avoid reallocations
+        let mut spans = Vec::with_capacity(suggestions.len() * 2);
+        
+        // Use static styles to avoid repeated allocations
+        const TRY_STYLE: Style = Style::new().fg(Color::DarkGray);
+        const NORMAL_STYLE: Style = Style::new().fg(Color::DarkGray);
+        const SELECTED_STYLE: Style = Style::new().bg(Color::DarkGray).fg(Color::White);
+        const SEPARATOR_STYLE: Style = Style::new().fg(Color::DarkGray);
+        
+        spans.push(Span::styled("try: ", TRY_STYLE));
+        
+        for (index, suggestion) in suggestions.iter().enumerate() {
+            if index > 0 {
+                spans.push(Span::styled(" | ", SEPARATOR_STYLE));
+            }
+            
+            let style = if Some(index) == selected_suggestion {
+                SELECTED_STYLE
+            } else {
+                NORMAL_STYLE
+            };
+            
+            spans.push(Span::styled(*suggestion, style));
+        }
+
+        let paragraph = Paragraph::new(Line::from(spans))
+            .wrap(Wrap { trim: true });
+        
+        paragraph.render(area, buf);
+    }
 }
 
 impl WidgetRef for &ChatWidget<'_> {
     fn render_ref(&self, area: Rect, buf: &mut Buffer) {
         let bottom_height = self.bottom_pane.calculate_required_height(&area);
+        
+        let is_conversation_new = self.conversation_history.is_conversation_new();
+        let suggestion_info = self.bottom_pane.get_suggestion_info(is_conversation_new);
+        
+        // Check if we need extra space for suggestions
+        let suggestions_height = if suggestion_info.is_some() {
+            1 // One line for suggestions
+        } else {
+            0
+        };
 
         let chunks = Layout::default()
             .direction(Direction::Vertical)
-            .constraints([Constraint::Min(0), Constraint::Length(bottom_height)])
+            .constraints([
+                Constraint::Min(0), 
+                Constraint::Length(bottom_height),
+                Constraint::Length(suggestions_height)
+            ])
             .split(area);
 
         self.conversation_history.render(chunks[0], buf);
         (&self.bottom_pane).render(chunks[1], buf);
+        
+        // Render suggestions if present
+        if let Some((selected_suggestion, suggestions)) = suggestion_info {
+            self.render_suggestions(chunks[2], buf, selected_suggestion, suggestions);
+        }
     }
 }

codex-rs/tui/src/conversation_history_widget.rs

@@ -51,6 +51,12 @@ impl ConversationHistoryWidget {
         self.has_input_focus = has_input_focus;
     }
 
+    pub(crate) fn is_conversation_new(&self) -> bool {
+        !self.entries.iter().any(|entry| 
+            matches!(entry.cell, HistoryCell::UserPrompt { .. })
+        )
+    }
+
     /// Returns true if it needs a redraw.
     pub(crate) fn handle_key_event(&mut self, key_event: KeyEvent) -> bool {
         match key_event.code {