practicode 0.1.9 → 0.1.11

package/src/tui/actions.rs

@@ -0,0 +1,377 @@
+use super::*;
+
+impl PracticodeApp {
+    pub(super) fn action_edit(&mut self) -> Result<()> {
+        self.editing_notes = false;
+        self.load_code_editor()?;
+        self.settings_cursor = None;
+        self.show_output = false;
+        self.focus = Focus::Code;
+        Ok(())
+    }
+
+    pub(super) fn action_run(&mut self) -> Result<()> {
+        self.save_code()?;
+        let result = judge(&self.root, &self.problem, &self.state.settings);
+        if result.passed {
+            record_pass(&self.root, &self.problem, &mut self.state)?;
+        }
+        let headline = format!(
+            "{} {}/{}",
+            if result.passed { "PASS" } else { "FAIL" },
+            result.passed_cases,
+            result.total_cases
+        );
+        let next_step = if result.passed {
+            ui_text(&self.state.settings.ui_language, "run_pass_next")
+        } else {
+            ui_text(&self.state.settings.ui_language, "run_fail_next")
+        };
+        self.write_text_output(&format!("{headline}\n{}\n\n{next_step}", result.output));
+        Ok(())
+    }
+
+    pub(super) fn action_next(&mut self, request: &str) -> Result<()> {
+        self.check_background_generation();
+        let request = request.trim();
+        let old_problem = self.state.current_problem.clone();
+        if let Some(problem) = next_problem(&self.root, &self.bank, &mut self.state)? {
+            self.generate_notice = None;
+            self.problem = problem;
+            self.load_code_editor()?;
+            self.settings_cursor = None;
+            self.show_output = false;
+            self.focus = Focus::Code;
+            return Ok(());
+        }
+        if self.generate_rx.is_some() {
+            self.write_text_output(
+                "A background generation is already running. Keep solving; /next will pick up the new problem when it finishes.",
+            );
+            return Ok(());
+        }
+        self.start_next_problem(old_problem, true, request.to_string());
+        Ok(())
+    }
+
+    pub(super) fn action_generate(&mut self, request: &str) {
+        self.check_background_generation();
+        if self.task_rx.is_some() || self.generate_rx.is_some() {
+            let message = "Generation is already running; skipped duplicate /generate.";
+            self.generate_notice = Some(message.to_string());
+            self.write_text_output(message);
+            return;
+        }
+        self.start_background_generation(request.trim().to_string());
+    }
+
+    pub(super) fn start_background_generation(&mut self, request: String) {
+        let root = self.root.clone();
+        let state = self.state.clone();
+        let (tx, rx) = mpsc::channel();
+        thread::spawn(move || {
+            let _ = tx.send(run_ai_generate(&root, &state, &request));
+        });
+        self.generate_bank_len = self.bank.len();
+        self.generate_started = Some(Instant::now());
+        self.generate_notice = Some("Generating in background.".to_string());
+        self.generate_rx = Some(rx);
+        self.settings_cursor = None;
+        self.show_output = false;
+        self.focus = Focus::Code;
+    }
+
+    pub(super) fn start_next_problem(
+        &mut self,
+        old_problem: String,
+        fallback_to_local: bool,
+        request: String,
+    ) {
+        if self.task_rx.is_some() {
+            self.write_text_output(ui_text(&self.state.settings.ui_language, "already_busy"));
+            return;
+        }
+        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();
+        thread::spawn(move || {
+            let output = run_ai_next(&root, &state, true, &request);
+            let _ = tx.send(TaskResult::Next {
+                output,
+                old_problem,
+                fallback_to_local,
+            });
+        });
+        self.task_rx = Some(rx);
+    }
+
+    pub(super) fn finish_next_problem(
+        &mut self,
+        output: String,
+        old_problem: String,
+        fallback_to_local: bool,
+    ) -> Result<()> {
+        self.bank = load_bank(&self.root)?;
+        self.state = load_state(&self.root, &self.bank)?;
+        self.problem = problem_by_id(&self.bank, &self.state.current_problem)
+            .cloned()
+            .unwrap_or_else(|| self.bank[0].clone());
+        if self.state.current_problem == old_problem {
+            if fallback_to_local
+                && let Some(problem) = next_problem(&self.root, &self.bank, &mut self.state)?
+            {
+                self.problem = problem;
+            } else {
+                self.write_text_output(&format!(
+                    "{}{}No next problem is available yet.",
+                    if output.is_empty() { "" } else { &output },
+                    if output.is_empty() { "" } else { "\n\n" }
+                ));
+                return Ok(());
+            }
+        }
+        self.load_code_editor()?;
+        self.settings_cursor = None;
+        self.show_output = false;
+        self.focus = Focus::Code;
+        Ok(())
+    }
+
+    pub(super) fn action_previous(&mut self) -> Result<()> {
+        let old_problem = self.state.current_problem.clone();
+        self.problem = previous_problem(&self.root, &self.bank, &mut self.state)?;
+        if self.state.current_problem == old_problem {
+            self.write_text_output("Already at the first known problem.");
+        } else {
+            self.load_code_editor()?;
+            self.settings_cursor = None;
+            self.show_output = false;
+            self.focus = Focus::Code;
+        }
+        Ok(())
+    }
+
+    pub(super) fn action_give_up(&mut self) -> Result<()> {
+        let answer = give_up(&self.root, &self.problem, &mut self.state)?;
+        let language = normalize_language(&self.state.settings.language);
+        self.write_output(&format!(
+            "Answer for {language}:\n\n```{language}\n{}\n```",
+            answer.trim_end()
+        ));
+        Ok(())
+    }
+
+    pub(super) fn action_cycle_language(&mut self) -> Result<()> {
+        let current = LANGUAGES
+            .iter()
+            .position(|language| language == &self.state.settings.language)
+            .unwrap_or(0);
+        self.set_language(LANGUAGES[(current + 1) % LANGUAGES.len()])
+    }
+
+    pub(super) fn action_toggle_ui_language(&mut self) -> Result<()> {
+        let current = UI_LANGUAGES
+            .iter()
+            .position(|language| language == &self.state.settings.ui_language)
+            .unwrap_or(0);
+        self.set_ui_language(UI_LANGUAGES[(current + 1) % UI_LANGUAGES.len()])
+    }
+
+    pub(super) fn action_toggle_theme(&mut self) -> Result<()> {
+        let current = THEMES
+            .iter()
+            .position(|theme| theme == &self.state.settings.theme)
+            .unwrap_or(0);
+        self.set_theme(THEMES[(current + 1) % THEMES.len()])
+    }
+
+    pub(super) fn set_language(&mut self, language: &str) -> Result<()> {
+        self.state.settings.language = language.to_string();
+        save_state(&self.root, &self.state)?;
+        self.load_code_editor()?;
+        self.settings_cursor = None;
+        self.show_output = false;
+        self.focus = Focus::Code;
+        Ok(())
+    }
+
+    pub(super) fn set_ui_language(&mut self, language: &str) -> Result<()> {
+        self.state.settings.ui_language = normalize_ui_language(language);
+        save_state(&self.root, &self.state)?;
+        self.write_text_output(&format!("UI language: {}", self.state.settings.ui_language));
+        Ok(())
+    }
+
+    pub(super) fn set_theme(&mut self, theme: &str) -> Result<()> {
+        self.state.settings.theme = theme.to_string();
+        save_state(&self.root, &self.state)?;
+        self.write_text_output(&format!("Theme: {theme}"));
+        Ok(())
+    }
+
+    pub(super) fn set_difficulty(&mut self, difficulty: &str) -> Result<()> {
+        let difficulty = difficulty.trim().to_lowercase();
+        if !DIFFICULTIES.contains(&difficulty.as_str()) {
+            self.write_text_output("Difficulty: auto, easy, medium, or hard.");
+            return Ok(());
+        }
+        let normalized = normalize_difficulty(&difficulty);
+        self.state.settings.difficulty = normalized.clone();
+        if normalized != "auto" {
+            self.state.suggested_next_difficulty = normalized;
+        }
+        save_state(&self.root, &self.state)?;
+        self.show_profile();
+        Ok(())
+    }
+
+    pub(super) fn set_topics(&mut self, topics: &str, avoid: bool) -> Result<()> {
+        let topics = parse_topic_list(topics);
+        if avoid {
+            self.state.settings.avoid_topics = topics;
+        } else {
+            self.state.settings.topics = topics;
+        }
+        save_state(&self.root, &self.state)?;
+        self.show_profile();
+        Ok(())
+    }
+
+    pub(super) fn set_generate_languages(&mut self, value: &str, ui: bool) -> Result<()> {
+        if ui {
+            self.state.settings.generate_ui_languages = parse_ui_language_list(value);
+        } else {
+            self.state.settings.generate_languages = parse_language_list(value);
+        }
+        save_state(&self.root, &self.state)?;
+        self.show_profile();
+        Ok(())
+    }
+
+    pub(super) fn set_ai_effort(&mut self, effort: &str) -> Result<()> {
+        self.state.settings.ai_effort =
+            normalize_ai_effort(&self.state.settings.ai_provider, effort);
+        save_state(&self.root, &self.state)?;
+        self.write_model_status();
+        Ok(())
+    }
+
+    pub(super) fn reset_profile(&mut self) -> Result<()> {
+        self.state.settings.difficulty = "auto".to_string();
+        self.state.settings.topics.clear();
+        self.state.settings.avoid_topics.clear();
+        self.state.settings.generate_languages.clear();
+        self.state.settings.generate_ui_languages.clear();
+        save_state(&self.root, &self.state)?;
+        self.show_profile();
+        Ok(())
+    }
+
+    pub(super) fn show_profile(&mut self) {
+        self.show_profile_with_intro("");
+    }
+
+    pub(super) fn show_profile_with_intro(&mut self, intro: &str) {
+        self.editing_notes = false;
+        self.showing_model_status = false;
+        if self.settings_cursor.is_none() {
+            self.settings_cursor = Some(0);
+        }
+        let profile = self.profile_text();
+        self.output = if intro.trim().is_empty() {
+            profile
+        } else {
+            format!("{}\n\n{profile}", intro.trim_end())
+        };
+        self.output_is_markdown = false;
+        self.show_output = true;
+        self.focus = Focus::Output;
+    }
+
+    pub(super) fn profile_text(&self) -> String {
+        settings_panel::render(
+            &self.state,
+            self.settings_cursor,
+            &self.available_models,
+            self.model_rx.is_some(),
+        )
+    }
+
+    pub(super) fn settings_row_count(&self) -> usize {
+        settings_panel::row_count()
+    }
+
+    pub(super) fn move_settings_cursor(&mut self, delta: isize) {
+        let len = self.settings_row_count() as isize;
+        let cursor = self.settings_cursor.unwrap_or(0) as isize;
+        self.settings_cursor = Some(((cursor + delta).rem_euclid(len)) as usize);
+        self.show_profile();
+    }
+
+    pub(super) fn change_selected_setting(&mut self) -> Result<()> {
+        let Some(row) = self.settings_cursor else {
+            return Ok(());
+        };
+        if row == settings_panel::AI_MODEL_ROW
+            && self.available_models_provider != self.state.settings.ai_provider
+        {
+            self.start_model_check();
+            self.check_models();
+            if self.model_rx.is_some() {
+                self.show_profile();
+                return Ok(());
+            }
+        }
+        let change = settings_panel::apply_selected(&mut self.state, row, &self.available_models);
+        if change.edit_notes {
+            self.start_note_editor()?;
+            return Ok(());
+        }
+        if change.provider_changed {
+            self.model_rx = None;
+            self.available_models.clear();
+            self.available_models_provider.clear();
+            self.model_message = None;
+        }
+        if change.reload_editor {
+            self.load_code_editor()?;
+        }
+        save_state(&self.root, &self.state)?;
+        self.show_profile();
+        Ok(())
+    }
+
+    pub(super) fn start_note_editor(&mut self) -> Result<()> {
+        self.save_code()?;
+        self.note_editor
+            .set_text(&read_problem_notes(&self.root).unwrap_or_default());
+        self.settings_cursor = None;
+        self.showing_model_status = false;
+        self.editing_notes = true;
+        self.show_output = true;
+        self.focus = Focus::Output;
+        Ok(())
+    }
+
+    pub(super) fn save_notes(&self) -> Result<()> {
+        let path = self.root.join(PROBLEM_NOTES_PATH);
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        let text = self.note_editor.text();
+        let text = text.trim_end();
+        fs::write(path, if text.is_empty() { "" } else { text })?;
+        Ok(())
+    }
+
+    pub(super) fn close_note_editor(&mut self) -> Result<()> {
+        self.save_notes()?;
+        self.editing_notes = false;
+        self.show_profile();
+        Ok(())
+    }
+}

