style(clippy): auto-fix code style issues and unnecessary map_or allocations detected by cargo clippy

server/src/api/events.rs

@@ -17,10 +17,10 @@ pub async fn wait_for_event_handler(
     loop {
         match rx.recv().await {
             Ok(event) => {
-                let topic_matches = topic.as_ref().map_or(true, |t| t == &event.topic);
+                let topic_matches = topic.as_ref().is_none_or(|t| t == &event.topic);
                 let session_matches = session_id
                     .as_ref()
-                    .map_or(true, |s| Some(s) == event.session_id.as_ref());
+                    .is_none_or(|s| Some(s) == event.session_id.as_ref());
 
                 if topic_matches && session_matches {
                     return axum::Json(event);

server/src/api/telemetry.rs

@@ -50,17 +50,17 @@ pub async fn nvim_telemetry_handler(
         let _ = tx.try_send(msg_str.clone());
     }
 
-    if payload.event == "BufWritePost" {
-        if let Some(ref file_path) = payload.file {
-            let normalized_file = file_path.replace("\\", "/");
-            let topic = format!("nvim:save:{}", normalized_file);
-            let event = crate::state::GenericEvent {
-                topic,
-                session_id: Some(payload.session_id.clone()),
-                payload: serde_json::json!(&payload),
-            };
-            let _ = state.handler.state.event_bus_tx.send(event);
-        }
+    if payload.event == "BufWritePost"
+        && let Some(ref file_path) = payload.file
+    {
+        let normalized_file = file_path.replace("\\", "/");
+        let topic = format!("nvim:save:{}", normalized_file);
+        let event = crate::state::GenericEvent {
+            topic,
+            session_id: Some(payload.session_id.clone()),
+            payload: serde_json::json!(&payload),
+        };
+        let _ = state.handler.state.event_bus_tx.send(event);
     }
 
     axum::Json(serde_json::json!({"status": "ok"}))

server/src/handlers/meta.rs

@@ -274,10 +274,9 @@ impl McpTool for ReadPreferencesHandler {
     }
 
     async fn execute(&self, _args: Value, state: Arc<MemoryState>) -> Result<String, String> {
-        let data = state
+        state
             .prefs
-            .read_with(|prefs| serde_json::to_string(prefs).map_err(|e| e.to_string()));
-        data
+            .read_with(|prefs| serde_json::to_string(prefs).map_err(|e| e.to_string()))
     }
 }
 

server/src/handlers/workspaces.rs

@@ -275,7 +275,7 @@ impl McpTool for ListContextWorkspacesHandler {
         let data = state.context_workspaces.read_with(|ws| {
             let filtered: Vec<_> = ws
                 .iter()
-                .filter(|w| req.namespace.as_ref().map_or(true, |ns| &w.namespace == ns))
+                .filter(|w| req.namespace.as_ref().is_none_or(|ns| &w.namespace == ns))
                 .collect();
             serde_json::to_string(&filtered).map_err(|e| e.to_string())
         })?;

server/src/router.rs

@@ -587,8 +587,16 @@ mod tests {
         });
         let res_list = handler.handle_request(req_list_res).await.unwrap();
         let resources_arr = res_list["result"]["resources"].as_array().unwrap();
-        assert!(resources_arr.iter().any(|r| r["uri"] == "memory://tasks/active"));
-        assert!(resources_arr.iter().any(|r| r["uri"] == "memory://pinned_files"));
+        assert!(
+            resources_arr
+                .iter()
+                .any(|r| r["uri"] == "memory://tasks/active")
+        );
+        assert!(
+            resources_arr
+                .iter()
+                .any(|r| r["uri"] == "memory://pinned_files")
+        );
 
         // Test resources/read
         let req_read_res = json!({
@@ -600,8 +608,16 @@ mod tests {
             }
         });
         let res_read = handler.handle_request(req_read_res).await.unwrap();
-        assert_eq!(res_read["result"]["contents"][0]["uri"], "memory://tasks/active");
-        assert!(res_read["result"]["contents"][0]["text"].as_str().unwrap().contains("[]")); // Empty tasks
+        assert_eq!(
+            res_read["result"]["contents"][0]["uri"],
+            "memory://tasks/active"
+        );
+        assert!(
+            res_read["result"]["contents"][0]["text"]
+                .as_str()
+                .unwrap()
+                .contains("[]")
+        ); // Empty tasks
 
         // Test prompts/list
         let req_list_prompts = json!({
@@ -627,7 +643,12 @@ mod tests {
         let res_get = handler.handle_request(req_get_prompt).await.unwrap();
         let messages = res_get["result"]["messages"].as_array().unwrap();
         assert_eq!(messages[0]["role"], "user");
-        assert!(messages[0]["content"]["text"].as_str().unwrap().contains("standup report"));
+        assert!(
+            messages[0]["content"]["text"]
+                .as_str()
+                .unwrap()
+                .contains("standup report")
+        );
     }
 
     #[tokio::test]

server/src/store.rs

@@ -28,7 +28,9 @@ impl<T: DeserializeOwned + Default + Serialize + Clone + Send + Sync + 'static>
                 let key_inner = key_clone.clone();
                 let json_data = {
                     let lock = cache_clone.read().unwrap_or_else(|e| e.into_inner());
-                    serde_json::to_vec(&*lock).map_err(|e| tracing::error!("Failed to serialize memory store: {}", e)).ok()
+                    serde_json::to_vec(&*lock)
+                        .map_err(|e| tracing::error!("Failed to serialize memory store: {}", e))
+                        .ok()
                 };
 
                 if let Some(json_data) = json_data {