practicode 0.1.0 → 0.1.2

package/scripts/release.sh

@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+current=$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -1)
+npm_current=$(node -p "require('./package.json').version")
+
+if [[ "$current" != "$npm_current" ]]; then
+  echo "Cargo.toml version ($current) does not match package.json ($npm_current)" >&2
+  exit 1
+fi
+
+if [[ -n "$(git status --porcelain)" ]]; then
+  echo "working tree is dirty; commit or stash changes first" >&2
+  exit 1
+fi
+
+branch=$(git branch --show-current)
+if [[ "$branch" != "main" ]]; then
+  echo "release from main, not $branch" >&2
+  exit 1
+fi
+
+git fetch origin main --tags
+if [[ "$(git rev-parse HEAD)" != "$(git rev-parse origin/main)" ]]; then
+  echo "local main is not synced with origin/main" >&2
+  exit 1
+fi
+
+echo "Current version: $current"
+version="${1:-}"
+if [[ -z "$version" ]]; then
+  read -r -p "Next version: " version
+fi
+
+if [[ ! "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+  echo "version must look like 0.1.1" >&2
+  exit 2
+fi
+
+node -e '
+const [current, next] = process.argv.slice(1).map(v => v.split(".").map(Number));
+const ok = next[0] > current[0] ||
+  (next[0] === current[0] && (next[1] > current[1] ||
+  (next[1] === current[1] && next[2] > current[2])));
+process.exit(ok ? 0 : 1);
+' "$current" "$version" || {
+  echo "next version must be greater than $current" >&2
+  exit 2
+}
+
+if git rev-parse -q --verify "refs/tags/v$version" >/dev/null; then
+  echo "tag v$version already exists locally" >&2
+  exit 1
+fi
+if git ls-remote --exit-code --tags origin "v$version" >/dev/null 2>&1; then
+  echo "tag v$version already exists on origin" >&2
+  exit 1
+fi
+
+echo "Releasing v$version"
+VERSION="$version" perl -0pi -e 's/^version = ".*"/version = "$ENV{VERSION}"/m' Cargo.toml
+node -e "const fs=require('fs'); const p=require('./package.json'); p.version=process.env.VERSION; fs.writeFileSync('package.json', JSON.stringify(p, null, 2) + '\n')"
+cargo test
+npm pack --dry-run >/dev/null
+
+git add Cargo.toml Cargo.lock package.json
+git commit -m "Release v$version"
+git tag "v$version"
+git push origin main "v$version"

package/src/ai.rs

@@ -3,13 +3,14 @@ use crate::{
         AppState, PROBLEM_NOTES_PATH, Problem, Settings, ensure_submission, normalize_ai_provider,
         render_problem,
     },
-    process::{run_capture, sh_quote, shell_process, unique_temp_path},
+    process::{run_capture, sh_quote, shell_process, unique_temp_path, which},
 };
 use anyhow::Result;
 use std::{
+    env,
     fs::{self, OpenOptions},
     io::Write,
-    path::Path,
+    path::{Path, PathBuf},
     process::Command,
     time::Duration,
 };
