chore(rust): align formatting and resolve clippy warnings

Author: Mgrsc

src/agent.rs

@@ -11,8 +11,8 @@ use uuid::Uuid;
 use crate::config::AgentConfig;
 use crate::logging::{summarize_json, summarize_text};
 use crate::providers::{
-    ChatOptions, ContentPart, ConversationMessage, Provider, Role, StreamEvent,
-    ThinkingBlock, ToolCall, ToolSpec, Usage,
+    ChatOptions, ContentPart, ConversationMessage, Provider, Role, StreamEvent, ThinkingBlock,
+    ToolCall, ToolSpec, Usage,
 };
 use crate::tools::{Tool, ToolResult};
 use crate::util::fs::atomic_write_text;
@@ -51,7 +51,10 @@ pub struct Agent {
 }
 
 impl Agent {
-    pub fn new(config: AgentConfig, compression_provider: (Arc<dyn Provider>, ChatOptions)) -> Self {
+    pub fn new(
+        config: AgentConfig,
+        compression_provider: (Arc<dyn Provider>, ChatOptions),
+    ) -> Self {
         Self {
             history: Vec::new(),
             total_usage: Usage::default(),
@@ -104,7 +107,7 @@ impl Agent {
             CallStrategy::<fn(&str)>::Blocking,
             None,
         )
-            .await
+        .await
     }
 
     pub async fn run_turn_stream(
@@ -365,7 +368,8 @@ impl Agent {
                     let kind = meta.get("kind").and_then(serde_json::Value::as_str);
                     match kind {
                         Some("openai_reasoning_content_delta") => {
-                            if let Some(delta) = meta.get("delta").and_then(serde_json::Value::as_str)
+                            if let Some(delta) =
+                                meta.get("delta").and_then(serde_json::Value::as_str)
                             {
                                 reasoning_buf.push_str(delta);
                             }

src/channels/telegram.rs

@@ -190,8 +190,7 @@ fn normalize_telegram_markdown(text: &str) -> String {
 fn escape_markdown_v2_char(ch: char, out: &mut String) {
     if matches!(
         ch,
-        '\\'
-            | '_'
+        '\\' | '_'
             | '*'
             | '['
             | ']'
@@ -371,9 +370,10 @@ fn render_markdown_v2_safe(text: &str) -> String {
             }
         }
 
-        if let Some(inner) = rest.strip_prefix("**").and_then(|t| {
-            t.find("**").map(|end| &t[..end]).filter(|t| !t.is_empty())
-        }) {
+        if let Some(inner) = rest
+            .strip_prefix("**")
+            .and_then(|t| t.find("**").map(|end| &t[..end]).filter(|t| !t.is_empty()))
+        {
             out.push('*');
             out.push_str(&escape_markdown_v2_text(inner));
             out.push('*');

src/commands.rs

@@ -127,24 +127,31 @@ pub async fn try_handle_command(
             let skills = hot.skills.len();
             let pending = hot.todo.pending_count();
 
-            let has_assistant = agent.history.iter().any(|m| matches!(m.role, Role::Assistant));
+            let has_assistant = agent
+                .history
+                .iter()
+                .any(|m| matches!(m.role, Role::Assistant));
             let usage_warning = total == 0 && has_assistant;
 
             let mut out = String::new();
-            out.push_str(&format!("⚙️  System\n"));
+            out.push_str("⚙️  System\n");
             out.push_str(&format!("  Version   {}\n", env!("ZERDA_VERSION")));
             out.push_str(&format!("  Platform  {platform} ({os_name})\n"));
             out.push_str(&format!("  Shell     {shell}\n"));
-            out.push_str(&format!("\n🤖 Provider\n"));
+            out.push_str("\n🤖 Provider\n");
             out.push_str(&format!("  Provider  {provider_name}\n"));
             out.push_str(&format!("  Model     {model}\n"));
             out.push_str(&format!("  Temp/TopP {temp} / {top_p}\n"));
-            out.push_str(&format!("\n💬 Session\n"));
-            out.push_str(&format!("  History   {non_system}/{max_history} messages\n"));
-            out.push_str(&format!("  Tools     {tool_total} ({builtin} builtin + {mcp} mcp)\n"));
+            out.push_str("\n💬 Session\n");
+            out.push_str(&format!(
+                "  History   {non_system}/{max_history} messages\n"
+            ));
+            out.push_str(&format!(
+                "  Tools     {tool_total} ({builtin} builtin + {mcp} mcp)\n"
+            ));
             out.push_str(&format!("  Skills    {skills} loaded\n"));
             out.push_str(&format!("  Todos     {pending} pending\n"));
-            out.push_str(&format!("\n📊 Tokens\n"));
+            out.push_str("\n📊 Tokens\n");
             out.push_str(&format!("  Input     {}\n", fmt_thousands(input_tokens)));
             out.push_str(&format!("  Output    {}\n", fmt_thousands(output_tokens)));
             out.push_str(&format!("  Total     {}", fmt_thousands(total)));
@@ -170,7 +177,7 @@ fn fmt_thousands(n: u64) -> String {
     let s = n.to_string();
     let mut result = String::with_capacity(s.len() + s.len() / 3);
     for (i, c) in s.chars().enumerate() {
-        if i > 0 && (s.len() - i) % 3 == 0 {
+        if i > 0 && (s.len() - i).is_multiple_of(3) {
             result.push(',');
         }
         result.push(c);

src/main.rs

@@ -87,18 +87,16 @@ async fn main() -> Result<()> {
                 print!("{}", include_str!("../zerda.toml.full"));
                 return Ok(());
             }
-            ConfigAction::Validate => {
-                match config::load_config(cli.config.as_deref()) {
-                    Ok(_) => {
-                        println!("Configuration is valid.");
-                        return Ok(());
-                    }
-                    Err(e) => {
-                        eprintln!("Configuration error: {e}");
-                        std::process::exit(1);
-                    }
+            ConfigAction::Validate => match config::load_config(cli.config.as_deref()) {
+                Ok(_) => {
+                    println!("Configuration is valid.");
+                    return Ok(());
                 }
-            }
+                Err(e) => {
+                    eprintln!("Configuration error: {e}");
+                    std::process::exit(1);
+                }
+            },
         }
     }
 
@@ -154,19 +152,23 @@ async fn main() -> Result<()> {
                 (Arc::from(p), opts)
             }
             Err(e) => {
-                tracing::warn!("Failed to create fast_model provider, falling back to main provider: {e}");
+                tracing::warn!(
+                    "Failed to create fast_model provider, falling back to main provider: {e}"
+                );
                 let p = providers::create_provider(&cfg.provider)
                     .expect("main provider already validated");
                 (Arc::from(p), chat_opts.clone())
             }
         }
     } else {
-        let p = providers::create_provider(&cfg.provider)
-            .expect("main provider already validated");
+        let p = providers::create_provider(&cfg.provider).expect("main provider already validated");
         (Arc::from(p), chat_opts.clone())
     };
 
-    let subagent_provider = (Arc::clone(&fast_model_provider.0), fast_model_provider.1.clone());
+    let subagent_provider = (
+        Arc::clone(&fast_model_provider.0),
+        fast_model_provider.1.clone(),
+    );
 
     let tools_runtime = tools::BuiltinToolsRuntime {
         tool_timeout: cfg.agent.tool_timeout,
@@ -181,7 +183,8 @@ async fn main() -> Result<()> {
         skill_cache: Arc::clone(&skill_cache),
         subagent_provider: Some(subagent_provider),
     };
-    let (mut all_tools, todo_handle) = tools::builtin_tools((tools_runtime, tools_dependencies).into());
+    let (mut all_tools, todo_handle) =
+        tools::builtin_tools((tools_runtime, tools_dependencies).into());
 
     let builtin_count = all_tools.len();
     let mcp_tools = tools::mcp::connect_mcp_servers(&cfg.mcp).await;
@@ -194,11 +197,16 @@ async fn main() -> Result<()> {
         None
     };
 
-    let system_prompt =
-        prompt::build_system_prompt(identity_text.as_deref(), None);
+    let system_prompt = prompt::build_system_prompt(identity_text.as_deref(), None);
 
     let compression_provider = (fast_model_provider.0, fast_model_provider.1);
-    let mut agent = agent::Agent::new(cfg.agent.clone(), (Arc::clone(&compression_provider.0), compression_provider.1.clone()));
+    let mut agent = agent::Agent::new(
+        cfg.agent.clone(),
+        (
+            Arc::clone(&compression_provider.0),
+            compression_provider.1.clone(),
+        ),
+    );
     agent.set_system_prompt(system_prompt);
 
     let sessions_dir = config::resolve_path(config::MEMORY_DIR).join("sessions");

src/prompt.rs

@@ -14,10 +14,7 @@ static ENV_INFO: LazyLock<EnvInfo> = LazyLock::new(|| EnvInfo {
     package_manager: detect_package_manager(),
 });
 
-pub fn build_system_prompt(
-    identity: Option<&str>,
-    channel_supplement: Option<&str>,
-) -> String {
+pub fn build_system_prompt(identity: Option<&str>, channel_supplement: Option<&str>) -> String {
     let mut parts: Vec<String> = Vec::new();
 
     if let Some(id) = identity {

src/providers/anthropic.rs

@@ -6,8 +6,8 @@ use serde_json::{json, Value};
 
 use super::{
     sse_stream, truncate_for_log, ChatOptions, ContentPart, ConversationMessage, HttpClient,
-    Provider, ProviderResponse, Role, StreamEvent, StreamResult, ThinkingBlock, ToolCall,
-    ToolSpec, Usage,
+    Provider, ProviderResponse, Role, StreamEvent, StreamResult, ThinkingBlock, ToolCall, ToolSpec,
+    Usage,
 };
 use crate::config::ProviderConfig;
 
@@ -183,7 +183,10 @@ impl AnthropicProvider {
                             .and_then(Value::as_str)
                             .map(std::string::ToString::to_string);
                         if !thinking.is_empty() || signature.is_some() {
-                            thinking_blocks.push(ThinkingBlock::Thinking { thinking, signature });
+                            thinking_blocks.push(ThinkingBlock::Thinking {
+                                thinking,
+                                signature,
+                            });
                         }
                     }
                     Some("redacted_thinking") => {
@@ -328,10 +331,7 @@ enum PendingThinkingKind {
     RedactedThinking,
 }
 
-fn parse_sse_event(
-    block: &str,
-    state: &mut AnthropicStreamState,
-) -> Vec<Result<StreamEvent>> {
+fn parse_sse_event(block: &str, state: &mut AnthropicStreamState) -> Vec<Result<StreamEvent>> {
     let mut event_type = "";
     let mut data_str = String::new();
 
@@ -373,7 +373,11 @@ fn parse_sse_event(
             let Some(cb) = data.get("content_block") else {
                 return Vec::new();
             };
-            let Some(index) = data.get("index").and_then(Value::as_u64).map(|v| v as usize) else {
+            let Some(index) = data
+                .get("index")
+                .and_then(Value::as_u64)
+                .map(|v| v as usize)
+            else {
                 return Vec::new();
             };
             let Some(block_type) = cb.get("type").and_then(Value::as_str) else {
@@ -419,7 +423,11 @@ fn parse_sse_event(
             let Some(delta) = data.get("delta") else {
                 return Vec::new();
             };
-            let Some(index) = data.get("index").and_then(Value::as_u64).map(|v| v as usize) else {
+            let Some(index) = data
+                .get("index")
+                .and_then(Value::as_u64)
+                .map(|v| v as usize)
+            else {
                 return Vec::new();
             };
             let Some(delta_type) = delta.get("type").and_then(Value::as_str) else {
@@ -472,7 +480,11 @@ fn parse_sse_event(
             }
         }
         "content_block_stop" => {
-            let Some(index) = data.get("index").and_then(Value::as_u64).map(|v| v as usize) else {
+            let Some(index) = data
+                .get("index")
+                .and_then(Value::as_u64)
+                .map(|v| v as usize)
+            else {
                 return Vec::new();
             };
             let Some(pending) = state.pending_thinking.remove(&index) else {

src/runner.rs

@@ -52,10 +52,7 @@ pub(crate) fn refresh_prompt(
     hot: &HotState,
     channel_supplement: Option<&str>,
 ) {
-    let system_prompt = build_system_prompt(
-        hot.identity_text.as_deref(),
-        channel_supplement,
-    );
+    let system_prompt = build_system_prompt(hot.identity_text.as_deref(), channel_supplement);
     agent.set_system_prompt(system_prompt);
 }
 
@@ -181,7 +178,10 @@ async fn post_turn(agent: &mut agent::Agent, hot: &HotState) -> BudgetStatus {
         }
     }
 
-    if let Err(e) = agent.auto_compact(&config::resolve_path(config::MEMORY_DIR)).await {
+    if let Err(e) = agent
+        .auto_compact(&config::resolve_path(config::MEMORY_DIR))
+        .await
+    {
         tracing::warn!("Auto-compact failed: {e}");
     }
     BudgetStatus::Ok
@@ -272,10 +272,7 @@ fn light_reload_blockers(old_cfg: &Config, new_cfg: &Config) -> Vec<String> {
     if old_cfg.agent.max_memory_tokens != new_cfg.agent.max_memory_tokens {
         blockers.push("agent.max_memory_tokens".to_string());
     }
-    if !fast_model_equal(
-        &old_cfg.agent.fast_model,
-        &new_cfg.agent.fast_model,
-    ) {
+    if !fast_model_equal(&old_cfg.agent.fast_model, &new_cfg.agent.fast_model) {
         blockers.push("agent.fast_model".to_string());
     }
     if old_cfg.agent.show_usage != new_cfg.agent.show_usage {
@@ -588,7 +585,10 @@ pub async fn run_serve(
                         } else {
                             let mut fresh = agent::Agent::new(
                                 hot.cfg.agent.clone(),
-                                (Arc::clone(&hot.compression_provider.0), hot.compression_provider.1.clone()),
+                                (
+                                    Arc::clone(&hot.compression_provider.0),
+                                    hot.compression_provider.1.clone(),
+                                ),
                             );
                             if let Ok((loaded_id, history)) =
                                 agent::Agent::load_session(sessions_dir, Some(&storage_id))
@@ -709,7 +709,10 @@ pub async fn run_serve(
         } else {
             let mut fresh = agent::Agent::new(
                 hot.cfg.agent.clone(),
-                (Arc::clone(&hot.compression_provider.0), hot.compression_provider.1.clone()),
+                (
+                    Arc::clone(&hot.compression_provider.0),
+                    hot.compression_provider.1.clone(),
+                ),
             );
             if let Ok((loaded_id, history)) =
                 agent::Agent::load_session(sessions_dir, Some(&storage_id))
@@ -760,21 +763,23 @@ pub async fn run_serve(
             let sender = sender.clone();
             let token = typing_cancel.clone();
             let span = turn_span.clone();
-            tokio::spawn(async move {
-                loop {
-                    if token.is_cancelled() {
-                        break;
-                    }
-                    if let Err(e) = ch.send_typing(&sender).await {
-                        tracing::debug!("Failed to send typing event: {e}");
-                    }
-                    tokio::select! {
-                        () = token.cancelled() => break,
-                        () = tokio::time::sleep(std::time::Duration::from_secs(4)) => {}
+            tokio::spawn(
+                async move {
+                    loop {
+                        if token.is_cancelled() {
+                            break;
+                        }
+                        if let Err(e) = ch.send_typing(&sender).await {
+                            tracing::debug!("Failed to send typing event: {e}");
+                        }
+                        tokio::select! {
+                            () = token.cancelled() => break,
+                            () = tokio::time::sleep(std::time::Duration::from_secs(4)) => {}
+                        }
                     }
                 }
-            }
-            .instrument(span));
+                .instrument(span),
+            );
         }
 
         let mut tool_phase_handle = None;

src/tools/subagent.rs

@@ -24,11 +24,7 @@ pub struct SubAgentTool {
 }
 
 impl SubAgentTool {
-    pub fn new(
-        provider: Arc<dyn Provider>,
-        mut chat_opts: ChatOptions,
-        tool_timeout: u64,
-    ) -> Self {
+    pub fn new(provider: Arc<dyn Provider>, mut chat_opts: ChatOptions, tool_timeout: u64) -> Self {
         chat_opts.max_tokens = MAX_TOKENS;
         Self {
             provider,