practicode 0.1.8 → 0.1.10

package/src/tui/tasks.rs

@@ -0,0 +1,279 @@
+use super::*;
+
+impl PracticodeApp {
+    pub(super) fn start_ai_prompt(&mut self, prompt: &str) -> Result<()> {
+        if self.task_rx.is_some() {
+            self.write_text_output(ui_text(&self.state.settings.ui_language, "already_busy"));
+            return Ok(());
+        }
+        self.save_code()?;
+        let label = normalize_ai_provider(&self.state.settings.ai_provider);
+        self.start_busy("ai", &format!("{label} is thinking"));
+        let root = self.root.clone();
+        let problem = self.problem.clone();
+        let settings = self.state.settings.clone();
+        let prompt = prompt.to_string();
+        let (tx, rx) = mpsc::channel();
+        thread::spawn(move || {
+            let output = run_ai_prompt(&root, &problem, &settings, &prompt);
+            let _ = tx.send(TaskResult::AiPrompt(output));
+        });
+        self.task_rx = Some(rx);
+        Ok(())
+    }
+
+    pub(super) fn check_task(&mut self) {
+        let task = self.task_rx.as_ref().and_then(|rx| rx.try_recv().ok());
+        if let Some(task) = task {
+            self.task_rx = None;
+            self.stop_busy();
+            match task {
+                TaskResult::AiPrompt(output) => self.write_output(&output),
+                TaskResult::Next {
+                    output,
+                    old_problem,
+                    fallback_to_local,
+                } => {
+                    if let Err(error) =
+                        self.finish_next_problem(output, old_problem, fallback_to_local)
+                    {
+                        self.write_text_output(&format!("Next failed\n{error}"));
+                    }
+                }
+            }
+        }
+    }
+
+    pub(super) fn check_background_generation(&mut self) {
+        let output = self.generate_rx.as_ref().and_then(|rx| rx.try_recv().ok());
+        let Some(output) = output else {
+            return;
+        };
+        self.generate_rx = None;
+        self.generate_started = None;
+        let old_len = self.generate_bank_len;
+        match load_bank(&self.root) {
+            Ok(bank) => {
+                let added = bank.len().saturating_sub(old_len);
+                self.bank = bank;
+                let _ = save_state(&self.root, &self.state);
+                self.generate_notice = Some(if added > 0 {
+                    format!("Generated {added} problem in background. Use /next.")
+                } else if output.contains("failed") {
+                    "Background generation failed. Use /generate to retry.".to_string()
+                } else {
+                    "Background generation finished. Use /problems to review.".to_string()
+                });
+            }
+            Err(error) => {
+                self.generate_notice = Some(format!(
+                    "Background generation finished, but bank reload failed: {error}"
+                ));
+            }
+        }
+    }
+
+    pub(super) 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());
+            match &result {
+                UpdateCheck::Available(version) => self.update_notice = Some(version.clone()),
+                UpdateCheck::Current | UpdateCheck::Disabled => self.update_notice = None,
+                UpdateCheck::Failed => {}
+            }
+        }
+    }
+
+    pub(super) fn start_update_check(&mut self) {
+        if self.update_rx.is_some() {
+            return;
+        }
+        self.last_update_check = Some(Instant::now());
+        let (tx, rx) = mpsc::channel();
+        thread::spawn(move || {
+            let _ = tx.send(check_latest_version());
+        });
+        self.update_rx = Some(rx);
+    }
+
+    pub(super) fn maybe_start_periodic_update_check(&mut self) {
+        if self.update_rx.is_some() {
+            return;
+        }
+        if self
+            .last_update_check
+            .is_none_or(|last| last.elapsed() >= UPDATE_CHECK_INTERVAL)
+        {
+            self.start_update_check();
+        }
+    }
+
+    pub(super) fn start_model_check(&mut self) {
+        let provider = self.state.settings.ai_provider.clone();
+        if self.model_rx.is_some() || self.available_models_provider == provider {
+            return;
+        }
+        let query_provider = provider.clone();
+        let (tx, rx) = mpsc::channel();
+        thread::spawn(move || {
+            let _ = tx.send(available_models(&query_provider));
+        });
+        self.available_models_provider = provider;
+        self.model_rx = Some(rx);
+    }
+
+    pub(super) fn check_models(&mut self) {
+        let models = self.model_rx.as_ref().and_then(|rx| rx.try_recv().ok());
+        if let Some(catalog) = models {
+            self.model_rx = None;
+            self.available_models = catalog.models;
+            self.model_message = catalog.message;
+            if self.showing_model_status {
+                self.output = self.model_status_text();
+                self.output_is_markdown = false;
+                self.show_output = true;
+            }
+        }
+    }
+
+    pub(super) fn model_status_text(&self) -> String {
+        let mut lines = vec![
+            format!("AI provider: {}", self.state.settings.ai_provider),
+            format!(
+                "AI model: {}",
+                if self.state.settings.ai_model == "auto" {
+                    "auto (provider default)"
+                } else {
+                    self.state.settings.ai_model.as_str()
+                }
+            ),
+            "Use /model auto to let the provider choose its default.".to_string(),
+        ];
+        if self.model_rx.is_some() {
+            lines.push("Loading provider model list...".to_string());
+        } else if self.available_models.is_empty() {
+            lines.push(
+                self.model_message
+                    .clone()
+                    .unwrap_or_else(|| "Provider model list is unavailable.".to_string()),
+            );
+            lines.push("Use /model <name> for a known model.".to_string());
+        } else {
+            lines.push("Available models:".to_string());
+            lines.extend(
+                self.available_models
+                    .iter()
+                    .map(|model| format!("- /model {model}")),
+            );
+        }
+        lines.join("\n")
+    }
+
+    pub(super) fn start_busy(&mut self, label: &str, body: &str) {
+        self.settings_cursor = None;
+        self.busy_label = label.to_string();
+        self.busy_body = body.to_string();
+        self.busy_started = Some(Instant::now());
+        self.busy_frame = 0;
+        self.busy_hits = 0;
+        self.busy_misses = 0;
+        self.show_output = true;
+        self.focus = Focus::Output;
+    }
+
+    pub(super) fn stop_busy(&mut self) {
+        self.busy_label.clear();
+        self.busy_body.clear();
+        self.busy_started = None;
+        self.busy_frame = 0;
+    }
+
+    pub(super) fn handle_busy_key(&mut self, key: KeyEvent) -> bool {
+        if self.task_rx.is_none() {
+            return false;
+        }
+        if key.code == KeyCode::Char('q') && key.modifiers.is_empty() {
+            self.should_quit = true;
+        } else if self.busy_label == "next"
+            && key.code == KeyCode::Char(' ')
+            && key.modifiers.is_empty()
+        {
+            if self.busy_game_on_target() {
+                self.busy_hits += 1;
+            } else {
+                self.busy_misses += 1;
+            }
+        }
+        self.focus = Focus::Output;
+        true
+    }
+
+    pub(super) fn write_output(&mut self, output: &str) {
+        self.settings_cursor = None;
+        self.showing_model_status = false;
+        self.output = output.to_string();
+        self.output_is_markdown = true;
+        self.show_output = true;
+        self.focus = Focus::Output;
+    }
+
+    pub(super) fn write_text_output(&mut self, output: &str) {
+        self.settings_cursor = None;
+        self.showing_model_status = false;
+        self.output = output.trim_end().to_string();
+        self.output_is_markdown = false;
+        self.show_output = true;
+        self.focus = Focus::Output;
+    }
+
+    pub(super) fn write_model_status(&mut self) {
+        self.output = self.model_status_text();
+        self.output_is_markdown = false;
+        self.showing_model_status = true;
+        self.show_output = true;
+        self.focus = Focus::Output;
+    }
+
+    pub(super) fn refresh_update_notice(&mut self) {
+        self.update_check = None;
+        self.update_notice = None;
+        self.start_update_check();
+        self.show_update_notice();
+    }
+
+    pub(super) 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"));
+        }
+    }
+
+    pub(super) 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}."));
+        Ok(())
+    }
+
+    pub(super) fn show_notes(&mut self) -> Result<()> {
+        let notes = read_problem_notes(&self.root)?;
+        if notes.is_empty() {
+            self.write_text_output("No notes yet. Use /topics or /avoid for standing preferences.");
+        } else {
+            self.write_text_output(&format!("Problem notes ({PROBLEM_NOTES_PATH})\n\n{notes}"));
+        }
+        Ok(())
+    }
+}

