feat: Complete initial REPL implementation with integrated ratatui and crossterm; update TASK.md to reflect progress and add notes on built-in commands

Author: HasanH47

TASK.md

@@ -99,13 +99,15 @@ default_model = "llama-3.3-70b-versatile"
 
 **Goal:** *Basic REPL* PRD: `ratatui` + `crossterm`, log berpikir, perintah built-in awal.
 
-- [ ] Integrasi `ratatui` + `crossterm`
-- [ ] Render *thinking log* + output streaming (sesuai gaya *Terminal UX* PRD)
-- [ ] Riwayat input + state sesi in-memory
-- [ ] Perintah built-in minimal: `/cost`, `/memory`, `/doctor` (sesuai tabel *Built-in Commands* PRD)
+- [x] Integrasi `ratatui` + `crossterm`
+- [x] Render *thinking log* + output streaming (sesuai gaya *Terminal UX* PRD)
+- [x] Riwayat input + state sesi in-memory
+- [x] Perintah built-in minimal: `/cost`, `/memory`, `/doctor` (sesuai tabel *Built-in Commands* PRD)
 
 **Definition of Done:** REPL bisa sesi percakapan singkat dengan log dan tiga perintah di atas.
 
+**Catatan:** `/cost` dan `/memory` berupa stub/jelasan tier sesuai PRD (pelacakan biaya nyata di Sprint 14+; persistensi memori di Sprint 6–7). `/doctor` memakai `doctor::report_lines` yang sama dengan subcommand `cantrik doctor`.
+
 ---
 
 ## Sprint 5 — Codebase intelligence: AST & indexing (Phase 1)

crates/cantrik-cli/Cargo.toml

@@ -12,4 +12,6 @@ path = "src/main.rs"
 cantrik-core = { path = "../cantrik-core" }
 clap.workspace = true
 clap_complete.workspace = true
+crossterm = "0.29.0"
+ratatui = { version = "0.30.0", features = ["crossterm"] }
 tokio.workspace = true

crates/cantrik-cli/src/commands/doctor.rs

@@ -4,18 +4,20 @@ use std::process::ExitCode;
 use cantrik_core::config::{load_merged_config, resolve_config_paths};
 use cantrik_core::llm::{ProviderKind, load_providers_toml, providers_toml_path, resolve_api_key};
 
