practicode 0.1.9 → 0.1.11

package/src/tui/events.rs

@@ -0,0 +1,225 @@
+use super::*;
+
+impl PracticodeApp {
+    pub(super) fn handle_key(&mut self, key: KeyEvent) -> Result<()> {
+        if key.code == KeyCode::Char('c') && key.modifiers.contains(KeyModifiers::CONTROL) {
+            self.should_quit = true;
+            return Ok(());
+        }
+        if self.handle_busy_key(key) {
+            return Ok(());
+        }
+        if self.editing_notes {
+            return self.handle_note_key(key);
+        }
+        match self.focus {
+            Focus::Command => self.handle_command_key(key),
+            Focus::Code => self.handle_code_key(key),
+            _ => self.handle_global_key(key),
+        }
+    }
+
+    pub(super) fn handle_mouse(&mut self, mouse: MouseEvent) -> Result<()> {
+        if self.task_rx.is_some() {
+            self.focus = Focus::Output;
+            return Ok(());
+        }
+        if !matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) {
+            return Ok(());
+        }
+        let position = Position::new(mouse.column, mouse.row);
+        if self.command_area.contains(position) {
+            self.focus_command();
+        } else if self.show_output && self.output_area.contains(position) {
+            self.focus = Focus::Output;
+        } else if self.code_area.contains(position) {
+            self.action_edit()?;
+        }
+        Ok(())
+    }
+
+    pub(super) fn handle_command_key(&mut self, key: KeyEvent) -> Result<()> {
+        match key.code {
+            KeyCode::Esc => {
+                self.command.clear();
+                self.command_cursor = 0;
+                self.command_palette_cursor = 0;
+                self.focus = Focus::None;
+            }
+            KeyCode::Enter => {
+                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(),
+            KeyCode::Left => self.command_cursor = self.command_cursor.saturating_sub(1),
+            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")?;
+            }
+            KeyCode::Char(char) if !key.modifiers.contains(KeyModifiers::CONTROL) => {
+                self.insert_command_char(char);
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+
+    pub(super) fn handle_code_key(&mut self, key: KeyEvent) -> Result<()> {
+        match key.code {
+            KeyCode::Esc => self.focus = Focus::None,
+            KeyCode::Char(char) if !key.modifiers.contains(KeyModifiers::CONTROL) => {
+                self.editor.insert_char(char);
+                self.save_code()?;
+            }
+            KeyCode::Enter => {
+                self.editor.insert_newline();
+                self.save_code()?;
+            }
+            KeyCode::Backspace => {
+                self.editor.backspace();
+                self.save_code()?;
+            }
+            KeyCode::Delete => {
+                self.editor.delete();
+                self.save_code()?;
+            }
+            KeyCode::Tab => {
+                for _ in 0..4 {
+                    self.editor.insert_char(' ');
+                }
+                self.save_code()?;
+            }
+            KeyCode::Left => self.editor.move_left(),
+            KeyCode::Right => self.editor.move_right(),
+            KeyCode::Up => self.editor.move_up(),
+            KeyCode::Down => self.editor.move_down(),
+            _ => {}
+        }
+        Ok(())
+    }
+
+    pub(super) fn handle_note_key(&mut self, key: KeyEvent) -> Result<()> {
+        match key.code {
+            KeyCode::Esc => self.close_note_editor()?,
+            KeyCode::Char(char) if !key.modifiers.contains(KeyModifiers::CONTROL) => {
+                self.note_editor.insert_char(char);
+                self.save_notes()?;
+            }
+            KeyCode::Enter => {
+                self.note_editor.insert_newline();
+                self.save_notes()?;
+            }
+            KeyCode::Backspace => {
+                self.note_editor.backspace();
+                self.save_notes()?;
+            }
+            KeyCode::Delete => {
+                self.note_editor.delete();
+                self.save_notes()?;
+            }
+            KeyCode::Tab => {
+                for _ in 0..4 {
+                    self.note_editor.insert_char(' ');
+                }
+                self.save_notes()?;
+            }
+            KeyCode::Left => self.note_editor.move_left(),
+            KeyCode::Right => self.note_editor.move_right(),
+            KeyCode::Up => self.note_editor.move_up(),
+            KeyCode::Down => self.note_editor.move_down(),
+            _ => {}
+        }
+        Ok(())
+    }
+
+    pub(super) fn handle_global_key(&mut self, key: KeyEvent) -> Result<()> {
+        if self.settings_cursor.is_some() {
+            match key.code {
+                KeyCode::Up | KeyCode::Char('k') => self.move_settings_cursor(-1),
+                KeyCode::Down | KeyCode::Char('j') => self.move_settings_cursor(1),
+                KeyCode::Char(' ') | KeyCode::Enter => self.change_selected_setting()?,
+                KeyCode::Esc => {
+                    self.settings_cursor = None;
+                    self.show_output = false;
+                    self.focus = Focus::Code;
+                }
+                _ => self.handle_global_shortcut(key)?,
+            }
+            return Ok(());
+        }
+        if let Some(cursor) = self.list_cursor {
+            match key.code {
+                KeyCode::Up | KeyCode::Char('k') => self.move_list_cursor(-1),
+                KeyCode::Down | KeyCode::Char('j') => self.move_list_cursor(1),
+                KeyCode::Enter => self.open_selected_problem()?,
+                KeyCode::Esc => {
+                    self.list_cursor = None;
+                    self.write_text_output("Closed list.");
+                }
+                _ => {
+                    self.list_cursor = Some(cursor);
+                    self.handle_global_shortcut(key)?;
+                }
+            }
+            return Ok(());
+        }
+        if key.code == KeyCode::Esc && self.show_output {
+            self.show_output = false;
+            self.focus = Focus::Code;
+            return Ok(());
+        }
+        self.handle_global_shortcut(key)
+    }
+
+    pub(super) fn handle_global_shortcut(&mut self, key: KeyEvent) -> Result<()> {
+        match key.code {
+            KeyCode::Char('/') => self.focus_command(),
+            KeyCode::Char('?') => self.handle_command("help")?,
+            KeyCode::Char('r') => self.action_run()?,
+            KeyCode::Char('n') => self.action_next("")?,
+            KeyCode::Char('p') => self.action_previous()?,
+            KeyCode::Char('g') => self.action_give_up()?,
+            KeyCode::Char('e') => self.action_edit()?,
+            KeyCode::Char('l') => self.action_cycle_language()?,
+            KeyCode::Char('u') => self.action_toggle_ui_language()?,
+            KeyCode::Char('q') => self.should_quit = true,
+            _ => {}
+        }
+        Ok(())
+    }
+
+    pub(super) fn focus_command(&mut self) {
+        if self.command.is_empty() {
+            self.command.push('/');
+            self.command_cursor = 1;
+        }
+        self.command_palette_cursor = 0;
+        self.focus = Focus::Command;
+    }
+
+    pub(super) fn submit_command(&mut self, value: &str) -> Result<()> {
+        let value = value
+            .trim()
+            .strip_prefix('/')
+            .unwrap_or(value.trim())
+            .trim();
+        self.handle_command(value)
+    }
+}

package/src/tui/problem_list.rs

@@ -0,0 +1,163 @@
+use super::*;
+
+impl PracticodeApp {
+    pub(super) fn load_code_editor(&mut self) -> Result<()> {
+        let path = ensure_submission(&self.root, &self.problem, &self.state.settings)?;
+        let text = fs::read_to_string(path).unwrap_or_default();
+        self.editor.set_text(&text);
+        Ok(())
+    }
+
+    pub(super) fn save_code(&self) -> Result<()> {
+        let path = ensure_submission(&self.root, &self.problem, &self.state.settings)?;
+        fs::write(path, self.editor.text())?;
+        Ok(())
+    }
+
+    pub(super) fn start_problem_list(&mut self) {
+        self.list_cursor = Some(self.current_problem_index());
+        self.write_text_output(&self.render_problem_list());
+    }
+
+    pub(super) fn render_problem_list(&self) -> String {
+        let status_by_id = self
+            .state
+            .history
+            .iter()
+            .map(|item| (item.id.as_str(), item.status.as_str()))
+            .collect::<HashMap<_, _>>();
+        let cursor = self
+            .list_cursor
+            .unwrap_or_else(|| self.current_problem_index());
+        let mut lines = vec![
+            "Problems".to_string(),
+            String::new(),
+            "    # ID                 Difficulty  Status      Code      Title".to_string(),
+        ];
+        for (index, problem) in self.bank.iter().enumerate() {
+            let marker = if index == cursor { ">" } else { " " };
+            let current = if problem.id == self.problem.id {
+                "*"
+            } else {
+                " "
+            };
+            let title = localized(&problem.title, &self.state.settings.ui_language);
+            let code_status = self.submission_status(problem).0;
+            lines.push(format!(
+                "{marker} {current} {:>2} {:<18} {:<10} {:<10} {:<9} {title}",
+                index + 1,
+                problem.id,
+                problem.difficulty,
+                status_by_id
+                    .get(problem.id.as_str())
+                    .copied()
+                    .unwrap_or("-"),
+                code_status,
+            ));
+        }
+        lines.push("\nup/down or j/k select | enter open | esc close".to_string());
+        lines.join("\n")
+    }
+
+    pub(super) fn current_problem_index(&self) -> usize {
+        self.bank
+            .iter()
+            .position(|problem| problem.id == self.problem.id)
+            .unwrap_or(0)
+    }
+
+    pub(super) fn move_list_cursor(&mut self, delta: isize) {
+        if self.bank.is_empty() {
+            return;
+        }
+        let cursor = self
+            .list_cursor
+            .unwrap_or_else(|| self.current_problem_index()) as isize;
+        let len = self.bank.len() as isize;
+        self.list_cursor = Some(((cursor + delta).rem_euclid(len)) as usize);
+        self.write_text_output(&self.render_problem_list());
+    }
+
+    pub(super) fn open_selected_problem(&mut self) -> Result<()> {
+        if let Some(cursor) = self.list_cursor {
+            let problem_id = self.bank[cursor].id.clone();
+            self.list_cursor = None;
+            self.open_problem(&problem_id)?;
+        }
+        Ok(())
+    }
+
+    pub(super) fn open_problem(&mut self, query: &str) -> Result<()> {
+        self.list_cursor = None;
+        let Some(problem) = self.find_problem(query).cloned() else {
+            self.write_text_output(&format!("Problem not found: {query}\nTry /problems."));
+            return Ok(());
+        };
+        self.problem = problem;
+        self.state.current_problem = self.problem.id.clone();
+        if !self
+            .state
+            .history
+            .iter()
+            .any(|item| item.id == self.problem.id)
+        {
+            self.state.history.push(HistoryItem {
+                id: self.problem.id.clone(),
+                status: "assigned".to_string(),
+            });
+        }
+        save_state(&self.root, &self.state)?;
+        ensure_problem_files(&self.root, &self.problem)?;
+        self.load_code_editor()?;
+        self.show_output = false;
+        self.focus = Focus::Code;
+        Ok(())
+    }
+
+    pub(super) fn find_problem(&self, query: &str) -> Option<&Problem> {
+        let needle = if query.trim().chars().all(|c| c.is_ascii_digit()) {
+            format!("{:03}", query.trim().parse::<usize>().ok()?)
+        } else {
+            query.trim().to_lowercase()
+        };
+        self.bank.iter().find(|problem| {
+            needle == problem.id.to_lowercase()
+                || needle == problem.slug.to_lowercase()
+                || problem.id.starts_with(&needle)
+        })
+    }
+
+    pub(super) fn problem_status(&self, problem: &Problem) -> String {
+        if self.state.solved.contains(&problem.id) {
+            return "solved".to_string();
+        }
+        self.state
+            .history
+            .iter()
+            .rev()
+            .find(|item| item.id == problem.id)
+            .map(|item| item.status.clone())
+            .unwrap_or_else(|| "not_started".to_string())
+    }
+
+    pub(super) fn submission_status(&self, problem: &Problem) -> (String, String) {
+        let language = normalize_language(&self.state.settings.language);
+        let path = self
+            .root
+            .join("submissions")
+            .join(&problem.id)
+            .join(format!("solution.{}", ext_for(&language)));
+        if !path.exists() {
+            return ("missing".to_string(), format!("({language})"));
+        }
+        let content = fs::read_to_string(&path).unwrap_or_default();
+        let relative = path.strip_prefix(&self.root).unwrap_or(&path).display();
+        if content == template_for(&language) {
+            ("template".to_string(), format!("({relative})"))
+        } else if content.trim().is_empty() {
+            ("empty".to_string(), format!("({relative})"))
+        } else {
+            ("written".to_string(), format!("({relative})"))
+        }
+    }
+}

package/src/tui/settings_panel.rs

@@ -1,14 +1,30 @@
-use crate::core::{AppState, DIFFICULTIES, LANGUAGES, THEMES, UI_LANGUAGES};
+use crate::core::{
+    AI_PROVIDERS, AppState, CLAUDE_AI_EFFORTS, CODEX_AI_EFFORTS, DIFFICULTIES, LANGUAGES, THEMES,
+    UI_LANGUAGES, normalize_ai_effort,
+};
 
 pub(super) struct SettingsChange {
     pub reload_editor: bool,
+    pub provider_changed: bool,
+    pub edit_notes: bool,
 }
 
+const AI_PROVIDER_ROW: usize = 4;
+pub(super) const AI_MODEL_ROW: usize = 5;
+const AI_EFFORT_ROW: usize = 6;
+const NOTE_ROW: usize = 7;
+const TOGGLE_START: usize = 8;
+
 pub(super) fn row_count() -> usize {
-    4 + LANGUAGES.len() + UI_LANGUAGES.len()
+    TOGGLE_START + LANGUAGES.len() + UI_LANGUAGES.len()
 }
 
-pub(super) fn render(state: &AppState, cursor: Option<usize>) -> String {
+pub(super) fn render(
+    state: &AppState,
+    cursor: Option<usize>,
+    available_models: &[String],
+    models_loading: bool,
+) -> String {
     let settings = &state.settings;
     let ui_language = settings.ui_language.as_str();
     let topics = list_or_none(&settings.topics, ui_language);
@@ -63,20 +79,52 @@ pub(super) fn render(state: &AppState, cursor: Option<usize>) -> String {
             "{}: {generate_ui_languages}",
             label(ui_language, "generated_ui_languages")
         ),
-        format!("AI provider: {}", settings.ai_provider),
-        format!(
-            "AI model: {}",
-            if settings.ai_model == "auto" {
-                label(ui_language, "provider_default")
-            } else {
-                settings.ai_model.as_str()
-            }
+        row(
+            cursor,
+            AI_PROVIDER_ROW,
+            &format!("AI provider: {}", settings.ai_provider),
+        ),
+        row(
+            cursor,
+            AI_MODEL_ROW,
+            &format!(
+                "AI model: {}{}",
+                if settings.ai_model == "auto" {
+                    label(ui_language, "provider_default")
+                } else {
+                    settings.ai_model.as_str()
+                },
+                if models_loading {
+                    " (loading)"
+                } else if available_models.is_empty() {
+                    " (/model to load)"
+                } else {
+                    ""
+                }
+            ),
+        ),
+        row(
+            cursor,
+            AI_EFFORT_ROW,
+            &format!(
+                "AI effort: {}",
+                if settings.ai_effort == "auto" {
+                    label(ui_language, "provider_default")
+                } else {
+                    settings.ai_effort.as_str()
+                }
+            ),
+        ),
+        row(
+            cursor,
+            NOTE_ROW,
+            &format!("{}: Enter", label(ui_language, "problem_notes")),
         ),
         String::new(),
         label(ui_language, "answer_toggles").to_string(),
     ];
     for (index, language) in LANGUAGES.iter().enumerate() {
-        let row_index = 4 + index;
+        let row_index = TOGGLE_START + index;
         let checked = generate_language_enabled(state, language);
         lines.push(row(
             cursor,
@@ -87,7 +135,7 @@ pub(super) fn render(state: &AppState, cursor: Option<usize>) -> String {
     lines.push(String::new());
     lines.push(label(ui_language, "ui_toggles").to_string());
     for (index, language) in UI_LANGUAGES.iter().enumerate() {
-        let row_index = 4 + LANGUAGES.len() + index;
+        let row_index = TOGGLE_START + LANGUAGES.len() + index;
         let checked = generate_ui_language_enabled(state, language);
         lines.push(row(
             cursor,
@@ -106,10 +154,84 @@ pub(super) fn render(state: &AppState, cursor: Option<usize>) -> String {
         "/generate-ui all|en, ko".to_string(),
         "/provider codex|claude".to_string(),
         "/model auto".to_string(),
+        "/effort auto|low|medium|high|xhigh|max".to_string(),
+        "/note".to_string(),
+        "/notes".to_string(),
     ]);
     lines.join("\n")
 }
 
+pub(super) fn apply_selected(
+    state: &mut AppState,
+    selected: usize,
+    available_models: &[String],
+) -> SettingsChange {
+    let mut change = SettingsChange {
+        reload_editor: false,
+        provider_changed: false,
+        edit_notes: false,
+    };
+    match selected {
+        0 => {
+            let current = LANGUAGES
+                .iter()
+                .position(|language| language == &state.settings.language)
+                .unwrap_or(0);
+            state.settings.language = LANGUAGES[(current + 1) % LANGUAGES.len()].to_string();
+            change.reload_editor = true;
+        }
+        1 => {
+            let current = UI_LANGUAGES
+                .iter()
+                .position(|language| language == &state.settings.ui_language)
+                .unwrap_or(0);
+            state.settings.ui_language =
+                UI_LANGUAGES[(current + 1) % UI_LANGUAGES.len()].to_string();
+        }
+        2 => {
+            let current = THEMES
+                .iter()
+                .position(|theme| theme == &state.settings.theme)
+                .unwrap_or(0);
+            state.settings.theme = THEMES[(current + 1) % THEMES.len()].to_string();
+        }
+        3 => {
+            let current = DIFFICULTIES
+                .iter()
+                .position(|difficulty| difficulty == &state.settings.difficulty)
+                .unwrap_or(0);
+            let difficulty = DIFFICULTIES[(current + 1) % DIFFICULTIES.len()].to_string();
+            state.settings.difficulty = difficulty.clone();
+            if difficulty != "auto" {
+                state.suggested_next_difficulty = difficulty;
+            }
+        }
+        AI_PROVIDER_ROW => {
+            let current = AI_PROVIDERS
+                .iter()
+                .position(|provider| provider == &state.settings.ai_provider)
+                .unwrap_or(0);
+            state.settings.ai_provider =
+                AI_PROVIDERS[(current + 1) % AI_PROVIDERS.len()].to_string();
+            state.settings.ai_model = "auto".to_string();
+            state.settings.ai_effort =
+                normalize_ai_effort(&state.settings.ai_provider, &state.settings.ai_effort);
+            change.provider_changed = true;
+        }
+        AI_MODEL_ROW => cycle_ai_model(state, available_models),
+        AI_EFFORT_ROW => cycle_ai_effort(state),
+        NOTE_ROW => change.edit_notes = true,
+        row if row < TOGGLE_START + LANGUAGES.len() => {
+            toggle_generate_language(state, LANGUAGES[row - TOGGLE_START]);
+        }
+        row if row < row_count() => {
+            toggle_generate_ui_language(state, UI_LANGUAGES[row - TOGGLE_START - LANGUAGES.len()]);
+        }
+        _ => {}
+    }
+    change
+}
+
 fn label<'a>(ui_language: &str, key: &'a str) -> &'a str {
     if ui_language == "ko" {
         match key {
@@ -124,6 +246,7 @@ fn label<'a>(ui_language: &str, key: &'a str) -> &'a str {
             "generated_answer_languages" => "생성 정답 언어",
             "generated_ui_languages" => "생성 문제 언어",
             "provider_default" => "auto (provider 기본값)",
+            "problem_notes" => "문제 생성 메모 편집",
             "answer_toggles" => "생성 정답 언어 토글",
             "ui_toggles" => "생성 문제 언어 토글",
             "commands" => "명령",
@@ -144,6 +267,7 @@ fn label<'a>(ui_language: &str, key: &'a str) -> &'a str {
             "generated_answer_languages" => "Generated answer languages",
             "generated_ui_languages" => "Generated UI languages",
             "provider_default" => "auto (provider default)",
+            "problem_notes" => "Edit problem notes",
             "answer_toggles" => "Generated answer language toggles",
             "ui_toggles" => "Generated problem text language toggles",
             "commands" => "Commands",
@@ -154,52 +278,27 @@ fn label<'a>(ui_language: &str, key: &'a str) -> &'a str {
     }
 }
 
-pub(super) fn apply_selected(state: &mut AppState, selected: usize) -> SettingsChange {
-    let mut reload_editor = false;
-    match selected {
-        0 => {
-            let current = LANGUAGES
-                .iter()
-                .position(|language| language == &state.settings.language)
-                .unwrap_or(0);
-            state.settings.language = LANGUAGES[(current + 1) % LANGUAGES.len()].to_string();
-            reload_editor = true;
-        }
-        1 => {
-            let current = UI_LANGUAGES
-                .iter()
-                .position(|language| language == &state.settings.ui_language)
-                .unwrap_or(0);
-            state.settings.ui_language =
-                UI_LANGUAGES[(current + 1) % UI_LANGUAGES.len()].to_string();
-        }
-        2 => {
-            let current = THEMES
-                .iter()
-                .position(|theme| theme == &state.settings.theme)
-                .unwrap_or(0);
-            state.settings.theme = THEMES[(current + 1) % THEMES.len()].to_string();
-        }
-        3 => {
-            let current = DIFFICULTIES
-                .iter()
-                .position(|difficulty| difficulty == &state.settings.difficulty)
-                .unwrap_or(0);
-            let difficulty = DIFFICULTIES[(current + 1) % DIFFICULTIES.len()].to_string();
-            state.settings.difficulty = difficulty.clone();
-            if difficulty != "auto" {
-                state.suggested_next_difficulty = difficulty;
-            }
-        }
-        row if row < 4 + LANGUAGES.len() => {
-            toggle_generate_language(state, LANGUAGES[row - 4]);
-        }
-        row if row < row_count() => {
-            toggle_generate_ui_language(state, UI_LANGUAGES[row - 4 - LANGUAGES.len()]);
-        }
-        _ => {}
-    }
-    SettingsChange { reload_editor }
+fn cycle_ai_model(state: &mut AppState, available_models: &[String]) {
+    let mut models = vec!["auto"];
+    models.extend(available_models.iter().map(String::as_str));
+    let current = models
+        .iter()
+        .position(|model| model == &state.settings.ai_model)
+        .unwrap_or(0);
+    state.settings.ai_model = models[(current + 1) % models.len()].to_string();
+}
+
+fn cycle_ai_effort(state: &mut AppState) {
+    let efforts = if state.settings.ai_provider == "claude" {
+        CLAUDE_AI_EFFORTS
+    } else {
+        CODEX_AI_EFFORTS
+    };
+    let current = efforts
+        .iter()
+        .position(|effort| effort == &state.settings.ai_effort)
+        .unwrap_or(0);
+    state.settings.ai_effort = efforts[(current + 1) % efforts.len()].to_string();
 }
 
 fn row(cursor: Option<usize>, index: usize, text: &str) -> String {