feat: add unified diff generation for file edits and fix replay message ordering

Author: jacobjmc

src-tauri/Cargo.lock

@@ -43,6 +43,7 @@ reqwest-eventsource = "0.6"
 libc = "0.2"
 chrono = { version = "0.4", features = ["clock"] }
 shell-words = "1.1"
+similar = "2.6"
 toml = "0.8"
 
 [target."cfg(not(any(target_os = \"android\", target_os = \"ios\")))".dependencies]

src-tauri/Cargo.toml

@@ -7,6 +7,7 @@
 //! OpenCode ↔ CodexMonitor translation happens here in Rust.
 
 use serde_json::{json, Value};
+use similar::TextDiff;
 use std::collections::HashMap;
 use std::sync::atomic::{AtomicU64, Ordering};
 
@@ -1307,6 +1308,36 @@ fn file_path_from_raw_input(raw_input: &Value) -> Option<String> {
         .map(ToOwned::to_owned)
 }
 
+/// Generate a unified diff from oldString/newString edit input.
+/// Returns a unified diff string with @@ hunk headers that the frontend can render.
+fn generate_edit_diff(raw_input: &Value, file_path: &str) -> Option<String> {
+    let old_string = raw_input.get("oldString").and_then(|v| v.as_str())?;
+    let new_string = raw_input.get("newString").and_then(|v| v.as_str())?;
+
+    // Don't generate diff for empty old/new (pure create or delete)
+    if old_string.is_empty() && new_string.is_empty() {
+        return None;
+    }
+
+    let diff = TextDiff::from_lines(old_string, new_string);
+    let mut output = String::new();
+
+    // Add file header
+    output.push_str(&format!("--- a/{file_path}\n"));
+    output.push_str(&format!("+++ b/{file_path}\n"));
+
+    // Generate unified diff hunks
+    for hunk in diff.unified_diff().context_radius(3).iter_hunks() {
+        output.push_str(&hunk.to_string());
+    }
+
+    if output.contains("@@") {
+        Some(output)
+    } else {
+        None
+    }
+}
+
 fn build_tool_item(
     item_id: &str,
     item_type: &str,
@@ -1355,7 +1386,11 @@ fn build_tool_item(
         if changes.is_empty() {
             if let Some(input) = raw_input {
                 if let Some(path) = file_path_from_raw_input(input) {
-                    changes.push(json!({ "path": path, "kind": "modify" }));
+                    let mut change = json!({ "path": path, "kind": "modify" });
+                    if let Some(diff) = generate_edit_diff(input, &path) {
+                        change["diff"] = json!(diff);
+                    }
+                    changes.push(change);
                 }
             }
         }
@@ -1498,6 +1533,46 @@ mod tests {
         assert_eq!(events[0]["params"]["item"]["status"], "completed");
     }
 
+    #[test]
+    fn edit_tool_generates_unified_diff() {
+        let mut state = make_state();
+        let completed = json!({
+            "type": "message.part.updated",
+            "properties": {
+                "part": {
+                    "type": "tool",
+                    "id": "tc_edit_diff",
+                    "tool": "edit",
+                    "state": {
+                        "status": "completed",
+                        "input": {
+                            "filePath": "src/main.rs",
+                            "oldString": "fn main() {\n    println!(\"Hello\");\n}",
+                            "newString": "fn main() {\n    println!(\"Hello, world!\");\n}"
+                        },
+                        "output": "File edited."
+                    }
+                }
+            }
+        });
+        let events = translate_sse_event(&completed, &mut state);
+        assert_eq!(events.len(), 1);
+        assert_eq!(events[0]["method"], "item/completed");
+        let item = &events[0]["params"]["item"];
+        assert_eq!(item["type"], "fileChange");
+
+        let changes = item["changes"].as_array().expect("changes should be array");
+        assert_eq!(changes.len(), 1);
+        assert_eq!(changes[0]["path"], "src/main.rs");
+
+        let diff = changes[0]["diff"].as_str().expect("diff should be string");
+        assert!(diff.contains("--- a/src/main.rs"));
+        assert!(diff.contains("+++ b/src/main.rs"));
+        assert!(diff.contains("@@"));
+        assert!(diff.contains("-    println!(\"Hello\");"));
+        assert!(diff.contains("+    println!(\"Hello, world!\");"));
+    }
+
     #[test]
     fn text_after_tool_completion_uses_new_agent_message_item() {
         let mut state = make_state();

src-tauri/src/backend/event_translator.rs

@@ -69,6 +69,39 @@ fn should_include_hidden_sessions(sort_key: &Option<String>) -> bool {
         .unwrap_or(false)
 }
 
+fn replay_message_order_key(message: &Value) -> Option<String> {
+    let timestamp = message
+        .get("createdAt")
+        .or_else(|| message.get("created_at"))
+        .or_else(|| message.get("updatedAt"))
+        .or_else(|| message.get("updated_at"))
+        .or_else(|| message.get("time").and_then(|time| time.get("created")))
+        .or_else(|| message.get("time").and_then(|time| time.get("createdAt")))
+        .or_else(|| message.get("time").and_then(|time| time.get("created_at")))
+        .or_else(|| message.get("time").and_then(|time| time.get("updated")))
+        .or_else(|| message.get("time").and_then(|time| time.get("updatedAt")))
+        .or_else(|| message.get("time").and_then(|time| time.get("updated_at")))?;
+
+    if let Some(value) = timestamp.as_u64() {
+        return Some(format!("{value:020}"));
+    }
+    if let Some(value) = timestamp.as_i64() {
+        return Some(format!("{value:020}"));
+    }
+    timestamp
+        .as_str()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(ToOwned::to_owned)
+}
+
+fn sort_replay_messages_chronologically(messages: &mut [Value]) {
+    messages.sort_by(|a, b| match (replay_message_order_key(a), replay_message_order_key(b)) {
+        (Some(a_key), Some(b_key)) => a_key.cmp(&b_key),
+        _ => std::cmp::Ordering::Equal,
+    });
+}
+
 async fn hidden_session_ids_for_workspace(
     workspaces: &Mutex<HashMap<String, WorkspaceEntry>>,
     workspace_id: &str,
@@ -136,7 +169,9 @@ pub(crate) async fn resume_thread_core<E: EventSink>(
     let mut latest_assistant_info: Option<Value> = None;
 
     if let Some(msg_list) = messages.as_array() {
-        for msg_entry in msg_list {
+        let mut ordered_messages = msg_list.clone();
+        sort_replay_messages_chronologically(&mut ordered_messages);
+        for msg_entry in &ordered_messages {
             let role = msg_entry
                 .get("info")
                 .and_then(|i| i.get("role"))
@@ -1336,6 +1371,32 @@ mod tests {
         assert!(!should_include_hidden_sessions(&None));
     }
 
+    #[test]
+    fn sort_replay_messages_orders_oldest_first_by_timestamp() {
+        let mut messages = vec![
+            json!({
+                "id": "msg-newer",
+                "time": { "created": 200 }
+            }),
+            json!({
+                "id": "msg-older",
+                "time": { "created": 100 }
+            }),
+            json!({
+                "id": "msg-middle",
+                "createdAt": 150
+            }),
+        ];
+
+        sort_replay_messages_chronologically(&mut messages);
+
+        let ids: Vec<String> = messages
+            .iter()
+            .filter_map(|msg| msg.get("id").and_then(|v| v.as_str()).map(ToOwned::to_owned))
+            .collect();
+        assert_eq!(ids, vec!["msg-older", "msg-middle", "msg-newer"]);
+    }
+
     #[test]
     fn private_and_loopback_ips_are_disallowed() {
         assert!(ip_is_disallowed(

src-tauri/src/shared/codex_core.rs

@@ -208,27 +208,42 @@ export const Messages = memo(function Messages({
   );
 
   useEffect(() => {
+    const itemsToExpand: string[] = [];
     for (let index = visibleItems.length - 1; index >= 0; index -= 1) {
       const item = visibleItems[index];
+      if (manuallyToggledExpandedRef.current.has(item.id)) {
+        continue;
+      }
       if (
         item.kind === "tool" &&
         item.toolType === "plan" &&
         (item.output ?? "").trim().length > 0
       ) {
-        if (manuallyToggledExpandedRef.current.has(item.id)) {
-          return;
-        }
-        setExpandedItems((prev) => {
-          if (prev.has(item.id)) {
-            return prev;
-          }
-          const next = new Set(prev);
-          next.add(item.id);
-          return next;
-        });
-        return;
+        itemsToExpand.push(item.id);
+        break;
+      }
+      if (
+        item.kind === "tool" &&
+        item.toolType === "fileChange" &&
+        item.changes?.some((change) => change.diff)
+      ) {
+        itemsToExpand.push(item.id);
       }
     }
+    if (itemsToExpand.length === 0) {
+      return;
+    }
+    setExpandedItems((prev) => {
+      const next = new Set(prev);
+      let changed = false;
+      for (const id of itemsToExpand) {
+        if (!next.has(id)) {
+          next.add(id);
+          changed = true;
+        }
+      }
+      return changed ? next : prev;
+    });
   }, [visibleItems]);
 
   useEffect(() => {