practicode 0.1.9 → 0.1.11

package/Cargo.lock

@@ -453,7 +453,7 @@ checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
 
 [[package]]
 name = "practicode"
-version = "0.1.9"
+version = "0.1.11"
 dependencies = [
  "anyhow",
  "crossterm",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "practicode"
-version = "0.1.9"
+version = "0.1.11"
 edition = "2024"
 description = "Local-first coding-test practice in a Rust terminal UI with optional AI help."
 readme = "README.md"

package/README.md

@@ -111,6 +111,9 @@ Submissions are saved as you type under `submissions/<problem-id>/solution.<ext>
 | `/generate-ui ko, en` | Limit generated problem text languages, or use `all` |
 | `/provider codex` | Set AI provider and show local CLI/daemon status |
 | `/model auto` | Use the provider default model for `/hint` and AI-backed `/next` |
+| `/effort auto` | Use the provider default effort, or set `low`, `medium`, `high`, `xhigh`; Claude also supports `max` |
+| `/note` | Edit problem-generation notes used by AI-backed `/next` and `/generate` |
+| `/notes` | Show saved problem-generation notes |
 | `/language python` | Set code language: `python`, `ts`, `java`, `rust` |
 | `/ui en` | Set UI language: `en`, `ko`, `ja`, `zh`, `es` |
 | `/theme dark` | Set theme: `dark` or `light` |
@@ -121,9 +124,9 @@ Older command names such as `/prev`, `/list`, `/giveup`, and `/lang` still work
 
 The default UI language is English. Switch it any time with `/ui ko`, `/ui ja`, `/ui zh`, or `/ui es`.
 
-Your user profile is saved in `.practicode/problem-state.json`. It keeps UI language, code language, theme, preferred difficulty, preferred topics, topics to avoid, and generation language scope. `auto` difficulty follows gradual progression; a fixed difficulty asks local selection and AI generation to prefer that level.
+Your user profile is saved in `.practicode/problem-state.json`. It keeps UI language, code language, theme, preferred difficulty, preferred topics, topics to avoid, generation language scope, and AI provider/model/effort. `auto` difficulty follows gradual progression; a fixed difficulty asks local selection and AI generation to prefer that level.
 
-Inside `/profile`, use `up/down` to move and `Space` or `Enter` to cycle common settings or enable/disable generated answer/UI languages. Use slash commands for free-form lists such as `/topics arrays, strings`.
+Inside `/profile`, use `up/down` to move and `Space` or `Enter` to cycle common settings, AI provider/model/effort, or generated answer/UI languages. The notes row opens an editor for `.practicode/problem_notes.md`. Use slash commands for free-form lists such as `/topics arrays, strings`.
 
 ## Problem Flow
 
@@ -144,6 +147,7 @@ Codex is the default provider:
 ```text
 /provider codex
 /model auto
+/effort auto
 ```
 
 Claude Code is also supported:
@@ -151,6 +155,7 @@ Claude Code is also supported:
 ```text
 /provider claude
 /model sonnet
+/effort high
 ```
 
 Generated problems and submissions stay local:

package/assets/i18n/en.json

@@ -47,7 +47,10 @@
   "cmd_model_auto": "Use provider default model",
   "cmd_model_available": "Use an available provider model",
   "cmd_model_custom": "Type a model name",
-  "cmd_note": "Add a next-problem note",
+  "cmd_effort": "Set AI effort",
+  "cmd_effort_auto": "Use provider default effort",
+  "cmd_effort_max": "Use Claude max effort",
+  "cmd_note": "Edit problem-generation notes",
   "cmd_notes": "Show saved notes",
   "cmd_lang": "Set code language",
   "cmd_ui": "Set UI language",

package/assets/i18n/es.json

@@ -47,7 +47,10 @@
   "cmd_model_auto": "Usar el modelo predeterminado del provider",
   "cmd_model_available": "Usar un modelo disponible del provider",
   "cmd_model_custom": "Escribir un nombre de modelo",
-  "cmd_note": "Agregar nota para generar problemas",
+  "cmd_effort": "Configurar AI effort",
+  "cmd_effort_auto": "Usar el effort predeterminado del provider",
+  "cmd_effort_max": "Usar Claude max effort",
+  "cmd_note": "Editar notas para generar problemas",
   "cmd_notes": "Ver notas guardadas",
   "cmd_lang": "Configurar lenguaje de codigo",
   "cmd_ui": "Configurar idioma de UI",

package/assets/i18n/ja.json

@@ -47,7 +47,10 @@
   "cmd_model_auto": "provider の既定モデルを使用",
   "cmd_model_available": "利用可能な provider モデルを使用",
   "cmd_model_custom": "モデル名を直接入力",
-  "cmd_note": "次の問題生成メモを追加",
+  "cmd_effort": "AI effort を設定",
+  "cmd_effort_auto": "provider の既定 effort を使用",
+  "cmd_effort_max": "Claude max effort を使用",
+  "cmd_note": "問題生成メモを編集",
   "cmd_notes": "保存済みメモを見る",
   "cmd_lang": "コード言語を設定",
   "cmd_ui": "UI 言語を設定",

package/assets/i18n/ko.json

@@ -47,7 +47,10 @@
   "cmd_model_auto": "provider 기본 모델 사용",
   "cmd_model_available": "사용 가능한 provider 모델 선택",
   "cmd_model_custom": "모델 이름 직접 입력",
-  "cmd_note": "다음 문제 생성 메모 추가",
+  "cmd_effort": "AI effort 설정",
+  "cmd_effort_auto": "provider 기본 effort 사용",
+  "cmd_effort_max": "Claude max effort 사용",
+  "cmd_note": "문제 생성 메모 편집",
   "cmd_notes": "저장된 메모 보기",
   "cmd_lang": "코드 언어 설정",
   "cmd_ui": "UI 언어 설정",

package/assets/i18n/zh.json

@@ -47,7 +47,10 @@
   "cmd_model_auto": "使用 provider 默认模型",
   "cmd_model_available": "使用可用的 provider 模型",
   "cmd_model_custom": "输入模型名称",
-  "cmd_note": "添加下次出题备注",
+  "cmd_effort": "设置 AI effort",
+  "cmd_effort_auto": "使用 provider 默认 effort",
+  "cmd_effort_max": "使用 Claude max effort",
+  "cmd_note": "编辑出题备注",
   "cmd_notes": "查看保存的备注",
   "cmd_lang": "设置代码语言",
   "cmd_ui": "设置 UI 语言",

package/docs/ARCHITECTURE.md

@@ -4,9 +4,25 @@ Practicode is local-first: user data stays under `.practicode/`, `problems/`, an
 
 ## Source Layout
 
-- `src/core.rs` owns problem data, state loading/saving, judging, and file generation.
-- `src/core/profile.rs` owns user-profile defaults and normalization.
-- `src/tui.rs` owns the Ratatui app shell, event routing, and workflow orchestration.
+- `src/core.rs` is the public core facade. Keep new domain logic in nested `src/core/` modules.
+- `src/core/model.rs` owns persisted/user-facing data shapes and core constants.
+- `src/core/bank.rs` owns local problem-bank loading, saving, starter data, and bank validation.
+- `src/core/state.rs` owns state loading, saving, and settings normalization.
+- `src/core/language.rs` owns language/provider normalization, templates, and extension mapping.
+- `src/core/render.rs` owns plain/markdown problem rendering.
+- `src/core/judge.rs` owns submission file creation, runtime commands, compilation, and judging.
+- `src/core/progress.rs` owns give-up/next/previous/pass history transitions.
+- `src/core/problem_files.rs` owns generated problem README/index file writes.
+- `src/core/profile.rs` owns user-profile defaults and normalization helpers.
+- `src/tui.rs` owns the `PracticodeApp` state shell, construction, run loop, and test accessors. Keep new TUI behavior in nested `src/tui/` modules.
+- `src/tui/actions.rs` owns user actions such as run, next, generate, language/theme/profile changes.
+- `src/tui/command_handlers.rs` owns slash-command routing.
+- `src/tui/command_input.rs` owns command palette input, completion, and Hangul composition.
+- `src/tui/events.rs` owns keyboard/mouse event routing.
+- `src/tui/tasks.rs` owns background AI/update/model tasks and output writing helpers.
+- `src/tui/view.rs` owns Ratatui drawing, pane styling, mouse-capture toggles, and cursor placement.
+- `src/tui/problem_list.rs` owns problem-list rendering and navigation.
+- `src/tui/status.rs` owns status-line text, busy-game text, mode hints, and help text.
 - `src/tui/commands.rs` owns the command palette catalog.
 - `src/tui/editor.rs` owns the in-terminal code editor state.
 - `src/tui/problem_view.rs` owns problem-statement rendering.
@@ -17,7 +33,7 @@ Practicode is local-first: user data stays under `.practicode/`, `problems/`, an
 
 ## Extension Rules
 
-- Add domain logic under the owning module first; keep `tui.rs` as orchestration, not a catch-all.
+- Add domain logic under the owning nested module first; keep `core.rs` and `tui.rs` as facades/shells, not catch-alls.
 - Add user-visible commands in `src/tui/commands.rs`, then route behavior in `PracticodeApp::handle_command`.
 - Add persisted user profile settings to `Settings`, normalize them in `normalize_settings`, and cover old-state compatibility with tests.
 - Keep provider-specific behavior in `src/ai.rs`; TUI should ask for status or start tasks, not know provider internals.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "practicode",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Local-first coding-test practice in a Rust terminal UI with optional AI help.",
   "license": "MIT",
   "repository": {

package/src/ai.rs

@@ -1,7 +1,7 @@
 use crate::{
     core::{
-        AppState, LANGUAGES, PROBLEM_NOTES_PATH, Problem, Settings, UI_LANGUAGES,
-        ensure_submission, normalize_ai_provider, render_problem,
+        AppState, CLAUDE_AI_EFFORTS, LANGUAGES, PROBLEM_NOTES_PATH, Problem, Settings,
+        UI_LANGUAGES, ensure_submission, normalize_ai_provider, render_problem,
     },
     process::{run_capture, sh_quote, shell_process, unique_temp_path, which},
 };
@@ -21,6 +21,10 @@ pub struct ModelCatalog {
     pub message: Option<String>,
 }
 
+const CODEX_MODEL_FALLBACKS: &[&str] =
+    &["gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex-spark"];
+const CLAUDE_MODEL_FALLBACKS: &[&str] = &["sonnet", "opus", "fable", "claude-fable-5"];
+
 pub fn run_ai_prompt(root: &Path, problem: &Problem, settings: &Settings, prompt: &str) -> String {
     let solution = match ensure_submission(root, problem, settings) {
         Ok(path) => path,
@@ -59,7 +63,8 @@ pub fn run_ai_next(root: &Path, state: &AppState, force: bool, request: &str) ->
         .current_dir(root)
         .env("PRACTICODE_NEXT_REQUEST", request)
         .env("PRACTICODE_AI_PROVIDER", &provider)
-        .env("PRACTICODE_AI_MODEL", &state.settings.ai_model);
+        .env("PRACTICODE_AI_MODEL", &state.settings.ai_model)
+        .env("PRACTICODE_AI_EFFORT", &state.settings.ai_effort);
     match run_capture(&mut process, "", Duration::from_secs(900)) {
         Ok(run) if run.code == Some(0) => {
             let output = output_text(&run.stdout, &run.stderr);
@@ -91,7 +96,8 @@ pub fn run_ai_generate(root: &Path, state: &AppState, request: &str) -> String {
         .env("PRACTICODE_NEXT_REQUEST", request)
         .env("PRACTICODE_GENERATE_BACKGROUND", "1")
         .env("PRACTICODE_AI_PROVIDER", &provider)
-        .env("PRACTICODE_AI_MODEL", &state.settings.ai_model);
+        .env("PRACTICODE_AI_MODEL", &state.settings.ai_model)
+        .env("PRACTICODE_AI_EFFORT", &state.settings.ai_effort);
     match run_capture(&mut process, "", Duration::from_secs(900)) {
         Ok(run) if run.code == Some(0) => {
             let output = output_text(&run.stdout, &run.stderr);
@@ -151,11 +157,15 @@ pub fn available_models(provider: &str) -> ModelCatalog {
     match normalize_ai_provider(provider).as_str() {
         "codex" => codex_models(),
         "claude" => ModelCatalog {
-            models: Vec::new(),
-            message: Some(
-                "Claude CLI does not expose a model list; use /model <name> for a known model."
-                    .to_string(),
-            ),
+            models: CLAUDE_MODEL_FALLBACKS
+                .iter()
+                .map(|model| (*model).to_string())
+                .collect(),
+            message: Some(format!(
+                "Bundled Claude presets from Claude Code {} --help. Efforts: {}.",
+                claude_version().unwrap_or_else(|| "current".to_string()),
+                CLAUDE_AI_EFFORTS.join(", ")
+            )),
         },
         _ => ModelCatalog::default(),
     }
@@ -231,7 +241,7 @@ fn codex_models() -> ModelCatalog {
     }
     if codex_daemon_path().is_none_or(|path| !path.exists()) {
         return ModelCatalog {
-            models: Vec::new(),
+            models: codex_cached_models(),
             message: Some("Codex app-server daemon is unavailable; install the standalone Codex app to list models, or use /model <name>.".to_string()),
         };
     }
@@ -243,18 +253,22 @@ fn codex_models() -> ModelCatalog {
     let input = r#"{"id":1,"method":"model/list","params":{"limit":25}}"#;
     let Ok(run) = run_capture(&mut command, &format!("{input}\n"), Duration::from_secs(2)) else {
         return ModelCatalog {
-            models: Vec::new(),
-            message: Some("Could not query Codex model list.".to_string()),
+            models: codex_cached_models(),
+            message: Some(
+                "Could not query Codex model list; using bundled/cache model presets.".to_string(),
+            ),
         };
     };
     if run.code != Some(0) {
         let detail = output_text(&run.stdout, &run.stderr);
         return ModelCatalog {
-            models: Vec::new(),
+            models: codex_cached_models(),
             message: Some(if detail.is_empty() {
-                "Could not query Codex model list.".to_string()
+                "Could not query Codex model list; using bundled/cache model presets.".to_string()
             } else {
-                format!("Could not query Codex model list: {detail}")
+                format!(
+                    "Could not query Codex model list; using bundled/cache model presets: {detail}"
+                )
             }),
         };
     }
@@ -272,6 +286,51 @@ fn codex_models() -> ModelCatalog {
     }
 }
 
+fn codex_cached_models() -> Vec<String> {
+    let mut models = env::var_os("HOME")
+        .and_then(|home| {
+            fs::read_to_string(PathBuf::from(home).join(".codex/models_cache.json")).ok()
+        })
+        .and_then(|text| serde_json::from_str::<serde_json::Value>(&text).ok())
+        .and_then(|value| {
+            value
+                .get("models")
+                .and_then(|models| models.as_array())
+                .cloned()
+        })
+        .unwrap_or_default()
+        .into_iter()
+        .filter_map(|model| {
+            model
+                .get("slug")
+                .and_then(|value| value.as_str())
+                .map(str::to_string)
+        })
+        .collect::<Vec<_>>();
+    if models.is_empty() {
+        models = CODEX_MODEL_FALLBACKS
+            .iter()
+            .map(|model| (*model).to_string())
+            .collect();
+    }
+    models
+}
+
+fn claude_version() -> Option<String> {
+    which("claude").and_then(|_| {
+        let mut command = Command::new("claude");
+        command.arg("--version");
+        run_capture(&mut command, "", Duration::from_secs(2))
+            .ok()
+            .and_then(|run| {
+                output_text(&run.stdout, &run.stderr)
+                    .lines()
+                    .next()
+                    .map(str::to_string)
+            })
+    })
+}
+
 fn parse_model_list(output: &str) -> Vec<String> {
     output
         .lines()
@@ -309,6 +368,7 @@ fn run_codex_prompt(root: &Path, settings: &Settings, prompt: &str) -> String {
     if let Some(model) = settings.model_arg() {
         command.args(["--model", model]);
     }
+    add_codex_effort_args(&mut command, settings);
     command.args(["-o", &output_path.display().to_string(), prompt]);
     let result = run_capture(&mut command, "", Duration::from_secs(600));
     let last_message = fs::read_to_string(&output_path).unwrap_or_default();
@@ -341,6 +401,9 @@ fn run_claude_prompt(root: &Path, settings: &Settings, prompt: &str) -> String {
     if let Some(model) = settings.model_arg() {
         command.args(["--model", model]);
     }
+    if let Some(effort) = settings.effort_arg() {
+        command.args(["--effort", effort]);
+    }
     command.args(["-p", prompt]);
     match run_capture(&mut command, "", Duration::from_secs(600)) {
         Ok(run) if run.code == Some(0) => {
@@ -371,6 +434,7 @@ fn default_codex_next_command(root: &Path, settings: &Settings, request: &str) -
     if let Some(model) = settings.model_arg() {
         exec.push_str(&format!(" --model {}", sh_quote(model)));
     }
+    push_codex_effort_arg(&mut exec, settings);
     exec.push(' ');
     exec.push_str(&sh_quote(&default_ai_next_prompt_with_settings(
         settings, request,
@@ -387,6 +451,7 @@ fn default_codex_generate_command(root: &Path, settings: &Settings, request: &st
     if let Some(model) = settings.model_arg() {
         exec.push_str(&format!(" --model {}", sh_quote(model)));
     }
+    push_codex_effort_arg(&mut exec, settings);
     exec.push(' ');
     exec.push_str(&sh_quote(&default_ai_generate_prompt_with_settings(
         settings, request,
@@ -407,6 +472,9 @@ fn default_claude_next_command(root: &Path, settings: &Settings, request: &str)
     if let Some(model) = settings.model_arg() {
         claude.push_str(&format!(" --model {}", sh_quote(model)));
     }
+    if let Some(effort) = settings.effort_arg() {
+        claude.push_str(&format!(" --effort {}", sh_quote(effort)));
+    }
     claude.push_str(" -p ");
     claude.push_str(&sh_quote(&default_ai_next_prompt_with_settings(
         settings, request,
@@ -423,6 +491,9 @@ fn default_claude_generate_command(root: &Path, settings: &Settings, request: &s
     if let Some(model) = settings.model_arg() {
         claude.push_str(&format!(" --model {}", sh_quote(model)));
     }
+    if let Some(effort) = settings.effort_arg() {
+        claude.push_str(&format!(" --effort {}", sh_quote(effort)));
+    }
     claude.push_str(" -p ");
     claude.push_str(&sh_quote(&default_ai_generate_prompt_with_settings(
         settings, request,
@@ -442,6 +513,23 @@ fn output_text(stdout: &str, stderr: &str) -> String {
         .join("\n")
 }
 
+fn add_codex_effort_args(command: &mut Command, settings: &Settings) {
+    if let Some(effort) = settings.effort_arg() {
+        let effort = if effort == "max" { "xhigh" } else { effort };
+        command.args(["-c", &format!("model_reasoning_effort=\"{effort}\"")]);
+    }
+}
+
+fn push_codex_effort_arg(command: &mut String, settings: &Settings) {
+    if let Some(effort) = settings.effort_arg() {
+        let effort = if effort == "max" { "xhigh" } else { effort };
+        command.push_str(&format!(
+            " -c {}",
+            sh_quote(&format!("model_reasoning_effort=\"{effort}\""))
+        ));
+    }
+}
+
 fn list_or_none(values: &[String]) -> String {
     if values.is_empty() {
         "(none)".to_string()

package/src/core/bank.rs

@@ -0,0 +1,148 @@
+use super::*;
+
+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, '-' | '_'))
+}