@@ -39,7 +40,7 @@ pub fn run_ai_prompt(root: &Path, problem: &Problem, settings: &Settings, prompt
 
 pub fn run_ai_next(root: &Path, state: &AppState, force: bool, request: &str) -> String {
     if state.settings.next_source != "ai" && !force {
-        return "AI next is disabled; using local problem bank.".to_string();
+        return "AI next is disabled; using local problems.".to_string();
     }
     let provider = normalize_ai_provider(&state.settings.ai_provider);
     let command = if state.settings.next_ai_command().trim().is_empty() {
@@ -78,9 +79,32 @@ pub fn default_ai_next_command(root: &Path, settings: &Settings, request: &str)
     }
 }
 
+pub fn provider_status(provider: &str) -> String {
+    match normalize_ai_provider(provider).as_str() {
+        "claude" => {
+            if which("claude").is_some() {
+                "Claude CLI found.".to_string()
+            } else {
+                "Claude CLI not found. Install Claude Code or choose /provider codex.".to_string()
+            }
+        }
+        _ => {
+            if which("codex").is_none() {
+                return "Codex CLI not found. Install Codex CLI or choose /provider claude."
+                    .to_string();
+            }
+            if codex_daemon_path().is_some_and(|path| path.exists()) {
+                "Codex CLI found. App-server daemon is available.".to_string()
+            } else {
+                "Codex CLI found. App-server daemon is not available; practicode will use codex exec directly.".to_string()
+            }
+        }
+    }
+}
+
 pub fn default_ai_next_prompt(request: &str) -> String {
     format!(
-        "Read AGENTS.md, docs/problem-authoring-notes.md if present, .practicode/problem_notes.md if present, problems/INDEX.md if present, .practicode/problem_bank.json if present, and .practicode/problem-state.json. The app has a built-in starter problem 001-hello-world, so do not duplicate it. Create exactly one new non-duplicate coding practice problem. User request for this problem: {}. Update .practicode/problem_bank.json, the local problem files, the index, and state files. Do not include the answer in the problem statement.",
+        "Read AGENTS.md, docs/problem-authoring-notes.md if present, .practicode/problem_notes.md if present, problems/INDEX.md if present, .practicode/problem_bank.json if present, and .practicode/problem-state.json. Create exactly one new non-duplicate coding practice problem. The built-in 001-hello-world already exists, so do not duplicate it. User request: {}. Make the smallest valid edits: update .practicode/problem_bank.json, one problem directory, problems/INDEX.md, and .practicode/problem-state.json. Do not include the answer in the problem statement.",
         if request.is_empty() {
             "(none)"
         } else {
@@ -177,9 +201,9 @@ fn run_claude_prompt(root: &Path, settings: &Settings, prompt: &str) -> String {
 }
 
 fn default_codex_next_command(root: &Path, settings: &Settings, request: &str) -> String {
-    let start = "codex app-server daemon start >/dev/null 2>&1 || true";
+    let start = "if [ -x \"$HOME/.codex/packages/standalone/current/codex\" ]; then codex app-server daemon start >/dev/null 2>&1 || true; fi";
     let mut exec = format!(
-        "codex exec --cd {} --sandbox workspace-write",
+        "codex exec --ephemeral --cd {} --sandbox workspace-write",
         sh_quote(&root.display().to_string())
     );
     if let Some(model) = settings.model_arg() {
@@ -190,6 +214,14 @@ fn default_codex_next_command(root: &Path, settings: &Settings, request: &str) -
     format!("{start}; {exec}")
 }
 
+fn codex_daemon_path() -> Option<PathBuf> {
+    env::var_os("HOME").map(|home| {
+        PathBuf::from(home)
+            .join(".codex/packages/standalone/current")
+            .join(if cfg!(windows) { "codex.exe" } else { "codex" })
+    })
+}
+
 fn default_claude_next_command(root: &Path, settings: &Settings, request: &str) -> String {
     let mut claude = "claude --permission-mode acceptEdits".to_string();
     if let Some(model) = settings.model_arg() {

package/src/core.rs

@@ -10,7 +10,7 @@ use std::{
 };
 
 pub const LANGUAGES: &[&str] = &["python", "ts", "java", "rust"];
-pub const UI_LANGUAGES: &[&str] = &["ko", "en"];
+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";
@@ -120,7 +120,7 @@ pub fn default_language() -> String {
 }
 
 pub fn default_ui_language() -> String {
-    "ko".to_string()
+    "en".to_string()
 }
 
 pub fn default_theme() -> String {
@@ -163,20 +163,34 @@ pub fn starter_problem() -> Problem {
         slug: "hello-world".to_string(),
         difficulty: "easy".to_string(),
         topics: vec!["io".to_string()],
-        title: map2("ko", "Hello World", "en", "Hello World"),
-        statement: map2(
-            "ko",
-            "표준 출력으로 정확히 `Hello, World!`를 출력하세요.",
-            "en",
-            "Print exactly `Hello, World!` to stdout.",
-        ),
-        input: map2("ko", "입력은 없습니다.", "en", "No input."),
-        output: map2(
-            "ko",
-            "`Hello, World!` 한 줄",
-            "en",
-            "One line: `Hello, World!`",
-        ),
+        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(),
@@ -210,6 +224,13 @@ pub fn map2(k1: &str, v1: &str, k2: &str, v2: &str) -> HashMap<String, 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() {
@@ -339,9 +360,7 @@ pub fn save_state(root: &Path, state: &AppState) -> Result<()> {
 
 pub fn normalize_settings(settings: &mut Settings) {
     settings.language = normalize_language(&settings.language);
-    if !UI_LANGUAGES.contains(&settings.ui_language.as_str()) {
-        settings.ui_language = "ko".to_string();
-    }
+    settings.ui_language = normalize_ui_language(&settings.ui_language);
     if !THEMES.contains(&settings.theme.as_str()) {
         settings.theme = "dark".to_string();
     }
@@ -381,9 +400,10 @@ pub fn normalize_ai_provider(provider: &str) -> String {
 }
 
 pub fn localized(map: &HashMap<String, String>, lang: &str) -> String {
-    map.get(lang)
-        .or_else(|| map.get("ko"))
+    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()
@@ -415,20 +435,19 @@ pub fn ensure_submission(root: &Path, problem: &Problem, settings: &Settings) ->
 }
 
 pub fn render_problem(problem: &Problem, ui_language: &str) -> String {
-    let lang = if UI_LANGUAGES.contains(&ui_language) {
-        ui_language
-    } else {
-        "ko"
-    };
+    let lang = normalize_ui_language(ui_language);
     let examples = problem
         .examples
         .iter()
         .enumerate()
         .map(|(index, case)| {
             format!(
-                "### Example {}\n\nInput\n\n{}\n\nOutput\n\n{}",
+                "### {} {}\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)
             )
         })
@@ -440,17 +459,82 @@ pub fn render_problem(problem: &Problem, ui_language: &str) -> String {
         .map(|(number, _)| number)
         .unwrap_or(&problem.id);
     format!(
-        "# {number}. {}\n\nDifficulty: {}\nTopics: {}\n\n{}\n\n## Input\n\n{}\n\n## Output\n\n{}\n\n## Examples\n\n{}",
-        localized(&problem.title, lang),
+        "# {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),
-        localized(&problem.input, lang),
-        localized(&problem.output, lang),
+        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') {

package/src/i18n.rs

@@ -0,0 +1,45 @@
+use std::{collections::HashMap, sync::OnceLock};
+
+pub const UI_LANGUAGES: &[&str] = &["en", "ko", "ja", "zh", "es"];
+
+static EN: OnceLock<HashMap<String, String>> = OnceLock::new();
+static KO: OnceLock<HashMap<String, String>> = OnceLock::new();
+static JA: OnceLock<HashMap<String, String>> = OnceLock::new();
+static ZH: OnceLock<HashMap<String, String>> = OnceLock::new();
+static ES: OnceLock<HashMap<String, String>> = OnceLock::new();
+
+pub fn normalize_ui_language(language: &str) -> String {
+    let lower = language.trim().to_lowercase();
+    let short = lower
+        .split(['-', '_'])
+        .next()
+        .filter(|value| !value.is_empty())
+        .unwrap_or("en");
+    if UI_LANGUAGES.contains(&short) {
+        short.to_string()
+    } else {
+        "en".to_string()
+    }
+}
+
+pub fn ui_text(lang: &str, key: &str) -> &'static str {
+    catalog(&normalize_ui_language(lang))
+        .get(key)
+        .or_else(|| catalog("en").get(key))
+        .map(String::as_str)
+        .unwrap_or("")
+}
+
+fn catalog(lang: &str) -> &'static HashMap<String, String> {
+    match lang {
+        "ko" => KO.get_or_init(|| load(include_str!("../assets/i18n/ko.json"))),
+        "ja" => JA.get_or_init(|| load(include_str!("../assets/i18n/ja.json"))),
+        "zh" => ZH.get_or_init(|| load(include_str!("../assets/i18n/zh.json"))),
+        "es" => ES.get_or_init(|| load(include_str!("../assets/i18n/es.json"))),
+        _ => EN.get_or_init(|| load(include_str!("../assets/i18n/en.json"))),
+    }
+}
+
+fn load(text: &str) -> HashMap<String, String> {
+    serde_json::from_str(text).expect("valid i18n catalog")
+}

package/src/lib.rs

@@ -4,9 +4,11 @@ use std::{env, io::stdout};
 
 pub mod ai;
 pub mod core;
+pub mod i18n;
 pub mod process;
 pub mod text;
 pub mod tui;
+pub mod update;
 
 pub fn run_cli() -> Result<()> {
     let root = env::current_dir().context("read current directory")?;