An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.
Rust
Finish the Rust CLI command surface for everyday session workflows
Yeachan-Heo96b19baf9db0
diff --git a/rust/crates/commands/src/lib.rs b/rust/crates/commands/src/lib.rsindex 3cd9d6d6..b396bb03 100644--- a/rust/crates/commands/src/lib.rs+++ b/rust/crates/commands/src/lib.rs@@ -105,6 +105,30 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[argument_hint: None,resume_supported: true,},+ SlashCommandSpec {+ name: "diff",+ summary: "Show git diff for current workspace changes",+ argument_hint: None,+ resume_supported: true,+ },+ SlashCommandSpec {+ name: "version",+ summary: "Show CLI version and build information",+ argument_hint: None,+ resume_supported: true,+ },+ SlashCommandSpec {+ name: "export",+ summary: "Export the current conversation to a file",+ argument_hint: Some("[file]"),+ resume_supported: true,+ },+ SlashCommandSpec {+ name: "session",+ summary: "List or switch managed local sessions",+ argument_hint: Some("[list|switch <session-id>]"),+ resume_supported: false,+ },];#[derive(Debug, Clone, PartialEq, Eq)]@@ -112,14 +136,33 @@ pub enum SlashCommand {Help,Status,Compact,- Model { model: Option<String> },- Permissions { mode: Option<String> },- Clear { confirm: bool },+ Model {+ model: Option<String>,+ },+ Permissions {+ mode: Option<String>,+ },+ Clear {+ confirm: bool,+ },Cost,- Resume { session_path: Option<String> },- Config { section: Option<String> },+ Resume {+ session_path: Option<String>,+ },+ Config {+ section: Option<String>,+ },Memory,Init,+ Diff,+ Version,+ Export {+ path: Option<String>,+ },+ Session {+ action: Option<String>,+ target: Option<String>,+ },Unknown(String),}@@ -155,6 +198,15 @@ impl SlashCommand {},"memory" => Self::Memory,"init" => Self::Init,+ "diff" => Self::Diff,+ "version" => Self::Version,+ "export" => Self::Export {+ path: parts.next().map(ToOwned::to_owned),+ },+ "session" => Self::Session {+ action: parts.next().map(ToOwned::to_owned),+ target: parts.next().map(ToOwned::to_owned),+ },other => Self::Unknown(other.to_string()),})}@@ -235,6 +287,10 @@ pub fn handle_slash_command(| SlashCommand::Config { .. }| SlashCommand::Memory| SlashCommand::Init+ | SlashCommand::Diff+ | SlashCommand::Version+ | SlashCommand::Export { .. }+ | SlashCommand::Session { .. }| SlashCommand::Unknown(_) => None,}}@@ -294,6 +350,21 @@ mod tests {);assert_eq!(SlashCommand::parse("/memory"), Some(SlashCommand::Memory));assert_eq!(SlashCommand::parse("/init"), Some(SlashCommand::Init));+ assert_eq!(SlashCommand::parse("/diff"), Some(SlashCommand::Diff));+ assert_eq!(SlashCommand::parse("/version"), Some(SlashCommand::Version));+ assert_eq!(+ SlashCommand::parse("/export notes.txt"),+ Some(SlashCommand::Export {+ path: Some("notes.txt".to_string())+ })+ );+ assert_eq!(+ SlashCommand::parse("/session switch abc123"),+ Some(SlashCommand::Session {+ action: Some("switch".to_string()),+ target: Some("abc123".to_string())+ })+ );}#[test]@@ -311,8 +382,12 @@ mod tests {assert!(help.contains("/config [env|hooks|model]"));assert!(help.contains("/memory"));assert!(help.contains("/init"));- assert_eq!(slash_command_specs().len(), 11);- assert_eq!(resume_supported_slash_commands().len(), 8);+ assert!(help.contains("/diff"));+ assert!(help.contains("/version"));+ assert!(help.contains("/export [file]"));+ assert!(help.contains("/session [list|switch <session-id>]"));+ assert_eq!(slash_command_specs().len(), 15);+ assert_eq!(resume_supported_slash_commands().len(), 11);}#[test]@@ -384,5 +459,14 @@ mod tests {assert!(handle_slash_command("/config env", &session, CompactionConfig::default()).is_none());+ assert!(handle_slash_command("/diff", &session, CompactionConfig::default()).is_none());+ assert!(handle_slash_command("/version", &session, CompactionConfig::default()).is_none());+ assert!(+ handle_slash_command("/export note.txt", &session, CompactionConfig::default())+ .is_none()+ );+ assert!(+ handle_slash_command("/session list", &session, CompactionConfig::default()).is_none()+ );}}diff --git a/rust/crates/rusty-claude-cli/src/main.rs b/rust/crates/rusty-claude-cli/src/main.rsindex a2e242b7..afbd550b 100644--- a/rust/crates/rusty-claude-cli/src/main.rs+++ b/rust/crates/rusty-claude-cli/src/main.rs@@ -5,6 +5,7 @@ use std::env;use std::fs;use std::io::{self, Write};use std::path::{Path, PathBuf};+use std::time::{SystemTime, UNIX_EPOCH};use api::{AnthropicClient, ContentBlockDelta, InputContentBlock, InputMessage, MessageRequest,@@ -21,15 +22,23 @@ use runtime::{PermissionMode, PermissionPolicy, ProjectContext, RuntimeError, Session, TokenUsage, ToolError,ToolExecutor, UsageTracker,};+use serde_json::json;use tools::{execute_tool, mvp_tool_specs};const DEFAULT_MODEL: &str = "claude-sonnet-4-20250514";const DEFAULT_MAX_TOKENS: u32 = 32;const DEFAULT_DATE: &str = "2026-03-31";+const VERSION: &str = env!("CARGO_PKG_VERSION");+const BUILD_TARGET: Option<&str> = option_env!("TARGET");+const GIT_SHA: Option<&str> = option_env!("GIT_SHA");fn main() {if let Err(error) = run() {- eprintln!("{error}");+ eprintln!(+ "error: {error}++Run `rusty-claude-cli --help` for usage."+ );std::process::exit(1);}}@@ -44,7 +53,11 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {session_path,commands,} => resume_session(&session_path, &commands),- CliAction::Prompt { prompt, model } => LiveCli::new(model, false)?.run_turn(&prompt)?,+ CliAction::Prompt {+ prompt,+ model,+ output_format,+ } => LiveCli::new(model, false)?.run_turn_with_output(&prompt, output_format)?,CliAction::Repl { model } => run_repl(model)?,CliAction::Help => print_help(),}@@ -66,15 +79,36 @@ enum CliAction {Prompt {prompt: String,model: String,+ output_format: CliOutputFormat,},Repl {model: String,},+ // prompt-mode formatting is only supported for non-interactive runsHelp,}+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+enum CliOutputFormat {+ Text,+ Json,+}++impl CliOutputFormat {+ fn parse(value: &str) -> Result<Self, String> {+ match value {+ "text" => Ok(Self::Text),+ "json" => Ok(Self::Json),+ other => Err(format!(+ "unsupported value for --output-format: {other} (expected text or json)"+ )),+ }+ }+}+fn parse_args(args: &[String]) -> Result<CliAction, String> {let mut model = DEFAULT_MODEL.to_string();+ let mut output_format = CliOutputFormat::Text;let mut rest = Vec::new();let mut index = 0;@@ -91,6 +125,17 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {model = flag[8..].to_string();index += 1;}+ "--output-format" => {+ let value = args+ .get(index + 1)+ .ok_or_else(|| "missing value for --output-format".to_string())?;+ output_format = CliOutputFormat::parse(value)?;+ index += 2;+ }+ flag if flag.starts_with("--output-format=") => {+ output_format = CliOutputFormat::parse(&flag[16..])?;+ index += 1;+ }other => {rest.push(other.to_string());index += 1;@@ -117,8 +162,17 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {if prompt.trim().is_empty() {return Err("prompt subcommand requires a prompt string".to_string());}- Ok(CliAction::Prompt { prompt, model })+ Ok(CliAction::Prompt {+ prompt,+ model,+ output_format,+ })}+ other if !other.starts_with('/') => Ok(CliAction::Prompt {+ prompt: rest.join(" "),+ model,+ output_format,+ }),other => Err(format!("unknown subcommand: {other}")),}}@@ -441,6 +495,7 @@ fn find_git_root() -> Result<PathBuf, Box<dyn std::error::Error>> {Ok(PathBuf::from(path))}+#[allow(clippy::too_many_lines)]fn run_resume_command(session_path: &Path,session: &Session,@@ -525,9 +580,30 @@ fn run_resume_command(session: session.clone(),message: Some(init_claude_md()?),}),+ SlashCommand::Diff => Ok(ResumeCommandOutcome {+ session: session.clone(),+ message: Some(render_diff_report()?),+ }),+ SlashCommand::Version => Ok(ResumeCommandOutcome {+ session: session.clone(),+ message: Some(render_version_report()),+ }),+ SlashCommand::Export { path } => {+ let export_path = resolve_export_path(path.as_deref(), session)?;+ fs::write(&export_path, render_export_text(session))?;+ Ok(ResumeCommandOutcome {+ session: session.clone(),+ message: Some(format!(+ "Export\n Result wrote transcript\n File {}\n Messages {}",+ export_path.display(),+ session.messages.len(),+ )),+ })+ }SlashCommand::Resume { .. }| SlashCommand::Model { .. }| SlashCommand::Permissions { .. }+ | SlashCommand::Session { .. }| SlashCommand::Unknown(_) => Err("unsupported resumed slash command".into()),}}@@ -535,8 +611,7 @@ fn run_resume_command(fn run_repl(model: String) -> Result<(), Box<dyn std::error::Error>> {let mut cli = LiveCli::new(model, true)?;let editor = input::LineEditor::new("› ");- println!("Rusty Claude CLI interactive mode");- println!("Type /help for commands. Shift+Enter or Ctrl+J inserts a newline.");+ println!("{}", cli.startup_banner());while let Some(input) = editor.read_line()? {let trimmed = input.trim();@@ -556,26 +631,57 @@ fn run_repl(model: String) -> Result<(), Box<dyn std::error::Error>> {Ok(())}+#[derive(Debug, Clone)]+struct SessionHandle {+ id: String,+ path: PathBuf,+}++#[derive(Debug, Clone)]+struct ManagedSessionSummary {+ id: String,+ path: PathBuf,+ modified_epoch_secs: u64,+ message_count: usize,+}+struct LiveCli {model: String,system_prompt: Vec<String>,runtime: ConversationRuntime<AnthropicRuntimeClient, CliToolExecutor>,+ session: SessionHandle,}impl LiveCli {fn new(model: String, enable_tools: bool) -> Result<Self, Box<dyn std::error::Error>> {let system_prompt = build_system_prompt()?;+ let session = create_managed_session_handle()?;let runtime = build_runtime(Session::new(),model.clone(),system_prompt.clone(),enable_tools,)?;- Ok(Self {+ let cli = Self {model,system_prompt,runtime,- })+ session,+ };+ cli.persist_session()?;+ Ok(cli)+ }++ fn startup_banner(&self) -> String {+ format!(+ "Rusty Claude CLI\n Model {}\n Working directory {}\n Session {}\n\nType /help for commands. Shift+Enter or Ctrl+J inserts a newline.",+ self.model,+ env::current_dir().map_or_else(+ |_| "<unknown>".to_string(),+ |path| path.display().to_string(),+ ),+ self.session.id,+ )}fn run_turn(&mut self, input: &str) -> Result<(), Box<dyn std::error::Error>> {@@ -595,6 +701,7 @@ impl LiveCli {&mut stdout,)?;println!();+ self.persist_session()?;Ok(())}Err(error) => {@@ -608,6 +715,60 @@ impl LiveCli {}}+ fn run_turn_with_output(+ &mut self,+ input: &str,+ output_format: CliOutputFormat,+ ) -> Result<(), Box<dyn std::error::Error>> {+ match output_format {+ CliOutputFormat::Text => self.run_turn(input),+ CliOutputFormat::Json => self.run_prompt_json(input),+ }+ }++ fn run_prompt_json(&mut self, input: &str) -> Result<(), Box<dyn std::error::Error>> {+ let client = AnthropicClient::from_env()?;+ let request = MessageRequest {+ model: self.model.clone(),+ max_tokens: DEFAULT_MAX_TOKENS,+ messages: vec![InputMessage {+ role: "user".to_string(),+ content: vec![InputContentBlock::Text {+ text: input.to_string(),+ }],+ }],+ system: (!self.system_prompt.is_empty()).then(|| self.system_prompt.join("\n\n")),+ tools: None,+ tool_choice: None,+ stream: false,+ };+ let runtime = tokio::runtime::Runtime::new()?;+ let response = runtime.block_on(client.send_message(&request))?;+ let text = response+ .content+ .iter()+ .filter_map(|block| match block {+ OutputContentBlock::Text { text } => Some(text.as_str()),+ OutputContentBlock::ToolUse { .. } => None,+ })+ .collect::<Vec<_>>()+ .join("");+ println!(+ "{}",+ json!({+ "message": text,+ "model": self.model,+ "usage": {+ "input_tokens": response.usage.input_tokens,+ "output_tokens": response.usage.output_tokens,+ "cache_creation_input_tokens": response.usage.cache_creation_input_tokens,+ "cache_read_input_tokens": response.usage.cache_read_input_tokens,+ }+ })+ );+ Ok(())+ }+fn handle_repl_command(&mut self,command: SlashCommand,@@ -624,11 +785,22 @@ impl LiveCli {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::Session { action, target } => {+ self.handle_session_command(action.as_deref(), target.as_deref())?;+ }SlashCommand::Unknown(name) => eprintln!("unknown slash command: /{name}"),}Ok(())}+ fn persist_session(&self) -> Result<(), Box<dyn std::error::Error>> {+ self.runtime.session().save_to_path(&self.session.path)?;+ Ok(())+ }+fn print_status(&self) {let cumulative = self.runtime.usage().cumulative_usage();let latest = self.runtime.usage().current_turn_usage();@@ -644,7 +816,7 @@ impl LiveCli {estimated_tokens: self.runtime.estimated_tokens(),},permission_mode_label(),- &status_context(None).expect("status context should load"),+ &status_context(Some(&self.session.path)).expect("status context should load"),));}@@ -679,6 +851,7 @@ impl LiveCli {let message_count = session.messages.len();self.runtime = build_runtime(session, model.clone(), self.system_prompt.clone(), true)?;self.model.clone_from(&model);+ self.persist_session()?;println!("{}",format_model_switch_report(&previous, &model, message_count)@@ -694,7 +867,7 @@ impl LiveCli {let normalized = normalize_permission_mode(&mode).ok_or_else(|| {format!(- "Unsupported permission mode '{mode}'. Use read-only, workspace-write, or danger-full-access."+ "unsupported permission mode '{mode}'. Use read-only, workspace-write, or danger-full-access.")})?;@@ -712,6 +885,7 @@ impl LiveCli {true,normalized,)?;+ self.persist_session()?;println!("{}",format_permissions_switch_report(&previous, normalized)@@ -727,6 +901,7 @@ impl LiveCli {return Ok(());}+ self.session = create_managed_session_handle()?;self.runtime = build_runtime_with_permission_mode(Session::new(),self.model.clone(),@@ -734,13 +909,12 @@ impl LiveCli {true,permission_mode_label(),)?;+ self.persist_session()?;println!(- "Session cleared- Mode fresh session- Preserved model {}- Permission mode {}",+ "Session cleared\n Mode fresh session\n Preserved model {}\n Permission mode {}\n Session {}",self.model,- permission_mode_label()+ permission_mode_label(),+ self.session.id,);Ok(())}@@ -754,12 +928,13 @@ impl LiveCli {&mut self,session_path: Option<String>,) -> Result<(), Box<dyn std::error::Error>> {- let Some(session_path) = session_path else {+ let Some(session_ref) = session_path else {println!("Usage: /resume <session-path>");return Ok(());};- let session = Session::load_from_path(&session_path)?;+ let handle = resolve_session_reference(&session_ref)?;+ let session = Session::load_from_path(&handle.path)?;let message_count = session.messages.len();self.runtime = build_runtime_with_permission_mode(session,@@ -768,9 +943,15 @@ impl LiveCli {true,permission_mode_label(),)?;+ self.session = handle;+ self.persist_session()?;println!("{}",- format_resume_report(&session_path, message_count, self.runtime.usage().turns())+ format_resume_report(+ &self.session.path.display().to_string(),+ message_count,+ self.runtime.usage().turns(),+ ));Ok(())}@@ -790,6 +971,71 @@ impl LiveCli {Ok(())}+ fn print_diff() -> Result<(), Box<dyn std::error::Error>> {+ println!("{}", render_diff_report()?);+ Ok(())+ }++ fn print_version() {+ println!("{}", render_version_report());+ }++ fn export_session(+ &self,+ requested_path: Option<&str>,+ ) -> Result<(), Box<dyn std::error::Error>> {+ let export_path = resolve_export_path(requested_path, self.runtime.session())?;+ fs::write(&export_path, render_export_text(self.runtime.session()))?;+ println!(+ "Export\n Result wrote transcript\n File {}\n Messages {}",+ export_path.display(),+ self.runtime.session().messages.len(),+ );+ Ok(())+ }++ fn handle_session_command(+ &mut self,+ action: Option<&str>,+ target: Option<&str>,+ ) -> Result<(), Box<dyn std::error::Error>> {+ match action {+ None | Some("list") => {+ println!("{}", render_session_list(&self.session.id)?);+ Ok(())+ }+ Some("switch") => {+ let Some(target) = target else {+ println!("Usage: /session switch <session-id>");+ return Ok(());+ };+ let handle = resolve_session_reference(target)?;+ let session = Session::load_from_path(&handle.path)?;+ let message_count = session.messages.len();+ self.runtime = build_runtime_with_permission_mode(+ session,+ self.model.clone(),+ self.system_prompt.clone(),+ true,+ 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(())+ }+ Some(other) => {+ println!("Unknown /session action '{other}'. Use /session list or /session switch <session-id>.");+ Ok(())+ }+ }+ }+fn compact(&mut self) -> Result<(), Box<dyn std::error::Error>> {let result = self.runtime.compact(CompactionConfig::default());let removed = result.removed_message_count;@@ -802,11 +1048,112 @@ impl LiveCli {true,permission_mode_label(),)?;+ self.persist_session()?;println!("{}", format_compact_report(removed, kept, skipped));Ok(())}}+fn sessions_dir() -> Result<PathBuf, Box<dyn std::error::Error>> {+ let cwd = env::current_dir()?;+ let path = cwd.join(".claude").join("sessions");+ fs::create_dir_all(&path)?;+ Ok(path)+}++fn create_managed_session_handle() -> Result<SessionHandle, Box<dyn std::error::Error>> {+ let id = generate_session_id();+ let path = sessions_dir()?.join(format!("{id}.json"));+ Ok(SessionHandle { id, path })+}++fn generate_session_id() -> String {+ let millis = SystemTime::now()+ .duration_since(UNIX_EPOCH)+ .map(|duration| duration.as_millis())+ .unwrap_or_default();+ format!("session-{millis}")+}++fn resolve_session_reference(reference: &str) -> Result<SessionHandle, Box<dyn std::error::Error>> {+ let direct = PathBuf::from(reference);+ let path = if direct.exists() {+ direct+ } else {+ sessions_dir()?.join(format!("{reference}.json"))+ };+ if !path.exists() {+ return Err(format!("session not found: {reference}").into());+ }+ let id = path+ .file_stem()+ .and_then(|value| value.to_str())+ .unwrap_or(reference)+ .to_string();+ Ok(SessionHandle { id, path })+}++fn list_managed_sessions() -> Result<Vec<ManagedSessionSummary>, Box<dyn std::error::Error>> {+ let mut sessions = Vec::new();+ for entry in fs::read_dir(sessions_dir()?)? {+ let entry = entry?;+ let path = entry.path();+ if path.extension().and_then(|ext| ext.to_str()) != Some("json") {+ continue;+ }+ let metadata = entry.metadata()?;+ let modified_epoch_secs = metadata+ .modified()+ .ok()+ .and_then(|time| time.duration_since(UNIX_EPOCH).ok())+ .map(|duration| duration.as_secs())+ .unwrap_or_default();+ let message_count = Session::load_from_path(&path)+ .map(|session| session.messages.len())+ .unwrap_or_default();+ let id = path+ .file_stem()+ .and_then(|value| value.to_str())+ .unwrap_or("unknown")+ .to_string();+ sessions.push(ManagedSessionSummary {+ id,+ path,+ modified_epoch_secs,+ message_count,+ });+ }+ sessions.sort_by(|left, right| right.modified_epoch_secs.cmp(&left.modified_epoch_secs));+ Ok(sessions)+}++fn render_session_list(active_session_id: &str) -> Result<String, Box<dyn std::error::Error>> {+ let sessions = list_managed_sessions()?;+ let mut lines = vec![+ "Sessions".to_string(),+ format!(" Directory {}", sessions_dir()?.display()),+ ];+ if sessions.is_empty() {+ lines.push(" No managed sessions saved yet.".to_string());+ return Ok(lines.join("\n"));+ }+ for session in sessions {+ let marker = if session.id == active_session_id {+ "● current"+ } else {+ "○ saved"+ };+ lines.push(format!(+ " {id:<20} {marker:<10} msgs={msgs:<4} modified={modified} path={path}",+ id = session.id,+ msgs = session.message_count,+ modified = session.modified_epoch_secs,+ path = session.path.display(),+ ));+ }+ Ok(lines.join("\n"))+}+fn render_repl_help() -> String {["REPL".to_string(),@@ -1096,6 +1443,120 @@ fn permission_mode_label() -> &'static str {}}+fn render_diff_report() -> Result<String, Box<dyn std::error::Error>> {+ let output = std::process::Command::new("git")+ .args(["diff", "--", ":(exclude).omx"])+ .current_dir(env::current_dir()?)+ .output()?;+ if !output.status.success() {+ let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();+ return Err(format!("git diff failed: {stderr}").into());+ }+ let diff = String::from_utf8(output.stdout)?;+ if diff.trim().is_empty() {+ return Ok(+ "Diff\n Result clean working tree\n Detail no current changes"+ .to_string(),+ );+ }+ Ok(format!("Diff\n\n{}", diff.trim_end()))+}++fn render_version_report() -> String {+ let git_sha = GIT_SHA.unwrap_or("unknown");+ let target = BUILD_TARGET.unwrap_or("unknown");+ format!(+ "Version\n Version {VERSION}\n Git SHA {git_sha}\n Target {target}\n Build date {DEFAULT_DATE}"+ )+}++fn render_export_text(session: &Session) -> String {+ let mut lines = vec!["# Conversation Export".to_string(), String::new()];+ for (index, message) in session.messages.iter().enumerate() {+ let role = match message.role {+ MessageRole::System => "system",+ MessageRole::User => "user",+ MessageRole::Assistant => "assistant",+ MessageRole::Tool => "tool",+ };+ lines.push(format!("## {}. {role}", index + 1));+ for block in &message.blocks {+ match block {+ ContentBlock::Text { text } => lines.push(text.clone()),+ ContentBlock::ToolUse { id, name, input } => {+ lines.push(format!("[tool_use id={id} name={name}] {input}"));+ }+ ContentBlock::ToolResult {+ tool_use_id,+ tool_name,+ output,+ is_error,+ } => {+ lines.push(format!(+ "[tool_result id={tool_use_id} name={tool_name} error={is_error}] {output}"+ ));+ }+ }+ }+ lines.push(String::new());+ }+ lines.join("\n")+}++fn default_export_filename(session: &Session) -> String {+ let stem = session+ .messages+ .iter()+ .find_map(|message| match message.role {+ MessageRole::User => message.blocks.iter().find_map(|block| match block {+ ContentBlock::Text { text } => Some(text.as_str()),+ _ => None,+ }),+ _ => None,+ })+ .map_or("conversation", |text| {+ text.lines().next().unwrap_or("conversation")+ })+ .chars()+ .map(|ch| {+ if ch.is_ascii_alphanumeric() {+ ch.to_ascii_lowercase()+ } else {+ '-'+ }+ })+ .collect::<String>()+ .split('-')+ .filter(|part| !part.is_empty())+ .take(8)+ .collect::<Vec<_>>()+ .join("-");+ let fallback = if stem.is_empty() {+ "conversation"+ } else {+ &stem+ };+ format!("{fallback}.txt")+}++fn resolve_export_path(+ requested_path: Option<&str>,+ session: &Session,+) -> Result<PathBuf, Box<dyn std::error::Error>> {+ let cwd = env::current_dir()?;+ let file_name =+ requested_path.map_or_else(|| default_export_filename(session), ToOwned::to_owned);+ let final_name = if Path::new(&file_name)+ .extension()+ .is_some_and(|ext| ext.eq_ignore_ascii_case("txt"))+ {+ file_name+ } else {+ format!("{file_name}.txt")+ };+ Ok(cwd.join(final_name))+}+fn build_system_prompt() -> Result<Vec<String>, Box<dyn std::error::Error>> {Ok(load_system_prompt(env::current_dir()?,@@ -1400,19 +1861,25 @@ fn convert_messages(messages: &[ConversationMessage]) -> Vec<InputMessage> {}fn print_help() {- println!("rusty-claude-cli");+ println!("rusty-claude-cli v{VERSION}");println!();println!("Usage:");println!(" rusty-claude-cli [--model MODEL]");- println!(" Start interactive REPL");- println!(" rusty-claude-cli [--model MODEL] prompt TEXT");- println!(" Send one prompt and stream the response");+ println!(" Start the interactive REPL");+ println!(" rusty-claude-cli [--model MODEL] [--output-format text|json] prompt TEXT");+ println!(" Send one prompt and exit");+ println!(" rusty-claude-cli [--model MODEL] [--output-format text|json] TEXT");+ println!(" Shorthand non-interactive prompt mode");println!(" rusty-claude-cli --resume SESSION.json [/status] [/compact] [...]");println!(" Inspect or maintain a saved session without entering the REPL");println!(" rusty-claude-cli dump-manifests");println!(" rusty-claude-cli bootstrap-plan");println!(" rusty-claude-cli system-prompt [--cwd PATH] [--date YYYY-MM-DD]");println!();+ println!("Flags:");+ println!(" --model MODEL Override the active model");+ println!(" --output-format FORMAT Non-interactive output format: text or json");+ println!();println!("Interactive slash commands:");println!("{}", render_slash_command_help());println!();@@ -1426,8 +1893,9 @@ fn print_help() {.join(", ");println!("Resume-safe commands: {resume_commands}");println!("Examples:");- println!(" rusty-claude-cli --resume session.json /status /compact /cost");- println!(" rusty-claude-cli --resume session.json /memory /config");+ println!(" rusty-claude-cli --model claude-opus \"summarize this repo\"");+ println!(" rusty-claude-cli --output-format json prompt \"explain src/main.rs\"");+ println!(" rusty-claude-cli --resume session.json /status /diff /export notes.txt");}#[cfg(test)]@@ -1438,7 +1906,7 @@ mod tests {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, SlashCommand, StatusUsage, DEFAULT_MODEL,+ CliAction, CliOutputFormat, SlashCommand, StatusUsage, DEFAULT_MODEL,};use runtime::{ContentBlock, ConversationMessage, MessageRole};use std::path::{Path, PathBuf};@@ -1465,6 +1933,26 @@ mod tests {CliAction::Prompt {prompt: "hello world".to_string(),model: DEFAULT_MODEL.to_string(),+ output_format: CliOutputFormat::Text,+ }+ );+ }++ #[test]+ fn parses_bare_prompt_and_json_output_flag() {+ let args = vec![+ "--output-format=json".to_string(),+ "--model".to_string(),+ "claude-opus".to_string(),+ "explain".to_string(),+ "this".to_string(),+ ];+ assert_eq!(+ parse_args(&args).expect("args should parse"),+ CliAction::Prompt {+ prompt: "explain this".to_string(),+ model: "claude-opus".to_string(),+ output_format: CliOutputFormat::Json,});}@@ -1546,6 +2034,10 @@ mod tests {assert!(help.contains("/config [env|hooks|model]"));assert!(help.contains("/memory"));assert!(help.contains("/init"));+ assert!(help.contains("/diff"));+ assert!(help.contains("/version"));+ assert!(help.contains("/export [file]"));+ assert!(help.contains("/session [list|switch <session-id>]"));assert!(help.contains("/exit"));}@@ -1557,7 +2049,10 @@ mod tests {.collect::<Vec<_>>();assert_eq!(names,- vec!["help", "status", "compact", "clear", "cost", "config", "memory", "init",]+ vec![+ "help", "status", "compact", "clear", "cost", "config", "memory", "init", "diff",+ "version", "export",+ ]);}