1use crate::{AgentTool, ToolCallEventStream};
2use action_log::ActionLog;
3use agent_client_protocol::ToolKind;
4use anyhow::{Context as _, Result, anyhow};
5use futures::{FutureExt as _, SinkExt, StreamExt, channel::mpsc};
6use gpui::{App, AppContext, Entity, SharedString, Task};
7use project::{Project, ProjectPath};
8use schemars::JsonSchema;
9use serde::{Deserialize, Serialize};
10use std::sync::Arc;
11
12/// Deletes the file or directory (and the directory's contents, recursively) at the specified path in the project, and returns confirmation of the deletion.
13#[derive(Debug, Serialize, Deserialize, JsonSchema)]
14pub struct DeletePathToolInput {
15 /// The path of the file or directory to delete.
16 ///
17 /// <example>
18 /// If the project has the following files:
19 ///
20 /// - directory1/a/something.txt
21 /// - directory2/a/things.txt
22 /// - directory3/a/other.txt
23 ///
24 /// You can delete the first file by providing a path of "directory1/a/something.txt"
25 /// </example>
26 pub path: String,
27}
28
29pub struct DeletePathTool {
30 project: Entity<Project>,
31 action_log: Entity<ActionLog>,
32}
33
34impl DeletePathTool {
35 pub fn new(project: Entity<Project>, action_log: Entity<ActionLog>) -> Self {
36 Self {
37 project,
38 action_log,
39 }
40 }
41}
42
43impl AgentTool for DeletePathTool {
44 type Input = DeletePathToolInput;
45 type Output = String;
46
47 fn name() -> &'static str {
48 "delete_path"
49 }
50
51 fn kind() -> ToolKind {
52 ToolKind::Delete
53 }
54
55 fn initial_title(
56 &self,
57 input: Result<Self::Input, serde_json::Value>,
58 _cx: &mut App,
59 ) -> SharedString {
60 if let Ok(input) = input {
61 format!("Delete “`{}`”", input.path).into()
62 } else {
63 "Delete path".into()
64 }
65 }
66
67 fn run(
68 self: Arc<Self>,
69 input: Self::Input,
70 event_stream: ToolCallEventStream,
71 cx: &mut App,
72 ) -> Task<Result<Self::Output>> {
73 let path = input.path;
74 let Some(project_path) = self.project.read(cx).find_project_path(&path, cx) else {
75 return Task::ready(Err(anyhow!(
76 "Couldn't delete {path} because that path isn't in this project."
77 )));
78 };
79
80 let Some(worktree) = self
81 .project
82 .read(cx)
83 .worktree_for_id(project_path.worktree_id, cx)
84 else {
85 return Task::ready(Err(anyhow!(
86 "Couldn't delete {path} because that path isn't in this project."
87 )));
88 };
89
90 let worktree_snapshot = worktree.read(cx).snapshot();
91 let (mut paths_tx, mut paths_rx) = mpsc::channel(256);
92 cx.background_spawn({
93 let project_path = project_path.clone();
94 async move {
95 for entry in
96 worktree_snapshot.traverse_from_path(true, false, false, &project_path.path)
97 {
98 if !entry.path.starts_with(&project_path.path) {
99 break;
100 }
101 paths_tx
102 .send(ProjectPath {
103 worktree_id: project_path.worktree_id,
104 path: entry.path.clone(),
105 })
106 .await?;
107 }
108 anyhow::Ok(())
109 }
110 })
111 .detach();
112
113 let project = self.project.clone();
114 let action_log = self.action_log.clone();
115 cx.spawn(async move |cx| {
116 loop {
117 let path_result = futures::select! {
118 path = paths_rx.next().fuse() => path,
119 _ = event_stream.cancelled_by_user().fuse() => {
120 anyhow::bail!("Delete cancelled by user");
121 }
122 };
123 let Some(path) = path_result else {
124 break;
125 };
126 if let Ok(buffer) = project
127 .update(cx, |project, cx| project.open_buffer(path, cx))
128 .await
129 {
130 action_log.update(cx, |action_log, cx| {
131 action_log.will_delete_buffer(buffer.clone(), cx)
132 });
133 }
134 }
135
136 let deletion_task = project
137 .update(cx, |project, cx| {
138 project.delete_file(project_path, false, cx)
139 })
140 .with_context(|| {
141 format!("Couldn't delete {path} because that path isn't in this project.")
142 })?;
143
144 futures::select! {
145 result = deletion_task.fuse() => {
146 result.with_context(|| format!("Deleting {path}"))?;
147 }
148 _ = event_stream.cancelled_by_user().fuse() => {
149 anyhow::bail!("Delete cancelled by user");
150 }
151 }
152 Ok(format!("Deleted {path}"))
153 })
154 }
155}