practicode 0.1.1 → 0.1.3

package/src/tui.rs

@@ -1,15 +1,19 @@
 use crate::{
-    ai::{append_problem_note, read_problem_notes, run_ai_next, run_ai_prompt},
+    ai::{
+        append_problem_note, available_models, provider_status, read_problem_notes, run_ai_next,
+        run_ai_prompt,
+    },
     core::{
         AI_PROVIDERS, AppState, HistoryItem, LANGUAGES, PROBLEM_NOTES_PATH, Problem, THEMES,
         UI_LANGUAGES, ensure_problem_files, ensure_submission, ext_for, give_up, judge, load_bank,
         load_state, localized, next_problem, normalize_ai_provider, normalize_language,
         normalize_next_source, normalize_ui_language, previous_problem, problem_by_id, record_pass,
-        render_problem, save_state, template_for, ui_text,
+        save_state, template_for, ui_text,
     },
     text::{
         byte_index, char_len, compose_hangul_jamo, display_width, prefix, render_markdown_plain,
     },
+    update::{CURRENT_VERSION, UpdateCheck, check_latest_version},
 };
 use anyhow::Result;
 use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
@@ -17,6 +21,7 @@ use ratatui::{
     DefaultTerminal, Frame,
     layout::{Constraint, Direction, Layout, Position, Rect},
     style::{Color, Modifier, Style},
+    text::{Line, Span, Text},
     widgets::{Block, Borders, Clear, Paragraph, Wrap},
 };
 use std::{
@@ -37,6 +42,14 @@ struct CommandHint {
     help: bool,
 }
 
+#[derive(Clone)]
+struct CommandChoice {
+    insert: String,
+    display: String,
+    desc_key: &'static str,
+    keep_open: bool,
+}
+
 const COMMAND_HINTS: &[CommandHint] = &[
     CommandHint {
         insert: "run",
@@ -88,9 +101,9 @@ const COMMAND_HINTS: &[CommandHint] = &[
         help: true,
     },
     CommandHint {
-        insert: "ai ",
-        display: "/ai <prompt>",
-        desc_key: "cmd_ai",
+        insert: "hint ",
+        display: "/hint <request>",
+        desc_key: "cmd_hint",
         keep_open: true,
         help: true,
     },
@@ -111,14 +124,14 @@ const COMMAND_HINTS: &[CommandHint] = &[
     CommandHint {
         insert: "model auto",
         display: "/model auto",
-        desc_key: "cmd_model",
+        desc_key: "cmd_model_auto",
         keep_open: false,
         help: true,
     },
     CommandHint {
         insert: "model ",
         display: "/model <name>",
-        desc_key: "cmd_model",
+        desc_key: "cmd_model_custom",
         keep_open: true,
         help: false,
     },
@@ -214,11 +227,11 @@ const COMMAND_HINTS: &[CommandHint] = &[
         help: false,
     },
     CommandHint {
-        insert: "source bank",
-        display: "/source bank",
+        insert: "source local",
+        display: "/source local",
         desc_key: "cmd_source",
         keep_open: false,
-        help: true,
+        help: false,
     },
     CommandHint {
         insert: "source ai",
@@ -227,6 +240,13 @@ const COMMAND_HINTS: &[CommandHint] = &[
         keep_open: false,
         help: false,
     },
+    CommandHint {
+        insert: "update",
+        display: "/update",
+        desc_key: "cmd_update",
+        keep_open: false,
+        help: true,
+    },
     CommandHint {
         insert: "help",
         display: "/help",
@@ -269,6 +289,12 @@ pub struct PracticodeApp {
     busy_body: String,
     busy_frame: usize,
     task_rx: Option<Receiver<TaskResult>>,
+    update_rx: Option<Receiver<UpdateCheck>>,
+    model_rx: Option<Receiver<Vec<String>>>,
+    available_models: Vec<String>,
+    available_models_provider: String,
+    update_check: Option<UpdateCheck>,
+    update_notice: Option<String>,
     should_quit: bool,
 }
 
@@ -306,6 +332,12 @@ impl PracticodeApp {
             busy_body: String::new(),
             busy_frame: 0,
             task_rx: None,
+            update_rx: None,
+            model_rx: None,
+            available_models: Vec::new(),
+            available_models_provider: String::new(),
+            update_check: None,
+            update_notice: None,
             should_quit: false,
         };
         app.load_code_editor()?;
@@ -313,9 +345,14 @@ impl PracticodeApp {
     }
 
     pub fn run(&mut self, terminal: &mut DefaultTerminal) -> Result<()> {
+        self.start_update_check();
+        self.start_model_check();
         while !self.should_quit {
             terminal.draw(|frame| self.draw(frame))?;
             self.check_task();
+            self.check_update();
+            self.start_model_check();
+            self.check_models();
             if event::poll(Duration::from_millis(100))?
                 && let Event::Key(key) = event::read()?
                 && key.kind != KeyEventKind::Release
@@ -323,7 +360,7 @@ impl PracticodeApp {
                 self.handle_key(key)?;
             }
             if !self.busy_label.is_empty() {
-                self.busy_frame = (self.busy_frame + 1) % 4;
+                self.busy_frame = (self.busy_frame + 1) % 16;
             }
         }
         self.save_code().ok();
@@ -362,6 +399,26 @@ impl PracticodeApp {
         self.task_rx.is_some()
     }
 
+    pub fn status_text_for_test(&self) -> String {
+        self.status_text()
+    }
+
+    pub fn command_suggestions_for_test(&self) -> Vec<String> {
+        self.command_suggestions()
+            .into_iter()
+            .map(|choice| choice.display)
+            .collect()
+    }
+
+    pub fn set_available_models_for_test(&mut self, models: Vec<&str>) {
+        self.available_models = models.into_iter().map(str::to_string).collect();
+        self.available_models_provider = self.state.settings.ai_provider.clone();
+    }
+
+    pub fn pane_title_for_test(title: &str, active: bool) -> String {
+        Self::pane_title(title, active)
+    }
+
     fn draw(&mut self, frame: &mut Frame) {
         let size = frame.area();
         let vertical = Layout::default()
@@ -377,20 +434,18 @@ impl PracticodeApp {
             .constraints([Constraint::Percentage(58), Constraint::Percentage(42)])
             .split(vertical[0]);
 
-        let problem = Paragraph::new(render_markdown_plain(&render_problem(
-            &self.problem,
-            &self.state.settings.ui_language,
-        )))
-        .block(Self::block(
-            ui_text(&self.state.settings.ui_language, "problem"),
-            self.state.settings.theme == "light",
-        ))
-        .wrap(Wrap { trim: false });
+        let problem = Paragraph::new(self.problem_text())
+            .block(Self::block(
+                ui_text(&self.state.settings.ui_language, "problem"),
+                self.state.settings.theme == "light",
+                false,
+            ))
+            .wrap(Wrap { trim: false });
         frame.render_widget(problem, body[0]);
 
         if self.show_output {
             let text = if !self.busy_label.is_empty() {
-                format!("{}{}", self.busy_body, ".".repeat(self.busy_frame))
+                format!("{}{}", self.busy_body, self.busy_dots())
             } else if self.output_is_markdown {
                 render_markdown_plain(&self.output)
             } else {
@@ -400,6 +455,7 @@ impl PracticodeApp {
                 .block(Self::block(
                     ui_text(&self.state.settings.ui_language, "output"),
                     self.state.settings.theme == "light",
+                    self.focus != Focus::Command,
                 ))
                 .wrap(Wrap { trim: false });
             frame.render_widget(output, body[1]);
@@ -408,8 +464,11 @@ impl PracticodeApp {
                 .editor
                 .visible_text(body[1].height.saturating_sub(2) as usize);
             let title = format!("solution.{}", ext_for(&self.state.settings.language));
-            let code = Paragraph::new(code)
-                .block(Self::block(&title, self.state.settings.theme == "light"));
+            let code = Paragraph::new(code).block(Self::block(
+                &title,
+                self.state.settings.theme == "light",
+                self.focus == Focus::Code,
+            ));
             frame.render_widget(code, body[1]);
         }
 
@@ -436,6 +495,7 @@ impl PracticodeApp {
             .block(Self::block(
                 ui_text(&self.state.settings.ui_language, "command"),
                 self.state.settings.theme == "light",
+                self.focus == Focus::Command,
             ))
             .wrap(Wrap { trim: false });
         frame.render_widget(command, vertical[2]);
@@ -443,12 +503,147 @@ impl PracticodeApp {
         self.set_terminal_cursor(frame, body[1], vertical[2]);
     }
 
+    fn problem_text(&self) -> Text<'static> {
+        let lang = normalize_ui_language(&self.state.settings.ui_language);
+        let light = self.state.settings.theme == "light";
+        let title_style = if light {
+            Style::default()
+                .fg(Color::Blue)
+                .add_modifier(Modifier::BOLD)
+        } else {
+            Style::default()
+                .fg(Color::Yellow)
+                .add_modifier(Modifier::BOLD)
+        };
+        let section_style = if light {
+            Style::default()
+                .fg(Color::Magenta)
+                .add_modifier(Modifier::BOLD)
+        } else {
+            Style::default()
+                .fg(Color::Cyan)
+                .add_modifier(Modifier::BOLD)
+        };
+        let body_style = if light {
+            Style::default().fg(Color::Black)
+        } else {
+            Style::default().fg(Color::Rgb(229, 231, 235))
+        };
+        let meta_style = if light {
+            Style::default().fg(Color::Rgb(75, 85, 99))
+        } else {
+            Style::default().fg(Color::Rgb(156, 163, 175))
+        };
+        let code_style = if light {
+            Style::default()
+                .fg(Color::Black)
+                .bg(Color::Rgb(229, 231, 235))
+        } else {
+            Style::default()
+                .fg(Color::Rgb(243, 244, 246))
+                .bg(Color::Rgb(31, 41, 55))
+        };
+        let number = self
+            .problem
+            .id
+            .split_once('-')
+            .map(|(number, _)| number)
+            .unwrap_or(&self.problem.id);
+        let mut lines = vec![
+            Line::from(Span::styled(
+                format!("{number}. {}", localized(&self.problem.title, &lang)),
+                title_style,
+            )),
+            Line::from(Span::styled(
+                format!(
+                    "{}: {}    {}: {}",
+                    ui_text(&lang, "difficulty"),
+                    self.problem.difficulty,
+                    ui_text(&lang, "topics"),
+                    self.problem.topics.join(", ")
+                ),
+                meta_style,
+            )),
+        ];
+        lines.push(Line::default());
+        for line in localized(&self.problem.statement, &lang).trim_end().lines() {
+            lines.push(Line::from(Span::styled(line.to_string(), body_style)));
+        }
+        Self::push_problem_section(
+            &mut lines,
+            ui_text(&lang, "input"),
+            &localized(&self.problem.input, &lang),
+            section_style,
+            body_style,
+        );
+        Self::push_problem_section(
+            &mut lines,
+            ui_text(&lang, "output"),
+            &localized(&self.problem.output, &lang),
+            section_style,
+            body_style,
+        );
+        lines.push(Line::default());
+        lines.push(Line::from(Span::styled(
+            ui_text(&lang, "examples").to_string(),
+            section_style,
+        )));
+        for (index, case) in self.problem.examples.iter().enumerate() {
+            lines.push(Line::from(Span::styled(
+                format!("  {} {}", ui_text(&lang, "example"), index + 1),
+                meta_style.add_modifier(Modifier::BOLD),
+            )));
+            lines.push(Line::from(Span::styled(
+                format!("    {}", ui_text(&lang, "input")),
+                meta_style,
+            )));
+            Self::push_code_lines(&mut lines, &case.input, code_style);
+            lines.push(Line::from(Span::styled(
+                format!("    {}", ui_text(&lang, "output")),
+                meta_style,
+            )));
+            Self::push_code_lines(&mut lines, &case.output, code_style);
+        }
+        Text::from(lines)
+    }
+
+    fn push_problem_section(
+        lines: &mut Vec<Line<'static>>,
+        title: &str,
+        body: &str,
+        section_style: Style,
+        body_style: Style,
+    ) {
+        lines.push(Line::default());
+        lines.push(Line::from(Span::styled(title.to_string(), section_style)));
+        for line in body.trim_end().lines() {
+            lines.push(Line::from(Span::styled(format!("  {line}"), body_style)));
+        }
+    }
+
+    fn push_code_lines(lines: &mut Vec<Line<'static>>, body: &str, code_style: Style) {
+        let body = body.trim_end();
+        if body.is_empty() {
+            lines.push(Line::from(vec![
+                Span::raw("      "),
+                Span::styled("<empty>".to_string(), code_style),
+            ]));
+            return;
+        }
+        for line in body.lines() {
+            lines.push(Line::from(vec![
+                Span::raw("      "),
+                Span::styled(line.to_string(), code_style),
+            ]));
+        }
+    }
+
     fn draw_command_palette(&self, frame: &mut Frame, command_area: Rect) {
         let suggestions = self.command_suggestions();
         if suggestions.is_empty() || command_area.y < 3 {
             return;
         }
-        let height = ((suggestions.len() + 3) as u16).min(10).min(command_area.y);
+        let height = ((suggestions.len() + 3) as u16).min(14).min(command_area.y);
         let area = Rect::new(
             command_area.x,
             command_area.y - height,
@@ -456,10 +651,13 @@ impl PracticodeApp {
             height,
         );
         let selected = self.command_palette_cursor.min(suggestions.len() - 1);
+        let visible = height.saturating_sub(2) as usize;
+        let start = selected.saturating_sub(visible.saturating_sub(1));
         let mut lines = suggestions
             .iter()
             .enumerate()
-            .take(height.saturating_sub(2) as usize)
+            .skip(start)
+            .take(visible)
             .map(|(index, hint)| {
                 let marker = if index == selected { ">" } else { " " };
                 format!(
@@ -475,20 +673,40 @@ impl PracticodeApp {
             Paragraph::new(lines.join("\n")).block(Self::block(
                 ui_text(&self.state.settings.ui_language, "commands"),
                 self.state.settings.theme == "light",
+                true,
             )),
             area,
         );
     }
 
-    fn block(title: &str, light: bool) -> Block<'_> {
+    fn block(title: &str, light: bool, active: bool) -> Block<'static> {
+        let border = if active {
+            if light {
+                Style::default()
+                    .fg(Color::Magenta)
+                    .add_modifier(Modifier::BOLD)
+            } else {
+                Style::default()
+                    .fg(Color::Yellow)
+                    .add_modifier(Modifier::BOLD)
+            }
+        } else if light {
+            Style::default().fg(Color::Blue)
+        } else {
+            Style::default().fg(Color::Cyan)
+        };
         Block::default()
             .borders(Borders::ALL)
-            .title(title)
-            .border_style(if light {
-                Style::default().fg(Color::Blue)
-            } else {
-                Style::default().fg(Color::Cyan)
-            })
+            .title(Self::pane_title(title, active))
+            .border_style(border)
+    }
+
+    fn pane_title(title: &str, active: bool) -> String {
+        if active {
+            format!("> {title}")
+        } else {
+            title.to_string()
+        }
     }
 
     fn handle_key(&mut self, key: KeyEvent) -> Result<()> {
@@ -667,18 +885,12 @@ impl PracticodeApp {
             "theme" if arg.is_empty() => self.action_toggle_theme()?,
             "theme" if THEMES.contains(&arg) => self.set_theme(arg)?,
             "source" | "next-source" if arg.is_empty() => {
-                self.write_text_output(&format!(
-                    "Next source: {}",
-                    self.state.settings.next_source
-                ));
+                self.write_text_output(&format!("Next source: {}", self.next_source_label()));
             }
-            "source" | "next-source" if matches!(arg, "bank" | "ai") => {
+            "source" | "next-source" if matches!(arg, "bank" | "local" | "ai") => {
                 self.state.settings.next_source = normalize_next_source(arg);
                 save_state(&self.root, &self.state)?;
-                self.write_text_output(&format!(
-                    "Next source: {}",
-                    self.state.settings.next_source
-                ));
+                self.write_text_output(&format!("Next source: {}", self.next_source_label()));
             }
             "ai-next-command" if !arg.is_empty() => {
                 self.state.settings.ai_next_command = arg.to_string();
@@ -688,29 +900,42 @@ impl PracticodeApp {
             }
             "provider" | "ai-provider" if arg.is_empty() => {
                 self.write_text_output(&format!(
-                    "AI provider: {}",
-                    self.state.settings.ai_provider
+                    "AI provider: {}\n{}",
+                    self.state.settings.ai_provider,
+                    provider_status(&self.state.settings.ai_provider)
                 ));
             }
             "provider" | "ai-provider" if AI_PROVIDERS.contains(&arg) => {
                 self.state.settings.ai_provider = normalize_ai_provider(arg);
+                self.model_rx = None;
+                self.available_models.clear();
+                self.available_models_provider.clear();
                 save_state(&self.root, &self.state)?;
                 self.write_text_output(&format!(
-                    "AI provider: {}",
-                    self.state.settings.ai_provider
+                    "AI provider: {}\n{}",
+                    self.state.settings.ai_provider,
+                    provider_status(&self.state.settings.ai_provider)
                 ));
             }
             "model" if arg.is_empty() => {
-                self.write_text_output(&format!("AI model: {}", self.state.settings.ai_model));
+                self.write_text_output(&self.model_status_text());
             }
             "model" => {
-                self.state.settings.ai_model = arg.to_string();
+                self.state.settings.ai_model = if arg == "auto" {
+                    "auto".to_string()
+                } else {
+                    arg.to_string()
+                };
                 save_state(&self.root, &self.state)?;
-                self.write_text_output(&format!("AI model: {arg}"));
+                self.write_text_output(&self.model_status_text());
+            }
+            "hint" if arg.is_empty() => {
+                self.start_ai_prompt("Give one concise hint for the current problem.")?
             }
-            "ai" if !arg.is_empty() => self.start_ai_prompt(arg)?,
+            "hint" | "ask" | "ai" if !arg.is_empty() => self.start_ai_prompt(arg)?,
             "note" if !arg.is_empty() => self.append_note(arg)?,
             "note" | "notes" => self.show_notes()?,
+            "update" => self.show_update_notice(),
             "exit" | "quit" | "q" => self.should_quit = true,
             _ => self.write_text_output(&format!("Unknown command: {value}\nTry /help.")),
         }
@@ -769,10 +994,13 @@ impl PracticodeApp {
 
     fn start_next_problem(&mut self, old_problem: String, force: bool, request: String) {
         if self.task_rx.is_some() {
-            self.write_text_output("Already busy.");
+            self.write_text_output(ui_text(&self.state.settings.ui_language, "already_busy"));
             return;
         }
-        self.start_busy("next", "Generating next problem");
+        self.start_busy(
+            "next",
+            ui_text(&self.state.settings.ui_language, "generating_next"),
+        );
         let root = self.root.clone();
         let state = self.state.clone();
         let (tx, rx) = mpsc::channel();
@@ -890,7 +1118,7 @@ impl PracticodeApp {
 
     fn start_ai_prompt(&mut self, prompt: &str) -> Result<()> {
         if self.task_rx.is_some() {
-            self.write_text_output("Already busy.");
+            self.write_text_output(ui_text(&self.state.settings.ui_language, "already_busy"));
             return Ok(());
         }
         self.save_code()?;
@@ -929,6 +1157,78 @@ impl PracticodeApp {
         }
     }
 
+    fn check_update(&mut self) {
+        let result = self.update_rx.as_ref().and_then(|rx| rx.try_recv().ok());
+        if let Some(result) = result {
+            self.update_rx = None;
+            self.update_check = Some(result.clone());
+            if let UpdateCheck::Available(version) = &result {
+                self.update_notice = Some(version.clone());
+            }
+        }
+    }
+
+    fn start_update_check(&mut self) {
+        if self.update_rx.is_some() {
+            return;
+        }
+        let (tx, rx) = mpsc::channel();
+        thread::spawn(move || {
+            let _ = tx.send(check_latest_version());
+        });
+        self.update_rx = Some(rx);
+    }
+
+    fn start_model_check(&mut self) {
+        let provider = self.state.settings.ai_provider.clone();
+        if self.model_rx.is_some() || self.available_models_provider == provider {
+            return;
+        }
+        let query_provider = provider.clone();
+        let (tx, rx) = mpsc::channel();
+        thread::spawn(move || {
+            let _ = tx.send(available_models(&query_provider));
+        });
+        self.available_models_provider = provider;
+        self.model_rx = Some(rx);
+    }
+
+    fn check_models(&mut self) {
+        let models = self.model_rx.as_ref().and_then(|rx| rx.try_recv().ok());
+        if let Some(models) = models {
+            self.model_rx = None;
+            self.available_models = models;
+        }
+    }
+
+    fn model_status_text(&self) -> String {
+        let mut lines = vec![
+            format!(
+                "AI model: {}",
+                if self.state.settings.ai_model == "auto" {
+                    "auto (provider default)"
+                } else {
+                    self.state.settings.ai_model.as_str()
+                }
+            ),
+            "Use /model auto to let the provider choose its default.".to_string(),
+        ];
+        if self.available_models.is_empty() {
+            lines.push(
+                "Provider model list is unavailable; use /model <name> for a known model."
+                    .to_string(),
+            );
+        } else {
+            lines.push("Available models:".to_string());
+            lines.extend(
+                self.available_models
+                    .iter()
+                    .map(|model| format!("- /model {model}")),
+            );
+        }
+        lines.join("\n")
+    }
+
     fn start_busy(&mut self, label: &str, body: &str) {
         self.busy_label = label.to_string();
         self.busy_body = body.to_string();
@@ -957,6 +1257,24 @@ impl PracticodeApp {
         self.focus = Focus::Output;
     }
 
+    fn show_update_notice(&mut self) {
+        let lang = self.state.settings.ui_language.clone();
+        if let Some(version) = &self.update_notice {
+            self.write_text_output(&format!(
+                "{}: practicode {version} (current {CURRENT_VERSION})\n\nnpm update -g practicode\ncargo install --force practicode",
+                ui_text(&lang, "update_available")
+            ));
+        } else if self.update_rx.is_some() {
+            self.write_text_output("Checking for updates...");
+        } else if matches!(self.update_check, Some(UpdateCheck::Disabled)) {
+            self.write_text_output(ui_text(&lang, "update_check_disabled"));
+        } else if matches!(self.update_check, Some(UpdateCheck::Failed)) {
+            self.write_text_output(ui_text(&lang, "update_check_failed"));
+        } else {
+            self.write_text_output(ui_text(&lang, "update_none"));
+        }
+    }
+
     fn append_note(&mut self, note: &str) -> Result<()> {
         append_problem_note(&self.root, note)?;
         self.write_text_output(&format!("Problem note saved to {PROBLEM_NOTES_PATH}."));
@@ -1004,7 +1322,7 @@ impl PracticodeApp {
         self.normalize_command_input();
     }
 
-    fn command_suggestions(&self) -> Vec<&'static CommandHint> {
+    fn command_suggestions(&self) -> Vec<CommandChoice> {
         if self.focus != Focus::Command {
             return Vec::new();
         }
@@ -1012,13 +1330,39 @@ impl PracticodeApp {
             return Vec::new();
         };
         let query = query.to_lowercase();
-        COMMAND_HINTS
-            .iter()
+        self.command_choices()
+            .into_iter()
             .filter(|hint| hint.insert.starts_with(query.trim_start()))
-            .take(7)
             .collect()
     }
 
+    fn command_choices(&self) -> Vec<CommandChoice> {
+        let mut choices = Vec::new();
+        for hint in COMMAND_HINTS {
+            if hint.insert == "model " {
+                for model in self
+                    .available_models
+                    .iter()
+                    .filter(|model| *model != "auto")
+                {
+                    choices.push(CommandChoice {
+                        insert: format!("model {model}"),
+                        display: format!("/model {model}"),
+                        desc_key: "cmd_model_available",
+                        keep_open: false,
+                    });
+                }
+            }
+            choices.push(CommandChoice {
+                insert: hint.insert.to_string(),
+                display: hint.display.to_string(),
+                desc_key: hint.desc_key,
+                keep_open: hint.keep_open,
+            });
+        }
+        choices
+    }
+
     fn move_command_palette(&mut self, delta: isize) {
         let len = self.command_suggestions().len();
         if len == 0 {
@@ -1033,19 +1377,19 @@ impl PracticodeApp {
         if suggestions.is_empty() {
             return Ok(false);
         }
-        let hint = suggestions[self.command_palette_cursor.min(suggestions.len() - 1)];
+        let hint = &suggestions[self.command_palette_cursor.min(suggestions.len() - 1)];
         if hint.keep_open {
             self.command = format!("/{}", hint.insert);
             self.command_cursor = char_len(&self.command);
             self.command_palette_cursor = 0;
             return Ok(true);
         }
-        let value = hint.insert;
+        let value = hint.insert.clone();
         self.command.clear();
         self.command_cursor = 0;
         self.command_palette_cursor = 0;
         self.focus = Focus::None;
-        self.submit_command(value)?;
+        self.submit_command(&value)?;
         Ok(true)
     }
 
@@ -1243,29 +1587,45 @@ impl PracticodeApp {
 
     fn status_text(&self) -> String {
         let code_status = self.submission_status(&self.problem).0;
+        let activity = if self.busy_label.is_empty() {
+            "idle".to_string()
+        } else {
+            format!("{}{}", self.busy_body, self.busy_dots())
+        };
+        let tail = self
+            .update_notice
+            .as_ref()
+            .map(|version| {
+                format!(
+                    "{}:{version} /update",
+                    ui_text(&self.state.settings.ui_language, "update")
+                )
+            })
+            .unwrap_or_else(|| self.mode_hint().to_string());
         format!(
-            " PRACTICODE | {} | {} | {} | {} | code:{} | {} | next:{} | ai:{}/{} | {} ",
+            " PRACTICODE | {} | {} | {} | {} | code:{} | {} | {} ",
             self.problem.id,
             self.problem.difficulty,
-            self.busy_status(),
             self.problem_status(&self.problem),
+            activity,
             code_status,
             self.state.settings.language,
-            self.state.settings.next_source,
-            self.state.settings.ai_provider,
-            self.state.settings.ai_model,
-            self.mode_hint(),
+            tail,
         )
     }
 
-    fn busy_status(&self) -> String {
-        if self.busy_label.is_empty() {
-            "idle".to_string()
+    fn next_source_label(&self) -> &'static str {
+        if self.state.settings.next_source == "ai" {
+            "ai"
         } else {
-            format!("busy:{}{}", self.busy_label, ".".repeat(self.busy_frame))
+            "local"
         }
     }
 
+    fn busy_dots(&self) -> String {
+        ".".repeat(self.busy_frame / 4)
+    }
+
     fn mode_hint(&self) -> &'static str {
         let lang = &self.state.settings.ui_language;
         match (self.focus, self.list_cursor.is_some(), self.show_output) {