Merge pull request #92 from 7df-lab/dev/tui0609

fix: update tui slash and turn rendering

Author: wangtsiao

crates/tui/src/bottom_pane/chat_composer.rs

@@ -3839,6 +3839,59 @@ impl ChatComposer {
         } else {
             StatefulWidgetRef::render_ref(&(&self.textarea), textarea_rect, buf, &mut state);
         }
+        let slash_parameter_hint =
+            if !textarea_is_empty && self.input_enabled && mask_char.is_none() {
+                let text = self.textarea.text();
+                let cursor = self.textarea.cursor();
+                let first_line_end = text.find('\n').unwrap_or(text.len());
+                if cursor == text.len() && first_line_end == text.len() {
+                    parse_slash_name(text).and_then(|(name, rest, _rest_offset)| {
+                        if rest.is_empty() && !name.contains('/') {
+                            slash_commands::find_builtin_command(name, self.builtin_command_flags())
+                                .and_then(SlashCommand::parameter_hint)
+                        } else {
+                            None
+                        }
+                    })
+                } else {
+                    None
+                }
+            } else {
+                None
+            };
+        if let Some(hint) = slash_parameter_hint
+            && let Some((cursor_x, cursor_y)) =
+                self.textarea.cursor_pos_with_state(textarea_rect, *state)
+            && cursor_y < textarea_rect.y.saturating_add(textarea_rect.height)
+            && cursor_x < textarea_rect.x.saturating_add(textarea_rect.width)
+        {
+            let hint_text = if self
+                .textarea
+                .text()
+                .chars()
+                .next_back()
+                .is_some_and(char::is_whitespace)
+            {
+                hint.to_string()
+            } else {
+                format!(" {hint}")
+            };
+            let remaining_width = textarea_rect
+                .x
+                .saturating_add(textarea_rect.width)
+                .saturating_sub(cursor_x);
+            if remaining_width > 0 {
+                let hint_span = if is_zellij {
+                    Span::styled(
+                        hint_text,
+                        textarea_style.fg(ratatui::style::Color::DarkGray),
+                    )
+                } else {
+                    Span::from(hint_text).dim()
+                };
+                buf.set_span(cursor_x, cursor_y, &hint_span, remaining_width);
+            }
+        }
         if textarea_is_empty {
             let text = if self.input_enabled {
                 self.placeholder_text.as_str().to_string()

crates/tui/src/bottom_pane/input_mode.rs

@@ -2,6 +2,8 @@ use ratatui::style::Color;
 use ratatui::style::Style;
 use ratatui::text::Span;
 
+use devo_protocol::InteractionMode;
+
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
 pub(crate) enum InputMode {
     #[default]
@@ -38,6 +40,20 @@ impl InputMode {
             Self::Shell => Color::Rgb(245, 142, 53),
         }
     }
+
+    pub(crate) fn interaction_mode(self) -> InteractionMode {
+        match self {
+            Self::Build | Self::Shell => InteractionMode::Build,
+            Self::Plan => InteractionMode::Plan,
+        }
+    }
+
+    pub(crate) fn from_interaction_mode(interaction_mode: InteractionMode) -> Self {
+        match interaction_mode {
+            InteractionMode::Build => Self::Build,
+            InteractionMode::Plan => Self::Plan,
+        }
+    }
 }
 
 #[cfg(test)]
@@ -63,5 +79,16 @@ mod tests {
             InputMode::Shell.styled_span(false),
             Span::styled("SHELL", Style::default().fg(Color::Rgb(245, 142, 53)))
         );
+        assert_eq!(InputMode::Build.interaction_mode(), InteractionMode::Build);
+        assert_eq!(InputMode::Plan.interaction_mode(), InteractionMode::Plan);
+        assert_eq!(InputMode::Shell.interaction_mode(), InteractionMode::Build);
+        assert_eq!(
+            InputMode::from_interaction_mode(InteractionMode::Build),
+            InputMode::Build
+        );
+        assert_eq!(
+            InputMode::from_interaction_mode(InteractionMode::Plan),
+            InputMode::Plan
+        );
     }
 }

crates/tui/src/bottom_pane/mod.rs

@@ -171,6 +171,7 @@ pub(crate) enum InputResult {
         text_elements: Vec<TextElement>,
         local_images: Vec<LocalImageAttachment>,
         mention_bindings: Vec<MentionBinding>,
+        input_mode: InputMode,
         interaction_mode: InteractionMode,
     },
     ShellCommand {
@@ -364,6 +365,7 @@ impl BottomPane {
                 text_elements: Vec::new(),
                 local_images: Vec::new(),
                 mention_bindings: Vec::new(),
+                input_mode: InputMode::Build,
                 interaction_mode: InteractionMode::Build,
             };
         }
@@ -785,15 +787,14 @@ impl BottomPane {
         } else {
             (text, text_elements)
         };
