claux 20260730.0.0

Terminal AI coding assistant with tool execution
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use anyhow::Result;
use async_trait::async_trait;
use serde::Deserialize;
use serde_json::{json, Value};
use std::sync::Arc;

use super::{interrupted_output, Tool, ToolOutput};
use crate::sandbox::SandboxPolicy;

pub struct WriteTool {
    sandbox_policy: Arc<SandboxPolicy>,
}

impl WriteTool {
    pub fn new(sandbox_policy: Arc<SandboxPolicy>) -> Self {
        Self { sandbox_policy }
    }
}

#[derive(Deserialize)]
struct Params {
    file_path: String,
    content: String,
}

#[async_trait]
impl Tool for WriteTool {
    fn name(&self) -> &str {
        "Write"
    }

    fn description(&self) -> &str {
        "Write content to a file. Creates parent directories if needed."
    }

    fn input_schema(&self) -> Value {
        json!({
            "type": "object",
            "properties": {
                "file_path": {
                    "type": "string",
                    "description": "Absolute path to the file to write"
                },
                "content": {
                    "type": "string",
                    "description": "Content to write to the file"
                }
            },
            "required": ["file_path", "content"]
        })
    }

    fn is_read_only(&self) -> bool {
        false
    }

    fn summarize(&self, input: &Value) -> String {
        input["file_path"].as_str().unwrap_or("?").to_string()
    }

    async fn execute(
        &self,
        input: Value,
        cancel: tokio_util::sync::CancellationToken,
    ) -> Result<ToolOutput> {
        if cancel.is_cancelled() {
            return Ok(interrupted_output());
        }
        let params: Params = serde_json::from_value(input)?;
        let requested = crate::tools::read::expand_tilde(&params.file_path);
        let path = match self.sandbox_policy.authorize_write(&requested) {
            Ok(path) => path,
            Err(error) => return Ok(super::sandbox_denied_output(error)),
        };

        // Create parent directories
        if let Some(parent) = path.parent() {
            std::fs::create_dir_all(parent)?;
        }

        if cancel.is_cancelled() {
            return Ok(interrupted_output());
        }
        std::fs::write(&path, &params.content)?;

        Ok(ToolOutput {
            content: format!("Successfully wrote to {}", params.file_path),
            is_error: false,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tokio_util::sync::CancellationToken;

    fn tool() -> WriteTool {
        WriteTool::new(Arc::new(SandboxPolicy::unrestricted_for_tests()))
    }

    #[tokio::test]
    async fn write_creates_the_file() {
        let temp = tempfile::tempdir().unwrap();
        let path = temp.path().join("nested/file.txt");

        let result = tool()
            .execute(
                json!({
                    "file_path": path.to_str().unwrap(),
                    "content": "hello"
                }),
                CancellationToken::new(),
            )
            .await
            .unwrap();

        assert!(!result.is_error);
        assert_eq!(std::fs::read_to_string(path).unwrap(), "hello");
    }

    #[tokio::test]
    async fn cancelled_write_does_not_create_the_file() {
        let temp = tempfile::tempdir().unwrap();
        let path = temp.path().join("nested/file.txt");
        let cancel = CancellationToken::new();
        cancel.cancel();

        let result = tool()
            .execute(
                json!({
                    "file_path": path.to_str().unwrap(),
                    "content": "must not be written"
                }),
                cancel,
            )
            .await
            .unwrap();

        assert!(result.is_error);
        assert_eq!(result.content, "Interrupted by user.");
        assert!(!path.exists());
        assert!(!temp.path().join("nested").exists());
    }
}