xcodeai 2.1.0

Autonomous AI coding agent — zero human intervention, sbox sandboxed, OpenAI-compatible
Documentation 
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

use crate::tools::{Tool, ToolContext, ToolResult};
use anyhow::Result;
use async_trait::async_trait;

/// A user-defined custom tool that executes a shell command.
/// Configured via `custom_tools` in config.json.
///
/// Example config:
/// ```json
/// {
///   "custom_tools": [
///     {
///       "name": "deploy",
///       "description": "Deploy the application to staging",
///       "command": "make deploy-staging",
///       "parameters": {}
///     }
///   ]
/// }
/// ```
pub struct CustomTool {
    pub tool_name: String,
    pub tool_description: String,
    pub command_template: String,
    pub tool_parameters: serde_json::Value,
}

#[async_trait]
impl Tool for CustomTool {
    fn name(&self) -> &str {
        &self.tool_name
    }

    fn description(&self) -> &str {
        &self.tool_description
    }

    fn parameters_schema(&self) -> serde_json::Value {
        if self.tool_parameters.is_object() && !self.tool_parameters.as_object().unwrap().is_empty()
        {
            serde_json::json!({
                "type": "object",
                "properties": self.tool_parameters,
                "required": []
            })
        } else {
            // No parameters — tool just runs the command as-is
            serde_json::json!({
                "type": "object",
                "properties": {
                    "args": {
                        "type": "string",
                        "description": "Optional arguments appended to the command"
                    }
                }
            })
        }
    }

    async fn execute(&self, args: serde_json::Value, ctx: &ToolContext) -> Result<ToolResult> {
        // Build the final command by substituting any {{param}} placeholders
        let mut command = self.command_template.clone();

        if let Some(obj) = args.as_object() {
            for (key, value) in obj {
                let placeholder = format!("{{{{{}}}}}", key);
                let val_str = match value.as_str() {
                    Some(s) => s.to_string(),
                    None => value.to_string(),
                };
                command = command.replace(&placeholder, &val_str);
            }
            // If there's a plain "args" field and no placeholder, append it
            if let Some(extra) = obj.get("args").and_then(|v| v.as_str()) {
                if !self.command_template.contains("{{args}}") {
                    command = format!("{} {}", command, extra);
                }
            }
        }

        // Execute the command
        let output = tokio::process::Command::new("sh")
            .arg("-c")
            .arg(&command)
            .current_dir(&ctx.working_dir)
            .output()
            .await;

        match output {
            Ok(out) => {
                let stdout = String::from_utf8_lossy(&out.stdout);
                let stderr = String::from_utf8_lossy(&out.stderr);
                let mut result = String::new();
                if !stdout.is_empty() {
                    result.push_str(&stdout);
                }
                if !stderr.is_empty() {
                    if !result.is_empty() {
                        result.push('\n');
                    }
                    result.push_str("STDERR:\n");
                    result.push_str(&stderr);
                }
                if result.is_empty() {
                    result = format!("Command completed with exit code {}", out.status.code().unwrap_or(-1));
                }
                Ok(ToolResult {
                    output: result,
                    is_error: !out.status.success(),
                })
            }
            Err(e) => Ok(ToolResult {
                output: format!("Failed to execute custom tool command: {}", e),
                is_error: true,
            }),
        }
    }
}