feat: support apply_patch fileChange diffs in tool translation

Author: jacobjmc

README.md

@@ -44,3 +44,4 @@ OpenCodeMonitor is a fork of [CodexMonitor](https://github.com/Dimillian/CodexMo
 ## License
 
 MIT — see [LICENSE](LICENSE)
+

src-tauri/src/backend/app_server.rs

@@ -74,7 +74,11 @@ struct PidFileData {
 /// Returns the path to the PID file (~/.opencode-monitor/server.pid).
 fn pid_file_path() -> Option<PathBuf> {
     let home = env::var("HOME").ok()?;
-    Some(PathBuf::from(home).join(".opencode-monitor").join("server.pid"))
+    Some(
+        PathBuf::from(home)
+            .join(".opencode-monitor")
+            .join("server.pid"),
+    )
 }
 
 /// Write PID file after starting the server.
@@ -434,7 +438,10 @@ pub(crate) async fn global_rest_get(
     let mut url = format!("{base_url}{path}");
     if let Some(directory) = directory.filter(|value| !value.trim().is_empty()) {
         let separator = if path.contains('?') { "&" } else { "?" };
-        url = format!("{url}{separator}directory={}", urlencoding::encode(directory));
+        url = format!(
+            "{url}{separator}directory={}",
+            urlencoding::encode(directory)
+        );
     }
     let resp = client.get(&url).send().await.map_err(|e| e.to_string())?;
     if !resp.status().is_success() {

src-tauri/src/backend/event_translator.rs

@@ -10,7 +10,7 @@ use serde_json::{json, Value};
 use std::collections::HashMap;
 use std::sync::atomic::{AtomicU64, Ordering};
 
-use crate::shared::diff_utils::generate_edit_diff;
+use crate::shared::diff_utils::{generate_apply_patch_changes, generate_edit_diff};
 
 /// Per-session turn state — tracks active turn and item IDs for a single session.
 #[derive(Default)]
@@ -1052,7 +1052,7 @@ fn translate_tool_part(
             }));
 
             if let Some(ref input) = raw_input {
-                let delta_text = serde_json::to_string_pretty(input).unwrap_or_default();
+                let delta_text = tool_input_delta_text(tool_name, input);
                 if !delta_text.is_empty() {
                     let method = if item_type == "fileChange" {
                         "item/fileChange/outputDelta"
@@ -1122,6 +1122,55 @@ fn translate_tool_part(
     events
 }
 
+fn tool_input_delta_text(tool_name: &str, raw_input: &Value) -> String {
+    if tool_name == "apply_patch" {
+        return build_apply_patch_delta_summary(raw_input)
+            .unwrap_or_else(|| "Applying patch...".to_string());
+    }
+
+    serde_json::to_string_pretty(raw_input).unwrap_or_default()
+}
+
+fn build_apply_patch_delta_summary(raw_input: &Value) -> Option<String> {
+    let patch_text = raw_input.get("patchText").and_then(|v| v.as_str())?;
+    if patch_text.trim().is_empty() {
+        return Some("Applying patch...".to_string());
+    }
+
+    let changes = generate_apply_patch_changes(raw_input)?;
+    if changes.is_empty() {
+        return Some("Applying patch...".to_string());
+    }
+
+    let mut labels = Vec::new();
+    for change in changes.iter().take(3) {
+        let kind = change
+            .get("kind")
+            .and_then(|v| v.as_str())
+            .unwrap_or("modify");
+        let path = change
+            .get("path")
+            .and_then(|v| v.as_str())
+            .unwrap_or("file");
+        labels.push(format!("{kind} {path}"));
+    }
+
+    let total = changes.len();
+    let mut summary = format!(
+        "Applying patch to {total} file{}",
+        if total == 1 { "" } else { "s" }
+    );
+    if !labels.is_empty() {
+        summary.push_str(": ");
+        summary.push_str(&labels.join(", "));
+    }
+    if total > labels.len() {
+        summary.push_str(&format!(", +{} more", total - labels.len()));
+    }
+
+    Some(summary)
+}
+
 fn build_explore_entry(tool_name: &str, title: &str, raw_input: Option<&Value>) -> Value {
     let kind = tool_to_explore_kind(tool_name);
 
@@ -1731,7 +1780,7 @@ pub(crate) fn build_agent_message_completed(
 
 fn tool_kind_to_item_type(kind: &str) -> &str {
     match kind {
-        "edit" | "write" | "create" => "fileChange",
+        "edit" | "write" | "create" | "apply_patch" => "fileChange",
         "bash" | "command" | "terminal" => "commandExecution",
         "read" | "grep" | "glob" | "list" | "ls" => "explore",
         "todowrite" => "todowrite",
@@ -1935,7 +1984,9 @@ fn build_tool_item(
         let mut changes = changes_from_content.unwrap_or_default();
         if changes.is_empty() {
             if let Some(input) = raw_input {
-                if let Some(path) = file_path_from_raw_input(input) {
+                if let Some(parsed_changes) = generate_apply_patch_changes(input) {
+                    changes = parsed_changes;
+                } else if let Some(path) = file_path_from_raw_input(input) {
                     let mut change = json!({ "path": path, "kind": "modify" });
                     if let Some(diff) = generate_edit_diff(input, &path) {
                         change["diff"] = json!(diff);
@@ -2123,6 +2174,90 @@ mod tests {
         assert!(diff.contains("+    println!(\"Hello, world!\");"));
     }
 
+    #[test]
+    fn apply_patch_tool_generates_file_change_entries() {
+        let mut state = make_state();
+        let completed = json!({
+            "type": "message.part.updated",
+            "properties": {
+                "part": {
+                    "type": "tool",
+                    "id": "tc_apply_patch",
+                    "tool": "apply_patch",
+                    "state": {
+                        "status": "completed",
+                        "input": {
+                            "patchText": "*** Begin Patch\n*** Update File: src/main.rs\n@@ -1,1 +1,1 @@\n-old\n+new\n*** Add File: notes.txt\n+hello\n*** Delete File: old.txt\n*** Update File: src/from.rs\n*** Move to: src/to.rs\n@@ -1,1 +1,1 @@\n-before\n+after\n*** End Patch"
+                        },
+                        "output": "Patch applied successfully."
+                    }
+                }
+            }
+        });
+
+        let events = translate_sse_event(&completed, &mut state);
+        assert_eq!(events.len(), 1);
+        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(), 4);
+        assert_eq!(changes[0]["path"], "src/main.rs");
+        assert_eq!(changes[0]["kind"], "modify");
+        assert!(changes[0]["diff"]
+            .as_str()
+            .expect("modify diff")
+            .contains("--- a/src/main.rs"));
+
+        assert_eq!(changes[1]["path"], "notes.txt");
+        assert_eq!(changes[1]["kind"], "add");
+        assert!(changes[1]["diff"]
+            .as_str()
+            .expect("add diff")
+            .contains("--- /dev/null"));
+
+        assert_eq!(changes[2]["path"], "old.txt");
+        assert_eq!(changes[2]["kind"], "delete");
+        assert!(changes[2].get("diff").is_none());
+
+        assert_eq!(changes[3]["path"], "src/to.rs");
+        let rename_diff = changes[3]["diff"].as_str().expect("rename diff");
+        assert!(rename_diff.contains("--- a/src/from.rs"));
+        assert!(rename_diff.contains("+++ b/src/to.rs"));
+    }
+
+    #[test]
+    fn apply_patch_running_delta_uses_summary_not_patch_text() {
+        let mut state = make_state();
+        let running = json!({
+            "type": "message.part.updated",
+            "properties": {
+                "part": {
+                    "type": "tool",
+                    "id": "tc_apply_patch_running",
+                    "tool": "apply_patch",
+                    "state": {
+                        "status": "running",
+                        "input": {
+                            "patchText": "*** Begin Patch\n*** Update File: src/main.rs\n@@ -1,1 +1,1 @@\n-old\n+new\n*** Add File: notes.txt\n+hello\n*** End Patch"
+                        }
+                    }
+                }
+            }
+        });
+
+        let events = translate_sse_event(&running, &mut state);
+        assert_eq!(events.len(), 2);
+        assert_eq!(events[0]["method"], "item/started");
+        assert_eq!(events[1]["method"], "item/fileChange/outputDelta");
+        let delta = events[1]["params"]["delta"].as_str().expect("delta string");
+        assert!(delta.contains("Applying patch to 2 files"));
+        assert!(delta.contains("modify src/main.rs"));
+        assert!(delta.contains("add notes.txt"));
+        assert!(!delta.contains("*** Begin Patch"));
+        assert!(!delta.contains("patchText"));
+    }
+
     #[test]
     fn text_after_tool_completion_uses_new_agent_message_item() {
         let mut state = make_state();

src-tauri/src/bin/codex_monitor_daemon.rs

@@ -806,31 +806,29 @@ impl DaemonState {
         };
         let directory = if let Some(workspace_id) = workspace_id.clone() {
             let workspaces = self.workspaces.lock().await;
-            workspaces.get(&workspace_id).map(|entry| entry.path.clone())
+            workspaces
+                .get(&workspace_id)
+                .map(|entry| entry.path.clone())
         } else {
             None
         };
-        let providers =
-            backend::app_server::global_rest_get(
-                codex_bin,
-                codex_args.as_deref(),
-                "/config/providers",
-                directory.as_deref(),
-            )
-            .await?;
+        let providers = backend::app_server::global_rest_get(
+            codex_bin,
+            codex_args.as_deref(),
+            "/config/providers",
+            directory.as_deref(),
+        )
+        .await?;
         let mut response = codex_core::model_list_response_from_providers(&providers);
         if let Some(obj) = response.as_object_mut() {
-            obj.insert(
-                "debug".to_string(),
-                {
-                    let mut debug = codex_core::model_list_debug_from_providers(&providers);
-                    if let Some(debug_obj) = debug.as_object_mut() {
-                        debug_obj.insert("requestWorkspaceId".to_string(), json!(workspace_id));
-                        debug_obj.insert("requestDirectory".to_string(), json!(directory));
-                    }
-                    debug
-                },
-            );
+            obj.insert("debug".to_string(), {
+                let mut debug = codex_core::model_list_debug_from_providers(&providers);
+                if let Some(debug_obj) = debug.as_object_mut() {
+                    debug_obj.insert("requestWorkspaceId".to_string(), json!(workspace_id));
+                    debug_obj.insert("requestDirectory".to_string(), json!(directory));
+                }
+                debug
+            });
         }
         Ok(response)
     }

src-tauri/src/codex/mod.rs

@@ -8,14 +8,13 @@ pub(crate) mod args;
 pub(crate) mod config;
 pub(crate) mod home;
 
+pub(crate) use crate::backend::app_server::WorkspaceSession;
 use crate::backend::app_server::{
     global_rest_get, opencode_restart_required_status as app_server_restart_required_status,
-    opencode_server_status as app_server_status,
-    restart_opencode_server as app_server_restart,
+    opencode_server_status as app_server_status, restart_opencode_server as app_server_restart,
     spawn_workspace_session as spawn_workspace_session_inner,
     takeover_external_server as app_server_takeover,
 };
-pub(crate) use crate::backend::app_server::WorkspaceSession;
 use crate::backend::events::AppServerEvent;
 use crate::event_sink::TauriEventSink;
 use crate::remote_backend;
@@ -531,7 +530,9 @@ pub(crate) async fn settings_model_list(
     };
     let directory = if let Some(workspace_id) = workspace_id.clone() {
         let workspaces = state.workspaces.lock().await;
-        workspaces.get(&workspace_id).map(|entry| entry.path.clone())
+        workspaces
+            .get(&workspace_id)
+            .map(|entry| entry.path.clone())
     } else {
         None
     };
@@ -544,17 +545,14 @@ pub(crate) async fn settings_model_list(
     .await?;
     let mut response = codex_core::model_list_response_from_providers(&providers);
     if let Some(obj) = response.as_object_mut() {
-        obj.insert(
-            "debug".to_string(),
-            {
-                let mut debug = codex_core::model_list_debug_from_providers(&providers);
-                if let Some(debug_obj) = debug.as_object_mut() {
-                    debug_obj.insert("requestWorkspaceId".to_string(), json!(workspace_id));
-                    debug_obj.insert("requestDirectory".to_string(), json!(directory));
-                }
-                debug
-            },
-        );
+        obj.insert("debug".to_string(), {
+            let mut debug = codex_core::model_list_debug_from_providers(&providers);
+            if let Some(debug_obj) = debug.as_object_mut() {
+                debug_obj.insert("requestWorkspaceId".to_string(), json!(workspace_id));
+                debug_obj.insert("requestDirectory".to_string(), json!(directory));
+            }
+            debug
+        });
     }
     Ok(response)
 }
@@ -565,8 +563,13 @@ pub(crate) async fn opencode_restart_required_status(
     app: AppHandle,
 ) -> Result<Value, String> {
     if remote_backend::is_remote_mode(&*state).await {
-        return remote_backend::call_remote(&*state, app, "opencode_restart_required_status", json!({}))
-            .await;
+        return remote_backend::call_remote(
+            &*state,
+            app,
+            "opencode_restart_required_status",
+            json!({}),
+        )
+        .await;
     }
     Ok(app_server_restart_required_status().await)
 }
@@ -577,7 +580,8 @@ pub(crate) async fn opencode_server_status(
     app: AppHandle,
 ) -> Result<Value, String> {
     if remote_backend::is_remote_mode(&*state).await {
-        return remote_backend::call_remote(&*state, app, "opencode_server_status", json!({})).await;
+        return remote_backend::call_remote(&*state, app, "opencode_server_status", json!({}))
+            .await;
     }
     Ok(app_server_status().await)
 }
@@ -588,7 +592,8 @@ pub(crate) async fn opencode_server_restart(
     app: AppHandle,
 ) -> Result<Value, String> {
     if remote_backend::is_remote_mode(&*state).await {
-        return remote_backend::call_remote(&*state, app, "opencode_server_restart", json!({})).await;
+        return remote_backend::call_remote(&*state, app, "opencode_server_restart", json!({}))
+            .await;
     }
     let (codex_bin, codex_args) = {
         let settings = state.app_settings.lock().await;

src-tauri/src/dictation/real.rs

@@ -432,7 +432,10 @@ pub(crate) async fn dictation_download_model(
     let model_id_clone = model_id.clone();
     eprintln!("[dictation] spawning download task for model: {}", model_id);
     let task = tokio::spawn(async move {
-        eprintln!("[dictation] download task started for model: {}", model_id_clone);
+        eprintln!(
+            "[dictation] download task started for model: {}",
+            model_id_clone
+        );
         let state = app_handle.state::<AppState>();
         let model_dir = model_dir(&app_handle);
         eprintln!("[dictation] model_dir: {:?}", model_dir);
@@ -520,7 +523,10 @@ pub(crate) async fn dictation_download_model(
         eprintln!("[dictation] starting HTTP GET request...");
         let response = match client.get(url).send().await {
             Ok(response) => {
-                eprintln!("[dictation] HTTP response received, status: {}", response.status());
+                eprintln!(
+                    "[dictation] HTTP response received, status: {}",
+                    response.status()
+                );
                 response
             }
             Err(error) => {
@@ -688,7 +694,10 @@ pub(crate) async fn dictation_download_model(
             return;
         }
 
-        eprintln!("[dictation] download completed successfully for model: {}", model_id_clone);
+        eprintln!(
+            "[dictation] download completed successfully for model: {}",
+            model_id_clone
+        );
         let status = ready_status(&model_id_clone, &model_path);
         update_status(&app_handle, &state, status).await;
         clear_download_state(&state).await;