Allow reviewing of agent changes without Git (#27668)

Release Notes:

- N/A

crates/assistant_tools/Cargo.toml

@@ -14,6 +14,7 @@ path = "src/assistant_tools.rs"
 [dependencies]
 anyhow.workspace = true
 assistant_tool.workspace = true
+clock.workspace = true
 chrono.workspace = true
 collections.workspace = true
 feature_flags.workspace = true
@@ -38,6 +39,7 @@ worktree.workspace = true
 open = { workspace = true }
 
 [dev-dependencies]
+clock = { workspace = true, features = ["test-support"] }
 collections = { workspace = true, features = ["test-support"] }
 gpui = { workspace = true, features = ["test-support"] }
 language = { workspace = true, features = ["test-support"] }

crates/assistant_tools/src/create_file_tool.rs

@@ -70,7 +70,7 @@ impl Tool for CreateFileTool {
         input: serde_json::Value,
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
-        _action_log: Entity<ActionLog>,
+        action_log: Entity<ActionLog>,
         cx: &mut App,
     ) -> Task<Result<String>> {
         let input = match serde_json::from_value::<CreateFileToolInput>(input) {
@@ -85,24 +85,20 @@ impl Tool for CreateFileTool {
         let destination_path: Arc<str> = input.path.as_str().into();
 
         cx.spawn(async move |cx| {
-            project
-                .update(cx, |project, cx| {
-                    project.create_entry(project_path.clone(), false, cx)
-                })?
-                .await
-                .map_err(|err| anyhow!("Unable to create {destination_path}: {err}"))?;
             let buffer = project
                 .update(cx, |project, cx| {
                     project.open_buffer(project_path.clone(), cx)
                 })?
                 .await
                 .map_err(|err| anyhow!("Unable to open buffer for {destination_path}: {err}"))?;
-            buffer.update(cx, |buffer, cx| {
-                buffer.set_text(contents, cx);
+            let edit_id = buffer.update(cx, |buffer, cx| buffer.set_text(contents, cx))?;
+
+            action_log.update(cx, |action_log, cx| {
+                action_log.will_create_buffer(buffer.clone(), edit_id, cx)
             })?;
 
             project
-                .update(cx, |project, cx| project.save_buffer(buffer.clone(), cx))?
+                .update(cx, |project, cx| project.save_buffer(buffer, cx))?
                 .await
                 .map_err(|err| anyhow!("Unable to save buffer for {destination_path}: {err}"))?;
 

crates/assistant_tools/src/delete_path_tool.rs

@@ -1,8 +1,9 @@
 use anyhow::{anyhow, Result};
 use assistant_tool::{ActionLog, Tool};
+use futures::{channel::mpsc, SinkExt, StreamExt};
 use gpui::{App, AppContext, Entity, Task};
 use language_model::LanguageModelRequestMessage;
-use project::Project;
+use project::{Project, ProjectPath};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
@@ -60,28 +61,76 @@ impl Tool for DeletePathTool {
         input: serde_json::Value,
         _messages: &[LanguageModelRequestMessage],
         project: Entity<Project>,
-        _action_log: Entity<ActionLog>,
+        action_log: Entity<ActionLog>,
         cx: &mut App,
     ) -> Task<Result<String>> {
         let path_str = match serde_json::from_value::<DeletePathToolInput>(input) {
             Ok(input) => input.path,
             Err(err) => return Task::ready(Err(anyhow!(err))),
         };
+        let Some(project_path) = project.read(cx).find_project_path(&path_str, cx) else {
+            return Task::ready(Err(anyhow!(
+                "Couldn't delete {path_str} because that path isn't in this project."
+            )));
+        };
 
-        match project
+        let Some(worktree) = project
             .read(cx)
-            .find_project_path(&path_str, cx)
-            .and_then(|path| project.update(cx, |project, cx| project.delete_file(path, false, cx)))
-        {
-            Some(deletion_task) => cx.background_spawn(async move {
-                match deletion_task.await {
+            .worktree_for_id(project_path.worktree_id, cx)
+        else {
+            return Task::ready(Err(anyhow!(
+                "Couldn't delete {path_str} because that path isn't in this project."
+            )));
+        };
+
+        let worktree_snapshot = worktree.read(cx).snapshot();
+        let (mut paths_tx, mut paths_rx) = mpsc::channel(256);
+        cx.background_spawn({
+            let project_path = project_path.clone();
+            async move {
+                for entry in
+                    worktree_snapshot.traverse_from_path(true, false, false, &project_path.path)
+                {
+                    if !entry.path.starts_with(&project_path.path) {
+                        break;
+                    }
+                    paths_tx
+                        .send(ProjectPath {
+                            worktree_id: project_path.worktree_id,
+                            path: entry.path.clone(),
+                        })
+                        .await?;
+                }
+                anyhow::Ok(())
+            }
+        })
+        .detach();
+
+        cx.spawn(async move |cx| {
+            while let Some(path) = paths_rx.next().await {
+                if let Ok(buffer) = project
+                    .update(cx, |project, cx| project.open_buffer(path, cx))?
+                    .await
+                {
+                    action_log.update(cx, |action_log, cx| {
+                        action_log.will_delete_buffer(buffer.clone(), cx)
+                    })?;
+                }
+            }
+
+            let delete = project.update(cx, |project, cx| {
+                project.delete_file(project_path, false, cx)
+            })?;
+
+            match delete {
+                Some(deletion_task) => match deletion_task.await {
                     Ok(()) => Ok(format!("Deleted {path_str}")),
                     Err(err) => Err(anyhow!("Failed to delete {path_str}: {err}")),
-                }
-            }),
-            None => Task::ready(Err(anyhow!(
-                "Couldn't delete {path_str} because that path isn't in this project."
-            ))),
-        }
+                },
+                None => Err(anyhow!(
+                    "Couldn't delete {path_str} because that path isn't in this project."
+                )),
+            }
+        })
     }
 }

crates/assistant_tools/src/edit_files_tool.rs

@@ -173,6 +173,7 @@ enum EditorResponse {
 struct AppliedAction {
     source: String,
     buffer: Entity<language::Buffer>,
+    edit_ids: Vec<clock::Lamport>,
 }
 
 #[derive(Debug)]
@@ -340,9 +341,18 @@ impl EditToolRequest {
                 self.push_search_error(error);
             }
             DiffResult::Diff(diff) => {
-                let _clock = buffer.update(cx, |buffer, cx| buffer.apply_diff(diff, cx))?;
+                let edit_ids = buffer.update(cx, |buffer, cx| {
+                    buffer.finalize_last_transaction();
+                    buffer.apply_diff(diff, false, cx);
+                    let transaction = buffer.finalize_last_transaction();
+                    transaction.map_or(Vec::new(), |transaction| transaction.edit_ids.clone())
+                })?;
 
-                self.push_applied_action(AppliedAction { source, buffer });
+                self.push_applied_action(AppliedAction {
+                    source,
+                    buffer,
+                    edit_ids,
+                });
             }
         }
 
@@ -464,7 +474,10 @@ impl EditToolRequest {
                 let mut changed_buffers = HashSet::default();
 
                 for action in applied {
-                    changed_buffers.insert(action.buffer);
+                    changed_buffers.insert(action.buffer.clone());
+                    self.action_log.update(cx, |log, cx| {
+                        log.buffer_edited(action.buffer, action.edit_ids, cx)
+                    })?;
                     write!(&mut output, "\n\n{}", action.source)?;
                 }
 
@@ -474,10 +487,6 @@ impl EditToolRequest {
                         .await?;
                 }
 
-                self.action_log
-                    .update(cx, |log, cx| log.buffer_edited(changed_buffers.clone(), cx))
-                    .log_err();
-
                 if !search_errors.is_empty() {
                     writeln!(
                         &mut output,

crates/assistant_tools/src/find_replace_file_tool.rs

@@ -5,7 +5,7 @@ use language_model::LanguageModelRequestMessage;
 use project::Project;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use std::{collections::HashSet, path::PathBuf, sync::Arc};
+use std::{path::PathBuf, sync::Arc};
 use ui::IconName;
 
 use crate::replace::replace_exact;
@@ -189,20 +189,21 @@ impl Tool for FindReplaceFileTool {
                 .await;
 
             if let Some(diff) = result {
-                buffer.update(cx, |buffer, cx| {
-                    let _ = buffer.apply_diff(diff, cx);
+                let edit_ids = buffer.update(cx, |buffer, cx| {
+                    buffer.finalize_last_transaction();
+                    buffer.apply_diff(diff, false, cx);
+                    let transaction = buffer.finalize_last_transaction();
+                    transaction.map_or(Vec::new(), |transaction| transaction.edit_ids.clone())
+                })?;
+
+                action_log.update(cx, |log, cx| {
+                    log.buffer_edited(buffer.clone(), edit_ids, cx)
                 })?;
 
                 project.update(cx, |project, cx| {
-                    project.save_buffer(buffer.clone(), cx)
+                    project.save_buffer(buffer, cx)
                 })?.await?;
 
-                action_log.update(cx, |log, cx| {
-                    let mut buffers = HashSet::default();
-                    buffers.insert(buffer);
-                    log.buffer_edited(buffers, cx);
-                })?;
-
                 Ok(format!("Edited {}", input.path.display()))
             } else {
                 let err = buffer.read_with(cx, |buffer, _cx| {

crates/assistant_tools/src/replace.rs

@@ -518,7 +518,7 @@ mod tests {
         // Call replace_flexible and transform the result
         replace_with_flexible_indent(old, new, &buffer_snapshot).map(|diff| {
             buffer.update(cx, |buffer, cx| {
-                let _ = buffer.apply_diff(diff, cx);
+                let _ = buffer.apply_diff(diff, false, cx);
                 buffer.text()
             })
         })