WIP tools

Author: brandonskiser

crates/agent/src/agent/agent_config/definitions.rs

@@ -175,7 +175,7 @@ impl Default for AgentConfigV2025_08_22 {
             use_legacy_mcp_json: false,
 
             resources: Default::default(),
-            allowed_tools: HashSet::from([BuiltInToolName::FileRead.to_string()]),
+            allowed_tools: HashSet::from([BuiltInToolName::FsRead.to_string()]),
         }
     }
 }

crates/agent/src/agent/agent_loop/types.rs

@@ -266,7 +266,9 @@ pub struct ImageBlock {
     pub source: ImageSource,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, strum::EnumString, strum::Display)]
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, strum::EnumString, strum::Display, strum::EnumIter,
+)]
 #[serde(rename_all = "lowercase")]
 #[strum(serialize_all = "lowercase")]
 pub enum ImageFormat {

crates/agent/src/agent/tools/execute_cmd.rs

@@ -64,9 +64,17 @@ const EXECUTE_CMD_SCHEMA: &str = r#"
 "#;
 
 impl BuiltInToolTrait for ExecuteCmd {
-    const DESCRIPTION: &str = EXECUTE_CMD_TOOL_DESCRIPTION;
-    const INPUT_SCHEMA: &str = EXECUTE_CMD_SCHEMA;
-    const NAME: BuiltInToolName = BuiltInToolName::ExecuteCmd;
+    fn name() -> BuiltInToolName {
+        BuiltInToolName::ExecuteCmd
+    }
+
+    fn description() -> std::borrow::Cow<'static, str> {
+        EXECUTE_CMD_TOOL_DESCRIPTION.into()
+    }
+
+    fn input_schema() -> std::borrow::Cow<'static, str> {
+        EXECUTE_CMD_SCHEMA.into()
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]

crates/agent/src/agent/tools/file_read.rs

@@ -28,7 +28,7 @@ use crate::agent::util::path::canonicalize_path;
 
 const MAX_READ_SIZE: u32 = 250 * 1024;
 
-const FILE_READ_TOOL_DESCRIPTION: &str = r#"
+const FS_READ_TOOL_DESCRIPTION: &str = r#"
 A tool for viewing file contents.
 
 WHEN TO USE THIS TOOL:
@@ -43,7 +43,6 @@ HOW TO USE:
 - Do not use this for directories, use the ls tool instead
 
 FEATURES:
-- Displays file contents with line numbers for easy reference
 - Can read from any position in a file using the offset parameter
 - Handles large files by limiting the number of lines read
 
@@ -54,21 +53,29 @@ LIMITATIONS:
 
 // TODO - migrate from JsonSchema, it's not very configurable and prone to breaking changes in the
 // generated structure.
-const FILE_READ_SCHEMA: &str = "";
+const FS_READ_SCHEMA: &str = "";
 