package/src/tui/view.rs

@@ -0,0 +1,342 @@
+use super::*;
+
+impl PracticodeApp {
+    pub(super) fn draw(&mut self, frame: &mut Frame) {
+        let size = frame.area();
+        let vertical = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([
+                Constraint::Min(1),
+                Constraint::Length(1),
+                Constraint::Length(3),
+            ])
+            .split(size);
+        let body = Layout::default()
+            .direction(Direction::Horizontal)
+            .constraints([Constraint::Percentage(58), Constraint::Percentage(42)])
+            .split(vertical[0]);
+        self.code_area = body[1];
+        self.output_area = body[1];
+        self.command_area = vertical[2];
+
+        let light = self.state.settings.theme == "light";
+        let problem = Paragraph::new(problem_view::render(
+            &self.problem,
+            &self.state.settings.ui_language,
+            light,
+        ))
+        .style(Self::pane_style(light))
+        .block(Self::block(
+            ui_text(&self.state.settings.ui_language, "problem"),
+            light,
+            false,
+        ))
+        .wrap(Wrap { trim: false });
+        frame.render_widget(problem, body[0]);
+
+        if self.show_output {
+            let text = self.output_text();
+            let output = Paragraph::new(text)
+                .style(Self::pane_style(light))
+                .block(Self::block(
+                    ui_text(&self.state.settings.ui_language, "output"),
+                    light,
+                    self.focus != Focus::Command,
+                ))
+                .wrap(Wrap { trim: false });
+            frame.render_widget(output, body[1]);
+        } else {
+            let code = self
+                .editor
+                .visible_text(body[1].height.saturating_sub(2) as usize);
+            let title = format!("solution.{}", ext_for(&self.state.settings.language));
+            let code = Paragraph::new(code)
+                .style(Self::pane_style(light))
+                .block(Self::block(&title, light, self.focus == Focus::Code));
+            frame.render_widget(code, body[1]);
+        }
+
+        let status = Paragraph::new(self.status_text()).style(if light {
+            Style::default()
+                .fg(Color::Blue)
+                .bg(Color::Rgb(219, 234, 254))
+                .add_modifier(Modifier::BOLD)
+        } else {
+            Style::default()
+                .fg(Color::Rgb(200, 211, 245))
+                .bg(Color::Rgb(21, 32, 51))
+                .add_modifier(Modifier::BOLD)
+        });
+        frame.render_widget(status, vertical[1]);
+
+        let command_text = if self.focus == Focus::Command || !self.command.is_empty() {
+            self.command.clone()
+        } else {
+            ui_text(&self.state.settings.ui_language, "command_placeholder").to_string()
+        };
+        let command = Paragraph::new(command_text)
+            .style(Self::pane_style(light))
+            .block(Self::block(
+                ui_text(&self.state.settings.ui_language, "command"),
+                light,
+                self.focus == Focus::Command,
+            ))
+            .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]);
+    }
+
+    pub(super) fn wants_mouse_capture(&self) -> bool {
+        !self.show_output
+    }
+
+    pub(super) fn sync_mouse_capture(&mut self) {
+        let want = self.wants_mouse_capture();
+        if want == self.mouse_capture {
+            return;
+        }
+        let result = if want {
+            execute!(stdout(), EnableMouseCapture)
+        } else {
+            execute!(stdout(), DisableMouseCapture)
+        };
+        if result.is_ok() {
+            self.mouse_capture = want;
+        }
+    }
+
+    pub(super) fn disable_mouse_capture(&mut self) {
+        if self.mouse_capture {
+            let _ = execute!(stdout(), DisableMouseCapture);
+            self.mouse_capture = false;
+        }
+    }
+
+    pub(super) fn output_text(&self) -> Text<'static> {
+        let light = self.state.settings.theme == "light";
+        let title_style = if light {
+            Style::default()
+                .fg(Color::Blue)
+                .add_modifier(Modifier::BOLD)
+        } else {
+            Style::default()
+                .fg(Color::Yellow)
+                .add_modifier(Modifier::BOLD)
+        };
+        let label_style = if light {
+            Style::default()
+                .fg(Color::Magenta)
+                .add_modifier(Modifier::BOLD)
+        } else {
+            Style::default()
+                .fg(Color::Cyan)
+                .add_modifier(Modifier::BOLD)
+        };
+        let body_style = if light {
+            Style::default().fg(Color::Black)
+        } else {
+            Style::default().fg(Color::Rgb(229, 231, 235))
+        };
+        let code_style = if light {
+            Style::default()
+                .fg(Color::Black)
+                .bg(Color::Rgb(229, 231, 235))
+        } else {
+            Style::default()
+                .fg(Color::Rgb(243, 244, 246))
+                .bg(Color::Rgb(31, 41, 55))
+        };
+        if !self.busy_label.is_empty() {
+            let elapsed = self
+                .busy_started
+                .map(|started| started.elapsed().as_secs())
+                .unwrap_or_default();
+            let mut lines = vec![Line::from(Span::styled(
+                format!("{}{}  {}s", self.busy_body, self.busy_dots(), elapsed),
+                title_style,
+            ))];
+            if self.busy_label == "next" {
+                lines.extend([
+                    Line::default(),
+                    Line::from(Span::styled(self.busy_game_track(), code_style)),
+                    Line::from(Span::styled(
+                        ui_text(&self.state.settings.ui_language, "busy_warmup").to_string(),
+                        body_style,
+                    )),
+                    Line::from(Span::styled(
+                        format!(
+                            "{}: {}    {}: {}",
+                            ui_text(&self.state.settings.ui_language, "hits"),
+                            self.busy_hits,
+                            ui_text(&self.state.settings.ui_language, "misses"),
+                            self.busy_misses
+                        ),
+                        label_style,
+                    )),
+                    Line::from(Span::styled(
+                        ui_text(&self.state.settings.ui_language, "busy_commands_paused")
+                            .to_string(),
+                        body_style,
+                    )),
+                ]);
+            }
+            return Text::from(lines);
+        }
+        let output = if self.output_is_markdown {
+            render_markdown_plain(&self.output)
+        } else {
+            self.output.clone()
+        };
+        let mut lines = Vec::new();
+        for line in output.lines() {
+            if line.is_empty() {
+                lines.push(Line::default());
+            } else if line.starts_with("PASS ")
+                || line.starts_with("FAIL ")
+                || line.starts_with("Case ")
+                || line.starts_with("Next:")
+                || line.starts_with("Fix:")
+            {
+                lines.push(Line::from(Span::styled(line.to_string(), title_style)));
+            } else if matches!(
+                line,
+                "Input" | "Expected" | "Got" | "Stdout" | "Stderr" | "Compile" | "Error"
+            ) {
+                lines.push(Line::from(Span::styled(line.to_string(), label_style)));
+            } else if line.starts_with("  ") {
+                lines.push(Line::from(vec![
+                    Span::raw("  "),
+                    Span::styled(line.trim_start().to_string(), code_style),
+                ]));
+            } else {
+                lines.push(Line::from(Span::styled(line.to_string(), body_style)));
+            }
+        }
+        Text::from(lines)
+    }
+
+    pub(super) 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(14).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 visible = height.saturating_sub(2) as usize;
+        let start = selected.saturating_sub(visible.saturating_sub(1));
+        let mut lines = suggestions
+            .iter()
+            .enumerate()
+            .skip(start)
+            .take(visible)
+            .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);
+        let light = self.state.settings.theme == "light";
+        frame.render_widget(
+            Paragraph::new(lines.join("\n"))
+                .style(Self::pane_style(light))
+                .block(Self::block(
+                    ui_text(&self.state.settings.ui_language, "commands"),
+                    light,
+                    true,
+                )),
+            area,
+        );
+    }
+
+    pub(super) fn block(title: &str, light: bool, active: bool) -> Block<'static> {
+        let border = if active {
+            if light {
+                Style::default()
+                    .fg(Color::Magenta)
+                    .add_modifier(Modifier::BOLD)
+            } else {
+                Style::default()
+                    .fg(Color::Yellow)
+                    .add_modifier(Modifier::BOLD)
+            }
+        } else if light {
+            Style::default().fg(Color::Blue)
+        } else {
+            Style::default().fg(Color::Cyan)
+        };
+        let border = border.bg(Self::pane_bg(light));
+        Block::default()
+            .borders(Borders::ALL)
+            .title(Self::pane_title(title, active))
+            .style(Self::pane_style(light))
+            .border_style(border)
+    }
+
+    pub(super) fn pane_style(light: bool) -> Style {
+        if light {
+            Style::default()
+                .fg(Color::Rgb(17, 24, 39))
+                .bg(Self::pane_bg(light))
+        } else {
+            Style::default()
+                .fg(Color::Rgb(229, 231, 235))
+                .bg(Self::pane_bg(light))
+        }
+    }
+
+    pub(super) fn pane_bg(light: bool) -> Color {
+        if light {
+            Color::Rgb(248, 250, 252)
+        } else {
+            Color::Rgb(17, 24, 39)
+        }
+    }
+
+    pub fn pane_style_for_test(light: bool) -> Style {
+        Self::pane_style(light)
+    }
+
+    pub(super) fn pane_title(title: &str, active: bool) -> String {
+        if active {
+            format!("> {title}")
+        } else {
+            title.to_string()
+        }
+    }
+    pub(super) fn set_terminal_cursor(
+        &self,
+        frame: &mut Frame,
+        code_area: Rect,
+        command_area: Rect,
+    ) {
+        match self.focus {
+            Focus::Command => {
+                let before = prefix(&self.command, self.command_cursor);
+                let x = command_area
+                    .x
+                    .saturating_add(1)
+                    .saturating_add(display_width(&before) as u16)
+                    .min(command_area.right().saturating_sub(2));
+                frame.set_cursor_position(Position::new(x, command_area.y.saturating_add(1)));
+            }
+            Focus::Code if !self.show_output => {
+                if let Some(position) = self.editor.cursor_position(code_area) {
+                    frame.set_cursor_position(position);
+                }
+            }
+            _ => {}
+        }
+    }
+}