An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.
Rust
Make the REPL resilient enough for real interactive workflows
Yeachan-Heo1104da215ede
diff --git a/rust/crates/rusty-claude-cli/src/app.rs b/rust/crates/rusty-claude-cli/src/app.rsindex 253c2880..b2864a3b 100644--- a/rust/crates/rusty-claude-cli/src/app.rs+++ b/rust/crates/rusty-claude-cli/src/app.rs@@ -2,7 +2,7 @@ use std::io::{self, Write};use std::path::PathBuf;use crate::args::{OutputFormat, PermissionMode};-use crate::input::LineEditor;+use crate::input::{LineEditor, ReadOutcome};use crate::render::{Spinner, TerminalRenderer};use runtime::{ConversationClient, ConversationMessage, RuntimeError, StreamEvent, UsageSummary};@@ -111,16 +111,21 @@ impl CliApp {}pub fn run_repl(&mut self) -> io::Result<()> {- let editor = LineEditor::new("› ");+ let mut editor = LineEditor::new("› ", Vec::new());println!("Rusty Claude CLI interactive mode");println!("Type /help for commands. Shift+Enter or Ctrl+J inserts a newline.");- while let Some(input) = editor.read_line()? {- if input.trim().is_empty() {- continue;+ loop {+ match editor.read_line()? {+ ReadOutcome::Submit(input) => {+ if input.trim().is_empty() {+ continue;+ }+ self.handle_submission(&input, &mut io::stdout())?;+ }+ ReadOutcome::Cancel => continue,+ ReadOutcome::Exit => break,}-- self.handle_submission(&input, &mut io::stdout())?;}Ok(())diff --git a/rust/crates/rusty-claude-cli/src/input.rs b/rust/crates/rusty-claude-cli/src/input.rsindex 3ca982e8..bca37911 100644--- a/rust/crates/rusty-claude-cli/src/input.rs+++ b/rust/crates/rusty-claude-cli/src/input.rs@@ -1,9 +1,8 @@use std::io::{self, IsTerminal, Write};-use crossterm::cursor::MoveToColumn;+use crossterm::cursor::{MoveDown, MoveToColumn, MoveUp};use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyModifiers};use crossterm::queue;-use crossterm::style::Print;use crossterm::terminal::{disable_raw_mode, enable_raw_mode, Clear, ClearType};#[derive(Debug, Clone, PartialEq, Eq)]@@ -85,21 +84,124 @@ impl InputBuffer {self.buffer.clear();self.cursor = 0;}++ pub fn replace(&mut self, value: impl Into<String>) {+ self.buffer = value.into();+ self.cursor = self.buffer.len();+ }++ #[must_use]+ fn current_command_prefix(&self) -> Option<&str> {+ if self.cursor != self.buffer.len() {+ return None;+ }+ let prefix = &self.buffer[..self.cursor];+ if prefix.contains(char::is_whitespace) || !prefix.starts_with('/') {+ return None;+ }+ Some(prefix)+ }++ pub fn complete_slash_command(&mut self, candidates: &[String]) -> bool {+ let Some(prefix) = self.current_command_prefix() else {+ return false;+ };++ let matches = candidates+ .iter()+ .filter(|candidate| candidate.starts_with(prefix))+ .map(String::as_str)+ .collect::<Vec<_>>();+ if matches.is_empty() {+ return false;+ }++ let replacement = longest_common_prefix(&matches);+ if replacement == prefix {+ return false;+ }++ self.replace(replacement);+ true+ }+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub struct RenderedBuffer {+ lines: Vec<String>,+ cursor_row: u16,+ cursor_col: u16,+}++impl RenderedBuffer {+ #[must_use]+ pub fn line_count(&self) -> usize {+ self.lines.len()+ }++ fn write(&self, out: &mut impl Write) -> io::Result<()> {+ for (index, line) in self.lines.iter().enumerate() {+ if index > 0 {+ writeln!(out)?;+ }+ write!(out, "{line}")?;+ }+ Ok(())+ }++ #[cfg(test)]+ #[must_use]+ pub fn lines(&self) -> &[String] {+ &self.lines+ }++ #[cfg(test)]+ #[must_use]+ pub fn cursor_position(&self) -> (u16, u16) {+ (self.cursor_row, self.cursor_col)+ }+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub enum ReadOutcome {+ Submit(String),+ Cancel,+ Exit,}pub struct LineEditor {prompt: String,+ continuation_prompt: String,+ history: Vec<String>,+ history_index: Option<usize>,+ draft: Option<String>,+ completions: Vec<String>,}impl LineEditor {#[must_use]- pub fn new(prompt: impl Into<String>) -> Self {+ pub fn new(prompt: impl Into<String>, completions: Vec<String>) -> Self {Self {prompt: prompt.into(),+ continuation_prompt: String::from("> "),+ history: Vec::new(),+ history_index: None,+ draft: None,+ completions,}}- pub fn read_line(&self) -> io::Result<Option<String>> {+ pub fn push_history(&mut self, entry: impl Into<String>) {+ let entry = entry.into();+ if entry.trim().is_empty() {+ return;+ }+ self.history.push(entry);+ self.history_index = None;+ self.draft = None;+ }++ pub fn read_line(&mut self) -> io::Result<ReadOutcome> {if !io::stdin().is_terminal() || !io::stdout().is_terminal() {return self.read_line_fallback();}@@ -107,29 +209,43 @@ impl LineEditor {enable_raw_mode()?;let mut stdout = io::stdout();let mut input = InputBuffer::new();- self.redraw(&mut stdout, &input)?;+ let mut rendered_lines = 1usize;+ self.redraw(&mut stdout, &input, rendered_lines)?;loop {let event = event::read()?;if let Event::Key(key) = event {- match Self::handle_key(key, &mut input) {- EditorAction::Continue => self.redraw(&mut stdout, &input)?,+ match self.handle_key(key, &mut input) {+ EditorAction::Continue => {+ rendered_lines = self.redraw(&mut stdout, &input, rendered_lines)?;+ }EditorAction::Submit => {disable_raw_mode()?;writeln!(stdout)?;- return Ok(Some(input.as_str().to_owned()));+ self.history_index = None;+ self.draft = None;+ return Ok(ReadOutcome::Submit(input.as_str().to_owned()));}EditorAction::Cancel => {disable_raw_mode()?;writeln!(stdout)?;- return Ok(None);+ self.history_index = None;+ self.draft = None;+ return Ok(ReadOutcome::Cancel);+ }+ EditorAction::Exit => {+ disable_raw_mode()?;+ writeln!(stdout)?;+ self.history_index = None;+ self.draft = None;+ return Ok(ReadOutcome::Exit);}}}}}- fn read_line_fallback(&self) -> io::Result<Option<String>> {+ fn read_line_fallback(&self) -> io::Result<ReadOutcome> {let mut stdout = io::stdout();write!(stdout, "{}", self.prompt)?;stdout.flush()?;@@ -137,22 +253,32 @@ impl LineEditor {let mut buffer = String::new();let bytes_read = io::stdin().read_line(&mut buffer)?;if bytes_read == 0 {- return Ok(None);+ return Ok(ReadOutcome::Exit);}while matches!(buffer.chars().last(), Some('\n' | '\r')) {buffer.pop();}- Ok(Some(buffer))+ Ok(ReadOutcome::Submit(buffer))}- fn handle_key(key: KeyEvent, input: &mut InputBuffer) -> EditorAction {+ #[allow(clippy::too_many_lines)]+ fn handle_key(&mut self, key: KeyEvent, input: &mut InputBuffer) -> EditorAction {match key {KeyEvent {code: KeyCode::Char('c'),modifiers,..- } if modifiers.contains(KeyModifiers::CONTROL) => EditorAction::Cancel,+ } if modifiers.contains(KeyModifiers::CONTROL) => {+ if input.as_str().is_empty() {+ EditorAction::Exit+ } else {+ input.clear();+ self.history_index = None;+ self.draft = None;+ EditorAction::Cancel+ }+ }KeyEvent {code: KeyCode::Char('j'),modifiers,@@ -194,6 +320,25 @@ impl LineEditor {input.move_right();EditorAction::Continue}+ KeyEvent {+ code: KeyCode::Up, ..+ } => {+ self.navigate_history_up(input);+ EditorAction::Continue+ }+ KeyEvent {+ code: KeyCode::Down,+ ..+ } => {+ self.navigate_history_down(input);+ EditorAction::Continue+ }+ KeyEvent {+ code: KeyCode::Tab, ..+ } => {+ input.complete_slash_command(&self.completions);+ EditorAction::Continue+ }KeyEvent {code: KeyCode::Home,..@@ -211,6 +356,8 @@ impl LineEditor {code: KeyCode::Esc, ..} => {input.clear();+ self.history_index = None;+ self.draft = None;EditorAction::Cancel}KeyEvent {@@ -219,22 +366,74 @@ impl LineEditor {..} if modifiers.is_empty() || modifiers == KeyModifiers::SHIFT => {input.insert(ch);+ self.history_index = None;+ self.draft = None;EditorAction::Continue}_ => EditorAction::Continue,}}- fn redraw(&self, out: &mut impl Write, input: &InputBuffer) -> io::Result<()> {- let display = input.as_str().replace('\n', "\\n\n> ");+ fn navigate_history_up(&mut self, input: &mut InputBuffer) {+ if self.history.is_empty() {+ return;+ }++ match self.history_index {+ Some(0) => {}+ Some(index) => {+ let next_index = index - 1;+ input.replace(self.history[next_index].clone());+ self.history_index = Some(next_index);+ }+ None => {+ self.draft = Some(input.as_str().to_owned());+ let next_index = self.history.len() - 1;+ input.replace(self.history[next_index].clone());+ self.history_index = Some(next_index);+ }+ }+ }++ fn navigate_history_down(&mut self, input: &mut InputBuffer) {+ let Some(index) = self.history_index else {+ return;+ };++ if index + 1 < self.history.len() {+ let next_index = index + 1;+ input.replace(self.history[next_index].clone());+ self.history_index = Some(next_index);+ return;+ }++ input.replace(self.draft.take().unwrap_or_default());+ self.history_index = None;+ }++ fn redraw(+ &self,+ out: &mut impl Write,+ input: &InputBuffer,+ previous_line_count: usize,+ ) -> io::Result<usize> {+ let rendered = render_buffer(&self.prompt, &self.continuation_prompt, input);+ if previous_line_count > 1 {+ queue!(out, MoveUp(saturating_u16(previous_line_count - 1)))?;+ }+ queue!(out, MoveToColumn(0), Clear(ClearType::FromCursorDown),)?;+ rendered.write(out)?;queue!(out,+ MoveUp(saturating_u16(rendered.line_count().saturating_sub(1))),MoveToColumn(0),- Clear(ClearType::CurrentLine),- Print(&self.prompt),- Print(display),)?;- out.flush()+ if rendered.cursor_row > 0 {+ queue!(out, MoveDown(rendered.cursor_row))?;+ }+ queue!(out, MoveToColumn(rendered.cursor_col))?;+ out.flush()?;+ Ok(rendered.line_count())}}@@ -243,11 +442,76 @@ enum EditorAction {Continue,Submit,Cancel,+ Exit,+}++#[must_use]+pub fn render_buffer(+ prompt: &str,+ continuation_prompt: &str,+ input: &InputBuffer,+) -> RenderedBuffer {+ let before_cursor = &input.as_str()[..input.cursor];+ let cursor_row = saturating_u16(before_cursor.chars().filter(|ch| *ch == '\n').count());+ let cursor_line = before_cursor.rsplit('\n').next().unwrap_or_default();+ let cursor_prompt = if cursor_row == 0 {+ prompt+ } else {+ continuation_prompt+ };+ let cursor_col = saturating_u16(cursor_prompt.chars().count() + cursor_line.chars().count());++ let mut lines = Vec::new();+ for (index, line) in input.as_str().split('\n').enumerate() {+ let prefix = if index == 0 {+ prompt+ } else {+ continuation_prompt+ };+ lines.push(format!("{prefix}{line}"));+ }+ if lines.is_empty() {+ lines.push(prompt.to_string());+ }++ RenderedBuffer {+ lines,+ cursor_row,+ cursor_col,+ }+}++#[must_use]+fn longest_common_prefix(values: &[&str]) -> String {+ let Some(first) = values.first() else {+ return String::new();+ };++ let mut prefix = (*first).to_string();+ for value in values.iter().skip(1) {+ while !value.starts_with(&prefix) {+ prefix.pop();+ if prefix.is_empty() {+ break;+ }+ }+ }+ prefix+}++#[must_use]+fn saturating_u16(value: usize) -> u16 {+ u16::try_from(value).unwrap_or(u16::MAX)}#[cfg(test)]mod tests {- use super::InputBuffer;+ use super::{render_buffer, InputBuffer, LineEditor};+ use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};++ fn key(code: KeyCode) -> KeyEvent {+ KeyEvent::new(code, KeyModifiers::NONE)+ }#[test]fn supports_basic_line_editing() {@@ -266,4 +530,119 @@ mod tests {assert_eq!(input.as_str(), "hix");assert_eq!(input.cursor(), 2);}++ #[test]+ fn completes_unique_slash_command() {+ let mut input = InputBuffer::new();+ for ch in "/he".chars() {+ input.insert(ch);+ }++ assert!(input.complete_slash_command(&[+ "/help".to_string(),+ "/hello".to_string(),+ "/status".to_string(),+ ]));+ assert_eq!(input.as_str(), "/hel");++ assert!(input.complete_slash_command(&["/help".to_string(), "/status".to_string()]));+ assert_eq!(input.as_str(), "/help");+ }++ #[test]+ fn ignores_completion_when_prefix_is_not_a_slash_command() {+ let mut input = InputBuffer::new();+ for ch in "hello".chars() {+ input.insert(ch);+ }++ assert!(!input.complete_slash_command(&["/help".to_string()]));+ assert_eq!(input.as_str(), "hello");+ }++ #[test]+ fn history_navigation_restores_current_draft() {+ let mut editor = LineEditor::new("› ", vec![]);+ editor.push_history("/help");+ editor.push_history("status report");++ let mut input = InputBuffer::new();+ for ch in "draft".chars() {+ input.insert(ch);+ }++ let _ = editor.handle_key(key(KeyCode::Up), &mut input);+ assert_eq!(input.as_str(), "status report");++ let _ = editor.handle_key(key(KeyCode::Up), &mut input);+ assert_eq!(input.as_str(), "/help");++ let _ = editor.handle_key(key(KeyCode::Down), &mut input);+ assert_eq!(input.as_str(), "status report");++ let _ = editor.handle_key(key(KeyCode::Down), &mut input);+ assert_eq!(input.as_str(), "draft");+ }++ #[test]+ fn tab_key_completes_from_editor_candidates() {+ let mut editor = LineEditor::new(+ "› ",+ vec![+ "/help".to_string(),+ "/status".to_string(),+ "/session".to_string(),+ ],+ );+ let mut input = InputBuffer::new();+ for ch in "/st".chars() {+ input.insert(ch);+ }++ let _ = editor.handle_key(key(KeyCode::Tab), &mut input);+ assert_eq!(input.as_str(), "/status");+ }++ #[test]+ fn renders_multiline_buffers_with_continuation_prompt() {+ let mut input = InputBuffer::new();+ for ch in "hello\nworld".chars() {+ if ch == '\n' {+ input.insert_newline();+ } else {+ input.insert(ch);+ }+ }++ let rendered = render_buffer("› ", "> ", &input);+ assert_eq!(+ rendered.lines(),+ &["› hello".to_string(), "> world".to_string()]+ );+ assert_eq!(rendered.cursor_position(), (1, 7));+ }++ #[test]+ fn ctrl_c_exits_only_when_buffer_is_empty() {+ let mut editor = LineEditor::new("› ", vec![]);+ let mut empty = InputBuffer::new();+ assert!(matches!(+ editor.handle_key(+ KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL),+ &mut empty,+ ),+ super::EditorAction::Exit+ ));++ let mut filled = InputBuffer::new();+ filled.insert('x');+ assert!(matches!(+ editor.handle_key(+ KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL),+ &mut filled,+ ),+ super::EditorAction::Cancel+ ));+ assert!(filled.as_str().is_empty());+ }}diff --git a/rust/crates/rusty-claude-cli/src/main.rs b/rust/crates/rusty-claude-cli/src/main.rsindex a8a28bdd..3002bf9e 100644--- a/rust/crates/rusty-claude-cli/src/main.rs+++ b/rust/crates/rusty-claude-cli/src/main.rs@@ -14,7 +14,9 @@ use api::{ToolResultContentBlock,};-use commands::{render_slash_command_help, resume_supported_slash_commands, SlashCommand};+use commands::{+ render_slash_command_help, resume_supported_slash_commands, slash_command_specs, SlashCommand,+};use compat_harness::{extract_manifest, UpstreamPaths};use render::{Spinner, TerminalRenderer};use runtime::{@@ -716,22 +718,35 @@ fn run_repl(allowed_tools: Option<AllowedToolSet>,) -> Result<(), Box<dyn std::error::Error>> {let mut cli = LiveCli::new(model, true, allowed_tools)?;- let editor = input::LineEditor::new("› ");+ let mut editor = input::LineEditor::new("› ", slash_command_completion_candidates());println!("{}", cli.startup_banner());- while let Some(input) = editor.read_line()? {- let trimmed = input.trim();- if trimmed.is_empty() {- continue;- }- if matches!(trimmed, "/exit" | "/quit") {- break;- }- if let Some(command) = SlashCommand::parse(trimmed) {- cli.handle_repl_command(command)?;- continue;+ loop {+ match editor.read_line()? {+ input::ReadOutcome::Submit(input) => {+ let trimmed = input.trim().to_string();+ if trimmed.is_empty() {+ continue;+ }+ if matches!(trimmed.as_str(), "/exit" | "/quit") {+ cli.persist_session()?;+ break;+ }+ if let Some(command) = SlashCommand::parse(&trimmed) {+ if cli.handle_repl_command(command)? {+ cli.persist_session()?;+ }+ continue;+ }+ editor.push_history(input);+ cli.run_turn(&trimmed)?;+ }+ input::ReadOutcome::Cancel => {}+ input::ReadOutcome::Exit => {+ cli.persist_session()?;+ break;+ }}- cli.run_turn(trimmed)?;}Ok(())@@ -885,28 +900,60 @@ impl LiveCli {fn handle_repl_command(&mut self,command: SlashCommand,- ) -> Result<(), Box<dyn std::error::Error>> {- match command {- SlashCommand::Help => println!("{}", render_repl_help()),- SlashCommand::Status => self.print_status(),- SlashCommand::Compact => self.compact()?,+ ) -> Result<bool, Box<dyn std::error::Error>> {+ Ok(match command {+ SlashCommand::Help => {+ println!("{}", render_repl_help());+ false+ }+ SlashCommand::Status => {+ self.print_status();+ false+ }+ SlashCommand::Compact => {+ self.compact()?;+ false+ }SlashCommand::Model { model } => self.set_model(model)?,SlashCommand::Permissions { mode } => self.set_permissions(mode)?,SlashCommand::Clear { confirm } => self.clear_session(confirm)?,- SlashCommand::Cost => self.print_cost(),+ SlashCommand::Cost => {+ self.print_cost();+ false+ }SlashCommand::Resume { session_path } => self.resume_session(session_path)?,- SlashCommand::Config { section } => Self::print_config(section.as_deref())?,- SlashCommand::Memory => Self::print_memory()?,- SlashCommand::Init => Self::run_init()?,- SlashCommand::Diff => Self::print_diff()?,- SlashCommand::Version => Self::print_version(),- SlashCommand::Export { path } => self.export_session(path.as_deref())?,+ SlashCommand::Config { section } => {+ Self::print_config(section.as_deref())?;+ false+ }+ SlashCommand::Memory => {+ Self::print_memory()?;+ false+ }+ SlashCommand::Init => {+ Self::run_init()?;+ false+ }+ SlashCommand::Diff => {+ Self::print_diff()?;+ false+ }+ SlashCommand::Version => {+ Self::print_version();+ false+ }+ SlashCommand::Export { path } => {+ self.export_session(path.as_deref())?;+ false+ }SlashCommand::Session { action, target } => {- self.handle_session_command(action.as_deref(), target.as_deref())?;+ self.handle_session_command(action.as_deref(), target.as_deref())?}- SlashCommand::Unknown(name) => eprintln!("unknown slash command: /{name}"),- }- Ok(())+ SlashCommand::Unknown(name) => {+ eprintln!("unknown slash command: /{name}");+ false+ }+ })}fn persist_session(&self) -> Result<(), Box<dyn std::error::Error>> {@@ -934,7 +981,7 @@ impl LiveCli {);}- fn set_model(&mut self, model: Option<String>) -> Result<(), Box<dyn std::error::Error>> {+ fn set_model(&mut self, model: Option<String>) -> Result<bool, Box<dyn std::error::Error>> {let Some(model) = model else {println!("{}",@@ -944,7 +991,7 @@ impl LiveCli {self.runtime.usage().turns(),));- return Ok(());+ return Ok(false);};if model == self.model {@@ -956,7 +1003,7 @@ impl LiveCli {self.runtime.usage().turns(),));- return Ok(());+ return Ok(false);}let previous = self.model.clone();@@ -970,18 +1017,20 @@ impl LiveCli {self.allowed_tools.clone(),)?;self.model.clone_from(&model);- self.persist_session()?;println!("{}",format_model_switch_report(&previous, &model, message_count));- Ok(())+ Ok(true)}- fn set_permissions(&mut self, mode: Option<String>) -> Result<(), Box<dyn std::error::Error>> {+ fn set_permissions(+ &mut self,+ mode: Option<String>,+ ) -> Result<bool, Box<dyn std::error::Error>> {let Some(mode) = mode else {println!("{}", format_permissions_report(permission_mode_label()));- return Ok(());+ return Ok(false);};let normalized = normalize_permission_mode(&mode).ok_or_else(|| {@@ -992,7 +1041,7 @@ impl LiveCli {if normalized == permission_mode_label() {println!("{}", format_permissions_report(normalized));- return Ok(());+ return Ok(false);}let previous = permission_mode_label().to_string();@@ -1005,20 +1054,19 @@ impl LiveCli {self.allowed_tools.clone(),normalized,)?;- self.persist_session()?;println!("{}",format_permissions_switch_report(&previous, normalized));- Ok(())+ Ok(true)}- fn clear_session(&mut self, confirm: bool) -> Result<(), Box<dyn std::error::Error>> {+ fn clear_session(&mut self, confirm: bool) -> Result<bool, Box<dyn std::error::Error>> {if !confirm {println!("clear: confirmation required; run /clear --confirm to start a fresh session.");- return Ok(());+ return Ok(false);}self.session = create_managed_session_handle()?;@@ -1030,14 +1078,13 @@ impl LiveCli {self.allowed_tools.clone(),permission_mode_label(),)?;- self.persist_session()?;println!("Session cleared\n Mode fresh session\n Preserved model {}\n Permission mode {}\n Session {}",self.model,permission_mode_label(),self.session.id,);- Ok(())+ Ok(true)}fn print_cost(&self) {@@ -1048,10 +1095,10 @@ impl LiveCli {fn resume_session(&mut self,session_path: Option<String>,- ) -> Result<(), Box<dyn std::error::Error>> {+ ) -> Result<bool, Box<dyn std::error::Error>> {let Some(session_ref) = session_path else {println!("Usage: /resume <session-path>");- return Ok(());+ return Ok(false);};let handle = resolve_session_reference(&session_ref)?;@@ -1066,7 +1113,6 @@ impl LiveCli {permission_mode_label(),)?;self.session = handle;- self.persist_session()?;println!("{}",format_resume_report(@@ -1075,7 +1121,7 @@ impl LiveCli {self.runtime.usage().turns(),));- Ok(())+ Ok(true)}fn print_config(section: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {@@ -1120,16 +1166,16 @@ impl LiveCli {&mut self,action: Option<&str>,target: Option<&str>,- ) -> Result<(), Box<dyn std::error::Error>> {+ ) -> Result<bool, Box<dyn std::error::Error>> {match action {None | Some("list") => {println!("{}", render_session_list(&self.session.id)?);- Ok(())+ Ok(false)}Some("switch") => {let Some(target) = target else {println!("Usage: /session switch <session-id>");- return Ok(());+ return Ok(false);};let handle = resolve_session_reference(target)?;let session = Session::load_from_path(&handle.path)?;@@ -1143,18 +1189,17 @@ impl LiveCli {permission_mode_label(),)?;self.session = handle;- self.persist_session()?;println!("Session switched\n Active session {}\n File {}\n Messages {}",self.session.id,self.session.path.display(),message_count,);- Ok(())+ Ok(true)}Some(other) => {println!("Unknown /session action '{other}'. Use /session list or /session switch <session-id>.");- Ok(())+ Ok(false)}}}@@ -1283,6 +1328,10 @@ fn render_repl_help() -> String {"REPL".to_string()," /exit Quit the REPL".to_string()," /quit Quit the REPL".to_string(),+ " Up/Down Navigate prompt history".to_string(),+ " Tab Complete slash commands".to_string(),+ " Ctrl-C Clear input (or exit on empty prompt)".to_string(),+ " Shift+Enter/Ctrl+J Insert a newline".to_string(),String::new(),render_slash_command_help(),]@@ -1866,6 +1915,63 @@ impl ApiClient for AnthropicRuntimeClient {}}+fn slash_command_completion_candidates() -> Vec<String> {+ slash_command_specs()+ .iter()+ .map(|spec| format!("/{}", spec.name))+ .collect()+}++fn format_tool_call_start(name: &str, input: &str) -> String {+ format!(+ "Tool call+ Name {name}+ Input {}",+ summarize_tool_payload(input)+ )+}++fn format_tool_result(name: &str, output: &str, is_error: bool) -> String {+ let status = if is_error { "error" } else { "ok" };+ format!(+ "### Tool `{name}`++- Status: {status}+- Output:++```json+{}+```+",+ prettify_tool_payload(output)+ )+}++fn summarize_tool_payload(payload: &str) -> String {+ let compact = match serde_json::from_str::<serde_json::Value>(payload) {+ Ok(value) => value.to_string(),+ Err(_) => payload.trim().to_string(),+ };+ truncate_for_summary(&compact, 96)+}++fn prettify_tool_payload(payload: &str) -> String {+ match serde_json::from_str::<serde_json::Value>(payload) {+ Ok(value) => serde_json::to_string_pretty(&value).unwrap_or_else(|_| payload.to_string()),+ Err(_) => payload.to_string(),+ }+}++fn truncate_for_summary(value: &str, limit: usize) -> String {+ let mut chars = value.chars();+ let truncated = chars.by_ref().take(limit).collect::<String>();+ if chars.next().is_some() {+ format!("{truncated}…")+ } else {+ truncated+ }+}+fn push_output_block(block: OutputContentBlock,out: &mut impl Write,@@ -1882,6 +1988,14 @@ fn push_output_block(}}OutputContentBlock::ToolUse { id, name, input } => {+ writeln!(+ out,+ "+{}",+ format_tool_call_start(&name, &input.to_string())+ )+ .and_then(|()| out.flush())+ .map_err(|error| RuntimeError::new(error.to_string()))?;*pending_tool = Some((id, name, input.to_string()));}}@@ -1941,13 +2055,19 @@ impl ToolExecutor for CliToolExecutor {.map_err(|error| ToolError::new(format!("invalid tool input JSON: {error}")))?;match execute_tool(tool_name, &value) {Ok(output) => {- let markdown = format!("### Tool `{tool_name}`\n\n```json\n{output}\n```\n");+ let markdown = format_tool_result(tool_name, &output, false);self.renderer.stream_markdown(&markdown, &mut io::stdout()).map_err(|error| ToolError::new(error.to_string()))?;Ok(output)}- Err(error) => Err(ToolError::new(error)),+ Err(error) => {+ let markdown = format_tool_result(tool_name, &error, true);+ self.renderer+ .stream_markdown(&markdown, &mut io::stdout())+ .map_err(|stream_error| ToolError::new(stream_error.to_string()))?;+ Err(ToolError::new(error))+ }}}}@@ -2051,10 +2171,10 @@ mod tests {filter_tool_specs, format_compact_report, format_cost_report, format_init_report,format_model_report, format_model_switch_report, format_permissions_report,format_permissions_switch_report, format_resume_report, format_status_report,- normalize_permission_mode, parse_args, parse_git_status_metadata, render_config_report,- render_init_claude_md, render_memory_report, render_repl_help,- resume_supported_slash_commands, status_context, CliAction, CliOutputFormat, SlashCommand,- StatusUsage, DEFAULT_MODEL,+ format_tool_call_start, format_tool_result, normalize_permission_mode, parse_args,+ parse_git_status_metadata, render_config_report, render_init_claude_md,+ render_memory_report, render_repl_help, resume_supported_slash_commands, status_context,+ CliAction, CliOutputFormat, SlashCommand, StatusUsage, DEFAULT_MODEL,};use runtime::{ContentBlock, ConversationMessage, MessageRole};use std::path::{Path, PathBuf};@@ -2516,4 +2636,22 @@ mod tests {assert_eq!(converted[1].role, "assistant");assert_eq!(converted[2].role, "user");}+ #[test]+ fn repl_help_mentions_history_completion_and_multiline() {+ let help = render_repl_help();+ assert!(help.contains("Up/Down"));+ assert!(help.contains("Tab"));+ assert!(help.contains("Shift+Enter/Ctrl+J"));+ }++ #[test]+ fn tool_rendering_helpers_compact_output() {+ let start = format_tool_call_start("read_file", r#"{"path":"src/main.rs"}"#);+ assert!(start.contains("Tool call"));+ assert!(start.contains("src/main.rs"));++ let done = format_tool_result("read_file", r#"{"contents":"hello"}"#, false);+ assert!(done.contains("Tool `read_file`"));+ assert!(done.contains("contents"));+ }}