Skip to content

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

Rust

Make claw's REPL feel self-explanatory from analysis through commit

Yeachan-Heo79da7c0adf0e
diff --git a/rust/crates/api/src/client.rs b/rust/crates/api/src/client.rs
index 2adaca44..1147a845 100644
--- a/rust/crates/api/src/client.rs
+++ b/rust/crates/api/src/client.rs
@@ -19,6 +19,7 @@ async fn stream_via_provider<P: Provider>(
provider.stream_message(request).await
}
+#[allow(clippy::large_enum_variant)]
#[derive(Debug, Clone)]
pub enum ProviderClient {
Anthropic(AnthropicClient),
diff --git a/rust/crates/api/src/providers/openai_compat.rs b/rust/crates/api/src/providers/openai_compat.rs
index e8210aeb..d1db46f2 100644
--- a/rust/crates/api/src/providers/openai_compat.rs
+++ b/rust/crates/api/src/providers/openai_compat.rs
@@ -296,6 +296,7 @@ impl OpenAiSseParser {
}
}
+#[allow(clippy::struct_excessive_bools)]
#[derive(Debug)]
struct StreamState {
model: String,
@@ -497,6 +498,7 @@ impl ToolCallState {
self.openai_index + 1
}
+ #[allow(clippy::unnecessary_wraps)]
fn start_event(&self) -> Result<Option<ContentBlockStartEvent>, ApiError> {
let Some(name) = self.name.clone() else {
return Ok(None);
diff --git a/rust/crates/api/tests/openai_compat_integration.rs b/rust/crates/api/tests/openai_compat_integration.rs
index b345b1f5..116451ed 100644
--- a/rust/crates/api/tests/openai_compat_integration.rs
+++ b/rust/crates/api/tests/openai_compat_integration.rs
@@ -195,6 +195,7 @@ async fn stream_message_normalizes_text_and_multiple_tool_calls() {
assert!(request.body.contains("\"stream\":true"));
}
+#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn provider_client_dispatches_xai_requests_from_env() {
let _lock = env_lock();
@@ -389,7 +390,7 @@ fn env_lock() -> std::sync::MutexGuard<'static, ()> {
static LOCK: OnceLock<StdMutex<()>> = OnceLock::new();
LOCK.get_or_init(|| StdMutex::new(()))
.lock()
- .unwrap_or_else(|poisoned| poisoned.into_inner())
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
}
struct ScopedEnvVar {
diff --git a/rust/crates/api/tests/provider_client_integration.rs b/rust/crates/api/tests/provider_client_integration.rs
index 204bf358..c290d00f 100644
--- a/rust/crates/api/tests/provider_client_integration.rs
+++ b/rust/crates/api/tests/provider_client_integration.rs
@@ -57,7 +57,7 @@ fn env_lock() -> std::sync::MutexGuard<'static, ()> {
static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
LOCK.get_or_init(|| Mutex::new(()))
.lock()
- .unwrap_or_else(|poisoned| poisoned.into_inner())
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
}
struct EnvVarGuard {
diff --git a/rust/crates/commands/src/lib.rs b/rust/crates/commands/src/lib.rs
index 0e46c56b..4e7a3ead 100644
--- a/rust/crates/commands/src/lib.rs
+++ b/rust/crates/commands/src/lib.rs
@@ -394,40 +394,153 @@ pub fn resume_supported_slash_commands() -> Vec<&'static SlashCommandSpec> {
.collect()
}
+fn slash_command_category(name: &str) -> &'static str {
+ match name {
+ "help" | "status" | "sandbox" | "model" | "permissions" | "cost" | "resume" | "session"
+ | "version" => "Session & visibility",
+ "compact" | "clear" | "config" | "memory" | "init" | "diff" | "commit" | "pr" | "issue"
+ | "export" | "plugin" => "Workspace & git",
+ "agents" | "skills" | "teleport" | "debug-tool-call" => "Discovery & debugging",
+ "bughunter" | "ultraplan" => "Analysis & automation",
+ _ => "Other",
+ }
+}
+
+fn format_slash_command_help_line(spec: &SlashCommandSpec) -> String {
+ let name = match spec.argument_hint {
+ Some(argument_hint) => format!("/{} {}", spec.name, argument_hint),
+ None => format!("/{}", spec.name),
+ };
+ let alias_suffix = if spec.aliases.is_empty() {
+ String::new()
+ } else {
+ format!(
+ " (aliases: {})",
+ spec.aliases
+ .iter()
+ .map(|alias| format!("/{alias}"))
+ .collect::<Vec<_>>()
+ .join(", ")
+ )
+ };
+ let resume = if spec.resume_supported {
+ " [resume]"
+ } else {
+ ""
+ };
+ format!(" {name:<20} {}{alias_suffix}{resume}", spec.summary)
+}
+
+fn levenshtein_distance(left: &str, right: &str) -> usize {
+ if left == right {
+ return 0;
+ }
+ 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] = (current[right_index] + 1)
+ .min(previous[right_index + 1] + 1)
+ .min(previous[right_index] + substitution_cost);
+ }
+ previous.clone_from(&current);
+ }
+
+ previous[right_chars.len()]
+}
+
+#[must_use]
+pub fn suggest_slash_commands(input: &str, limit: usize) -> Vec<String> {
+ let query = input.trim().trim_start_matches('/').to_ascii_lowercase();
+ if query.is_empty() || limit == 0 {
+ return Vec::new();
+ }
+
+ let mut suggestions = slash_command_specs()
+ .iter()
+ .filter_map(|spec| {
+ let best = std::iter::once(spec.name)
+ .chain(spec.aliases.iter().copied())
+ .map(str::to_ascii_lowercase)
+ .map(|candidate| {
+ let prefix_rank =
+ if candidate.starts_with(&query) || query.starts_with(&candidate) {
+ 0
+ } else if candidate.contains(&query) || query.contains(&candidate) {
+ 1
+ } else {
+ 2
+ };
+ let distance = levenshtein_distance(&candidate, &query);
+ (prefix_rank, distance)
+ })
+ .min();
+
+ best.and_then(|(prefix_rank, distance)| {
+ if prefix_rank <= 1 || distance <= 2 {
+ Some((prefix_rank, distance, spec.name.len(), spec.name))
+ } else {
+ None
+ }
+ })
+ })
+ .collect::<Vec<_>>();
+
+ suggestions.sort_unstable();
+ suggestions
+ .into_iter()
+ .map(|(_, _, _, name)| format!("/{name}"))
+ .take(limit)
+ .collect()
+}
+
#[must_use]
pub fn render_slash_command_help() -> String {
let mut lines = vec![
"Slash commands".to_string(),
+ " Start here /status, /diff, /agents, /skills, /commit".to_string(),
" [resume] means the command also works with --resume SESSION.jsonl".to_string(),
+ String::new(),
];
- for spec in slash_command_specs() {
- let name = match spec.argument_hint {
- Some(argument_hint) => format!("/{} {}", spec.name, argument_hint),
- None => format!("/{}", spec.name),
- };
- let alias_suffix = if spec.aliases.is_empty() {
- String::new()
- } else {
- format!(
- " (aliases: {})",
- spec.aliases
- .iter()
- .map(|alias| format!("/{alias}"))
- .collect::<Vec<_>>()
- .join(", ")
- )
- };
- let resume = if spec.resume_supported {
- " [resume]"
- } else {
- ""
- };
- lines.push(format!(
- " {name:<20} {}{alias_suffix}{resume}",
- spec.summary
- ));
+
+ let categories = [
+ "Session & visibility",
+ "Workspace & git",
+ "Discovery & debugging",
+ "Analysis & automation",
+ ];
+
+ for category in categories {
+ lines.push(category.to_string());
+ for spec in slash_command_specs()
+ .iter()
+ .filter(|spec| slash_command_category(spec.name) == category)
+ {
+ lines.push(format_slash_command_help_line(spec));
+ }
+ lines.push(String::new());
}
- lines.join("\n")
+
+ lines
+ .into_iter()
+ .rev()
+ .skip_while(String::is_empty)
+ .collect::<Vec<_>>()
+ .into_iter()
+ .rev()
+ .collect::<Vec<_>>()
+ .join("\n")
}
#[derive(Debug, Clone, PartialEq, Eq)]
@@ -1223,7 +1336,7 @@ mod tests {
handle_plugins_slash_command, handle_slash_command, load_agents_from_roots,
load_skills_from_roots, render_agents_report, render_plugins_report, render_skills_report,
render_slash_command_help, resume_supported_slash_commands, slash_command_specs,
- DefinitionSource, SkillOrigin, SkillRoot, SlashCommand,
+ suggest_slash_commands, DefinitionSource, SkillOrigin, SkillRoot, SlashCommand,
};
use plugins::{PluginKind, PluginManager, PluginManagerConfig, PluginMetadata, PluginSummary};
use runtime::{CompactionConfig, ContentBlock, ConversationMessage, MessageRole, Session};
@@ -1466,7 +1579,12 @@ mod tests {
#[test]
fn renders_help_from_shared_specs() {
let help = render_slash_command_help();
+ assert!(help.contains("Start here /status, /diff, /agents, /skills, /commit"));
assert!(help.contains("works with --resume SESSION.jsonl"));
+ assert!(help.contains("Session & visibility"));
+ assert!(help.contains("Workspace & git"));
+ assert!(help.contains("Discovery & debugging"));
+ assert!(help.contains("Analysis & automation"));
assert!(help.contains("/help"));
assert!(help.contains("/status"));
assert!(help.contains("/sandbox"));
@@ -1501,6 +1619,13 @@ mod tests {
assert_eq!(resume_supported_slash_commands().len(), 14);
}
+ #[test]
+ fn suggests_closest_slash_commands_for_typos_and_aliases() {
+ assert_eq!(suggest_slash_commands("stats", 3), vec!["/status"]);
+ assert_eq!(suggest_slash_commands("/plugns", 3), vec!["/plugin"]);
+ assert_eq!(suggest_slash_commands("zzz", 3), Vec::<String>::new());
+ }
+
#[test]
fn compacts_sessions_via_slash_command() {
let mut session = Session::new();
diff --git a/rust/crates/runtime/src/conversation.rs b/rust/crates/runtime/src/conversation.rs
index ec3544a2..681c51f5 100644
--- a/rust/crates/runtime/src/conversation.rs
+++ b/rust/crates/runtime/src/conversation.rs
@@ -170,7 +170,7 @@ where
system_prompt,
max_iterations: usize::MAX,
usage_tracker,
- hook_runner: HookRunner::from_feature_config(&feature_config),
+ hook_runner: HookRunner::from_feature_config(feature_config),
auto_compaction_input_tokens_threshold: auto_compaction_threshold_from_env(),
hook_abort_signal: HookAbortSignal::default(),
hook_progress_reporter: None,
diff --git a/rust/crates/runtime/src/session.rs b/rust/crates/runtime/src/session.rs
index f08face8..f926a2d4 100644
--- a/rust/crates/runtime/src/session.rs
+++ b/rust/crates/runtime/src/session.rs
@@ -168,16 +168,23 @@ impl Session {
{
Self::from_json(&value)?
}
- Err(_) => Self::from_jsonl(&contents)?,
- Ok(_) => Self::from_jsonl(&contents)?,
+ Err(_) | Ok(_) => Self::from_jsonl(&contents)?,
};
Ok(session.with_persistence_path(path.to_path_buf()))
}
pub fn push_message(&mut self, message: ConversationMessage) -> Result<(), SessionError> {
self.touch();
- self.messages.push(message.clone());
- self.append_persisted_message(&message)
+ self.messages.push(message);
+ let persist_result = {
+ let message_ref = self.messages.last().expect("message was just pushed");
+ self.append_persisted_message(message_ref)
+ };
+ if let Err(error) = persist_result {
+ self.messages.pop();
+ return Err(error);
+ }
+ Ok(())
}
pub fn push_user_text(&mut self, text: impl Into<String>) -> Result<(), SessionError> {
@@ -270,8 +277,7 @@ impl Session {
let session_id = object
.get("session_id")
.and_then(JsonValue::as_str)
- .map(ToOwned::to_owned)
- .unwrap_or_else(generate_session_id);
+ .map_or_else(generate_session_id, ToOwned::to_owned);
let created_at_ms = object
.get("created_at_ms")
.map(|value| required_u64_from_value(value, "created_at_ms"))
@@ -813,7 +819,7 @@ fn normalize_optional_string(value: Option<String>) -> Option<String> {
fn current_time_millis() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
- .map(|duration| duration.as_millis() as u64)
+ .map(|duration| u64::try_from(duration.as_millis()).unwrap_or(u64::MAX))
.unwrap_or_default()
}
@@ -881,7 +887,12 @@ fn cleanup_rotated_logs(path: &Path) -> Result<(), SessionError> {
entry_path
.file_name()
.and_then(|value| value.to_str())
- .is_some_and(|name| name.starts_with(&prefix) && name.ends_with(".jsonl"))
+ .is_some_and(|name| {
+ name.starts_with(&prefix)
+ && Path::new(name)
+ .extension()
+ .is_some_and(|ext| ext.eq_ignore_ascii_case("jsonl"))
+ })
})
.collect::<Vec<_>>();
@@ -907,7 +918,7 @@ mod tests {
use crate::json::JsonValue;
use crate::usage::TokenUsage;
use std::fs;
- use std::path::PathBuf;
+ use std::path::{Path, PathBuf};
use std::time::{SystemTime, UNIX_EPOCH};
#[test]
@@ -1057,8 +1068,9 @@ mod tests {
#[test]
fn rotates_and_cleans_up_large_session_logs() {
let path = temp_session_path("rotation");
- fs::write(&path, "x".repeat((super::ROTATE_AFTER_BYTES + 10) as usize))
- .expect("oversized file should write");
+ let oversized_length =
+ usize::try_from(super::ROTATE_AFTER_BYTES + 10).expect("rotate threshold should fit");
+ fs::write(&path, "x".repeat(oversized_length)).expect("oversized file should write");
rotate_session_file_if_needed(&path).expect("rotation should succeed");
assert!(
!path.exists(),
@@ -1086,7 +1098,7 @@ mod tests {
std::env::temp_dir().join(format!("runtime-session-{label}-{nanos}.json"))
}
- fn rotation_files(path: &PathBuf) -> Vec<PathBuf> {
+ fn rotation_files(path: &Path) -> Vec<PathBuf> {
let stem = path
.file_stem()
.and_then(|value| value.to_str())
@@ -1101,7 +1113,10 @@ mod tests {
.file_name()
.and_then(|value| value.to_str())
.is_some_and(|name| {
- name.starts_with(&format!("{stem}.rot-")) && name.ends_with(".jsonl")
+ name.starts_with(&format!("{stem}.rot-"))
+ && Path::new(name)
+ .extension()
+ .is_some_and(|ext| ext.eq_ignore_ascii_case("jsonl"))
})
})
.collect()
diff --git a/rust/crates/rusty-claude-cli/src/main.rs b/rust/crates/rusty-claude-cli/src/main.rs
index 4f8362a4..17d795aa 100644
--- a/rust/crates/rusty-claude-cli/src/main.rs
+++ b/rust/crates/rusty-claude-cli/src/main.rs
@@ -22,7 +22,8 @@ use api::{
use commands::{
handle_agents_slash_command, handle_plugins_slash_command, handle_skills_slash_command,
- render_slash_command_help, resume_supported_slash_commands, slash_command_specs, SlashCommand,
+ render_slash_command_help, resume_supported_slash_commands, slash_command_specs,
+ suggest_slash_commands, SlashCommand,
};
use compat_harness::{extract_manifest, UpstreamPaths};
use init::initialize_repo;
@@ -30,12 +31,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;
@@ -323,13 +323,13 @@ 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(command) => Err(format!(
- "unsupported direct slash command outside the REPL: {command_name}",
- command_name = match command {
- SlashCommand::Unknown(name) => format!("/{name}"),
- _ => rest[0].clone(),
- }
- )),
+ Some(command) => Err(match command {
+ SlashCommand::Unknown(name) => format_unknown_slash_command_message(&name),
+ _ => format!(
+ "slash command {command_name} is interactive-only. Start `claw` and run it there, or use `claw --resume SESSION.jsonl {command_name}` when the command is marked [resume] in /help.",
+ command_name = rest[0]
+ ),
+ }),
None => Err(format!("unknown subcommand: {}", rest[0])),
}
}
@@ -670,6 +670,7 @@ struct StatusContext {
memory_file_count: usize,
project_root: Option<PathBuf>,
git_branch: Option<String>,
+ git_summary: GitWorkspaceSummary,
sandbox_status: runtime::SandboxStatus,
}
@@ -682,6 +683,59 @@ struct StatusUsage {
estimated_tokens: usize,
}
+#[allow(clippy::struct_field_names)]
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+struct GitWorkspaceSummary {
+ changed_files: usize,
+ staged_files: usize,
+ unstaged_files: usize,
+ untracked_files: usize,
+ conflicted_files: usize,
+}
+
+impl GitWorkspaceSummary {
+ fn is_clean(self) -> bool {
+ self.changed_files == 0
+ }
+
+ fn headline(self) -> String {
+ if self.is_clean() {
+ "clean".to_string()
+ } else {
+ let mut details = Vec::new();
+ if self.staged_files > 0 {
+ details.push(format!("{} staged", self.staged_files));
+ }
+ if self.unstaged_files > 0 {
+ details.push(format!("{} unstaged", self.unstaged_files));
+ }
+ if self.untracked_files > 0 {
+ details.push(format!("{} untracked", self.untracked_files));
+ }
+ if self.conflicted_files > 0 {
+ details.push(format!("{} conflicted", self.conflicted_files));
+ }
+ format!(
+ "dirty · {} files · {}",
+ self.changed_files,
+ details.join(", ")
+ )
+ }
+ }
+}
+
+fn format_unknown_slash_command_message(name: &str) -> String {
+ let suggestions = suggest_slash_commands(name, 3);
+ if suggestions.is_empty() {
+ format!("unknown slash command: /{name}. Use /help to list available commands.")
+ } else {
+ format!(
+ "unknown slash command: /{name}. Did you mean {}? Use /help to list available commands.",
+ suggestions.join(", ")
+ )
+ }
+}
+
fn format_model_report(model: &str, message_count: usize, turns: u32) -> String {
format!(
"Model
@@ -827,6 +881,44 @@ fn parse_git_status_branch(status: Option<&str>) -> Option<String> {
}
}
+fn parse_git_workspace_summary(status: Option<&str>) -> GitWorkspaceSummary {
+ let mut summary = GitWorkspaceSummary::default();
+ let Some(status) = status else {
+ return summary;
+ };
+
+ for line in status.lines() {
+ if line.starts_with("## ") || line.trim().is_empty() {
+ continue;
+ }
+
+ summary.changed_files += 1;
+ let mut chars = line.chars();
+ let index_status = chars.next().unwrap_or(' ');
+ let worktree_status = chars.next().unwrap_or(' ');
+
+ if index_status == '?' && worktree_status == '?' {
+ summary.untracked_files += 1;
+ continue;
+ }
+
+ if index_status != ' ' {
+ summary.staged_files += 1;
+ }
+ if worktree_status != ' ' {
+ summary.unstaged_files += 1;
+ }
+ if (matches!(index_status, 'U' | 'A') && matches!(worktree_status, 'U' | 'A'))
+ || index_status == 'U'
+ || worktree_status == 'U'
+ {
+ summary.conflicted_files += 1;
+ }
+ }
+
+ summary
+}
+
fn resolve_git_branch_for(cwd: &Path) -> Option<String> {
let branch = run_git_capture_in(cwd, &["branch", "--show-current"])?;
let branch = branch.trim();
@@ -1188,6 +1280,15 @@ impl LiveCli {
|_| "<unknown>".to_string(),
|path| path.display().to_string(),
);
+ let status = status_context(None).ok();
+ let git_branch = status
+ .as_ref()
+ .and_then(|context| context.git_branch.as_deref())
+ .unwrap_or("unknown");
+ let workspace = status.as_ref().map_or_else(
+ || "unknown".to_string(),
+ |context| context.git_summary.headline(),
+ );
format!(
"\x1b[38;5;196m\
██████╗██╗ █████╗ ██╗ ██╗\n\
@@ -1198,11 +1299,15 @@ impl LiveCli {
╚═════╝╚══════╝╚═╝ ╚═╝ ╚══╝╚══╝\x1b[0m \x1b[38;5;208mCode\x1b[0m 🦞\n\n\
\x1b[2mModel\x1b[0m {}\n\
\x1b[2mPermissions\x1b[0m {}\n\
+ \x1b[2mBranch\x1b[0m {}\n\
+ \x1b[2mWorkspace\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",
+ Type \x1b[1m/help\x1b[0m for commands · \x1b[1m/status\x1b[0m for live context · \x1b[1m/diff\x1b[0m then \x1b[1m/commit\x1b[0m to ship · \x1b[2mShift+Enter\x1b[0m for newline",
self.model,
self.permission_mode.as_str(),
+ git_branch,
+ workspace,
cwd,
self.session.id,
)
@@ -1416,7 +1521,7 @@ impl LiveCli {
false
}
SlashCommand::Unknown(name) => {
- eprintln!("unknown slash command: /{name}");
+ eprintln!("{}", format_unknown_slash_command_message(&name));
false
}
})
@@ -1885,12 +1990,19 @@ impl LiveCli {
}
fn run_commit(&mut self) -> Result<(), Box<dyn std::error::Error>> {
- let status = git_output(&["status", "--short"])?;
- if status.trim().is_empty() {
- println!("Commit\n Result skipped\n Reason no workspace changes");
+ let status = git_output(&["status", "--short", "--branch"])?;
+ let summary = parse_git_workspace_summary(Some(&status));
+ let branch = parse_git_status_branch(Some(&status));
+ if summary.is_clean() {
+ println!("{}", format_commit_skipped_report());
return Ok(());
}
+ println!(
+ "{}",
+ format_commit_preflight_report(branch.as_deref(), summary)
+ );
+
git_status_ok(&["add", "-A"])?;
let staged_stat = git_output(&["diff", "--cached", "--stat"])?;
let prompt = format!(
@@ -1911,13 +2023,12 @@ impl LiveCli {
.output()?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
- return Err(format!("git commit failed: {stderr}").into());
+ return Err(format_git_commit_failure(&stderr).into());
}
println!(
- "Commit\n Result created\n Message file {}\n\n{}",
- path.display(),
- message.trim()
+ "{}",
+ format_commit_success_report(branch.as_deref(), summary, &path, &staged_stat, &message,)
);
Ok(())
}
@@ -2058,33 +2169,35 @@ fn list_managed_sessions() -> Result<Vec<ManagedSessionSummary>, Box<dyn std::er
.map(|duration| duration.as_secs())
.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,
@@ -2165,6 +2278,7 @@ fn status_context(
let project_context = ProjectContext::discover_with_git(&cwd, DEFAULT_DATE)?;
let (project_root, git_branch) =
parse_git_status_metadata(project_context.git_status.as_deref());
+ let git_summary = parse_git_workspace_summary(project_context.git_status.as_deref());
let sandbox_status = resolve_sandbox_status(runtime_config.sandbox(), &cwd);
Ok(StatusContext {
cwd,
@@ -2174,6 +2288,7 @@ fn status_context(
memory_file_count: project_context.instruction_files.len(),
project_root,
git_branch,
+ git_summary,
sandbox_status,
})
}
@@ -2210,15 +2325,26 @@ fn format_status_report(
Cwd {}
Project root {}
Git branch {}
+ Git state {}
+ Changed files {}
+ Staged {}
+ Unstaged {}
+ Untracked {}
Session {}
Config files loaded {}/{}
- Memory files {}",
+ Memory files {}
+ Suggested flow /status → /diff → /commit",
context.cwd.display(),
context
.project_root
.as_ref()
.map_or_else(|| "unknown".to_string(), |path| path.display().to_string()),
context.git_branch.as_deref().unwrap_or("unknown"),
+ context.git_summary.headline(),
+ context.git_summary.changed_files,
+ context.git_summary.staged_files,
+ context.git_summary.unstaged_files,
+ context.git_summary.untracked_files,
context.session_path.as_ref().map_or_else(
|| "live-repl".to_string(),
|path| path.display().to_string()
@@ -2279,6 +2405,70 @@ fn format_sandbox_report(status: &runtime::SandboxStatus) -> String {
)
}
+fn format_commit_preflight_report(branch: Option<&str>, summary: GitWorkspaceSummary) -> String {
+ format!(
+ "Commit
+ Result preparing
+ Branch {}
+ Workspace {}
+ Changed files {}
+ Action auto-stage workspace changes and draft Lore commit message",
+ branch.unwrap_or("unknown"),
+ summary.headline(),
+ summary.changed_files,
+ )
+}
+
+fn format_commit_skipped_report() -> String {
+ "Commit
+ Result skipped
+ Reason no workspace changes
+ Next /status to inspect context · /diff to inspect repo changes"
+ .to_string()
+}
+
+fn format_commit_success_report(
+ branch: Option<&str>,
+ summary: GitWorkspaceSummary,
+ message_path: &Path,
+ staged_stat: &str,
+ message: &str,
+) -> String {
+ let staged_summary = staged_stat.trim();
+ format!(
+ "Commit
+ Result created
+ Branch {}
+ Workspace {}
+ Changed files {}
+ Message file {}
+
+Staged diff
+{}
+
+Lore message
+{}",
+ branch.unwrap_or("unknown"),
+ summary.headline(),
+ summary.changed_files,
+ message_path.display(),
+ if staged_summary.is_empty() {
+ " <summary unavailable>".to_string()
+ } else {
+ indent_block(staged_summary, 2)
+ },
+ message.trim()
+ )
+}
+
+fn format_git_commit_failure(stderr: &str) -> String {
+ if stderr.contains("Author identity unknown") || stderr.contains("Please tell me who you are") {
+ "git commit failed: author identity is not configured. Run `git config user.name \"Your Name\"` and `git config user.email \"[email protected]\"`, then retry /commit.".to_string()
+ } else {
+ format!("git commit failed: {stderr}")
+ }
+}
+
fn render_config_report(section: Option<&str>) -> Result<String, Box<dyn std::error::Error>> {
let cwd = env::current_dir()?;
let loader = ConfigLoader::default_for(&cwd);
@@ -3146,7 +3336,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 +3477,6 @@ impl AnthropicRuntimeClient {
progress_reporter,
})
}
-
}
fn resolve_cli_auth_source() -> Result<AuthSource, Box<dyn std::error::Error>> {
@@ -4023,7 +4213,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,
@@ -4245,18 +4437,19 @@ 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_commit_preflight_report, format_commit_skipped_report, format_commit_success_report,
+ 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,
+ format_tool_call_start, format_tool_result, format_unknown_slash_command_message,
+ normalize_permission_mode, parse_args, parse_git_status_branch,
+ parse_git_status_metadata_for, parse_git_workspace_summary, 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,
- resume_supported_slash_commands, run_resume_command, status_context, CliAction,
- CliOutputFormat, InternalPromptProgressEvent,
+ render_memory_report, render_repl_help, resolve_model_alias, resolve_session_reference,
+ response_to_events, resume_supported_slash_commands, run_resume_command, status_context,
+ CliAction, CliOutputFormat, GitWorkspaceSummary, InternalPromptProgressEvent,
InternalPromptProgressState, SlashCommand, StatusUsage, DEFAULT_MODEL,
- create_managed_session_handle, resolve_session_reference,
};
use api::{MessageResponse, OutputContentBlock, Usage};
use plugins::{PluginTool, PluginToolDefinition, PluginToolPermission};
@@ -4532,7 +4725,16 @@ mod tests {
);
let error = parse_args(&["/status".to_string()])
.expect_err("/status should remain REPL-only when invoked directly");
- assert!(error.contains("unsupported direct slash command"));
+ assert!(error.contains("interactive-only"));
+ assert!(error.contains("claw --resume SESSION.jsonl /status"));
+ }
+
+ #[test]
+ fn formats_unknown_slash_command_with_suggestions() {
+ let report = format_unknown_slash_command_message("stats");
+ assert!(report.contains("unknown slash command: /stats"));
+ assert!(report.contains("Did you mean /status?"));
+ assert!(report.contains("Use /help"));
}
#[test]
@@ -4775,6 +4977,13 @@ mod tests {
memory_file_count: 4,
project_root: Some(PathBuf::from("/tmp")),
git_branch: Some("main".to_string()),
+ git_summary: GitWorkspaceSummary {
+ changed_files: 3,
+ staged_files: 1,
+ unstaged_files: 1,
+ untracked_files: 1,
+ conflicted_files: 0,
+ },
sandbox_status: runtime::SandboxStatus::default(),
},
);
@@ -4787,9 +4996,54 @@ mod tests {
assert!(status.contains("Cwd /tmp/project"));
assert!(status.contains("Project root /tmp"));
assert!(status.contains("Git branch main"));
+ assert!(
+ status.contains("Git state dirty · 3 files · 1 staged, 1 unstaged, 1 untracked")
+ );
+ assert!(status.contains("Changed files 3"));
+ assert!(status.contains("Staged 1"));
+ assert!(status.contains("Unstaged 1"));
+ assert!(status.contains("Untracked 1"));
assert!(status.contains("Session session.jsonl"));
assert!(status.contains("Config files loaded 2/3"));
assert!(status.contains("Memory files 4"));
+ assert!(status.contains("Suggested flow /status → /diff → /commit"));
+ }
+
+ #[test]
+ fn commit_reports_surface_workspace_context() {
+ let summary = GitWorkspaceSummary {
+ changed_files: 2,
+ staged_files: 1,
+ unstaged_files: 1,
+ untracked_files: 0,
+ conflicted_files: 0,
+ };
+
+ let preflight = format_commit_preflight_report(Some("feature/ux"), summary);
+ assert!(preflight.contains("Result preparing"));
+ assert!(preflight.contains("Branch feature/ux"));
+ assert!(preflight.contains("Workspace dirty · 2 files · 1 staged, 1 unstaged"));
+
+ let success = format_commit_success_report(
+ Some("feature/ux"),
+ summary,
+ Path::new("/tmp/message.txt"),
+ " src/main.rs | 4 ++--",
+ "Improve slash command guidance",
+ );
+ assert!(success.contains("Result created"));
+ assert!(success.contains("Message file /tmp/message.txt"));
+ assert!(success.contains("Staged diff"));
+ assert!(success.contains("src/main.rs | 4 ++--"));
+ assert!(success.contains("Lore message"));
+ }
+
+ #[test]
+ fn commit_skipped_report_points_to_next_steps() {
+ let report = format_commit_skipped_report();
+ assert!(report.contains("Reason no workspace changes"));
+ assert!(report.contains("/status to inspect context"));
+ assert!(report.contains("/diff to inspect repo changes"));
}
#[test]
@@ -4847,6 +5101,32 @@ mod tests {
);
}
+ #[test]
+ fn parses_git_workspace_summary_counts() {
+ let summary = parse_git_workspace_summary(Some(
+ "## feature/ux
+M src/main.rs
+ M README.md
+?? notes.md
+UU conflicted.rs",
+ ));
+
+ assert_eq!(
+ summary,
+ GitWorkspaceSummary {
+ changed_files: 4,
+ staged_files: 2,
+ unstaged_files: 2,
+ untracked_files: 1,
+ conflicted_files: 1,
+ }
+ );
+ assert_eq!(
+ summary.headline(),
+ "dirty · 4 files · 2 staged, 2 unstaged, 1 untracked, 1 conflicted"
+ );
+ }
+
#[test]
fn render_diff_report_shows_clean_tree_for_committed_repo() {
let _guard = env_lock();
@@ -5051,8 +5331,13 @@ 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");
diff --git a/rust/crates/tools/src/lib.rs b/rust/crates/tools/src/lib.rs
index f37c636f..4c846ac3 100644
--- a/rust/crates/tools/src/lib.rs
+++ b/rust/crates/tools/src/lib.rs
@@ -91,7 +91,10 @@ impl GlobalToolRegistry {
Ok(Self { plugin_tools })
}
- pub fn normalize_allowed_tools(&self, values: &[String]) -> Result<Option<BTreeSet<String>>, String> {
+ pub fn normalize_allowed_tools(
+ &self,
+ values: &[String],
+ ) -> Result<Option<BTreeSet<String>>, String> {
if values.is_empty() {
return Ok(None);
}
@@ -100,7 +103,11 @@ impl GlobalToolRegistry {
let canonical_names = builtin_specs
.iter()
.map(|spec| spec.name.to_string())
- .chain(self.plugin_tools.iter().map(|tool| tool.definition().name.clone()))
+ .chain(
+ self.plugin_tools
+ .iter()
+ .map(|tool| tool.definition().name.clone()),
+ )
.collect::<Vec<_>>();
let mut name_map = canonical_names
.iter()
@@ -151,7 +158,8 @@ impl GlobalToolRegistry {
.plugin_tools
.iter()
.filter(|tool| {
- allowed_tools.is_none_or(|allowed| allowed.contains(tool.definition().name.as_str()))
+ allowed_tools
+ .is_none_or(|allowed| allowed.contains(tool.definition().name.as_str()))
})
.map(|tool| ToolDefinition {
name: tool.definition().name.clone(),
@@ -174,7 +182,8 @@ impl GlobalToolRegistry {
.plugin_tools
.iter()
.filter(|tool| {
- allowed_tools.is_none_or(|allowed| allowed.contains(tool.definition().name.as_str()))
+ allowed_tools
+ .is_none_or(|allowed| allowed.contains(tool.definition().name.as_str()))
})
.map(|tool| {
(
@@ -1809,8 +1818,9 @@ struct ProviderRuntimeClient {
}
impl ProviderRuntimeClient {
+ #[allow(clippy::needless_pass_by_value)]
fn new(model: String, allowed_tools: BTreeSet<String>) -> Result<Self, String> {
- let model = resolve_model_alias(&model).to_string();
+ let model = resolve_model_alias(&model).clone();
let client = ProviderClient::from_model(&model).map_err(|error| error.to_string())?;
Ok(Self {
runtime: tokio::runtime::Runtime::new().map_err(|error| error.to_string())?,
@@ -1822,6 +1832,7 @@ impl ProviderRuntimeClient {
}
impl ApiClient for ProviderRuntimeClient {
+ #[allow(clippy::too_many_lines)]
fn stream(&mut self, request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError> {
let tools = tool_specs_for_allowed_tools(Some(&self.allowed_tools))
.into_iter()
@@ -2057,7 +2068,9 @@ fn push_prompt_cache_record(client: &ProviderClient, events: &mut Vec<AssistantE
}
}
-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,