practicode 0.1.9 → 0.1.11

package/src/core.rs

@@ -9,990 +9,25 @@ use std::{
     time::Duration,
 };
 
+mod bank;
+mod judge;
+mod language;
+mod model;
+mod problem_files;
 mod profile;
+mod progress;
+mod render;
+mod state;
+
+pub use crate::i18n::{UI_LANGUAGES, normalize_ui_language, ui_text};
+pub use bank::*;
+pub use judge::*;
+pub use language::*;
+pub use model::*;
+pub use problem_files::*;
 pub use profile::{
     DIFFICULTIES, default_difficulty, normalize_difficulty, normalize_topic_list, parse_topic_list,
 };
-
-pub const LANGUAGES: &[&str] = &["python", "ts", "java", "rust"];
-pub use crate::i18n::{UI_LANGUAGES, normalize_ui_language, ui_text};
-pub const THEMES: &[&str] = &["dark", "light"];
-pub const AI_PROVIDERS: &[&str] = &["codex", "claude"];
-pub const BANK_PATH: &str = ".practicode/problem_bank.json";
-pub const STATE_PATH: &str = ".practicode/problem-state.json";
-pub const PROBLEM_NOTES_PATH: &str = ".practicode/problem_notes.md";
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct Settings {
-    #[serde(default = "default_language")]
-    pub language: String,
-    #[serde(default = "default_ui_language")]
-    pub ui_language: String,
-    #[serde(default = "default_theme")]
-    pub theme: String,
-    #[serde(default = "default_difficulty")]
-    pub difficulty: String,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub topics: Vec<String>,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub avoid_topics: Vec<String>,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub generate_languages: Vec<String>,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub generate_ui_languages: Vec<String>,
-    #[serde(default = "default_editor")]
-    pub editor: String,
-    #[serde(default = "default_next_source")]
-    pub next_source: String,
-    #[serde(default = "default_ai_provider")]
-    pub ai_provider: String,
-    #[serde(default = "default_ai_model")]
-    pub ai_model: String,
-    #[serde(default, skip_serializing_if = "String::is_empty")]
-    pub ai_next_command: String,
-}
-
-impl Default for Settings {
-    fn default() -> Self {
-        Self {
-            language: default_language(),
-            ui_language: default_ui_language(),
-            theme: default_theme(),
-            difficulty: default_difficulty(),
-            topics: Vec::new(),
-            avoid_topics: Vec::new(),
-            generate_languages: Vec::new(),
-            generate_ui_languages: Vec::new(),
-            editor: default_editor(),
-            next_source: default_next_source(),
-            ai_provider: default_ai_provider(),
-            ai_model: default_ai_model(),
-            ai_next_command: String::new(),
-        }
-    }
-}
-
-impl Settings {
-    pub fn next_ai_command(&self) -> &str {
-        &self.ai_next_command
-    }
-
-    pub fn model_arg(&self) -> Option<&str> {
-        let model = self.ai_model.trim();
-        if model.is_empty() || model == "auto" {
-            None
-        } else {
-            Some(model)
-        }
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct HistoryItem {
-    pub id: String,
-    pub status: String,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct AppState {
-    pub current_problem: String,
-    #[serde(default)]
-    pub settings: Settings,
-    #[serde(default)]
-    pub solved: Vec<String>,
-    #[serde(default)]
-    pub history: Vec<HistoryItem>,
-    #[serde(default = "default_suggested_difficulty")]
-    pub suggested_next_difficulty: String,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct Problem {
-    pub id: String,
-    pub slug: String,
-    pub difficulty: String,
-    pub topics: Vec<String>,
-    pub title: HashMap<String, String>,
-    pub statement: HashMap<String, String>,
-    pub input: HashMap<String, String>,
-    pub output: HashMap<String, String>,
-    pub examples: Vec<IoCase>,
-    pub cases: Vec<IoCase>,
-    pub answers: HashMap<String, String>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct IoCase {
-    pub input: String,
-    pub output: String,
-}
-
-#[derive(Clone, Debug)]
-pub struct JudgeResult {
-    pub passed: bool,
-    pub passed_cases: usize,
-    pub total_cases: usize,
-    pub output: String,
-}
-
-pub fn default_language() -> String {
-    "python".to_string()
-}
-
-pub fn default_ui_language() -> String {
-    "en".to_string()
-}
-
-pub fn default_theme() -> String {
-    "dark".to_string()
-}
-
-pub fn default_editor() -> String {
-    "vim".to_string()
-}
-
-pub fn default_next_source() -> String {
-    "bank".to_string()
-}
-
-pub fn default_ai_provider() -> String {
-    "codex".to_string()
-}
-
-pub fn default_ai_model() -> String {
-    "auto".to_string()
-}
-
-pub fn default_suggested_difficulty() -> String {
-    "easy".to_string()
-}
-
-pub fn ext_for(language: &str) -> &'static str {
-    match normalize_language(language).as_str() {
-        "python" => "py",
-        "ts" => "ts",
-        "java" => "java",
-        "rust" => "rs",
-        _ => "py",
-    }
-}
-
-pub fn starter_problem() -> Problem {
-    Problem {
-        id: "001-hello-world".to_string(),
-        slug: "hello-world".to_string(),
-        difficulty: "easy".to_string(),
-        topics: vec!["io".to_string()],
-        title: localized_map(&[
-            ("en", "Hello World"),
-            ("ko", "Hello World"),
-            ("ja", "Hello World"),
-            ("zh", "Hello World"),
-            ("es", "Hello World"),
-        ]),
-        statement: localized_map(&[
-            ("en", "Print exactly `Hello, World!` to stdout."),
-            ("ko", "표준 출력으로 정확히 `Hello, World!`를 출력하세요."),
-            ("ja", "標準出力に正確に `Hello, World!` を出力してください。"),
-            ("zh", "向标准输出准确打印 `Hello, World!`。"),
-            ("es", "Imprime exactamente `Hello, World!` en stdout."),
-        ]),
-        input: localized_map(&[
-            ("en", "No input."),
-            ("ko", "입력은 없습니다."),
-            ("ja", "入力はありません。"),
-            ("zh", "没有输入。"),
-            ("es", "No hay entrada."),
-        ]),
-        output: localized_map(&[
-            ("en", "One line: `Hello, World!`"),
-            ("ko", "`Hello, World!` 한 줄"),
-            ("ja", "1行: `Hello, World!`"),
-            ("zh", "一行: `Hello, World!`"),
-            ("es", "Una linea: `Hello, World!`"),
-        ]),
-        examples: vec![IoCase {
-            input: String::new(),
-            output: "Hello, World!\n".to_string(),
-        }],
-        cases: vec![IoCase {
-            input: String::new(),
-            output: "Hello, World!\n".to_string(),
-        }],
-        answers: HashMap::from([
-            ("python".to_string(), "print('Hello, World!')\n".to_string()),
-            (
-                "ts".to_string(),
-                "console.log('Hello, World!');\n".to_string(),
-            ),
-            (
-                "java".to_string(),
-                "class Solution {\n    public static void main(String[] args) {\n        System.out.println(\"Hello, World!\");\n    }\n}\n".to_string(),
-            ),
-            (
-                "rust".to_string(),
-                "fn main() {\n    println!(\"Hello, World!\");\n}\n".to_string(),
-            ),
-        ]),
-    }
-}
-
-pub fn map2(k1: &str, v1: &str, k2: &str, v2: &str) -> HashMap<String, String> {
-    HashMap::from([
-        (k1.to_string(), v1.to_string()),
-        (k2.to_string(), v2.to_string()),
-    ])
-}
-
-pub fn localized_map(entries: &[(&str, &str)]) -> HashMap<String, String> {
-    entries
-        .iter()
-        .map(|(key, value)| ((*key).to_string(), (*value).to_string()))
-        .collect()
-}
-
-pub fn load_bank(root: &Path) -> Result<Vec<Problem>> {
-    let path = root.join(BANK_PATH);
-    if path.exists() {
-        let text = fs::read_to_string(&path).with_context(|| format!("read {}", path.display()))?;
-        let bank: Vec<Problem> =
-            serde_json::from_str(&text).with_context(|| format!("parse {}", path.display()))?;
-        validate_bank(&bank, &path)?;
-        Ok(bank)
-    } else {
-        Ok(vec![starter_problem()])
-    }
-}
-
-pub fn save_bank(root: &Path, bank: &[Problem]) -> Result<()> {
-    let path = root.join(BANK_PATH);
-    validate_bank(bank, &path)?;
-    if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent)?;
-    }
-    fs::write(&path, serde_json::to_string_pretty(bank)? + "\n")?;
-    Ok(())
-}
-
-fn validate_bank(bank: &[Problem], path: &Path) -> Result<()> {
-    if bank.is_empty() {
-        bail!("{} must contain at least one problem", path.display());
-    }
-    for problem in bank {
-        if !is_safe_name(&problem.id) {
-            bail!("{} has invalid problem id {:?}", path.display(), problem.id);
-        }
-        if !is_safe_name(&problem.slug) {
-            bail!(
-                "{} has invalid slug {:?} for {}",
-                path.display(),
-                problem.slug,
-                problem.id
-            );
-        }
-        if problem.cases.is_empty() {
-            bail!(
-                "{} problem {} has no judge cases",
-                path.display(),
-                problem.id
-            );
-        }
-        if problem.answers.is_empty() {
-            bail!(
-                "{} problem {} must contain at least one answer",
-                path.display(),
-                problem.id
-            );
-        }
-        for language in problem.answers.keys() {
-            if !LANGUAGES.contains(&language.as_str()) {
-                bail!(
-                    "{} problem {} has unsupported answer language {language}",
-                    path.display(),
-                    problem.id,
-                );
-            }
-        }
-    }
-    Ok(())
-}
-
-fn is_safe_name(value: &str) -> bool {
-    !value.is_empty()
-        && value
-            .chars()
-            .all(|char| char.is_ascii_alphanumeric() || matches!(char, '-' | '_'))
-}
-
-pub fn load_state(root: &Path, bank: &[Problem]) -> Result<AppState> {
-    let path = root.join(STATE_PATH);
-    if !path.exists() {
-        return Ok(AppState {
-            current_problem: bank[0].id.clone(),
-            settings: Settings::default(),
-            solved: Vec::new(),
-            history: vec![HistoryItem {
-                id: bank[0].id.clone(),
-                status: "assigned".to_string(),
-            }],
-            suggested_next_difficulty: "easy".to_string(),
-        });
-    }
-
-    let text = fs::read_to_string(&path).with_context(|| format!("read {}", path.display()))?;
-    let mut state: AppState =
-        serde_json::from_str(&text).with_context(|| format!("parse {}", path.display()))?;
-    if !bank
-        .iter()
-        .any(|problem| problem.id == state.current_problem)
-    {
-        state.current_problem = bank[0].id.clone();
-    }
-    normalize_settings(&mut state.settings);
-    if state.history.is_empty() {
-        state.history.push(HistoryItem {
-            id: state.current_problem.clone(),
-            status: "assigned".to_string(),
-        });
-    }
-    Ok(state)
-}
-
-pub fn save_state(root: &Path, state: &AppState) -> Result<()> {
-    #[derive(Serialize)]
-    struct StateFile<'a> {
-        current_problem: &'a str,
-        next_number: usize,
-        suggested_next_difficulty: &'a str,
-        settings: &'a Settings,
-        solved: &'a [String],
-        history: &'a [HistoryItem],
-    }
-
-    let path = root.join(STATE_PATH);
-    if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent)?;
-    }
-    let file = StateFile {
-        current_problem: &state.current_problem,
-        next_number: state.history.len() + 1,
-        suggested_next_difficulty: &state.suggested_next_difficulty,
-        settings: &state.settings,
-        solved: &state.solved,
-        history: &state.history,
-    };
-    fs::write(path, serde_json::to_string_pretty(&file)? + "\n")?;
-    Ok(())
-}
-
-pub fn normalize_settings(settings: &mut Settings) {
-    settings.language = normalize_language(&settings.language);
-    settings.ui_language = normalize_ui_language(&settings.ui_language);
-    if !THEMES.contains(&settings.theme.as_str()) {
-        settings.theme = "dark".to_string();
-    }
-    settings.difficulty = normalize_difficulty(&settings.difficulty);
-    settings.topics = normalize_topic_list(&settings.topics);
-    settings.avoid_topics = normalize_topic_list(&settings.avoid_topics);
-    settings.generate_languages = normalize_language_list(&settings.generate_languages);
-    settings.generate_ui_languages = normalize_ui_language_list(&settings.generate_ui_languages);
-    settings.next_source = normalize_next_source(&settings.next_source);
-    settings.ai_provider = normalize_ai_provider(&settings.ai_provider);
-    if settings.ai_model.trim().is_empty() {
-        settings.ai_model = default_ai_model();
-    }
-}
-
-pub fn problem_by_id<'a>(bank: &'a [Problem], problem_id: &str) -> Option<&'a Problem> {
-    bank.iter().find(|problem| problem.id == problem_id)
-}
-
-pub fn normalize_language(language: &str) -> String {
-    let language = language.trim().to_lowercase();
-    if LANGUAGES.contains(&language.as_str()) {
-        language
-    } else {
-        "python".to_string()
-    }
-}
-
-pub fn parse_language_list(value: &str) -> Vec<String> {
-    let mut languages = Vec::new();
-    for language in value.split(',') {
-        let language = language.trim().to_lowercase();
-        if language == "all" {
-            return Vec::new();
-        }
-        if LANGUAGES.contains(&language.as_str()) && !languages.contains(&language) {
-            languages.push(language);
-        }
-    }
-    languages
-}
-
-pub fn normalize_language_list(languages: &[String]) -> Vec<String> {
-    parse_language_list(&languages.join(","))
-}
-
-pub fn parse_ui_language_list(value: &str) -> Vec<String> {
-    let mut languages = Vec::new();
-    for language in value.split(',') {
-        let lower = language.trim().to_lowercase();
-        if lower == "all" {
-            return Vec::new();
-        }
-        let language = lower
-            .split(['-', '_'])
-            .next()
-            .filter(|value| UI_LANGUAGES.contains(value))
-            .unwrap_or("");
-        if language == "all" {
-            return Vec::new();
-        }
-        if !language.is_empty() && !languages.iter().any(|value| value == language) {
-            languages.push(language.to_string());
-        }
-    }
-    languages
-}
-
-pub fn normalize_ui_language_list(languages: &[String]) -> Vec<String> {
-    parse_ui_language_list(&languages.join(","))
-}
-
-pub fn normalize_next_source(source: &str) -> String {
-    if source == "ai" {
-        "ai".to_string()
-    } else {
-        "bank".to_string()
-    }
-}
-
-pub fn normalize_ai_provider(provider: &str) -> String {
-    if provider == "claude" {
-        "claude".to_string()
-    } else {
-        "codex".to_string()
-    }
-}
-
-pub fn localized(map: &HashMap<String, String>, lang: &str) -> String {
-    let lang = normalize_ui_language(lang);
-    map.get(lang.as_str())
-        .or_else(|| map.get("en"))
-        .or_else(|| map.get("ko"))
-        .or_else(|| map.values().next())
-        .cloned()
-        .unwrap_or_default()
-}
-
-pub fn template_for(language: &str) -> String {
-    match normalize_language(language).as_str() {
-        "python" => "# Read from stdin and print to stdout.\nimport sys\n\n\n".to_string(),
-        "ts" => "const fs = require('fs');\nconst input = fs.readFileSync(0, 'utf8');\n\n".to_string(),
-        "java" => "import java.io.*;\n\nclass Solution {\n    public static void main(String[] args) throws Exception {\n    }\n}\n".to_string(),
-        "rust" => "fn main() {\n}\n".to_string(),
-        _ => String::new(),
-    }
-}
-
-pub fn ensure_submission(root: &Path, problem: &Problem, settings: &Settings) -> Result<PathBuf> {
-    let language = normalize_language(&settings.language);
-    let path = root
-        .join("submissions")
-        .join(&problem.id)
-        .join(format!("solution.{}", ext_for(&language)));
-    if !path.exists() {
-        if let Some(parent) = path.parent() {
-            fs::create_dir_all(parent)?;
-        }
-        fs::write(&path, template_for(&language))?;
-    }
-    Ok(path)
-}
-
-pub fn render_problem(problem: &Problem, ui_language: &str) -> String {
-    let lang = normalize_ui_language(ui_language);
-    let examples = problem
-        .examples
-        .iter()
-        .enumerate()
-        .map(|(index, case)| {
-            format!(
-                "### {} {}\n\n{}\n\n{}\n\n{}\n\n{}",
-                ui_text(&lang, "example"),
-                index + 1,
-                ui_text(&lang, "input"),
-                fenced_text(&case.input),
-                ui_text(&lang, "output"),
-                fenced_text(&case.output)
-            )
-        })
-        .collect::<Vec<_>>()
-        .join("\n\n");
-    let number = problem
-        .id
-        .split_once('-')
-        .map(|(number, _)| number)
-        .unwrap_or(&problem.id);
-    format!(
-        "# {number}. {}\n\n{}: {}\n{}: {}\n\n{}\n\n## {}\n\n{}\n\n## {}\n\n{}\n\n## {}\n\n{}",
-        localized(&problem.title, &lang),
-        ui_text(&lang, "difficulty"),
-        problem.difficulty,
-        ui_text(&lang, "topics"),
-        problem.topics.join(", "),
-        localized(&problem.statement, &lang),
-        ui_text(&lang, "input"),
-        localized(&problem.input, &lang),
-        ui_text(&lang, "output"),
-        localized(&problem.output, &lang),
-        ui_text(&lang, "examples"),
-        examples
-    )
-}
-
-pub fn render_problem_tui(problem: &Problem, ui_language: &str) -> String {
-    let lang = normalize_ui_language(ui_language);
-    let number = problem
-        .id
-        .split_once('-')
-        .map(|(number, _)| number)
-        .unwrap_or(&problem.id);
-    let mut lines = vec![
-        format!("{number}. {}", localized(&problem.title, &lang)),
-        format!(
-            "{}: {}    {}: {}",
-            ui_text(&lang, "difficulty"),
-            problem.difficulty,
-            ui_text(&lang, "topics"),
-            problem.topics.join(", ")
-        ),
-        String::new(),
-        localized(&problem.statement, &lang),
-    ];
-    push_tui_section(
-        &mut lines,
-        ui_text(&lang, "input"),
-        &localized(&problem.input, &lang),
-    );
-    push_tui_section(
-        &mut lines,
-        ui_text(&lang, "output"),
-        &localized(&problem.output, &lang),
-    );
-    lines.push(String::new());
-    lines.push(ui_text(&lang, "examples").to_string());
-    for (index, case) in problem.examples.iter().enumerate() {
-        lines.push(format!("  {} {}", ui_text(&lang, "example"), index + 1));
-        lines.push(format!("    {}:", ui_text(&lang, "input")));
-        push_case_text(&mut lines, &case.input);
-        lines.push(format!("    {}:", ui_text(&lang, "output")));
-        push_case_text(&mut lines, &case.output);
-    }
-    lines.join("\n").trim_end().to_string()
-}
-
-fn push_tui_section(lines: &mut Vec<String>, title: &str, body: &str) {
-    lines.push(String::new());
-    lines.push(title.to_string());
-    for line in body.trim_end().lines() {
-        lines.push(format!("  {line}"));
-    }
-}
-
-fn push_case_text(lines: &mut Vec<String>, body: &str) {
-    let body = body.trim_end();
-    if body.is_empty() {
-        lines.push("      <empty>".to_string());
-    } else {
-        for line in body.lines() {
-            lines.push(format!("      {line}"));
-        }
-    }
-}
-
-pub fn fenced_text(value: &str) -> String {
-    let mut body = value.to_string();
-    if !body.ends_with('\n') {
-        body.push('\n');
-    }
-    format!("```text\n{body}```")
-}
-
-pub fn judge(root: &Path, problem: &Problem, settings: &Settings) -> JudgeResult {
-    if problem.cases.is_empty() {
-        return JudgeResult {
-            passed: false,
-            passed_cases: 0,
-            total_cases: 0,
-            output: "problem has no judge cases".to_string(),
-        };
-    }
-    let path = match ensure_submission(root, problem, settings) {
-        Ok(path) => path,
-        Err(error) => {
-            return JudgeResult {
-                passed: false,
-                passed_cases: 0,
-                total_cases: problem.cases.len(),
-                output: error.to_string(),
-            };
-        }
-    };
-    let language = normalize_language(&settings.language);
-    let command = match command_for(root, &path, &language) {
-        Ok(Some(command)) => command,
-        Ok(None) => {
-            return JudgeResult {
-                passed: false,
-                passed_cases: 0,
-                total_cases: problem.cases.len(),
-                output: format!("Missing runtime for {}", settings.language),
-            };
-        }
-        Err(error) => {
-            return JudgeResult {
-                passed: false,
-                passed_cases: 0,
-                total_cases: problem.cases.len(),
-                output: format!("compile failed\n{error}"),
-            };
-        }
-    };
-    let run_dir = root.join(".practicode/build").join(&problem.id).join("run");
-    if let Err(error) = fs::create_dir_all(&run_dir) {
-        return JudgeResult {
-            passed: false,
-            passed_cases: 0,
-            total_cases: problem.cases.len(),
-            output: error.to_string(),
-        };
-    }
-
-    let mut passed = 0;
-    let mut lines = Vec::new();
-    for (index, case) in problem.cases.iter().enumerate() {
-        let mut process = Command::new(&command.program);
-        process.args(&command.args).current_dir(&run_dir);
-        let run = match run_capture(&mut process, &case.input, Duration::from_secs(5)) {
-            Ok(run) => run,
-            Err(error) => {
-                lines.push(format!("Case {}: FAIL", index + 1));
-                push_labeled_block(&mut lines, "Error", &error.to_string());
-                break;
-            }
-        };
-        let got = run.stdout.trim();
-        let expected = case.output.trim();
-        if !run.timed_out && run.code == Some(0) && got == expected {
-            passed += 1;
-            lines.push(format!("Case {}: PASS", index + 1));
-            if !run.stderr.trim().is_empty() {
-                push_labeled_block(&mut lines, "Stderr", run.stderr.trim_end());
-            }
-        } else {
-            lines.push(format!("Case {}: FAIL", index + 1));
-            if run.timed_out {
-                push_labeled_block(&mut lines, "Error", "timeout: 5s");
-            }
-            push_labeled_block(&mut lines, "Input", case.input.trim_end());
-            push_labeled_block(&mut lines, "Expected", expected);
-            push_labeled_block(&mut lines, "Got", run.stdout.trim_end());
-            if !run.stderr.trim().is_empty() {
-                push_labeled_block(&mut lines, "Stderr", run.stderr.trim_end());
-            }
-            break;
-        }
-    }
-
-    JudgeResult {
-        passed: passed == problem.cases.len(),
-        passed_cases: passed,
-        total_cases: problem.cases.len(),
-        output: lines.join("\n"),
-    }
-}
-
-fn push_labeled_block(lines: &mut Vec<String>, label: &str, body: &str) {
-    lines.push(String::new());
-    lines.push(label.to_string());
-    if body.is_empty() {
-        lines.push("  <empty>".to_string());
-    } else {
-        lines.extend(body.lines().map(|line| format!("  {line}")));
-    }
-}
-
-pub fn command_for(root: &Path, path: &Path, language: &str) -> Result<Option<CommandSpec>> {
-    match language {
-        "python" => Ok(which("python3")
-            .or_else(|| which("python"))
-            .map(|program| CommandSpec {
-                program,
-                args: vec![path.display().to_string()],
-            })),
-        "ts" => Ok(which("node").map(|program| CommandSpec {
-            program,
-            args: vec![
-                "--experimental-strip-types".to_string(),
-                path.display().to_string(),
-            ],
-        })),
-        "java" => compile_java(root, path),
-        "rust" => compile_rust(root, path),
-        _ => Ok(None),
-    }
-}
-
-fn compile_java(root: &Path, path: &Path) -> Result<Option<CommandSpec>> {
-    let Some(javac) = which("javac") else {
-        return Ok(None);
-    };
-    let Some(java) = which("java") else {
-        return Ok(None);
-    };
-    let build = root
-        .join(".practicode/build")
-        .join(path.parent().and_then(Path::file_name).unwrap_or_default())
-        .join("java");
-    fs::create_dir_all(&build)?;
-    let mut compile = Command::new(javac);
-    compile
-        .args([
-            "-d",
-            &build.display().to_string(),
-            &path.display().to_string(),
-        ])
-        .current_dir(root);
-    let output = run_capture(&mut compile, "", Duration::from_secs(30))?;
-    if output.code != Some(0) {
-        return Err(anyhow!(output.stderr.trim().to_string()));
-    }
-    Ok(Some(CommandSpec {
-        program: java,
-        args: vec![
-            "-cp".to_string(),
-            build.display().to_string(),
-            "Solution".to_string(),
-        ],
-    }))
-}
-
-fn compile_rust(root: &Path, path: &Path) -> Result<Option<CommandSpec>> {
-    let Some(rustc) = which("rustc") else {
-        return Ok(None);
-    };
-    let build = root
-        .join(".practicode/build")
-        .join(path.parent().and_then(Path::file_name).unwrap_or_default());
-    fs::create_dir_all(&build)?;
-    let exe = build.join(if cfg!(windows) {
-        "solution.exe"
-    } else {
-        "solution"
-    });
-    let mut compile = Command::new(rustc);
-    compile
-        .args([
-            path.display().to_string(),
-            "-o".to_string(),
-            exe.display().to_string(),
-        ])
-        .current_dir(root);
-    let output = run_capture(&mut compile, "", Duration::from_secs(30))?;
-    if output.code != Some(0) {
-        return Err(anyhow!(output.stderr.trim().to_string()));
-    }
-    Ok(Some(CommandSpec {
-        program: exe,
-        args: Vec::new(),
-    }))
-}
-
-pub fn give_up(root: &Path, problem: &Problem, state: &mut AppState) -> Result<String> {
-    let language = normalize_language(&state.settings.language);
-    let answer = problem
-        .answers
-        .get(&language)
-        .cloned()
-        .unwrap_or_else(|| problem.answers.values().next().cloned().unwrap_or_default());
-    mark_history(state, &problem.id, "gave_up");
-    upsert_problem_index(root, problem, "gave_up")?;
-    save_state(root, state)?;
-    Ok(answer)
-}
-
-pub fn next_problem(
-    root: &Path,
-    bank: &[Problem],
-    state: &mut AppState,
-) -> Result<Option<Problem>> {
-    let seen = state
-        .history
-        .iter()
-        .map(|item| item.id.as_str())
-        .collect::<Vec<_>>();
-    let preferred = if state.settings.difficulty == "auto" {
-        &state.suggested_next_difficulty
-    } else {
-        &state.settings.difficulty
-    };
-    let problem = bank
-        .iter()
-        .find(|item| !seen.contains(&item.id.as_str()) && &item.difficulty == preferred)
-        .or_else(|| bank.iter().find(|item| !seen.contains(&item.id.as_str())));
-    let Some(problem) = problem.cloned() else {
-        return Ok(None);
-    };
-    state.current_problem = problem.id.clone();
-    mark_history(state, &problem.id, "assigned");
-    save_state(root, state)?;
-    ensure_problem_files(root, &problem)?;
-    upsert_problem_index(root, &problem, "assigned")?;
-    Ok(Some(problem))
-}
-
-pub fn previous_problem(root: &Path, bank: &[Problem], state: &mut AppState) -> Result<Problem> {
-    let known_ids = bank
-        .iter()
-        .map(|problem| problem.id.as_str())
-        .collect::<Vec<_>>();
-    let history = state
-        .history
-        .iter()
-        .filter(|item| known_ids.contains(&item.id.as_str()))
-        .map(|item| item.id.clone())
-        .collect::<Vec<_>>();
-    let Some(index) = history.iter().position(|id| id == &state.current_problem) else {
-        return problem_by_id(bank, &state.current_problem)
-            .cloned()
-            .ok_or_else(|| anyhow!("current problem missing"));
-    };
-    if index == 0 {
-        return problem_by_id(bank, &state.current_problem)
-            .cloned()
-            .ok_or_else(|| anyhow!("current problem missing"));
-    }
-    state.current_problem = history[index - 1].clone();
-    save_state(root, state)?;
-    problem_by_id(bank, &state.current_problem)
-        .cloned()
-        .ok_or_else(|| anyhow!("current problem missing"))
-}
-
-pub fn record_pass(root: &Path, problem: &Problem, state: &mut AppState) -> Result<()> {
-    if !state.solved.contains(&problem.id) {
-        state.solved.push(problem.id.clone());
-    }
-    mark_history(state, &problem.id, "solved");
-    upsert_problem_index(root, problem, "solved")?;
-    state.suggested_next_difficulty = if state.solved.len() >= 2 {
-        "medium".to_string()
-    } else {
-        "easy".to_string()
-    };
-    save_state(root, state)
-}
-
-pub fn mark_history(state: &mut AppState, problem_id: &str, status: &str) {
-    if let Some(item) = state.history.iter_mut().find(|item| item.id == problem_id) {
-        item.status = status.to_string();
-    } else {
-        state.history.push(HistoryItem {
-            id: problem_id.to_string(),
-            status: status.to_string(),
-        });
-    }
-}
-
-pub fn ensure_problem_files(root: &Path, problem: &Problem) -> Result<()> {
-    let problem_dir = root.join("problems").join(&problem.id);
-    fs::create_dir_all(&problem_dir)?;
-    let readme = problem_dir.join("README.md");
-    if readme.exists() {
-        return Ok(());
-    }
-    let examples = problem
-        .examples
-        .iter()
-        .map(|case| format!("input:\n{}output:\n{}", case.input, case.output))
-        .collect::<Vec<_>>()
-        .join("\n");
-    fs::write(
-        readme,
-        format!(
-            "# {}. {}\n\n난이도: {}\n\n{}\n\n## 입력\n\n{}\n\n## 출력\n\n{}\n\n## 예시\n\n```text\n{}\n```\n",
-            problem.id,
-            localized(&problem.title, "ko"),
-            problem.difficulty,
-            localized(&problem.statement, "ko"),
-            localized(&problem.input, "ko"),
-            localized(&problem.output, "ko"),
-            examples
-        ),
-    )?;
-    Ok(())
-}
-
-pub fn upsert_problem_index(root: &Path, problem: &Problem, status: &str) -> Result<()> {
-    let index = root.join("problems/INDEX.md");
-    if let Some(parent) = index.parent() {
-        fs::create_dir_all(parent)?;
-    }
-    let mut rows: HashMap<String, (String, String, String, String)> = HashMap::new();
-    if index.exists() {
-        for line in fs::read_to_string(&index)?.lines() {
-            let parts = line
-                .trim()
-                .trim_matches('|')
-                .split('|')
-                .map(str::trim)
-                .collect::<Vec<_>>();
-            if parts.len() == 5 && parts[0].chars().all(|c| c.is_ascii_digit()) {
-                rows.insert(
-                    parts[0].to_string(),
-                    (
-                        parts[1].to_string(),
-                        parts[2].to_string(),
-                        parts[3].to_string(),
-                        parts[4].to_string(),
-                    ),
-                );
-            }
-        }
-    }
-    let number = problem
-        .id
-        .split_once('-')
-        .map(|(number, _)| number)
-        .unwrap_or(&problem.id);
-    rows.insert(
-        number.to_string(),
-        (
-            problem.slug.clone(),
-            problem.difficulty.clone(),
-            problem.topics.join(", "),
-            status.to_string(),
-        ),
-    );
-    let mut numbers = rows.keys().cloned().collect::<Vec<_>>();
-    numbers.sort();
-    let body = numbers
-        .into_iter()
-        .filter_map(|number| {
-            rows.get(&number)
-                .map(|(slug, difficulty, topics, row_status)| {
-                    format!("| {number} | {slug} | {difficulty} | {topics} | {row_status} |")
-                })
-        })
-        .collect::<Vec<_>>()
-        .join("\n");
-    fs::write(
-        index,
-        format!(
-            "# Problem Index\n\n| # | Slug | Difficulty | Topics | Status |\n|---|------|------------|--------|--------|\n{body}\n"
-        ),
-    )?;
-    Ok(())
-}
+pub use progress::*;
+pub use render::*;
+pub use state::*;