Skip to content

An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

Rust

Reduce CLI dead-ends around help and session recovery

Yeachan-Heoa127ad7878a2
diff --git a/rust/crates/rusty-claude-cli/src/main.rs b/rust/crates/rusty-claude-cli/src/main.rs
index 4f8362a4..194456fd 100644
--- a/rust/crates/rusty-claude-cli/src/main.rs
+++ b/rust/crates/rusty-claude-cli/src/main.rs
@@ -30,12 +30,11 @@ use plugins::{PluginManager, PluginManagerConfig};
use render::{MarkdownStreamState, Spinner, TerminalRenderer};
use runtime::{
clear_oauth_credentials, generate_pkce_pair, generate_state, load_system_prompt,
- parse_oauth_callback_request_target, resolve_sandbox_status, save_oauth_credentials,
- ApiClient, ApiRequest, AssistantEvent, CompactionConfig, ConfigLoader, ConfigSource,
- ContentBlock, ConversationMessage, ConversationRuntime, MessageRole, PromptCacheEvent,
- OAuthAuthorizationRequest, OAuthConfig,
- OAuthTokenExchangeRequest, PermissionMode, PermissionPolicy, ProjectContext, RuntimeError,
- Session, TokenUsage, ToolError, ToolExecutor, UsageTracker,
+ parse_oauth_callback_request_target, resolve_sandbox_status, save_oauth_credentials, ApiClient,
+ ApiRequest, AssistantEvent, CompactionConfig, ConfigLoader, ConfigSource, ContentBlock,
+ ConversationMessage, ConversationRuntime, MessageRole, OAuthAuthorizationRequest, OAuthConfig,
+ OAuthTokenExchangeRequest, PermissionMode, PermissionPolicy, ProjectContext, PromptCacheEvent,
+ RuntimeError, Session, TokenUsage, ToolError, ToolExecutor, UsageTracker,
};
use serde_json::json;
use tools::GlobalToolRegistry;
@@ -56,16 +55,38 @@ const GIT_SHA: Option<&str> = option_env!("GIT_SHA");
const INTERNAL_PROGRESS_HEARTBEAT_INTERVAL: Duration = Duration::from_secs(3);
const PRIMARY_SESSION_EXTENSION: &str = "jsonl";
const LEGACY_SESSION_EXTENSION: &str = "json";
+const LATEST_SESSION_REFERENCE: &str = "latest";
+const SESSION_REFERENCE_ALIASES: &[&str] = &[LATEST_SESSION_REFERENCE, "last", "recent"];
+const CLI_OPTION_SUGGESTIONS: &[&str] = &[
+ "--help",
+ "-h",
+ "--version",
+ "-V",
+ "--model",
+ "--output-format",
+ "--permission-mode",
+ "--dangerously-skip-permissions",
+ "--allowedTools",
+ "--allowed-tools",
+ "--resume",
+ "--print",
+ "-p",
+];
type AllowedToolSet = BTreeSet<String>;
fn main() {
if let Err(error) = run() {
- eprintln!(
- "error: {error}
+ let message = error.to_string();
+ if message.contains("`claw --help`") {
+ eprintln!("error: {message}");
+ } else {
+ eprintln!(
+ "error: {message}
Run `claw --help` for usage."
- );
+ );
+ }
std::process::exit(1);
}
}
@@ -165,6 +186,7 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
let mut model = DEFAULT_MODEL.to_string();
let mut output_format = CliOutputFormat::Text;
let mut permission_mode = default_permission_mode();
+ let mut wants_help = false;
let mut wants_version = false;
let mut allowed_tool_values = Vec::new();
let mut rest = Vec::new();
@@ -172,6 +194,10 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
while index < args.len() {
match args[index].as_str() {
+ "--help" | "-h" if rest.is_empty() => {
+ wants_help = true;
+ index += 1;
+ }
"--version" | "-V" => {
wants_version = true;
index += 1;
@@ -232,6 +258,15 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
output_format = CliOutputFormat::Text;
index += 1;
}
+ "--resume" if rest.is_empty() => {
+ rest.push("--resume".to_string());
+ index += 1;
+ }
+ flag if rest.is_empty() && flag.starts_with("--resume=") => {
+ rest.push("--resume".to_string());
+ rest.push(flag[9..].to_string());
+ index += 1;
+ }
"--allowedTools" | "--allowed-tools" => {
let value = args
.get(index + 1)
@@ -247,6 +282,9 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
allowed_tool_values.push(flag[16..].to_string());
index += 1;
}
+ other if rest.is_empty() && other.starts_with('-') => {
+ return Err(format_unknown_option(other))
+ }
other => {
rest.push(other.to_string());
index += 1;
@@ -254,6 +292,10 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
}
}
+ if wants_help {
+ return Ok(CliAction::Help);
+ }
+
if wants_version {
return Ok(CliAction::Version);
}
@@ -267,9 +309,6 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
permission_mode,
});
}
- if matches!(rest.first().map(String::as_str), Some("--help" | "-h")) {
- return Ok(CliAction::Help);
- }
if rest.first().map(String::as_str) == Some("--resume") {
return parse_resume_args(&rest[1..]);
}
@@ -323,17 +362,127 @@ fn parse_direct_slash_cli_action(rest: &[String]) -> Result<CliAction, String> {
Some(SlashCommand::Help) => Ok(CliAction::Help),
Some(SlashCommand::Agents { args }) => Ok(CliAction::Agents { args }),
Some(SlashCommand::Skills { args }) => Ok(CliAction::Skills { args }),
+ Some(SlashCommand::Unknown(name)) => Err(format_unknown_direct_slash_command(&name)),
Some(command) => Err(format!(
"unsupported direct slash command outside the REPL: {command_name}",
- command_name = match command {
- SlashCommand::Unknown(name) => format!("/{name}"),
- _ => rest[0].clone(),
+ command_name = {
+ let _ = command;
+ rest[0].clone()
}
)),
None => Err(format!("unknown subcommand: {}", rest[0])),
}
}
+fn format_unknown_option(option: &str) -> String {
+ let mut message = format!("unknown option: {option}");
+ if let Some(suggestion) = suggest_closest_term(option, CLI_OPTION_SUGGESTIONS) {
+ message.push_str("\nDid you mean ");
+ message.push_str(suggestion);
+ message.push('?');
+ }
+ message.push_str("\nRun `claw --help` for usage.");
+ message
+}
+
+fn format_unknown_direct_slash_command(name: &str) -> String {
+ let mut message = format!("unknown slash command outside the REPL: /{name}");
+ if let Some(suggestions) = render_suggestion_line("Did you mean", &suggest_slash_commands(name))
+ {
+ message.push('\n');
+ message.push_str(&suggestions);
+ }
+ message.push_str("\nRun `claw --help` for CLI usage, or start `claw` and use /help.");
+ message
+}
+
+fn format_unknown_slash_command(name: &str) -> String {
+ let mut message = format!("Unknown slash command: /{name}");
+ if let Some(suggestions) = render_suggestion_line("Did you mean", &suggest_slash_commands(name))
+ {
+ message.push('\n');
+ message.push_str(&suggestions);
+ }
+ message.push_str("\n Help /help lists available slash commands");
+ message
+}
+
+fn render_suggestion_line(label: &str, suggestions: &[String]) -> Option<String> {
+ (!suggestions.is_empty()).then(|| format!(" {label:<16} {}", suggestions.join(", "),))
+}
+
+fn suggest_slash_commands(input: &str) -> Vec<String> {
+ let mut candidates = slash_command_specs()
+ .iter()
+ .flat_map(|spec| {
+ std::iter::once(spec.name)
+ .chain(spec.aliases.iter().copied())
+ .map(|name| format!("/{name}"))
+ .collect::<Vec<_>>()
+ })
+ .collect::<Vec<_>>();
+ candidates.sort();
+ candidates.dedup();
+ let candidate_refs = candidates.iter().map(String::as_str).collect::<Vec<_>>();
+ ranked_suggestions(input.trim_start_matches('/'), &candidate_refs)
+ .into_iter()
+ .map(str::to_string)
+ .collect()
+}
+
+fn suggest_closest_term<'a>(input: &str, candidates: &'a [&'a str]) -> Option<&'a str> {
+ ranked_suggestions(input, candidates).into_iter().next()
+}
+
+fn ranked_suggestions<'a>(input: &str, candidates: &'a [&'a str]) -> Vec<&'a str> {
+ let normalized_input = input.trim_start_matches('/').to_ascii_lowercase();
+ let mut ranked = candidates
+ .iter()
+ .filter_map(|candidate| {
+ let normalized_candidate = candidate.trim_start_matches('/').to_ascii_lowercase();
+ let distance = levenshtein_distance(&normalized_input, &normalized_candidate);
+ let prefix_bonus = usize::from(
+ !(normalized_candidate.starts_with(&normalized_input)
+ || normalized_input.starts_with(&normalized_candidate)),
+ );
+ let score = distance + prefix_bonus;
+ (score <= 4).then_some((score, *candidate))
+ })
+ .collect::<Vec<_>>();
+ ranked.sort_by(|left, right| left.cmp(right).then_with(|| left.1.cmp(right.1)));
+ ranked
+ .into_iter()
+ .map(|(_, candidate)| candidate)
+ .take(3)
+ .collect()
+}
+
+fn levenshtein_distance(left: &str, right: &str) -> usize {
+ if left.is_empty() {
+ return right.chars().count();
+ }
+ if right.is_empty() {
+ return left.chars().count();
+ }
+
+ let right_chars = right.chars().collect::<Vec<_>>();
+ let mut previous = (0..=right_chars.len()).collect::<Vec<_>>();
+ let mut current = vec![0; right_chars.len() + 1];
+
+ for (left_index, left_char) in left.chars().enumerate() {
+ current[0] = left_index + 1;
+ for (right_index, right_char) in right_chars.iter().enumerate() {
+ let substitution_cost = usize::from(left_char != *right_char);
+ current[right_index + 1] = (previous[right_index + 1] + 1)
+ .min(current[right_index] + 1)
+ .min(previous[right_index] + substitution_cost);
+ }
+ previous.clone_from(&current);
+ }
+
+ previous[right_chars.len()]
+}
+
fn resolve_model_alias(model: &str) -> &str {
match model {
"opus" => "claude-opus-4-6",
@@ -421,11 +570,13 @@ fn parse_system_prompt_args(args: &[String]) -> Result<CliAction, String> {
}
fn parse_resume_args(args: &[String]) -> Result<CliAction, String> {
- let session_path = args
- .first()
- .ok_or_else(|| "missing session path for --resume".to_string())
- .map(PathBuf::from)?;
- let commands = args[1..].to_vec();
+ let (session_path, commands) = match args.first() {
+ None => (PathBuf::from(LATEST_SESSION_REFERENCE), Vec::new()),
+ Some(first) if first.trim_start().starts_with('/') => {
+ (PathBuf::from(LATEST_SESSION_REFERENCE), args.to_vec())
+ }
+ Some(first) => (PathBuf::from(first), args[1..].to_vec()),
+ };
if commands
.iter()
.any(|command| !command.trim_start().starts_with('/'))
@@ -783,6 +934,15 @@ fn format_resume_report(session_path: &str, message_count: usize, turns: u32) ->
)
}
+fn render_resume_usage() -> String {
+ format!(
+ "Resume
+ Usage /resume <session-path|session-id|{LATEST_SESSION_REFERENCE}>
+ Auto-save .claw/sessions/<session-id>.{PRIMARY_SESSION_EXTENSION}
+ Tip use /session list to inspect saved sessions"
+ )
+}
+
fn format_compact_report(removed: usize, resulting_messages: usize, skipped: bool) -> String {
if skipped {
format!(
@@ -1014,6 +1174,7 @@ fn run_resume_command(
message: Some(handle_skills_slash_command(args.as_deref(), &cwd)?),
})
}
+ SlashCommand::Unknown(name) => Err(format_unknown_slash_command(name).into()),
SlashCommand::Bughunter { .. }
| SlashCommand::Commit
| SlashCommand::Pr { .. }
@@ -1025,8 +1186,7 @@ fn run_resume_command(
| SlashCommand::Model { .. }
| SlashCommand::Permissions { .. }
| SlashCommand::Session { .. }
- | SlashCommand::Plugins { .. }
- | SlashCommand::Unknown(_) => Err("unsupported resumed slash command".into()),
+ | SlashCommand::Plugins { .. } => Err("unsupported resumed slash command".into()),
}
}
@@ -1080,7 +1240,7 @@ struct SessionHandle {
struct ManagedSessionSummary {
id: String,
path: PathBuf,
- modified_epoch_secs: u64,
+ modified_epoch_millis: u128,
message_count: usize,
parent_session_id: Option<String>,
branch_name: Option<String>,
@@ -1188,6 +1348,10 @@ impl LiveCli {
|_| "<unknown>".to_string(),
|path| path.display().to_string(),
);
+ let session_path = self.session.path.strip_prefix(Path::new(&cwd)).map_or_else(
+ |_| self.session.path.display().to_string(),
+ |path| path.display().to_string(),
+ );
format!(
"\x1b[38;5;196m\
██████╗██╗ █████╗ ██╗ ██╗\n\
@@ -1199,12 +1363,14 @@ impl LiveCli {
\x1b[2mModel\x1b[0m {}\n\
\x1b[2mPermissions\x1b[0m {}\n\
\x1b[2mDirectory\x1b[0m {}\n\
- \x1b[2mSession\x1b[0m {}\n\n\
- Type \x1b[1m/help\x1b[0m for commands · \x1b[2mShift+Enter\x1b[0m for newline",
+ \x1b[2mSession\x1b[0m {}\n\
+ \x1b[2mAuto-save\x1b[0m {}\n\n\
+ Type \x1b[1m/help\x1b[0m for commands · \x1b[2m/resume latest\x1b[0m jumps back to the newest session",
self.model,
self.permission_mode.as_str(),
cwd,
self.session.id,
+ session_path,
)
}
@@ -1416,7 +1582,7 @@ impl LiveCli {
false
}
SlashCommand::Unknown(name) => {
- eprintln!("unknown slash command: /{name}");
+ eprintln!("{}", format_unknown_slash_command(&name));
false
}
})
@@ -1592,7 +1758,7 @@ impl LiveCli {
session_path: Option<String>,
) -> Result<bool, Box<dyn std::error::Error>> {
let Some(session_ref) = session_path else {
- println!("Usage: /resume <session-path>");
+ println!("{}", render_resume_usage());
return Ok(false);
};
@@ -2002,12 +2168,23 @@ fn create_managed_session_handle(
}
fn resolve_session_reference(reference: &str) -> Result<SessionHandle, Box<dyn std::error::Error>> {
+ if SESSION_REFERENCE_ALIASES
+ .iter()
+ .any(|alias| reference.eq_ignore_ascii_case(alias))
+ {
+ let latest = latest_managed_session()?;
+ return Ok(SessionHandle {
+ id: latest.id,
+ path: latest.path,
+ });
+ }
+
let direct = PathBuf::from(reference);
let looks_like_path = direct.extension().is_some() || direct.components().count() > 1;
let path = if direct.exists() {
direct
} else if looks_like_path {
- return Err(format!("session not found: {reference}").into());
+ return Err(format_missing_session_reference(reference).into());
} else {
resolve_managed_session_path(reference)?
};
@@ -2031,7 +2208,7 @@ fn resolve_managed_session_path(session_id: &str) -> Result<PathBuf, Box<dyn std
return Ok(path);
}
}
- Err(format!("session not found: {session_id}").into())
+ Err(format_missing_session_reference(session_id).into())
}
fn is_managed_session_file(path: &Path) -> bool {
@@ -2051,53 +2228,79 @@ fn list_managed_sessions() -> Result<Vec<ManagedSessionSummary>, Box<dyn std::er
continue;
}
let metadata = entry.metadata()?;
- let modified_epoch_secs = metadata
+ let modified_epoch_millis = metadata
.modified()
.ok()
.and_then(|time| time.duration_since(UNIX_EPOCH).ok())
- .map(|duration| duration.as_secs())
+ .map(|duration| duration.as_millis())
.unwrap_or_default();
let (id, message_count, parent_session_id, branch_name) = Session::load_from_path(&path)
- .map(|session| {
- let parent_session_id = session
- .fork
- .as_ref()
- .map(|fork| fork.parent_session_id.clone());
- let branch_name = session
- .fork
- .as_ref()
- .and_then(|fork| fork.branch_name.clone());
- (
- session.session_id,
- session.messages.len(),
- parent_session_id,
- branch_name,
- )
- })
- .unwrap_or_else(|_| {
- (
- path.file_stem()
- .and_then(|value| value.to_str())
- .unwrap_or("unknown")
- .to_string(),
- 0,
- None,
- None,
- )
- });
+ .map_or_else(
+ |_| {
+ (
+ path.file_stem()
+ .and_then(|value| value.to_str())
+ .unwrap_or("unknown")
+ .to_string(),
+ 0,
+ None,
+ None,
+ )
+ },
+ |session| {
+ let parent_session_id = session
+ .fork
+ .as_ref()
+ .map(|fork| fork.parent_session_id.clone());
+ let branch_name = session
+ .fork
+ .as_ref()
+ .and_then(|fork| fork.branch_name.clone());
+ (
+ session.session_id,
+ session.messages.len(),
+ parent_session_id,
+ branch_name,
+ )
+ },
+ );
sessions.push(ManagedSessionSummary {
id,
path,
- modified_epoch_secs,
+ modified_epoch_millis,
message_count,
parent_session_id,
branch_name,
});
}
- sessions.sort_by(|left, right| right.modified_epoch_secs.cmp(&left.modified_epoch_secs));
+ sessions.sort_by(|left, right| {
+ right
+ .modified_epoch_millis
+ .cmp(&left.modified_epoch_millis)
+ .then_with(|| right.id.cmp(&left.id))
+ });
Ok(sessions)
}
+fn latest_managed_session() -> Result<ManagedSessionSummary, Box<dyn std::error::Error>> {
+ list_managed_sessions()?
+ .into_iter()
+ .next()
+ .ok_or_else(|| format_no_managed_sessions().into())
+}
+
+fn format_missing_session_reference(reference: &str) -> String {
+ format!(
+ "session not found: {reference}\nHint: managed sessions live in .claw/sessions/. Try `{LATEST_SESSION_REFERENCE}` for the most recent session or `/session list` in the REPL."
+ )
+}
+
+fn format_no_managed_sessions() -> String {
+ format!(
+ "no managed sessions found in .claw/sessions/\nStart `claw` to create a session, then rerun with `--resume {LATEST_SESSION_REFERENCE}`."
+ )
+}
+
fn render_session_list(active_session_id: &str) -> Result<String, Box<dyn std::error::Error>> {
let sessions = list_managed_sessions()?;
let mut lines = vec![
@@ -2129,7 +2332,7 @@ fn render_session_list(active_session_id: &str) -> Result<String, Box<dyn std::e
" {id:<20} {marker:<10} msgs={msgs:<4} modified={modified}{lineage} path={path}",
id = session.id,
msgs = session.message_count,
- modified = session.modified_epoch_secs,
+ modified = format_session_modified_age(session.modified_epoch_millis),
lineage = lineage,
path = session.path.display(),
));
@@ -2137,6 +2340,24 @@ fn render_session_list(active_session_id: &str) -> Result<String, Box<dyn std::e
Ok(lines.join("\n"))
}
+fn format_session_modified_age(modified_epoch_millis: u128) -> String {
+ let now = std::time::SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .ok()
+ .map_or(modified_epoch_millis, |duration| duration.as_millis());
+ let delta_seconds = now
+ .saturating_sub(modified_epoch_millis)
+ .checked_div(1_000)
+ .unwrap_or_default();
+ match delta_seconds {
+ 0..=4 => "just-now".to_string(),
+ 5..=59 => format!("{delta_seconds}s-ago"),
+ 60..=3_599 => format!("{}m-ago", delta_seconds / 60),
+ 3_600..=86_399 => format!("{}h-ago", delta_seconds / 3_600),
+ _ => format!("{}d-ago", delta_seconds / 86_400),
+ }
+}
+
fn render_repl_help() -> String {
[
"REPL".to_string(),
@@ -2146,6 +2367,9 @@ fn render_repl_help() -> 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(),
+ " Auto-save .claw/sessions/<session-id>.jsonl".to_string(),
+ " Resume latest /resume latest".to_string(),
+ " Browse sessions /session list".to_string(),
String::new(),
render_slash_command_help(),
]
@@ -3146,7 +3370,8 @@ fn build_runtime(
allowed_tools: Option<AllowedToolSet>,
permission_mode: PermissionMode,
progress_reporter: Option<InternalPromptProgressReporter>,
-) -> Result<ConversationRuntime<AnthropicRuntimeClient, CliToolExecutor>, Box<dyn std::error::Error>> {
+) -> Result<ConversationRuntime<AnthropicRuntimeClient, CliToolExecutor>, Box<dyn std::error::Error>>
+{
let (feature_config, tool_registry) = build_runtime_plugin_state()?;
let mut runtime = ConversationRuntime::new_with_features(
session,
@@ -3286,7 +3511,6 @@ impl AnthropicRuntimeClient {
progress_reporter,
})
}
-
}
fn resolve_cli_auth_source() -> Result<AuthSource, Box<dyn std::error::Error>> {
@@ -4023,7 +4247,9 @@ fn push_prompt_cache_record(client: &AnthropicClient, events: &mut Vec<Assistant
}
}
-fn prompt_cache_record_to_runtime_event(record: api::PromptCacheRecord) -> Option<PromptCacheEvent> {
+fn prompt_cache_record_to_runtime_event(
+ record: api::PromptCacheRecord,
+) -> Option<PromptCacheEvent> {
let cache_break = record.cache_break?;
Some(PromptCacheEvent {
unexpected: cache_break.unexpected,
@@ -4146,6 +4372,7 @@ fn convert_messages(messages: &[ConversationMessage]) -> Vec<InputMessage> {
.collect()
}
+#[allow(clippy::too_many_lines)]
fn print_help_to(out: &mut impl Write) -> io::Result<()> {
writeln!(out, "claw v{VERSION}")?;
writeln!(out)?;
@@ -4167,7 +4394,7 @@ fn print_help_to(out: &mut impl Write) -> io::Result<()> {
writeln!(out, " Shorthand non-interactive prompt mode")?;
writeln!(
out,
- " claw --resume SESSION.jsonl [/status] [/compact] [...]"
+ " claw --resume [SESSION.jsonl|session-id|latest] [/status] [/compact] [...]"
)?;
writeln!(
out,
@@ -4217,6 +4444,20 @@ fn print_help_to(out: &mut impl Write) -> io::Result<()> {
.collect::<Vec<_>>()
.join(", ");
writeln!(out, "Resume-safe commands: {resume_commands}")?;
+ writeln!(out)?;
+ writeln!(out, "Session shortcuts:")?;
+ writeln!(
+ out,
+ " REPL turns auto-save to .claw/sessions/<session-id>.{PRIMARY_SESSION_EXTENSION}"
+ )?;
+ writeln!(
+ out,
+ " Use `{LATEST_SESSION_REFERENCE}` with --resume, /resume, or /session switch to target the newest saved session"
+ )?;
+ writeln!(
+ out,
+ " Use /session list in the REPL to browse managed sessions"
+ )?;
writeln!(out, "Examples:")?;
writeln!(out, " claw --model claude-opus \"summarize this repo\"")?;
writeln!(
@@ -4227,9 +4468,10 @@ fn print_help_to(out: &mut impl Write) -> io::Result<()> {
out,
" claw --allowedTools read,glob \"summarize Cargo.toml\""
)?;
+ writeln!(out, " claw --resume {LATEST_SESSION_REFERENCE}")?;
writeln!(
out,
- " claw --resume session.jsonl /status /diff /export notes.txt"
+ " claw --resume {LATEST_SESSION_REFERENCE} /status /diff /export notes.txt"
)?;
writeln!(out, " claw agents")?;
writeln!(out, " claw /skills")?;
@@ -4245,18 +4487,18 @@ fn print_help() {
#[cfg(test)]
mod tests {
use super::{
- describe_tool_progress, filter_tool_specs, format_compact_report, format_cost_report,
- format_internal_prompt_progress_line, format_model_report, format_model_switch_report,
- format_permissions_report,
+ create_managed_session_handle, describe_tool_progress, filter_tool_specs,
+ format_compact_report, format_cost_report, format_internal_prompt_progress_line,
+ format_model_report, format_model_switch_report, format_permissions_report,
format_permissions_switch_report, format_resume_report, format_status_report,
- format_tool_call_start, format_tool_result, normalize_permission_mode, parse_args,
- parse_git_status_branch, parse_git_status_metadata_for, permission_policy,
- print_help_to, push_output_block, render_config_report, render_diff_report,
- render_memory_report, render_repl_help, resolve_model_alias, response_to_events,
+ format_tool_call_start, format_tool_result, format_unknown_slash_command,
+ normalize_permission_mode, parse_args, parse_git_status_branch,
+ parse_git_status_metadata_for, permission_policy, print_help_to, push_output_block,
+ render_config_report, render_diff_report, render_memory_report, render_repl_help,
+ render_resume_usage, resolve_model_alias, resolve_session_reference, response_to_events,
resume_supported_slash_commands, run_resume_command, status_context, CliAction,
- CliOutputFormat, InternalPromptProgressEvent,
- InternalPromptProgressState, SlashCommand, StatusUsage, DEFAULT_MODEL,
- create_managed_session_handle, resolve_session_reference,
+ CliOutputFormat, InternalPromptProgressEvent, InternalPromptProgressState, SlashCommand,
+ StatusUsage, DEFAULT_MODEL,
};
use api::{MessageResponse, OutputContentBlock, Usage};
use plugins::{PluginTool, PluginToolDefinition, PluginToolPermission};
@@ -4551,6 +4793,25 @@ mod tests {
);
}
+ #[test]
+ fn parses_resume_flag_without_path_as_latest_session() {
+ assert_eq!(
+ parse_args(&["--resume".to_string()]).expect("args should parse"),
+ CliAction::ResumeSession {
+ session_path: PathBuf::from("latest"),
+ commands: vec![],
+ }
+ );
+ assert_eq!(
+ parse_args(&["--resume".to_string(), "/status".to_string()])
+ .expect("resume shortcut should parse"),
+ CliAction::ResumeSession {
+ session_path: PathBuf::from("latest"),
+ commands: vec!["/status".to_string()],
+ }
+ );
+ }
+
#[test]
fn parses_resume_flag_with_multiple_slash_commands() {
let args = vec![
@@ -4573,6 +4834,14 @@ mod tests {
);
}
+ #[test]
+ fn rejects_unknown_options_with_helpful_guidance() {
+ let error = parse_args(&["--resum".to_string()]).expect_err("unknown option should fail");
+ assert!(error.contains("unknown option: --resum"));
+ assert!(error.contains("Did you mean --resume?"));
+ assert!(error.contains("claw --help"));
+ }
+
#[test]
fn filtered_tool_specs_respect_allowlist() {
let allowed = ["read_file", "grep_search"]
@@ -4643,6 +4912,8 @@ mod tests {
assert!(help.contains("/agents"));
assert!(help.contains("/skills"));
assert!(help.contains("/exit"));
+ assert!(help.contains("Auto-save .claw/sessions/<session-id>.jsonl"));
+ assert!(help.contains("Resume latest /resume latest"));
}
#[test]
@@ -5022,8 +5293,10 @@ mod tests {
let mut help = Vec::new();
print_help_to(&mut help).expect("help should render");
let help = String::from_utf8(help).expect("help should be utf8");
- assert!(help.contains("claw --resume SESSION.jsonl"));
- assert!(help.contains("claw --resume session.jsonl /status /diff /export notes.txt"));
+ assert!(help.contains("claw --resume [SESSION.jsonl|session-id|latest]"));
+ assert!(help.contains("Use `latest` with --resume, /resume, or /session switch"));
+ assert!(help.contains("claw --resume latest"));
+ assert!(help.contains("claw --resume latest /status /diff /export notes.txt"));
}
#[test]
@@ -5051,14 +5324,68 @@ mod tests {
let resolved = resolve_session_reference("legacy").expect("legacy session should resolve");
assert_eq!(
- resolved.path.canonicalize().expect("resolved path should exist"),
- legacy_path.canonicalize().expect("legacy path should exist")
+ resolved
+ .path
+ .canonicalize()
+ .expect("resolved path should exist"),
+ legacy_path
+ .canonicalize()
+ .expect("legacy path should exist")
);
std::env::set_current_dir(previous).expect("restore cwd");
std::fs::remove_dir_all(workspace).expect("workspace should clean up");
}
+ #[test]
+ fn latest_session_alias_resolves_most_recent_managed_session() {
+ let _guard = cwd_lock().lock().expect("cwd lock");
+ let workspace = temp_workspace("latest-session-alias");
+ std::fs::create_dir_all(&workspace).expect("workspace should create");
+ let previous = std::env::current_dir().expect("cwd");
+ std::env::set_current_dir(&workspace).expect("switch cwd");
+
+ let older = create_managed_session_handle("session-older").expect("older handle");
+ Session::new()
+ .with_persistence_path(older.path.clone())
+ .save_to_path(&older.path)
+ .expect("older session should save");
+ std::thread::sleep(Duration::from_millis(20));
+ let newer = create_managed_session_handle("session-newer").expect("newer handle");
+ Session::new()
+ .with_persistence_path(newer.path.clone())
+ .save_to_path(&newer.path)
+ .expect("newer session should save");
+
+ let resolved = resolve_session_reference("latest").expect("latest session should resolve");
+ assert_eq!(
+ resolved
+ .path
+ .canonicalize()
+ .expect("resolved path should exist"),
+ newer.path.canonicalize().expect("newer path should exist")
+ );
+
+ std::env::set_current_dir(previous).expect("restore cwd");
+ std::fs::remove_dir_all(workspace).expect("workspace should clean up");
+ }
+
+ #[test]
+ fn unknown_slash_command_guidance_suggests_nearby_commands() {
+ let message = format_unknown_slash_command("stats");
+ assert!(message.contains("Unknown slash command: /stats"));
+ assert!(message.contains("/status"));
+ assert!(message.contains("/help"));
+ }
+
+ #[test]
+ fn resume_usage_mentions_latest_shortcut() {
+ let usage = render_resume_usage();
+ assert!(usage.contains("/resume <session-path|session-id|latest>"));
+ assert!(usage.contains(".claw/sessions/<session-id>.jsonl"));
+ assert!(usage.contains("/session list"));
+ }
+
fn cwd_lock() -> &'static Mutex<()> {
static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
LOCK.get_or_init(|| Mutex::new(()))