+        let input_mode = self.input_mode;
         InputResult::Submitted {
             text,
             text_elements,
             local_images,
             mention_bindings,
-            interaction_mode: match self.input_mode {
-                InputMode::Build | InputMode::Shell => InteractionMode::Build,
-                InputMode::Plan => InteractionMode::Plan,
-            },
+            input_mode,
+            interaction_mode: input_mode.interaction_mode(),
         }
     }
 

crates/tui/src/chatwidget.rs

@@ -24,6 +24,7 @@ use devo_protocol::TurnId;
 use crate::app_event_sender::AppEventSender;
 use crate::bottom_pane::BottomPane;
 use crate::bottom_pane::BottomPaneParams;
+use crate::bottom_pane::InputMode;
 use crate::bottom_pane::LocalImageAttachment;
 use crate::bottom_pane::MentionBinding;
 use crate::history_cell::HistoryCell;
@@ -269,7 +270,10 @@ pub(crate) struct ChatWidget {
     last_query_total_tokens: usize,
     last_plan_progress: Option<(usize, usize)>,
     queued_count: usize,
+    queued_input_modes: VecDeque<InputMode>,
+    promoted_input_modes: VecDeque<InputMode>,
     active_turn_id: Option<TurnId>,
+    current_turn_mode: InputMode,
     committed_server_assistant_in_turn: bool,
     current_turn_has_user_shell_command: bool,
     pending_approval: Option<PendingApprovalRequest>,
@@ -400,7 +404,10 @@ impl ChatWidget {
             last_query_total_tokens: 0,
             last_plan_progress: None,
             queued_count: 0,
+            queued_input_modes: VecDeque::new(),
+            promoted_input_modes: VecDeque::new(),
             active_turn_id: None,
+            current_turn_mode: InputMode::Build,
             committed_server_assistant_in_turn: false,
             current_turn_has_user_shell_command: false,
             pending_approval: None,

crates/tui/src/chatwidget/configuration.rs

@@ -62,8 +62,13 @@ impl ChatWidget {
         }
 
         if let Some(model) = self.session.model.as_mut() {
+            let display_name = if model.slug == slug && !model.display_name.is_empty() {
+                model.display_name.clone()
+            } else {
+                slug.clone()
+            };
             model.slug = slug.clone();
-            model.display_name = slug;
+            model.display_name = display_name;
             self.session.reasoning_effort = model
                 .resolve_thinking_selection(self.thinking_selection.as_deref())
                 .effective_reasoning_effort;

crates/tui/src/chatwidget/input.rs

@@ -18,6 +18,7 @@ use ratatui::text::Span;
 use crate::ansi_escape::ansi_escape_line;
 use crate::app_command::AppCommand;
 use crate::app_event::AppEvent;
+use crate::bottom_pane::InputMode;
 use crate::bottom_pane::InputResult;
 use crate::history_cell;
 use crate::history_cell::PlainHistoryCell;
@@ -87,6 +88,7 @@ impl ChatWidget {
                 text_elements,
                 local_images,
                 mention_bindings,
+                input_mode,
                 interaction_mode,
             } => {
                 let user_message = UserMessage {
@@ -100,6 +102,7 @@ impl ChatWidget {
                     // Turn is active — show in bottom pane as pending cell.
                     self.bottom_pane
                         .push_pending_cell(user_message.text.clone());
+                    self.queued_input_modes.push_back(input_mode);
                     self.queued_count += 1;
                     self.app_event_tx.send(AppEvent::Command(
                         AppCommand::user_turn_with_interaction_mode(
@@ -114,13 +117,14 @@ impl ChatWidget {
                     ));
                     self.set_status_message("Message queued");
                 } else {
-                    self.submit_user_message_with_interaction_mode(user_message, interaction_mode);
+                    self.submit_user_message_with_modes(user_message, interaction_mode, input_mode);
                 }
             }
             InputResult::ShellCommand { command } => {
                 if self.busy {
                     self.set_status_message("Cannot run shell command while generating");
                 } else {
+                    self.current_turn_mode = InputMode::Shell;
                     self.app_event_tx
                         .send(AppEvent::Command(AppCommand::execute_shell_command(
                             command,
@@ -132,6 +136,7 @@ impl ChatWidget {
                 if self.busy {
                     self.set_status_message("Cannot run shell command while generating");
                 } else {
+                    self.current_turn_mode = InputMode::Shell;
                     self.app_event_tx
                         .send(AppEvent::Command(AppCommand::submit_shell_input(command)));
                     self.set_status_message("Shell command submitted");
@@ -215,9 +220,7 @@ impl ChatWidget {
                 self.set_status_message("Persistent composer history is not available");
             }
             AppEvent::ClearTranscript => {
-                self.history.clear();
-                self.next_history_flush_index = 0;
-                self.frame_requester.schedule_frame();
+                self.clear_transcript_view();
             }
             AppEvent::Interrupt => self.set_status_message("Interrupted"),
             AppEvent::Command(command) => {
@@ -282,18 +285,20 @@ impl ChatWidget {
     }
 
     pub(super) fn submit_user_message(&mut self, user_message: UserMessage) {
-        self.submit_user_message_with_interaction_mode(user_message, InteractionMode::Build);
+        self.submit_user_message_with_modes(user_message, InteractionMode::Build, InputMode::Build);
     }
 
-    pub(super) fn submit_user_message_with_interaction_mode(
+    pub(super) fn submit_user_message_with_modes(
         &mut self,
         user_message: UserMessage,
         interaction_mode: InteractionMode,
+        input_mode: InputMode,
     ) {
         if user_message.text.trim().is_empty() {
             return;
         }
 
+        self.current_turn_mode = input_mode;
         let local_image_paths = user_message
             .local_images
             .iter()
@@ -306,6 +311,7 @@ impl ChatWidget {
             local_image_paths,
             user_message.remote_image_urls.clone(),
             self.active_accent_color(),
+            input_mode,
         ));
 
         self.app_event_tx.send(AppEvent::Command(

crates/tui/src/chatwidget/restored_session.rs

@@ -7,6 +7,7 @@ use std::collections::HashMap;
 use std::collections::HashSet;
 use std::path::PathBuf;
 
+use crate::bottom_pane::InputMode;
 use crate::events::TranscriptItem;
 use crate::exec_cell::CommandOutput;
 use crate::exec_cell::ExecCell;
@@ -208,6 +209,7 @@ impl ChatWidget {
                         Vec::new(),
                         Vec::new(),
                         self.active_accent_color(),
+                        InputMode::Build,
                     )));
                 }
                 devo_protocol::SessionHistoryItemKind::Assistant => {
@@ -253,6 +255,7 @@ impl ChatWidget {
                 devo_protocol::SessionHistoryItemKind::TurnSummary => {
                     self.add_history_entry_without_redraw(Box::new(
                         history_cell::TurnSummaryCell::new(
+                            InputMode::Build,
                             item.title.clone(),
                             item.duration_ms,
                             self.active_accent_color(),

crates/tui/src/chatwidget/session_header.rs

@@ -371,7 +371,15 @@ impl ChatWidget {
     }
 
     pub(super) fn refresh_header_box(&mut self) {
-        if self.history.is_empty() {
+        if self
+            .history
+            .first()
+            .and_then(|cell| {
+                cell.as_any()
+                    .downcast_ref::<history_cell::SessionInfoCell>()
+            })
+            .is_none()
+        {
             return;
         }
         let accent = self.active_accent_color();

crates/tui/src/chatwidget/session_history.rs

@@ -11,6 +11,7 @@ use ratatui::text::Span;
 
 use devo_core::ItemId;
 
+use crate::bottom_pane::InputMode;
 use crate::events::PlanStep;
 use crate::events::PlanStepStatus;
 use crate::events::TranscriptItem;
@@ -36,10 +37,28 @@ impl ChatWidget {
         self.active_tool_calls.clear();
         self.pending_tool_calls.clear();
         self.active_text_items.clear();
+        self.queued_input_modes.clear();
+        self.promoted_input_modes.clear();
+        self.current_turn_mode = InputMode::Build;
         self.bottom_pane.clear_composer();
         self.set_status_message("Resuming session");
     }
 
+    pub(super) fn clear_transcript_view(&mut self) {
+        self.history.clear();
+        self.next_history_flush_index = 0;
+        self.active_cell = None;
+        self.active_cell_revision = self.active_cell_revision.wrapping_add(1);
+        self.last_terminal_assistant_visible_hash = None;
+        self.active_text_items.clear();
+        self.active_proposed_plan = None;
+        self.stream_chunking_policy.reset();
+        self.selection_mode = false;
+        self.selected_user_cell_index = None;
+        self.user_cell_history_indices.clear();
+        self.frame_requester.schedule_frame();
+    }
+
     pub(super) fn set_default_placeholder(&mut self) {
         self.bottom_pane
             .set_placeholder_text("Ask Devo".to_string());
@@ -264,6 +283,7 @@ impl ChatWidget {
                     Vec::new(),
                     Vec::new(),
                     self.active_accent_color(),
+                    InputMode::Build,
                 )));
             }
             TranscriptItemKind::Assistant => {
@@ -306,6 +326,7 @@ impl ChatWidget {
                 // item.title contains model name, item.duration_ms contains seconds
                 self.add_history_entry_without_redraw(Box::new(
                     history_cell::TurnSummaryCell::new(
+                        InputMode::Build,
                         item.title.clone(),
                         item.duration_ms,
                         self.active_accent_color(),
@@ -349,12 +370,18 @@ impl ChatWidget {
     /// as a normal user input cell.
     pub(super) fn unqueue_oldest_pending(&mut self) {
         if let Some(text) = self.bottom_pane.pop_oldest_pending_cell() {
+            let input_mode = self
+                .queued_input_modes
+                .pop_front()
+                .unwrap_or(InputMode::Build);
+            self.promoted_input_modes.push_back(input_mode);
             self.add_to_history(history_cell::new_user_prompt(
                 text,
                 Vec::new(),
                 Vec::new(),
                 Vec::new(),
                 self.active_accent_color(),
+                input_mode,
             ));
         }
         self.queued_count = self.queued_count.saturating_sub(1);