Correct formatting

Author: RoyCoding8

src/app.rs

@@ -541,11 +541,7 @@ impl App {
             let mut ok = 0usize;
             let mut failed = 0usize;
             for idx in action.trash {
-                match self
-                    .chat_sessions
-                    .get(idx)
-                    .map(chat::soft_delete)
-                {
+                match self.chat_sessions.get(idx).map(chat::soft_delete) {
                     Some(Ok(())) => ok += 1,
                     _ => failed += 1,
                 }

src/chat.rs

@@ -161,15 +161,21 @@ struct SessionMeta {
     turn_count: usize,
 }
 
-pub fn scan_all(workspace: &Path, provider_filter: Option<crate::types::ProviderId>) -> Vec<ChatSession> {
+pub fn scan_all(
+    workspace: &Path,
+    provider_filter: Option<crate::types::ProviderId>,
+) -> Vec<ChatSession> {
     let mut sessions = Vec::new();
     let include = |p: ChatProvider| -> bool {
         provider_filter.is_none_or(|prov| {
             matches!(
                 (prov, p),
                 (crate::types::ProviderId::Claude, ChatProvider::Claude)
                     | (crate::types::ProviderId::Codex, ChatProvider::Codex)
-                    | (crate::types::ProviderId::Antigravity, ChatProvider::Antigravity)
+                    | (
+                        crate::types::ProviderId::Antigravity,
+                        ChatProvider::Antigravity
+                    )
                     | (crate::types::ProviderId::Kiro, ChatProvider::Kiro)
                     | (crate::types::ProviderId::OpenCode, ChatProvider::OpenCode)
             )
@@ -639,7 +645,8 @@ fn scan_opencode() -> Vec<ChatSession> {
     let Some(db_path) = opencode_db_path() else {
         return vec![];
     };
-    let Ok(conn) = Connection::open_with_flags(&db_path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY)
+    let Ok(conn) =
+        Connection::open_with_flags(&db_path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY)
     else {
         return vec![];
     };
@@ -667,8 +674,8 @@ fn scan_opencode() -> Vec<ChatSession> {
         .map(|r| r.filter_map(|r| r.ok()).collect())
         .unwrap_or_default();
     rows.into_iter()
-        .map(|(id, title, directory, created, updated, msg_count)| {
-            ChatSession {
+        .map(
+            |(id, title, directory, created, updated, msg_count)| ChatSession {
                 id: id.clone(),
                 title,
                 provider: ChatProvider::OpenCode,
@@ -681,8 +688,8 @@ fn scan_opencode() -> Vec<ChatSession> {
                 size_bytes: 0,
                 imported: false,
                 trash_manifest: None,
-            }
-        })
+            },
+        )
         .collect()
 }
 
@@ -715,8 +722,7 @@ fn load_opencode_archive(session: &ChatSession) -> Result<ChatArchive> {
                 });
             }
         }
-        if let Some(tool_name) = str_field(&val, &["name"]).or_else(|| str_field(&val, &["tool"]))
-        {
+        if let Some(tool_name) = str_field(&val, &["name"]).or_else(|| str_field(&val, &["tool"])) {
             tools.push(ChatToolCall {
                 name: tool_name.to_string(),
                 timestamp: None,
@@ -742,28 +748,27 @@ fn extract_text_field(val: &Value) -> String {
     str_field(val, &["content", "text", "message"])
         .map(ToOwned::to_owned)
         .or_else(|| {
-            val.get("content")
-                .and_then(|c| {
-                    if let Some(s) = c.as_str() {
-                        Some(s.to_string())
-                    } else if let Some(arr) = c.as_array() {
-                        let parts: Vec<String> = arr
-                            .iter()
-                            .filter_map(|item| {
-                                str_field(item, &["text"])
-                                    .or_else(|| str_field(item, &["content"]))
-                                    .map(ToOwned::to_owned)
-                            })
-                            .collect();
-                        if parts.is_empty() {
-                            None
-                        } else {
-                            Some(parts.join("\n"))
-                        }
-                    } else {
+            val.get("content").and_then(|c| {
+                if let Some(s) = c.as_str() {
+                    Some(s.to_string())
+                } else if let Some(arr) = c.as_array() {
+                    let parts: Vec<String> = arr
+                        .iter()
+                        .filter_map(|item| {
+                            str_field(item, &["text"])
+                                .or_else(|| str_field(item, &["content"]))
+                                .map(ToOwned::to_owned)
+                        })
+                        .collect();
+                    if parts.is_empty() {
                         None
+                    } else {
+                        Some(parts.join("\n"))
                     }
-                })
+                } else {
+                    None
+                }
+            })
         })
         .unwrap_or_default()
 }

src/scanner.rs

@@ -322,9 +322,9 @@ fn collect_hook_items(
                 .get("hooks")
                 .and_then(|h| h.as_array())
                 .and_then(|a| a.first())
-        .and_then(|h| h.get("name").or_else(|| h.get("command")))
-            .and_then(|n| n.as_str())
-            .map(String::from);
+                .and_then(|h| h.get("name").or_else(|| h.get("command")))
+                .and_then(|n| n.as_str())
+                .map(String::from);
             let display = hook_name
                 .clone()
                 .unwrap_or_else(|| format!("{}: {}", event, matcher));
@@ -543,21 +543,15 @@ fn scan_kiro(root: &Path, scope: Scope) -> Vec<ConfigItem> {
         ProviderId::Kiro,
     ));
 
-    for (agents_dir, force_disabled) in [
-        (d.join("agents"), false),
-        (d.join("agents.disabled"), true),
-    ] {
+    for (agents_dir, force_disabled) in
+        [(d.join("agents"), false), (d.join("agents.disabled"), true)]
+    {
         if agents_dir.is_dir() {
             if let Ok(rd) = std::fs::read_dir(&agents_dir) {
                 for e in rd.flatten() {
                     let p = e.path();
                     if p.extension().and_then(|e| e.to_str()) == Some("json") {
-                        items.extend(scan_hook_entries(
-                            &p,
-                            ProviderId::Kiro,
-                            &[],
-                            force_disabled,
-                        ));
+                        items.extend(scan_hook_entries(&p, ProviderId::Kiro, &[], force_disabled));
                     }
                 }
             }