-impl BuiltInToolTrait for FileRead {
-    const DESCRIPTION: &str = FILE_READ_TOOL_DESCRIPTION;
-    const INPUT_SCHEMA: &str = FILE_READ_SCHEMA;
-    const NAME: BuiltInToolName = BuiltInToolName::FileRead;
+impl BuiltInToolTrait for FsRead {
+    fn name() -> BuiltInToolName {
+        BuiltInToolName::FsRead
+    }
+
+    fn description() -> std::borrow::Cow<'static, str> {
+        FS_READ_TOOL_DESCRIPTION.into()
+    }
+
+    fn input_schema() -> std::borrow::Cow<'static, str> {
+        FS_READ_SCHEMA.into()
+    }
 }
 
 /// A tool for reading files
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
-pub struct FileRead {
-    pub ops: Vec<FileReadOp>,
+pub struct FsRead {
+    pub ops: Vec<FsReadOp>,
 }
 
-impl FileRead {
+impl FsRead {
     pub fn tool_schema() -> serde_json::Value {
         let schema = schema_for!(Self);
         serde_json::to_value(schema).expect("creating tool schema should not fail")
@@ -124,7 +131,7 @@ impl FileRead {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
-pub struct FileReadOp {
+pub struct FsReadOp {
     /// Path to the file
     pub path: String,
     /// Number of lines to read
@@ -133,7 +140,7 @@ pub struct FileReadOp {
     pub offset: Option<u32>,
 }
 
-impl FileReadOp {
+impl FsReadOp {
     async fn execute(&self) -> Result<ToolExecutionOutputItem, ToolExecutionError> {
         let path = PathBuf::from(canonicalize_path(&self.path).map_err(|e| ToolExecutionError::Custom(e.to_string()))?);
 
@@ -182,7 +189,7 @@ mod tests {
 
     #[test]
     fn test_file_read_tool_schema() {
-        let schema = FileRead::tool_schema();
+        let schema = FsRead::tool_schema();
         println!("{}", serde_json::to_string_pretty(&schema).unwrap());
     }
 }

crates/agent/src/agent/tools/file_write.rs

@@ -3,11 +3,11 @@ use std::path::{
     PathBuf,
 };
 
-use schemars::JsonSchema;
 use serde::{
     Deserialize,
     Serialize,
 };
+use syntect::util::LinesWithEndings;
 
 use super::{
     BuiltInToolName,
@@ -17,8 +17,8 @@ use super::{
 };
 use crate::agent::util::path::canonicalize_path;
 
-const FILE_WRITE_TOOL_DESCRIPTION: &str = r#"
-A tool for creating and editing files.
+const FS_WRITE_TOOL_DESCRIPTION: &str = r#"
+A tool for creating and editing text files.
 
 WHEN TO USE THIS TOOL:
 - Use when you need to create a new file, or modify an existing file
@@ -33,9 +33,10 @@ HOW TO USE:
 
 TIPS:
 - Read the file first before making modifications to ensure you have the most up-to-date version of the file.
+- To append content to the end of a file, use `insert` with no `insert_line`
 "#;
 
-const FILE_WRITE_SCHEMA: &str = r#"
+const FS_WRITE_SCHEMA: &str = r#"
 {
     "type": "object",
     "properties": {
@@ -53,7 +54,7 @@ const FILE_WRITE_SCHEMA: &str = r#"
             "type": "string"
         },
         "insert_line": {
-            "description": "Required parameter of `insert` command. The `content` will be inserted AFTER the line `insert_line` of `path`.",
+            "description": "Optional parameter of `insert` command. Line is 0-indexed. `content` will be inserted at the provided line. If not provided, content will be inserted at the end of the file on a new line, inserting a newline at the end of the file if it is missing.",
             "type": "integer"
         },
         "new_str": {
@@ -76,27 +77,38 @@ const FILE_WRITE_SCHEMA: &str = r#"
 }
 "#;
 
-impl BuiltInToolTrait for FileWrite {
-    const DESCRIPTION: &str = FILE_WRITE_TOOL_DESCRIPTION;
-    const INPUT_SCHEMA: &str = FILE_WRITE_SCHEMA;
-    const NAME: BuiltInToolName = BuiltInToolName::FileWrite;
+#[cfg(unix)]
+const NEWLINE: &str = "\n";
+
+impl BuiltInToolTrait for FsWrite {
+    fn name() -> BuiltInToolName {
+        BuiltInToolName::FsWrite
+    }
+
+    fn description() -> std::borrow::Cow<'static, str> {
+        FS_WRITE_TOOL_DESCRIPTION.into()
+    }
+
+    fn input_schema() -> std::borrow::Cow<'static, str> {
+        FS_WRITE_SCHEMA.into()
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 #[serde(tag = "command")]
-pub enum FileWrite {
+pub enum FsWrite {
     Create(FileCreate),
     StrReplace(StrReplace),
     Insert(Insert),
 }
 
-impl FileWrite {
+impl FsWrite {
     pub fn path(&self) -> &str {
         match self {
-            FileWrite::Create(v) => &v.path,
-            FileWrite::StrReplace(v) => &v.path,
-            FileWrite::Insert(v) => &v.path,
+            FsWrite::Create(v) => &v.path,
+            FsWrite::StrReplace(v) => &v.path,
+            FsWrite::Insert(v) => &v.path,
         }
     }
 
@@ -114,15 +126,15 @@ impl FileWrite {
         }
 
         match &self {
-            FileWrite::Create(_) => (),
-            FileWrite::StrReplace(_) => {
+            FsWrite::Create(_) => (),
+            FsWrite::StrReplace(_) => {
                 if !self.canonical_path()?.exists() {
                     errors.push(
                         "The provided path must exist in order to replace or insert contents into it".to_string(),
                     );
                 }
             },
-            FileWrite::Insert(v) => {
+            FsWrite::Insert(v) => {
                 if v.content.is_empty() {
                     errors.push("Content to insert must not be empty".to_string());
                 }
@@ -136,35 +148,27 @@ impl FileWrite {
         }
     }
 
-    pub async fn make_context(&self) -> eyre::Result<FileWriteContext> {
+    pub async fn make_context(&self) -> eyre::Result<FsWriteContext> {
         // TODO - return file diff context
-        Ok(FileWriteContext {
+        Ok(FsWriteContext {
             path: self.path().to_string(),
         })
     }
 
-    pub async fn execute(&self, _state: Option<&mut FileWriteState>) -> ToolExecutionResult {
+    pub async fn execute(&self, _state: Option<&mut FsWriteState>) -> ToolExecutionResult {
         let path = self.canonical_path().map_err(ToolExecutionError::Custom)?;
 
         match &self {
-            FileWrite::Create(v) => v.execute(path).await?,
-            FileWrite::StrReplace(v) => v.execute(path).await?,
-            FileWrite::Insert(v) => v.execute(path).await?,
+            FsWrite::Create(v) => v.execute(path).await?,
+            FsWrite::StrReplace(v) => v.execute(path).await?,
+            FsWrite::Insert(v) => v.execute(path).await?,
         }
 
         Ok(Default::default())
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub enum FileWriteOp {
-    Create(FileCreate),
-    StrReplace(StrReplace),
-    Insert(Insert),
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct FileCreate {
     path: String,
     content: String,
@@ -190,7 +194,7 @@ impl FileCreate {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct StrReplace {
     path: String,
@@ -238,7 +242,7 @@ impl StrReplace {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Insert {
     path: String,
@@ -247,20 +251,53 @@ pub struct Insert {
 }
 
 impl Insert {
-    async fn execute(&self, _path: impl AsRef<Path>) -> Result<(), ToolExecutionError> {
-        panic!("unimplemented")
+    async fn execute(&self, path: impl AsRef<Path>) -> Result<(), ToolExecutionError> {
+        let path = path.as_ref();
+
+        let mut file = tokio::fs::read_to_string(path)
+            .await
+            .map_err(|e| ToolExecutionError::io(format!("failed to read {}", path.to_string_lossy()), e))?;
+
+        let line_count = file.lines().count() as u32;
+
+        if let Some(insert_line) = self.insert_line {
+            let insert_line = insert_line.clamp(0, line_count);
+
+            // Get the index to insert at.
+            let mut i = 0;
+            for line in LinesWithEndings::from(&file).take(insert_line as usize) {
+                i += line.len();
+            }
+
+            let mut content = self.content.clone();
+            if !content.ends_with(NEWLINE) {
+                content.push_str(NEWLINE);
+            }
+            file.insert_str(i, &content);
+        } else {
+            if !file.ends_with(NEWLINE) {
+                file.push_str(NEWLINE);
+            }
+            file.push_str(&self.content);
+        }
+
+        tokio::fs::write(path, file)
+            .await
+            .map_err(|e| ToolExecutionError::io(format!("failed to write to {}", path.to_string_lossy()), e))?;
+
+        Ok(())
     }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct FileWriteContext {
+pub struct FsWriteContext {
     path: String,
 }
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct FileWriteState {
+pub struct FsWriteState {
     pub line_tracker: FileLineTracker,
 }