-pub(crate) fn run(cwd: &Path) -> ExitCode {
+/// Lines for `cantrik doctor` and REPL `/doctor` (same content, no secrets).
+pub(crate) fn report_lines(cwd: &Path) -> Vec<String> {
+    let mut lines = Vec::new();
     let paths = resolve_config_paths(cwd);
     let providers_path = providers_toml_path();
 
-    println!("doctor: Cantrik {}", env!("CARGO_PKG_VERSION"));
-    println!("  global config : {}", paths.global.display());
-    println!("  project config: {}", paths.project.display());
-    println!("  providers.toml: {}", providers_path.display());
+    lines.push(format!("doctor: Cantrik {}", env!("CARGO_PKG_VERSION")));
+    lines.push(format!("  global config : {}", paths.global.display()));
+    lines.push(format!("  project config: {}", paths.project.display()));
+    lines.push(format!("  providers.toml: {}", providers_path.display()));
 
     match load_providers_toml(&providers_path) {
         Ok(prov) => {
-            println!("  providers load: OK");
+            lines.push("  providers load: OK".to_string());
             for kind in ProviderKind::ALL {
                 let status = match kind {
                     ProviderKind::Ollama => "local (no API key required)",
@@ -39,29 +41,45 @@ pub(crate) fn run(cwd: &Path) -> ExitCode {
                         }
                     }
                 };
-                println!("  - {}: {status}", kind.as_str());
+                lines.push(format!("  - {}: {status}", kind.as_str()));
             }
         }
-        Err(e) => println!("  providers: {e}"),
+        Err(e) => lines.push(format!("  providers: {e}")),
     }
 
     match load_merged_config(cwd) {
         Ok(config) => {
-            println!("  config load: OK");
+            lines.push("  config load: OK".to_string());
             if let Some(lang) = config.ui.language.as_deref() {
-                println!("  ui.language  : {lang}");
+                lines.push(format!("  ui.language  : {lang}"));
             }
             if let Some(p) = config.llm.provider.as_deref() {
-                println!("  llm.provider : {p}");
+                lines.push(format!("  llm.provider : {p}"));
             }
             if let Some(m) = config.llm.model.as_deref() {
-                println!("  llm.model    : {m}");
+                lines.push(format!("  llm.model    : {m}"));
             }
-            ExitCode::SUCCESS
         }
-        Err(error) => {
-            eprintln!("  config load: FAILED — {error}");
-            ExitCode::from(1)
+        Err(error) => lines.push(format!("  config load: FAILED — {error}")),
+    }
+
+    lines
+}
+
+pub(crate) fn run(cwd: &Path) -> ExitCode {
+    let lines = report_lines(cwd);
+    let mut config_failed = false;
+    for line in &lines {
+        if line.contains("config load: FAILED") {
+            config_failed = true;
+            eprintln!("{line}");
+        } else {
+            println!("{line}");
         }
     }
+    if config_failed {
+        ExitCode::from(1)
+    } else {
+        ExitCode::SUCCESS
+    }
 }

crates/cantrik-cli/src/lib.rs

@@ -2,8 +2,9 @@
 
 mod cli;
 mod commands;
+mod repl;
 
-use std::io::{self, BufRead, IsTerminal, Read, Write};
+use std::io::{self, IsTerminal, Read};
 use std::path::Path;
 use std::process::ExitCode;
 
@@ -115,7 +116,7 @@ pub async fn run() -> ExitCode {
             }
 
             if io::stdin().is_terminal() {
-                repl_placeholder().await
+                repl_run(cwd).await
             } else {
                 stdin_pipe_ask(&cwd).await
             }
@@ -174,47 +175,26 @@ async fn stdin_pipe_ask(cwd: &Path) -> ExitCode {
     commands::ask::run(&config, &text).await
 }
 
-async fn repl_placeholder() -> ExitCode {
-    let result = tokio::task::spawn_blocking(repl_sync).await;
-    match result {
-        Ok(code) => code,
-        Err(e) => {
-            eprintln!("REPL task failed: {e}");
-            ExitCode::FAILURE
-        }
-    }
-}
-
-fn repl_sync() -> ExitCode {
-    println!(
-        "Cantrik REPL (placeholder). Type 'exit' or 'quit', or Ctrl+D to leave. Full TUI arrives in Sprint 4."
-    );
-    let stdin = io::stdin();
-    let mut line = String::new();
-    loop {
-        line.clear();
-        print!("cantrik> ");
-        let _ = io::stdout().flush();
-        let n = match stdin.lock().read_line(&mut line) {
-            Ok(n) => n,
-            Err(error) => {
-                eprintln!("failed to read line: {error}");
-                return ExitCode::FAILURE;
-            }
-        };
-        if n == 0 {
-            println!();
-            break;
+async fn repl_run(cwd: std::path::PathBuf) -> ExitCode {
+    let config = match load_merged_config(&cwd) {
+        Ok(config) => config,
+        Err(error) => {
+            eprintln!("failed to load config: {error}");
+            return ExitCode::FAILURE;
         }
-        let trimmed = line.trim();
-        if trimmed.eq_ignore_ascii_case("exit") || trimmed.eq_ignore_ascii_case("quit") {
-            break;
+    };
+    let handle = tokio::runtime::Handle::current();
+    match tokio::task::spawn_blocking(move || repl::run_sync(cwd, config, handle)).await {
+        Ok(Ok(())) => ExitCode::SUCCESS,
+        Ok(Err(error)) => {
+            eprintln!("REPL exited with error: {error}");
+            ExitCode::FAILURE
         }
-        if !trimmed.is_empty() {
-            println!("(REPL placeholder) you said: {trimmed}");
+        Err(join_error) => {
+            eprintln!("REPL task failed: {join_error}");
+            ExitCode::FAILURE
         }
     }
-    ExitCode::SUCCESS
 }
 
 #[cfg(test)]