Add create-file-tool (#27381)

<img width="627" alt="Screenshot 2025-03-24 at 12 52 04 PM"
src="https://github.com/user-attachments/assets/0e8c061a-11c5-4d60-a694-55575b6c8f5e"
/>

Release Notes:

- N/A

crates/assistant_tools/src/assistant_tools.rs

@@ -1,5 +1,6 @@
 mod bash_tool;
 mod copy_path_tool;
+mod create_file_tool;
 mod delete_path_tool;
 mod diagnostics_tool;
 mod edit_files_tool;
@@ -21,6 +22,7 @@ use http_client::HttpClientWithUrl;
 use move_path_tool::MovePathTool;
 
 use crate::bash_tool::BashTool;
+use crate::create_file_tool::CreateFileTool;
 use crate::delete_path_tool::DeletePathTool;
 use crate::diagnostics_tool::DiagnosticsTool;
 use crate::edit_files_tool::EditFilesTool;
@@ -38,6 +40,7 @@ pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {
 
     let registry = ToolRegistry::global(cx);
     registry.register_tool(BashTool);
+    registry.register_tool(CreateFileTool);
     registry.register_tool(CopyPathTool);
     registry.register_tool(DeletePathTool);
     registry.register_tool(MovePathTool);

crates/assistant_tools/src/create_file_tool.rs

@@ -0,0 +1,106 @@
+use anyhow::{anyhow, Result};
+use assistant_tool::{ActionLog, Tool};
+use gpui::{App, Entity, Task};
+use language_model::LanguageModelRequestMessage;
+use project::Project;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct CreateFileToolInput {
+    /// The path where the file should be created.
+    ///
+    /// <example>
+    /// If the project has the following structure:
+    ///
+    /// - directory1/
+    /// - directory2/
+    ///
+    /// You can create a new file by providing a path of "directory1/new_file.txt"
+    /// </example>
+    pub path: String,
+
+    /// The text contents of the file to create.
+    ///
+    /// <example>
+    /// To create a file with the text "Hello, World!", provide contents of "Hello, World!"
+    /// </example>
+    pub contents: String,
+}
+
+pub struct CreateFileTool;
+
+impl Tool for CreateFileTool {
+    fn name(&self) -> String {
+        "create-file".into()
+    }
+
+    fn needs_confirmation(&self) -> bool {
+        true
+    }
+
+    fn description(&self) -> String {
+        include_str!("./create_file_tool/description.md").into()
+    }
+
+    fn input_schema(&self) -> serde_json::Value {
+        let schema = schemars::schema_for!(CreateFileToolInput);
+        serde_json::to_value(&schema).unwrap()
+    }
+
+    fn ui_text(&self, input: &serde_json::Value) -> String {
+        match serde_json::from_value::<CreateFileToolInput>(input.clone()) {
+            Ok(input) => {
+                let path = input.path.as_str();
+                format!("Create file `{path}`")
+            }
+            Err(_) => "Create file".to_string(),
+        }
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: serde_json::Value,
+        _messages: &[LanguageModelRequestMessage],
+        project: Entity<Project>,
+        _action_log: Entity<ActionLog>,
+        cx: &mut App,
+    ) -> Task<Result<String>> {
+        let input = match serde_json::from_value::<CreateFileToolInput>(input) {
+            Ok(input) => input,
+            Err(err) => return Task::ready(Err(anyhow!(err))),
+        };
+        let project_path = match project.read(cx).find_project_path(&input.path, cx) {
+            Some(project_path) => project_path,
+            None => return Task::ready(Err(anyhow!("Path to create was outside the project"))),
+        };
+        let contents: Arc<str> = input.contents.as_str().into();
+        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);
+            })?;
+
+            project
+                .update(cx, |project, cx| project.save_buffer(buffer.clone(), cx))?
+                .await
+                .map_err(|err| anyhow!("Unable to save buffer for {destination_path}: {err}"))?;
+
+            Ok(format!("Created file {destination_path}"))
+        })
+    }
+}

crates/assistant_tools/src/create_file_tool/description.md

@@ -0,0 +1,3 @@
+Creates a new file at the specified path within the project, containing the given text content. Returns confirmation that the file was created.
+
+This tool is the most efficient way to create new files within the project, so it should always be chosen whenever it's necessary to create a new file in the project with specific text content, or whenever a file in the project needs such a drastic change that you would prefer to replace the entire thing instead of making individual edits. This tool should not be used when making changes to parts of an existing file but not all of it. In those cases, it's better to use another approach to edit the file.

crates/assistant_tools/src/edit_files_tool/description.md

@@ -3,3 +3,5 @@ Edit files in the current project by specifying instructions in natural language
 When using this tool, you should suggest one coherent edit that can be made to the codebase.
 
 When the set of edits you want to make is large or complex, feel free to invoke this tool multiple times, each time focusing on a specific change you wanna make.
+
+You should use this tool when you want to edit a subset of a file's contents, but not the entire file. You should not use this tool when you want to replace the entire contents of a file with completely different contents, and you absolutely must never use this tool to create new files from scratch. If you ever consider using this tool to create a new file from scratch, for any reason, instead you must reconsider and choose a different approach.