Allow reviewing of agent changes without Git (#27668)

Release Notes:

- N/A

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."
+                )),
+            }
+        })
     }
 }