practicode 0.1.8 → 0.1.10

package/src/tui/events.rs

@@ -0,0 +1,188 @@
+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(());
+        }
+        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_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/status.rs

@@ -0,0 +1,106 @@
+use super::*;
+
+impl PracticodeApp {
+    pub(super) 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 = if let Some(version) = self.update_notice.as_ref() {
+            format!(
+                "{}:{version} /update",
+                ui_text(&self.state.settings.ui_language, "update")
+            )
+        } else if self.task_rx.is_some() {
+            self.mode_hint().to_string()
+        } else if let Some(status) = self.background_generation_status() {
+            status
+        } else {
+            self.mode_hint().to_string()
+        };
+        format!(
+            " PRACTICODE | {} | {} | {} | {} | code:{} | {} | {} ",
+            self.problem.id,
+            self.problem.difficulty,
+            self.problem_status(&self.problem),
+            activity,
+            code_status,
+            self.state.settings.language,
+            tail,
+        )
+    }
+
+    pub(super) fn next_source_help(&self) -> String {
+        "Next behavior: /next opens unsolved local problems first and asks AI only when none remain. Use /generate <request> to create a problem in the background.".to_string()
+    }
+
+    pub(super) fn background_generation_status(&self) -> Option<String> {
+        if self.generate_rx.is_some() {
+            let elapsed = self
+                .generate_started
+                .map(|started| started.elapsed().as_secs())
+                .unwrap_or_default();
+            Some(format!("bg generate {elapsed}s"))
+        } else {
+            self.generate_notice.clone()
+        }
+    }
+
+    pub(super) fn busy_dots(&self) -> String {
+        ".".repeat((self.busy_frame / 8) % 4)
+    }
+
+    pub(super) fn busy_game_track(&self) -> String {
+        let width = 9;
+        let target = width / 2;
+        let position = (self.busy_frame / 2) % width;
+        let mut cells = vec!['-'; width];
+        cells[target] = '|';
+        cells[position] = if position == target { 'X' } else { '*' };
+        format!("[{}]", cells.into_iter().collect::<String>())
+    }
+
+    pub(super) fn busy_game_on_target(&self) -> bool {
+        (self.busy_frame / 2) % 9 == 4
+    }
+
+    pub(super) fn mode_hint(&self) -> &'static str {
+        let lang = &self.state.settings.ui_language;
+        if self.task_rx.is_some() {
+            return if self.busy_label == "next" {
+                ui_text(lang, "hint_busy_next")
+            } else {
+                ui_text(lang, "hint_busy")
+            };
+        }
+        match (self.focus, self.list_cursor.is_some(), self.show_output) {
+            (Focus::Command, _, _) => ui_text(lang, "hint_command"),
+            (_, true, _) => ui_text(lang, "hint_list"),
+            (_, _, true) if self.settings_cursor.is_some() => ui_text(lang, "hint_settings"),
+            (_, _, true) => ui_text(lang, "hint_output"),
+            (Focus::Code, _, _) => ui_text(lang, "hint_code"),
+            _ => ui_text(lang, "hint_idle"),
+        }
+    }
+
+    pub(super) 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"),
+        )
+    }
+}