package/src/tui/command_handlers.rs

@@ -0,0 +1,138 @@
+use super::*;
+
+impl PracticodeApp {
+    pub(super) fn handle_command(&mut self, value: &str) -> Result<()> {
+        if self.task_rx.is_some() {
+            let command = value
+                .trim()
+                .strip_prefix('/')
+                .unwrap_or(value.trim())
+                .split_whitespace()
+                .next()
+                .unwrap_or("");
+            if matches!(command, "exit" | "quit" | "q") {
+                self.should_quit = true;
+            } else {
+                self.focus = Focus::Output;
+            }
+            return Ok(());
+        }
+        if value.is_empty() || matches!(value, "help" | "h" | "?") {
+            self.list_cursor = None;
+            self.write_output(&self.help_text());
+            return Ok(());
+        }
+        if value.starts_with("vim") {
+            self.list_cursor = None;
+            self.write_text_output("The code editor is already open on the right.");
+            return Ok(());
+        }
+        let (command, arg) = value.split_once(char::is_whitespace).unwrap_or((value, ""));
+        let arg = arg.trim();
+        if !matches!(command, "list" | "problems") {
+            self.list_cursor = None;
+        }
+        match command {
+            "run" | "r" => self.action_run()?,
+            "code" | "edit" | "e" => self.action_edit()?,
+            "next" | "n" => self.action_next(arg)?,
+            "generate" | "gen" | "new" => self.action_generate(arg),
+            "back" | "prev" | "previous" | "p" => self.action_previous()?,
+            "answer" | "giveup" | "give" | "g" => self.action_give_up()?,
+            "problems" | "list" => self.start_problem_list(),
+            "open" | "o" if !arg.is_empty() => self.open_problem(arg)?,
+            "language" | "lang" if arg.is_empty() => self.action_cycle_language()?,
+            "language" | "lang" if LANGUAGES.contains(&arg) => self.set_language(arg)?,
+            "ui" if arg.is_empty() => self.action_toggle_ui_language()?,
+            "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)?,
+            "profile" | "settings" if arg.is_empty() => self.show_profile(),
+            "profile" | "settings" if arg == "reset" => self.reset_profile()?,
+            "difficulty" | "level" if arg.is_empty() => self.show_profile(),
+            "difficulty" | "level" => self.set_difficulty(arg)?,
+            "topics" | "topic" if arg.is_empty() => self.show_profile(),
+            "topics" | "topic" => self.set_topics(arg, false)?,
+            "avoid" | "skip" if arg.is_empty() => self.show_profile(),
+            "avoid" | "skip" => self.set_topics(arg, true)?,
+            "generate-languages" | "gen-languages" | "gen-lang" if arg.is_empty() => {
+                self.show_profile()
+            }
+            "generate-languages" | "gen-languages" | "gen-lang" => {
+                self.set_generate_languages(arg, false)?
+            }
+            "generate-ui" | "gen-ui" if arg.is_empty() => self.show_profile(),
+            "generate-ui" | "gen-ui" => self.set_generate_languages(arg, true)?,
+            "source" | "next-source" if arg.is_empty() => {
+                self.write_text_output(&self.next_source_help());
+            }
+            "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(&self.next_source_help());
+            }
+            "ai-next-command" if !arg.is_empty() => {
+                self.state.settings.ai_next_command = arg.to_string();
+                self.state.settings.next_source = "ai".to_string();
+                save_state(&self.root, &self.state)?;
+                self.write_text_output("AI next command saved.");
+            }
+            "provider" | "ai-provider" if arg.is_empty() => {
+                self.write_text_output(&format!(
+                    "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.state.settings.ai_model = "auto".to_string();
+                self.state.settings.ai_effort = normalize_ai_effort(
+                    &self.state.settings.ai_provider,
+                    &self.state.settings.ai_effort,
+                );
+                self.model_rx = None;
+                self.available_models.clear();
+                self.available_models_provider.clear();
+                self.model_message = None;
+                save_state(&self.root, &self.state)?;
+                self.write_text_output(&format!(
+                    "AI provider: {}\n{}",
+                    self.state.settings.ai_provider,
+                    provider_status(&self.state.settings.ai_provider)
+                ));
+            }
+            "model" if arg.is_empty() => {
+                self.start_model_check();
+                self.check_models();
+                self.write_model_status();
+            }
+            "model" => {
+                self.state.settings.ai_model = if arg == "auto" {
+                    "auto".to_string()
+                } else {
+                    arg.to_string()
+                };
+                save_state(&self.root, &self.state)?;
+                self.start_model_check();
+                self.check_models();
+                self.write_model_status();
+            }
+            "effort" | "reasoning" | "ai-effort" if arg.is_empty() => {
+                self.write_model_status();
+            }
+            "effort" | "reasoning" | "ai-effort" => self.set_ai_effort(arg)?,
+            "hint" if arg.is_empty() => {
+                self.start_ai_prompt("Give one concise hint for the current problem.")?
+            }
+            "hint" | "ask" | "ai" if !arg.is_empty() => self.start_ai_prompt(arg)?,
+            "note" if !arg.is_empty() => self.append_note(arg)?,
+            "note" => self.start_note_editor()?,
+            "notes" => self.show_notes()?,
+            "update" => self.refresh_update_notice(),
+            "exit" | "quit" | "q" => self.should_quit = true,
+            _ => self.write_text_output(&format!("Unknown command: {value}\nTry /help.")),
+        }
+        Ok(())
+    }
+}

package/src/tui/command_input.rs

@@ -0,0 +1,120 @@
+use super::*;
+
+impl PracticodeApp {
+    pub(super) fn insert_command_char(&mut self, char: char) {
+        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();
+    }
+
+    pub(super) fn delete_command_before_cursor(&mut self) {
+        if self.command_cursor == 0 {
+            return;
+        }
+        let start = byte_index(&self.command, self.command_cursor - 1);
+        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();
+    }
+
+    pub(super) fn delete_command_at_cursor(&mut self) {
+        if self.command_cursor >= char_len(&self.command) {
+            return;
+        }
+        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();
+    }
+
+    pub(super) fn command_suggestions(&self) -> Vec<CommandChoice> {
+        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();
+        self.command_choices()
+            .into_iter()
+            .filter(|hint| hint.insert.starts_with(query.trim_start()))
+            .collect()
+    }
+
+    pub(super) fn command_choices(&self) -> Vec<CommandChoice> {
+        let mut choices = Vec::new();
+        for hint in COMMAND_HINTS {
+            if hint.insert == "effort max" && self.state.settings.ai_provider != "claude" {
+                continue;
+            }
+            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
+    }
+
+    pub(super) 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;
+    }
+
+    pub(super) 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.clone();
+        self.command.clear();
+        self.command_cursor = 0;
+        self.command_palette_cursor = 0;
+        self.focus = Focus::None;
+        self.submit_command(&value)?;
+        Ok(true)
+    }
+
+    pub(super) fn normalize_command_input(&mut self) {
+        let normalized = compose_hangul_jamo(&self.command);
+        if normalized == self.command {
+            self.command_cursor = self.command_cursor.min(char_len(&self.command));
+            return;
+        }
+        let old_prefix = prefix(&self.command, self.command_cursor);
+        self.command = normalized;
+        self.command_cursor =
+            char_len(&compose_hangul_jamo(&old_prefix)).min(char_len(&self.command));
+    }
+}

package/src/tui/commands.rs

@@ -162,6 +162,62 @@ pub(super) const COMMAND_HINTS: &[CommandHint] = &[
         keep_open: true,
         help: false,
     },
+    CommandHint {
+        insert: "note",
+        display: "/note",
+        desc_key: "cmd_note",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "notes",
+        display: "/notes",
+        desc_key: "cmd_notes",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "effort auto",
+        display: "/effort auto",
+        desc_key: "cmd_effort_auto",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "effort low",
+        display: "/effort low",
+        desc_key: "cmd_effort",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "effort medium",
+        display: "/effort medium",
+        desc_key: "cmd_effort",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "effort high",
+        display: "/effort high",
+        desc_key: "cmd_effort",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "effort xhigh",
+        display: "/effort xhigh",
+        desc_key: "cmd_effort",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "effort max",
+        display: "/effort max",
+        desc_key: "cmd_effort_max",
+        keep_open: false,
+        help: false,
+    },
     CommandHint {
         insert: "language python",
         display: "/language python",