spire-ai 0.1.3

AI-native SDK for SpireDB — RAG, code search, agents
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

//! Bash tool — executes shell commands in the project directory.

use async_trait::async_trait;
use serde_json::Value;

use crate::error::Result;
use crate::llm::types::ToolDef;
use crate::tool::{Tool, ToolResult};

/// Executes bash commands in the project directory.
pub struct BashTool {
    project_dir: String,
    timeout_secs: u64,
}

impl BashTool {
    pub fn new(project_dir: impl Into<String>) -> Self {
        Self {
            project_dir: project_dir.into(),
            timeout_secs: 120,
        }
    }
}

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

    fn needs_confirmation(&self) -> bool {
        true
    }

    fn def(&self) -> ToolDef {
        ToolDef {
            name: "bash".into(),
            description: "Run a shell command. Use for building, testing, installing, git, etc."
                .into(),
            parameters: serde_json::json!({
                "type": "object",
                "properties": {
                    "command": {
                        "type": "string",
                        "description": "The bash command to execute."
                    },
                    "timeout": {
                        "type": "integer",
                        "description": "Timeout in seconds (default 30, max 120)."
                    }
                },
                "required": ["command"]
            }),
        }
    }

    async fn call(&self, args: Value) -> Result<ToolResult> {
        let command = match args["command"].as_str() {
            Some(c) => c,
            None => return Ok(ToolResult::error("missing required parameter: command")),
        };

        let timeout = args["timeout"]
            .as_u64()
            .unwrap_or(30)
            .min(self.timeout_secs);

        let child = tokio::process::Command::new("bash")
            .arg("-c")
            .arg(command)
            .current_dir(&self.project_dir)
            .stdout(std::process::Stdio::piped())
            .stderr(std::process::Stdio::piped())
            .kill_on_drop(true)
            .spawn();

        let child = match child {
            Ok(c) => c,
            Err(e) => return Ok(ToolResult::error(format!("failed to spawn: {e}"))),
        };

        let result = tokio::time::timeout(
            std::time::Duration::from_secs(timeout),
            child.wait_with_output(),
        )
        .await;

        match result {
            Ok(Ok(output)) => {
                let code = output.status.code().unwrap_or(-1);
                let stdout = String::from_utf8_lossy(&output.stdout);
                let stderr = String::from_utf8_lossy(&output.stderr);

                let mut out = format!("exit {code}\n");
                if !stdout.is_empty() {
                    out.push_str(&stdout);
                }
                if !stderr.is_empty() {
                    if !stdout.is_empty() && !stdout.ends_with('\n') {
                        out.push('\n');
                    }
                    out.push_str(&stderr);
                }

                // Truncate very long output
                if out.len() > 30_000 {
                    out.truncate(30_000);
                    out.push_str("\n... (output truncated)");
                }

                Ok(ToolResult::ok(out))
            }
            Ok(Err(e)) => Ok(ToolResult::error(format!("command failed: {e}"))),
            Err(_) => Ok(ToolResult::error(format!("timed out after {timeout}s"))),
        }
    }
}