refactor(justfile): drop aliases/duplication, enforce single canonical commands, and add descriptions for all recipes

server/src/state.rs

@@ -140,31 +140,7 @@ impl MemoryState {
     }
 
     pub fn broadcast_activity(&self, category: &str, message: &str) {
-        let time = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap_or_default()
-            .as_millis() as u64;
-
-        let item = serde_json::json!({
-            "time": time,
-            "category": category,
-            "message": message
-        });
-
-        self.telemetry.recent_activities.modify(|activities| {
-            activities.push_front(item.clone());
-            if activities.len() > 100 {
-                activities.pop_back();
-            }
-        });
-
-        let payload = serde_json::json!({
-            "jsonrpc": "2.0",
-            "method": "notifications/activity",
-            "params": item
-        })
-        .to_string();
-        let _ = self.activity_tx.send(payload);
+        self.record_activity(category, message, None);
     }
 
     pub fn read_graph<F, R>(&self, f: F) -> R
@@ -237,25 +213,34 @@ impl MemoryState {
         let ts = std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)
             .unwrap_or_default()
-            .as_secs();
+            .as_millis() as u64;
+
+        let category_upper = category.to_uppercase();
 
         let activity = ActivityRecord {
             timestamp: ts,
-            category: category.to_string(),
+            category: category_upper,
             summary: summary.to_string(),
             details: details.map(|s| s.to_string()),
         };
 
-        let record = serde_json::to_value(&activity).unwrap_or_default();
+        let record_val = serde_json::to_value(&activity).unwrap_or_default();
 
         self.telemetry.recent_activities.modify(|activities| {
-            activities.push_front(record.clone());
+            activities.push_front(record_val.clone());
             if activities.len() > 100 {
                 activities.pop_back();
             }
         });
 
-        let _ = self.activity_tx.send(record.to_string());
+        let payload = serde_json::json!({
+            "jsonrpc": "2.0",
+            "method": "notifications/activity",
+            "params": activity
+        })
+        .to_string();
+
+        let _ = self.activity_tx.send(payload);
     }
 
     pub fn record_terminal_history(&self, payload: TerminalHistory) {
@@ -329,6 +314,51 @@ mod tests {
         );
         assert_eq!(results[0].1, "task", "Expected document type to be task");
     }
+
+    #[tokio::test]
+    async fn test_record_and_broadcast_activity() {
+        let dir = tempdir().unwrap();
+        let state = MemoryState::new(dir.path().to_str().unwrap());
+        let mut rx = state.activity_tx.subscribe();
+
+        // 1. Record an activity with details
+        state.record_activity("code_change", "Refactored state.rs", Some("Updated ActivityRecord schema"));
+
+        // Verify recent_activities store
+        let activities: Vec<ActivityRecord> = state.telemetry.recent_activities.read_with(|act| {
+            act.iter()
+                .filter_map(|v| serde_json::from_value(v.clone()).ok())
+                .collect()
+        });
+
+        assert_eq!(activities.len(), 1);
+        assert_eq!(activities[0].category, "CODE_CHANGE");
+        assert_eq!(activities[0].summary, "Refactored state.rs");
+        assert_eq!(activities[0].details, Some("Updated ActivityRecord schema".to_string()));
+        assert!(activities[0].timestamp > 1_700_000_000_000, "Timestamp must be in epoch milliseconds");
+
+        // Verify broadcast channel message
+        let broadcast_msg = rx.recv().await.expect("Expected broadcast notification");
+        let broadcast_val: serde_json::Value = serde_json::from_str(&broadcast_msg).expect("Valid JSON");
+        assert_eq!(broadcast_val["jsonrpc"], "2.0");
+        assert_eq!(broadcast_val["method"], "notifications/activity");
+        assert_eq!(broadcast_val["params"]["category"], "CODE_CHANGE");
+
+        // 2. Broadcast an activity without details
+        state.broadcast_activity("task", "Completed live activity fix");
+
+        let activities_updated: Vec<ActivityRecord> = state.telemetry.recent_activities.read_with(|act| {
+            act.iter()
+                .filter_map(|v| serde_json::from_value(v.clone()).ok())
+                .collect()
+        });
+
+        assert_eq!(activities_updated.len(), 2);
+        assert_eq!(activities_updated[0].category, "TASK");
+        assert_eq!(activities_updated[0].summary, "Completed live activity fix");
+        assert_eq!(activities_updated[0].details, None);
+        assert!(activities_updated[0].timestamp >= activities_updated[1].timestamp);
+    }
 }
 
 use crate::embedding::{cosine_similarity, generate_embedding_async, generate_embeddings_async};