practicode 0.1.0

package/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "practicode"
+version = "0.1.0"
+edition = "2024"
+description = "Local-first coding-test practice in a Rust terminal UI with optional AI help."
+readme = "README.md"
+license = "MIT"
+repository = "https://github.com/baba9811/practicode"
+homepage = "https://github.com/baba9811/practicode"
+keywords = ["algorithms", "ai", "coding-practice", "competitive", "tui"]
+categories = ["command-line-utilities", "development-tools", "text-editors"]
+
+[dependencies]
+anyhow = "1"
+crossterm = "0.29"
+ratatui = "0.29"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+unicode-width = "0.2"
+wait-timeout = "0.2"

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 baba9811
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,200 @@
+# practicode
+
+![Rust](https://img.shields.io/badge/Rust-terminal%20app-000000?logo=rust&logoColor=white)
+![Ratatui](https://img.shields.io/badge/Ratatui-TUI-00B4D8)
+![Local first](https://img.shields.io/badge/local--first-practice-14B8A6)
+![AI ready](https://img.shields.io/badge/AI-Codex%20%2B%20Claude-111827)
+![CI](https://github.com/baba9811/practicode/actions/workflows/ci.yml/badge.svg)
+
+![practicode terminal UI](assets/practicode-terminal.svg)
+
+Personal coding practice, right in your terminal.
+
+`practicode` is a small Rust TUI for stdin/stdout practice: problem on the left, code on the right, judge loop in the same terminal.
+No browser tab shuffle, no paste dance, just solve and run.
+
+## Why It Exists
+
+- Fast local judging for Python, TypeScript, Java, and Rust
+- Gradual problem flow with local history
+- AI-powered `/next <request>` when you want a custom problem
+- Personal problem-generation notes
+- Small stack: Rust, Ratatui, Crossterm, and plain process execution
+
+## Quick Start
+
+```bash
+git clone https://github.com/baba9811/practicode.git
+cd practicode
+cargo run --
+```
+
+Want a local binary?
+
+```bash
+cargo install practicode
+practicode
+```
+
+Prefer npm from GitHub?
+
+```bash
+npm install -g github:baba9811/practicode
+practicode
+```
+
+Working from a local checkout?
+
+```bash
+cargo install --path .
+practicode
+```
+
+Or with npm:
+
+```bash
+npm install -g .
+practicode
+```
+
+The npm wrapper builds the Rust binary with Cargo, so Rust/Cargo is still required.
+
+## Daily Loop
+
+The code editor starts focused.
+
+```text
+write code
+Esc, then /run
+Esc, then /next easy string problem
+```
+
+Submissions are saved as you type under `submissions/<problem-id>/solution.<ext>`.
+
+## Commands
+
+Press `Esc`, then `/`, to focus the command bar.
+
+| Command | Action |
+| --- | --- |
+| `/run` | Judge the current submission |
+| `/next` | Open the next local problem, or ask AI to create one |
+| `/next easy string problem` | Ask AI for a custom next problem |
+| `/prev` | Go back through problem history |
+| `/list` | Browse problems with `up/down` or `j/k`, open with `Enter` |
+| `/open 2` | Open by number, id, or slug |
+| `/giveup` | Show the reference answer |
+| `/ai hint` | Ask the selected AI about the current problem and submission |
+| `/provider codex` | Set AI provider: `codex` or `claude` |
+| `/model sonnet` | Set the model for `/ai` and AI-backed `/next`; use `auto` for the CLI default |
+| `/note prefer hashmap practice` | Append a standing note for future problem generation |
+| `/notes` | Show your local next-problem notes |
+| `/lang python` | Set language: `python`, `ts`, `java`, `rust` |
+| `/ui ko` | Set UI language: `ko`, `en` |
+| `/theme` | Toggle dark/light theme |
+| `/source ai` | Prefer AI for next-problem generation |
+| `/exit` | Quit |
+
+The editor owns normal typing keys.
+Press `Esc`, then `/`, when you want the command bar.
+
+## Custom Problem Generation
+
+`/next <request>` passes your request into the selected AI problem generator. Examples:
+
+```text
+/next a slightly harder string problem
+/next hashmap practice, easy
+/next sorting problem, no graph yet
+```
+
+AI generation reads [docs/problem-authoring-notes.md](docs/problem-authoring-notes.md) every time it creates a problem. Add personal preferences from inside the TUI:
+
+```text
+/note Prefer concise statements.
+/note I want more string and hashmap practice.
+/note Avoid DP until I ask for it.
+```
+
+Those notes are stored in `.practicode/problem_notes.md`, so they stay local.
+
+## AI Providers
+
+Codex is the default:
+
+```text
+/provider codex
+/model auto
+```
+
+Claude Code is also supported:
+
+```text
+/provider claude
+/model sonnet
+/source ai
+```
+
+`/ai <prompt>` uses the current provider for coaching. AI-backed `/next` uses the same provider and model.
+If you want a custom daemon or wrapper script, set `/ai-next-command <shell command>`; practicode passes `PRACTICODE_NEXT_REQUEST`, `PRACTICODE_AI_PROVIDER`, and `PRACTICODE_AI_MODEL`.
+
+Generated problem banks stay local:
+
+| Path | Purpose |
+| --- | --- |
+| `.practicode/problem_bank.json` | Local/custom/generated problem bank |
+| `.practicode/problem_notes.md` | Optional personal problem-generation notes |
+| `.practicode/problem-state.json` | Current problem, history, settings |
+| `problems/` | Generated problem markdown/index files |
+| `submissions/` | Your answer files |
+
+Those paths are ignored by git, so your practice history stays yours.
+
+## Safety
+
+`/run` executes your local submission as a normal process. practicode runs it from `.practicode/build/<problem-id>/run`, but this is not an OS sandbox. Only run code you trust.
+
+## Debug Prints
+
+`/run` shows raw stdout when a case fails. If you want debug output without changing the judged answer, print to stderr:
+
+```python
+import sys
+
+print("debug", value, file=sys.stderr)
+```
+
+## Development
+
+```bash
+cargo test
+cargo run -- --smoke
+cargo run --
+```
+
+The source is split by boring responsibility:
+
+| Path | Role |
+| --- | --- |
+| `src/core.rs` | Problem bank, state, rendering, judging |
+| `src/tui.rs` | Ratatui app, editor, command parser |
+| `src/ai.rs` | Codex/Claude command integration and notes |
+| `src/text.rs` | UTF-8 cursor math and Hangul composition |
+| `src/process.rs` | Process execution helpers |
+| `tests/` | Integration tests split by module |
+
+## Discovery Notes
+
+Recommended GitHub topics for this repo:
+`coding-practice`, `competitive-programming`, `algorithms`, `ratatui`, `tui`, `rust`, `codex`, `claude-code`, `local-first`.
+
+## References
+
+- Ratatui terminal UI library: https://ratatui.rs/
+- Crossterm terminal backend/events: https://github.com/crossterm-rs/crossterm
+- Codex CLI open-source repo: https://github.com/openai/codex
+- Claude Code CLI reference: https://docs.anthropic.com/en/docs/claude-code/cli-reference
+- Kattis problem package format: https://www.kattis.com/problem-package-format/
+- ICPC judging guidelines: https://icpc.global/regionals/regional-contest-cookbook-judging-guidelines
+- GitHub README image guidance: https://docs.github.com/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-readmes
+- GitHub repository topics: https://docs.github.com/articles/classifying-your-repository-with-topics

package/assets/practicode-terminal.svg

@@ -0,0 +1,24 @@
+<svg width="1200" height="720" viewBox="0 0 1200 720" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <rect width="1200" height="720" fill="#070b12"/>
+  <rect x="64" y="52" width="1072" height="616" rx="10" fill="#0b111a" stroke="#1f6f7a" stroke-width="2"/>
+  <rect x="88" y="78" width="594" height="440" rx="4" fill="#0f1720" stroke="#00c2d1" stroke-width="2"/>
+  <rect x="704" y="78" width="408" height="440" rx="4" fill="#0d141c" stroke="#31536b" stroke-width="2"/>
+  <text x="112" y="112" fill="#d7e1ec" font-family="SFMono-Regular, Menlo, Consolas, monospace" font-size="18" font-weight="700">Problem</text>
+  <text x="728" y="112" fill="#d7e1ec" font-family="SFMono-Regular, Menlo, Consolas, monospace" font-size="18" font-weight="700">solution.py</text>
+  <text x="112" y="158" fill="#f8fafc" font-family="SFMono-Regular, Menlo, Consolas, monospace" font-size="22" font-weight="700">001. Hello World</text>
+  <text x="112" y="204" fill="#c8d3f5" font-family="SFMono-Regular, Menlo, Consolas, monospace" font-size="16">Difficulty: easy</text>
+  <text x="112" y="232" fill="#c8d3f5" font-family="SFMono-Regular, Menlo, Consolas, monospace" font-size="16">Topics: io</text>
+  <text x="112" y="286" fill="#f8fafc" font-family="SFMono-Regular, Menlo, Consolas, monospace" font-size="17">Print exactly Hello, World! to stdout.</text>
+  <text x="112" y="352" fill="#00a8ff" font-family="SFMono-Regular, Menlo, Consolas, monospace" font-size="17" text-decoration="underline">Input</text>
+  <text x="112" y="386" fill="#f8fafc" font-family="SFMono-Regular, Menlo, Consolas, monospace" font-size="17">No input.</text>
+  <text x="112" y="442" fill="#00a8ff" font-family="SFMono-Regular, Menlo, Consolas, monospace" font-size="17" text-decoration="underline">Output</text>
+  <text x="112" y="476" fill="#f6c177" font-family="SFMono-Regular, Menlo, Consolas, monospace" font-size="17">Hello, World!</text>
+  <text x="728" y="158" fill="#6b7280" font-family="SFMono-Regular, Menlo, Consolas, monospace" font-size="17">  1</text>
+  <text x="776" y="158" fill="#7dd3fc" font-family="SFMono-Regular, Menlo, Consolas, monospace" font-size="17">print</text>
+  <text x="828" y="158" fill="#f8fafc" font-family="SFMono-Regular, Menlo, Consolas, monospace" font-size="17">('Hello, World!')</text>
+  <rect x="64" y="536" width="1072" height="28" fill="#152033"/>
+  <text x="84" y="556" fill="#c8d3f5" font-family="SFMono-Regular, Menlo, Consolas, monospace" font-size="15" font-weight="700">PRACTICODE | 001-hello-world | easy | idle | solved | code:written | python | next:ai | ai:codex/auto</text>
+  <rect x="64" y="586" width="1072" height="58" rx="2" fill="#0b1017" stroke="#008cff" stroke-width="2"/>
+  <text x="84" y="606" fill="#c8d3f5" font-family="SFMono-Regular, Menlo, Consolas, monospace" font-size="15" font-weight="700">Command</text>
+  <text x="84" y="630" fill="#f8fafc" font-family="SFMono-Regular, Menlo, Consolas, monospace" font-size="18">/ai hint about edge cases</text>
+</svg>

package/bin/practicode.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require("node:child_process");
+const { existsSync } = require("node:fs");
+const path = require("node:path");
+
+const root = path.resolve(__dirname, "..");
+const exe = path.join(
+  root,
+  "target",
+  "release",
+  process.platform === "win32" ? "practicode.exe" : "practicode",
+);
+
+if (!existsSync(exe)) {
+  const build = spawnSync(
+    "cargo",
+    ["build", "--release", "--locked", "--manifest-path", path.join(root, "Cargo.toml")],
+    { stdio: "inherit" },
+  );
+  if (build.error) {
+    console.error(`practicode: failed to run cargo: ${build.error.message}`);
+    process.exit(1);
+  }
+  if (build.status !== 0) {
+    process.exit(build.status ?? 1);
+  }
+}
+
+const run = spawnSync(exe, process.argv.slice(2), {
+  cwd: process.cwd(),
+  stdio: "inherit",
+});
+
+if (run.error) {
+  console.error(`practicode: failed to run binary: ${run.error.message}`);
+  process.exit(1);
+}
+process.exit(run.status ?? 1);

package/docs/problem-authoring-notes.md

@@ -0,0 +1,33 @@
+# Problem Authoring Notes
+
+Use this when AI creates a new `/next` problem.
+
+## Shape
+
+- Keep one clear task per problem.
+- Prefer stdin/stdout fundamentals first: arithmetic, strings, arrays, maps, sorting, two pointers, then graphs/DP later.
+- State input, output, examples, and constraints explicitly.
+- Make examples small enough to verify by hand.
+- Include enough hidden cases to catch empty/min/max, duplicates, ties, ordering, and whitespace mistakes.
+- Keep answers for `python`, `ts`, `java`, and `rust` in `.practicode/problem_bank.json`; never put answers in `README.md`.
+
+## Difficulty
+
+- `easy`: one idea, direct parsing, O(n) or O(n log n), no tricky proof.
+- `medium`: combine two ideas or need a careful invariant.
+- Move up only after recent submitted solutions pass and look clean.
+
+## Local Preferences
+
+If `.practicode/problem_notes.md` exists, read it too. That file is for personal themes like:
+
+```text
+Prefer Korean statements.
+I want more string and hashmap practice.
+Avoid DP until I ask for it.
+```
+
+## References
+
+- Kattis problem package format: https://www.kattis.com/problem-package-format/
+- ICPC judging guidelines: https://icpc.global/regionals/regional-contest-cookbook-judging-guidelines

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "practicode",
+  "version": "0.1.0",
+  "description": "Local-first coding-test practice in a Rust terminal UI with optional AI help.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/baba9811/practicode.git"
+  },
+  "homepage": "https://github.com/baba9811/practicode#readme",
+  "bin": {
+    "practicode": "bin/practicode.js"
+  },
+  "scripts": {
+    "build": "cargo build --release --locked",
+    "postinstall": "node scripts/npm-postinstall.js",
+    "smoke": "node bin/practicode.js --smoke"
+  },
+  "files": [
+    "assets/",
+    "bin/",
+    "docs/",
+    "scripts/",
+    "src/",
+    "Cargo.lock",
+    "Cargo.toml",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "algorithms",
+    "coding-practice",
+    "competitive-programming",
+    "ratatui",
+    "rust",
+    "tui"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/npm-postinstall.js

@@ -0,0 +1,20 @@
+const { spawnSync } = require("node:child_process");
+const path = require("node:path");
+
+if (process.env.PRACTICODE_SKIP_BUILD === "1") {
+  process.exit(0);
+}
+
+const root = path.resolve(__dirname, "..");
+const build = spawnSync("cargo", ["build", "--release", "--locked"], {
+  cwd: root,
+  stdio: "inherit",
+});
+
+if (build.error) {
+  console.warn(`practicode: cargo build skipped: ${build.error.message}`);
+  console.warn("practicode: install Rust/Cargo before first run, or set PRACTICODE_SKIP_BUILD=1.");
+  process.exit(0);
+}
+
+process.exit(build.status ?? 1);

package/src/ai.rs

@@ -0,0 +1,213 @@
+use crate::{
+    core::{
+        AppState, PROBLEM_NOTES_PATH, Problem, Settings, ensure_submission, normalize_ai_provider,
+        render_problem,
+    },
+    process::{run_capture, sh_quote, shell_process, unique_temp_path},
+};
+use anyhow::Result;
+use std::{
+    fs::{self, OpenOptions},
+    io::Write,
+    path::Path,
+    process::Command,
+    time::Duration,
+};
+
+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,
+        Err(error) => return format!("AI prompt failed\n{error}"),
+    };
+    let code = fs::read_to_string(&solution).unwrap_or_default();
+    let relative = solution
+        .strip_prefix(root)
+        .unwrap_or(&solution)
+        .display()
+        .to_string();
+    let full_prompt = format!(
+        "You are a concise coding-test coach. Help with the current problem and current submission. Prefer hints over full answers unless the user explicitly asks for the answer.\n\nUser request:\n{prompt}\n\nProblem:\n{}\n\nCurrent {} submission ({relative}):\n```{}\n{code}\n```",
+        render_problem(problem, &settings.ui_language),
+        settings.language,
+        settings.language
+    );
+    match normalize_ai_provider(&settings.ai_provider).as_str() {
+        "claude" => run_claude_prompt(root, settings, &full_prompt),
+        _ => run_codex_prompt(root, settings, &full_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();
+    }
+    let provider = normalize_ai_provider(&state.settings.ai_provider);
+    let command = if state.settings.next_ai_command().trim().is_empty() {
+        default_ai_next_command(root, &state.settings, request)
+    } else {
+        state.settings.next_ai_command().to_string()
+    };
+    let mut process = shell_process(&command);
+    process
+        .current_dir(root)
+        .env("PRACTICODE_NEXT_REQUEST", request)
+        .env("PRACTICODE_AI_PROVIDER", &provider)
+        .env("PRACTICODE_AI_MODEL", &state.settings.ai_model);
+    match run_capture(&mut process, "", Duration::from_secs(900)) {
+        Ok(run) if run.code == Some(0) => {
+            let output = output_text(&run.stdout, &run.stderr);
+            format!("{provider} command finished\n{output}")
+                .trim()
+                .to_string()
+        }
+        Ok(run) => {
+            let output = output_text(&run.stdout, &run.stderr);
+            format!(
+                "{provider} command failed ({})\n{output}",
+                run.code.unwrap_or(-1)
+            )
+        }
+        Err(error) => format!("{provider} command failed\n{error}"),
+    }
+}
+
+pub fn default_ai_next_command(root: &Path, settings: &Settings, request: &str) -> String {
+    match normalize_ai_provider(&settings.ai_provider).as_str() {
+        "claude" => default_claude_next_command(root, settings, request),
+        _ => default_codex_next_command(root, settings, request),
+    }
+}
+
+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.",
+        if request.is_empty() {
+            "(none)"
+        } else {
+            request
+        }
+    )
+}
+
+pub fn append_problem_note(root: &Path, note: &str) -> Result<()> {
+    let path = root.join(PROBLEM_NOTES_PATH);
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    let mut file = OpenOptions::new().create(true).append(true).open(path)?;
+    writeln!(file, "{}", note.trim())?;
+    Ok(())
+}
+
+pub fn read_problem_notes(root: &Path) -> Result<String> {
+    let path = root.join(PROBLEM_NOTES_PATH);
+    if path.exists() {
+        Ok(fs::read_to_string(path)?.trim_end().to_string())
+    } else {
+        Ok(String::new())
+    }
+}
+
+fn run_codex_prompt(root: &Path, settings: &Settings, prompt: &str) -> String {
+    let output_path = unique_temp_path("practicode-last-message", "txt");
+    let mut command = Command::new("codex");
+    command
+        .args([
+            "exec",
+            "--cd",
+            &root.display().to_string(),
+            "--sandbox",
+            "read-only",
+        ])
+        .current_dir(root);
+    if let Some(model) = settings.model_arg() {
+        command.args(["--model", model]);
+    }
+    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();
+    let _ = fs::remove_file(&output_path);
+    match result {
+        Ok(run) if run.code == Some(0) => {
+            let output = output_text(&run.stdout, &run.stderr);
+            let last = last_message.trim();
+            if !last.is_empty() {
+                last.to_string()
+            } else if !output.is_empty() {
+                output
+            } else {
+                "Codex returned no output.".to_string()
+            }
+        }
+        Ok(run) => {
+            let output = output_text(&run.stdout, &run.stderr);
+            format!("Codex prompt failed ({})\n{output}", run.code.unwrap_or(-1))
+        }
+        Err(error) => format!("Codex prompt failed\n{error}"),
+    }
+}
+
+fn run_claude_prompt(root: &Path, settings: &Settings, prompt: &str) -> String {
+    let mut command = Command::new("claude");
+    command
+        .args(["--permission-mode", "plan"])
+        .current_dir(root);
+    if let Some(model) = settings.model_arg() {
+        command.args(["--model", model]);
+    }
+    command.args(["-p", prompt]);
+    match run_capture(&mut command, "", Duration::from_secs(600)) {
+        Ok(run) if run.code == Some(0) => {
+            let output = output_text(&run.stdout, &run.stderr);
+            if output.is_empty() {
+                "Claude returned no output.".to_string()
+            } else {
+                output
+            }
+        }
+        Ok(run) => {
+            let output = output_text(&run.stdout, &run.stderr);
+            format!(
+                "Claude prompt failed ({})\n{output}",
+                run.code.unwrap_or(-1)
+            )
+        }
+        Err(error) => format!("Claude prompt failed\n{error}"),
+    }
+}
+
+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 mut exec = format!(
+        "codex exec --cd {} --sandbox workspace-write",
+        sh_quote(&root.display().to_string())
+    );
+    if let Some(model) = settings.model_arg() {
+        exec.push_str(&format!(" --model {}", sh_quote(model)));
+    }
+    exec.push(' ');
+    exec.push_str(&sh_quote(&default_ai_next_prompt(request)));
+    format!("{start}; {exec}")
+}
+
+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() {
+        claude.push_str(&format!(" --model {}", sh_quote(model)));
+    }
+    claude.push_str(" -p ");
+    claude.push_str(&sh_quote(&default_ai_next_prompt(request)));
+    format!(
+        "claude daemon status >/dev/null 2>&1 || true; cd {}; {}",
+        sh_quote(&root.display().to_string()),
+        claude
+    )
+}
+
+fn output_text(stdout: &str, stderr: &str) -> String {
+    [stdout.trim(), stderr.trim()]
+        .into_iter()
+        .filter(|part| !part.is_empty())
+        .collect::<Vec<_>>()
+        .join("\n")
+}