practicode 0.1.0 → 0.1.2

package/src/tui.rs

@@ -1,15 +1,16 @@
 use crate::{
-    ai::{append_problem_note, read_problem_notes, run_ai_next, run_ai_prompt},
+    ai::{append_problem_note, 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, previous_problem, problem_by_id, record_pass, render_problem,
-        save_state, template_for,
+        normalize_next_source, normalize_ui_language, previous_problem, problem_by_id, record_pass,
+        render_problem_tui, 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,7 +18,7 @@ use ratatui::{
     DefaultTerminal, Frame,
     layout::{Constraint, Direction, Layout, Position, Rect},
     style::{Color, Modifier, Style},
-    widgets::{Block, Borders, Paragraph, Wrap},
+    widgets::{Block, Borders, Clear, Paragraph, Wrap},
 };
 use std::{
     collections::HashMap,
@@ -28,46 +29,227 @@ use std::{
     time::Duration,
 };
 
-pub const HELP: &str = r#"# Help
-
-## Daily loop
-
-1. Type code in the right pane.
-2. Press `Esc`, then `/run`.
-3. Use `/next` when it passes.
-
-## Commands
-
-- `/run` judge current submission
-- `/edit` focus the code editor
-- `/next [request]` next problem, optionally with a request
-- `/prev` previous problem
-- `/list` choose from problem list
-- `/open 2` open by number, id, or slug
-- `/giveup` show answer
-- `/ai hint` ask the selected AI about current problem + code
-- `/provider codex|claude`
-- `/model auto|sonnet|opus|...`
-- `/note prefer strings this week`
-- `/notes` show next-problem notes
-- `/lang python|ts|java|rust`
-- `/ui ko|en`
-- `/theme dark|light`
-- `/source bank|ai`
-- `/exit` quit
-
-## Keys
-
-- `Esc` leaves the editor or output pane
-- `/` opens the command bar when the editor is not focused
-- `?` opens this help when the editor is not focused
-- `up/down` or `j/k` move in `/list`
-
-## Debug prints
+#[derive(Clone, Copy)]
+struct CommandHint {
+    insert: &'static str,
+    display: &'static str,
+    desc_key: &'static str,
+    keep_open: bool,
+    help: bool,
+}
 
-- stdout prints are shown when a case fails
-- stderr prints are shown without affecting the expected stdout
-"#;
+const COMMAND_HINTS: &[CommandHint] = &[
+    CommandHint {
+        insert: "run",
+        display: "/run",
+        desc_key: "cmd_run",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "edit",
+        display: "/edit",
+        desc_key: "cmd_edit",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "next",
+        display: "/next",
+        desc_key: "cmd_next",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "prev",
+        display: "/prev",
+        desc_key: "cmd_prev",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "list",
+        display: "/list",
+        desc_key: "cmd_list",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "open ",
+        display: "/open <id>",
+        desc_key: "cmd_open",
+        keep_open: true,
+        help: true,
+    },
+    CommandHint {
+        insert: "giveup",
+        display: "/giveup",
+        desc_key: "cmd_giveup",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "ai ",
+        display: "/ai <prompt>",
+        desc_key: "cmd_ai",
+        keep_open: true,
+        help: true,
+    },
+    CommandHint {
+        insert: "provider codex",
+        display: "/provider codex",
+        desc_key: "cmd_provider",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "provider claude",
+        display: "/provider claude",
+        desc_key: "cmd_provider",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "model auto",
+        display: "/model auto",
+        desc_key: "cmd_model",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "model ",
+        display: "/model <name>",
+        desc_key: "cmd_model",
+        keep_open: true,
+        help: false,
+    },
+    CommandHint {
+        insert: "note ",
+        display: "/note <text>",
+        desc_key: "cmd_note",
+        keep_open: true,
+        help: true,
+    },
+    CommandHint {
+        insert: "notes",
+        display: "/notes",
+        desc_key: "cmd_notes",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "lang python",
+        display: "/lang python",
+        desc_key: "cmd_lang",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "lang ts",
+        display: "/lang ts",
+        desc_key: "cmd_lang",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "lang java",
+        display: "/lang java",
+        desc_key: "cmd_lang",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "lang rust",
+        display: "/lang rust",
+        desc_key: "cmd_lang",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "ui en",
+        display: "/ui en",
+        desc_key: "cmd_ui",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "ui ko",
+        display: "/ui ko",
+        desc_key: "cmd_ui",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "ui ja",
+        display: "/ui ja",
+        desc_key: "cmd_ui",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "ui zh",
+        display: "/ui zh",
+        desc_key: "cmd_ui",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "ui es",
+        display: "/ui es",
+        desc_key: "cmd_ui",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "theme dark",
+        display: "/theme dark",
+        desc_key: "cmd_theme",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "theme light",
+        display: "/theme light",
+        desc_key: "cmd_theme",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "source local",
+        display: "/source local",
+        desc_key: "cmd_source",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "source ai",
+        display: "/source ai",
+        desc_key: "cmd_source",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "update",
+        display: "/update",
+        desc_key: "cmd_update",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "help",
+        display: "/help",
+        desc_key: "cmd_help",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "exit",
+        display: "/exit",
+        desc_key: "cmd_exit",
+        keep_open: false,
+        help: true,
+    },
+];
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum Focus {
@@ -85,6 +267,7 @@ pub struct PracticodeApp {
     editor: TextEditor,
     command: String,
     command_cursor: usize,
+    command_palette_cursor: usize,
     output: String,
     output_is_markdown: bool,
     show_output: bool,
@@ -94,6 +277,9 @@ pub struct PracticodeApp {
     busy_body: String,
     busy_frame: usize,
     task_rx: Option<Receiver<TaskResult>>,
+    update_rx: Option<Receiver<UpdateCheck>>,
+    update_check: Option<UpdateCheck>,
+    update_notice: Option<String>,
     should_quit: bool,
 }
 
@@ -121,6 +307,7 @@ impl PracticodeApp {
             editor: TextEditor::default(),
             command: String::new(),
             command_cursor: 0,
+            command_palette_cursor: 0,
             output: String::new(),
             output_is_markdown: false,
             show_output: false,
@@ -130,6 +317,9 @@ impl PracticodeApp {
             busy_body: String::new(),
             busy_frame: 0,
             task_rx: None,
+            update_rx: None,
+            update_check: None,
+            update_notice: None,
             should_quit: false,
         };
         app.load_code_editor()?;
@@ -137,9 +327,11 @@ impl PracticodeApp {
     }
 
     pub fn run(&mut self, terminal: &mut DefaultTerminal) -> Result<()> {
+        self.start_update_check();
         while !self.should_quit {
             terminal.draw(|frame| self.draw(frame))?;
             self.check_task();
+            self.check_update();
             if event::poll(Duration::from_millis(100))?
                 && let Event::Key(key) = event::read()?
                 && key.kind != KeyEventKind::Release
@@ -147,7 +339,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();
@@ -174,6 +366,10 @@ impl PracticodeApp {
         self.command_cursor
     }
 
+    pub fn handle_key_for_test(&mut self, key: KeyEvent) -> Result<()> {
+        self.handle_key(key)
+    }
+
     pub fn busy_label(&self) -> &str {
         &self.busy_label
     }
@@ -182,6 +378,10 @@ impl PracticodeApp {
         self.task_rx.is_some()
     }
 
+    pub fn status_text_for_test(&self) -> String {
+        self.status_text()
+    }
+
     fn draw(&mut self, frame: &mut Frame) {
         let size = frame.area();
         let vertical = Layout::default()
@@ -197,24 +397,30 @@ impl PracticodeApp {
             .constraints([Constraint::Percentage(58), Constraint::Percentage(42)])
             .split(vertical[0]);
 
-        let problem = Paragraph::new(render_markdown_plain(&render_problem(
+        let problem = Paragraph::new(render_problem_tui(
             &self.problem,
             &self.state.settings.ui_language,
-        )))
-        .block(Self::block("Problem", self.state.settings.theme == "light"))
+        ))
+        .block(Self::block(
+            ui_text(&self.state.settings.ui_language, "problem"),
+            self.state.settings.theme == "light",
+        ))
         .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 {
                 self.output.clone()
             };
             let output = Paragraph::new(text)
-                .block(Self::block("Output", self.state.settings.theme == "light"))
+                .block(Self::block(
+                    ui_text(&self.state.settings.ui_language, "output"),
+                    self.state.settings.theme == "light",
+                ))
                 .wrap(Wrap { trim: false });
             frame.render_widget(output, body[1]);
         } else {
@@ -244,15 +450,56 @@ impl PracticodeApp {
         let command_text = if self.focus == Focus::Command || !self.command.is_empty() {
             self.command.clone()
         } else {
-            "/run, /next easy string problem, /ai hint, /help".to_string()
+            ui_text(&self.state.settings.ui_language, "command_placeholder").to_string()
         };
         let command = Paragraph::new(command_text)
-            .block(Self::block("Command", self.state.settings.theme == "light"))
+            .block(Self::block(
+                ui_text(&self.state.settings.ui_language, "command"),
+                self.state.settings.theme == "light",
+            ))
             .wrap(Wrap { trim: false });
         frame.render_widget(command, vertical[2]);
+        self.draw_command_palette(frame, vertical[2]);
         self.set_terminal_cursor(frame, body[1], vertical[2]);
     }
 
+    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 area = Rect::new(
+            command_area.x,
+            command_area.y - height,
+            command_area.width,
+            height,
+        );
+        let selected = self.command_palette_cursor.min(suggestions.len() - 1);
+        let mut lines = suggestions
+            .iter()
+            .enumerate()
+            .take(height.saturating_sub(2) as usize)
+            .map(|(index, hint)| {
+                let marker = if index == selected { ">" } else { " " };
+                format!(
+                    "{marker} {:<16} {}",
+                    hint.display,
+                    ui_text(&self.state.settings.ui_language, hint.desc_key)
+                )
+            })
+            .collect::<Vec<_>>();
+        lines.push(ui_text(&self.state.settings.ui_language, "palette_hint").to_string());
+        frame.render_widget(Clear, area);
+        frame.render_widget(
+            Paragraph::new(lines.join("\n")).block(Self::block(
+                ui_text(&self.state.settings.ui_language, "commands"),
+                self.state.settings.theme == "light",
+            )),
+            area,
+        );
+    }
+
     fn block(title: &str, light: bool) -> Block<'_> {
         Block::default()
             .borders(Borders::ALL)
@@ -277,14 +524,18 @@ impl PracticodeApp {
             KeyCode::Esc => {
                 self.command.clear();
                 self.command_cursor = 0;
+                self.command_palette_cursor = 0;
                 self.focus = Focus::None;
             }
             KeyCode::Enter => {
-                let value = self.command.trim().to_string();
-                self.command.clear();
-                self.command_cursor = 0;
-                self.focus = Focus::None;
-                self.submit_command(&value)?;
+                if !self.accept_command_palette()? {
+                    let value = self.command.trim().to_string();
+                    self.command.clear();
+                    self.command_cursor = 0;
+                    self.command_palette_cursor = 0;
+                    self.focus = Focus::None;
+                    self.submit_command(&value)?;
+                }
             }
             KeyCode::Backspace => self.delete_command_before_cursor(),
             KeyCode::Delete => self.delete_command_at_cursor(),
@@ -292,11 +543,14 @@ impl PracticodeApp {
             KeyCode::Right => {
                 self.command_cursor = (self.command_cursor + 1).min(char_len(&self.command));
             }
+            KeyCode::Up => self.move_command_palette(-1),
+            KeyCode::Down => self.move_command_palette(1),
             KeyCode::Home => self.command_cursor = 0,
             KeyCode::End => self.command_cursor = char_len(&self.command),
             KeyCode::Char('?') if self.command.trim().is_empty() || self.command.trim() == "/" => {
                 self.command.clear();
                 self.command_cursor = 0;
+                self.command_palette_cursor = 0;
                 self.focus = Focus::None;
                 self.handle_command("help")?;
             }
@@ -389,6 +643,7 @@ impl PracticodeApp {
             self.command.push('/');
             self.command_cursor = 1;
         }
+        self.command_palette_cursor = 0;
         self.focus = Focus::Command;
     }
 
@@ -404,7 +659,7 @@ impl PracticodeApp {
     fn handle_command(&mut self, value: &str) -> Result<()> {
         if value.is_empty() || matches!(value, "help" | "h" | "?") {
             self.list_cursor = None;
-            self.write_output(HELP);
+            self.write_output(&self.help_text());
             return Ok(());
         }
         if value.starts_with("vim") {
@@ -428,22 +683,16 @@ impl PracticodeApp {
             "lang" if arg.is_empty() => self.action_cycle_language()?,
             "lang" if LANGUAGES.contains(&arg) => self.set_language(arg)?,
             "ui" if arg.is_empty() => self.action_toggle_ui_language()?,
-            "ui" if UI_LANGUAGES.contains(&arg) => self.set_ui_language(arg)?,
+            "ui" => self.set_ui_language(&normalize_ui_language(arg))?,
             "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();
@@ -453,16 +702,18 @@ 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);
                 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() => {
@@ -476,6 +727,7 @@ impl PracticodeApp {
             "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.")),
         }
@@ -534,10 +786,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();
@@ -640,9 +895,9 @@ impl PracticodeApp {
     }
 
     fn set_ui_language(&mut self, language: &str) -> Result<()> {
-        self.state.settings.ui_language = language.to_string();
+        self.state.settings.ui_language = normalize_ui_language(language);
         save_state(&self.root, &self.state)?;
-        self.write_text_output(&format!("UI language: {language}"));
+        self.write_text_output(&format!("UI language: {}", self.state.settings.ui_language));
         Ok(())
     }
 
@@ -655,7 +910,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()?;
@@ -694,6 +949,28 @@ 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_busy(&mut self, label: &str, body: &str) {
         self.busy_label = label.to_string();
         self.busy_body = body.to_string();
@@ -722,6 +999,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}."));
@@ -742,6 +1037,7 @@ impl PracticodeApp {
         let byte = byte_index(&self.command, self.command_cursor);
         self.command.insert(byte, char);
         self.command_cursor += 1;
+        self.command_palette_cursor = 0;
         self.normalize_command_input();
     }
 
@@ -753,6 +1049,7 @@ impl PracticodeApp {
         let end = byte_index(&self.command, self.command_cursor);
         self.command.replace_range(start..end, "");
         self.command_cursor -= 1;
+        self.command_palette_cursor = 0;
         self.normalize_command_input();
     }
 
@@ -763,9 +1060,55 @@ impl PracticodeApp {
         let start = byte_index(&self.command, self.command_cursor);
         let end = byte_index(&self.command, self.command_cursor + 1);
         self.command.replace_range(start..end, "");
+        self.command_palette_cursor = 0;
         self.normalize_command_input();
     }
 
+    fn command_suggestions(&self) -> Vec<&'static CommandHint> {
+        if self.focus != Focus::Command {
+            return Vec::new();
+        }
+        let Some(query) = self.command.trim_start().strip_prefix('/') else {
+            return Vec::new();
+        };
+        let query = query.to_lowercase();
+        COMMAND_HINTS
+            .iter()
+            .filter(|hint| hint.insert.starts_with(query.trim_start()))
+            .take(7)
+            .collect()
+    }
+
+    fn move_command_palette(&mut self, delta: isize) {
+        let len = self.command_suggestions().len();
+        if len == 0 {
+            return;
+        }
+        let cursor = self.command_palette_cursor as isize;
+        self.command_palette_cursor = ((cursor + delta).rem_euclid(len as isize)) as usize;
+    }
+
+    fn accept_command_palette(&mut self) -> Result<bool> {
+        let suggestions = self.command_suggestions();
+        if suggestions.is_empty() {
+            return Ok(false);
+        }
+        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;
+        self.command.clear();
+        self.command_cursor = 0;
+        self.command_palette_cursor = 0;
+        self.focus = Focus::None;
+        self.submit_command(value)?;
+        Ok(true)
+    }
+
     fn normalize_command_input(&mut self) {
         let normalized = compose_hangul_jamo(&self.command);
         if normalized == self.command {
@@ -960,38 +1303,74 @@ 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) {
-            (Focus::Command, _, _) => "Enter submit | Esc cancel",
-            (_, true, _) => "up/down move | Enter open | Esc close",
-            (_, _, true) => "Esc code | / command | ? help",
-            (Focus::Code, _, _) => "Esc then / command",
-            _ => "/ command | ? help",
+            (Focus::Command, _, _) => ui_text(lang, "hint_command"),
+            (_, true, _) => ui_text(lang, "hint_list"),
+            (_, _, true) => ui_text(lang, "hint_output"),
+            (Focus::Code, _, _) => ui_text(lang, "hint_code"),
+            _ => ui_text(lang, "hint_idle"),
         }
     }
+
+    fn help_text(&self) -> String {
+        let lang = &self.state.settings.ui_language;
+        let commands = COMMAND_HINTS
+            .iter()
+            .filter(|hint| hint.help)
+            .map(|hint| format!("- `{}` {}", hint.display, ui_text(lang, hint.desc_key)))
+            .collect::<Vec<_>>()
+            .join("\n");
+        format!(
+            "# {}\n\n## {}\n\n1. Type code in the right pane.\n2. Press `Esc`, then choose `/run` from the command palette.\n3. Use `/next` when it passes.\n\n## {}\n\n{}\n\n## {}\n\n- `/` opens the command palette outside the editor.\n- `↑/↓` selects a command and `Enter` accepts it.\n- `Esc` cancels the command palette or leaves output.\n\n## {}\n\n- stdout is shown when a case fails.\n- stderr is shown without affecting the expected stdout.",
+            ui_text(lang, "help_title"),
+            ui_text(lang, "daily_loop"),
+            ui_text(lang, "commands"),
+            commands,
+            ui_text(lang, "keys"),
+            ui_text(lang, "debug_prints"),
+        )
+    }
 }
 
 #[derive(Clone, Debug)]