enya-agent 0.1.0

package/crates/enact-core/src/tool/git.rs

@@ -0,0 +1,162 @@
+//! Git operations tool
+
+use crate::tool::Tool;
+use async_trait::async_trait;
+use serde_json::json;
+use std::process::Stdio;
+use tokio::process::Command;
+
+/// Git operations tool
+pub struct GitTool;
+
+impl GitTool {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl Default for GitTool {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl Tool for GitTool {
+    fn name(&self) -> &str {
+        "git"
+    }
+
+    fn description(&self) -> &str {
+        "Execute git commands (clone, status, add, commit, push, pull, etc.)"
+    }
+
+    fn parameters_schema(&self) -> serde_json::Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "operation": {
+                    "type": "string",
+                    "enum": ["clone", "status", "add", "commit", "push", "pull", "branch", "checkout", "log"],
+                    "description": "Git operation to perform"
+                },
+                "args": {
+                    "type": "array",
+                    "items": { "type": "string" },
+                    "description": "Additional arguments for the git command"
+                },
+                "message": {
+                    "type": "string",
+                    "description": "Commit message (for commit operation)"
+                },
+                "repo_url": {
+                    "type": "string",
+                    "description": "Repository URL (for clone operation)"
+                },
+                "directory": {
+                    "type": "string",
+                    "description": "Target directory (for clone) or repository directory"
+                }
+            },
+            "required": ["operation"]
+        })
+    }
+
+    fn requires_network(&self) -> bool {
+        true // Git often requires network access
+    }
+
+    async fn execute(&self, args: serde_json::Value) -> anyhow::Result<serde_json::Value> {
+        let operation = args
+            .get("operation")
+            .and_then(|v| v.as_str())
+            .ok_or_else(|| anyhow::anyhow!("Missing 'operation' parameter"))?;
+
+        let operation_args = args
+            .get("args")
+            .and_then(|v| v.as_array())
+            .map(|arr| {
+                arr.iter()
+                    .filter_map(|v| v.as_str())
+                    .map(|s| s.to_string())
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_default();
+
+        let mut cmd = Command::new("git");
+        cmd.arg(operation);
+
+        // Handle specific operations with special parameters
+        match operation {
+            "clone" => {
+                if let Some(url) = args.get("repo_url").and_then(|v| v.as_str()) {
+                    cmd.arg(url);
+                } else {
+                    anyhow::bail!("clone operation requires 'repo_url' parameter");
+                }
+                if let Some(dir) = args.get("directory").and_then(|v| v.as_str()) {
+                    cmd.arg(dir);
+                }
+            }
+            "commit" => {
+                if let Some(msg) = args.get("message").and_then(|v| v.as_str()) {
+                    cmd.arg("-m").arg(msg);
+                }
+            }
+            _ => {}
+        }
+
+        // Add additional args
+        for arg in operation_args {
+            cmd.arg(arg);
+        }
+
+        // Set working directory if specified
+        if let Some(dir) = args.get("directory").and_then(|v| v.as_str()) {
+            cmd.current_dir(dir);
+        }
+
+        let output = cmd.output().await?;
+
+        let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+
+        Ok(json!({
+            "success": output.status.success(),
+            "stdout": stdout,
+            "stderr": stderr,
+            "exit_code": output.status.code(),
+            "operation": operation
+        }))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_git_status() {
+        let tool = GitTool::new();
+        let result = tool.execute(json!({
+            "operation": "status",
+            "directory": "."
+        })).await.unwrap();
+
+        // Should succeed if we're in a git repo
+        if result["success"].as_bool().unwrap_or(false) {
+            assert!(result["stdout"].as_str().is_some());
+        }
+    }
+
+    #[tokio::test]
+    async fn test_git_version() {
+        let tool = GitTool::new();
+        let result = tool.execute(json!({
+            "operation": "version"
+        })).await.unwrap();
+
+        assert_eq!(result["success"], true);
+        assert!(result["stdout"].as_str().unwrap().contains("git version"));
+    }
+}

package/crates/enact-core/src/tool/http.rs

@@ -0,0 +1,214 @@
+//! HTTP request tool
+
+use crate::tool::Tool;
+use async_trait::async_trait;
+use serde_json::json;
+use std::collections::HashMap;
+use std::time::Duration;
+
+const DEFAULT_TIMEOUT_SECS: u64 = 30;
+const MAX_RESPONSE_SIZE: usize = 10 * 1024 * 1024; // 10MB
+
+/// HTTP request tool for making API calls
+pub struct HttpRequestTool;
+
+impl HttpRequestTool {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl Default for HttpRequestTool {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl Tool for HttpRequestTool {
+    fn name(&self) -> &str {
+        "http_request"
+    }
+
+    fn description(&self) -> &str {
+        "Make HTTP requests (GET, POST, PUT, DELETE, etc.) to APIs and web services"
+    }
+
+    fn parameters_schema(&self) -> serde_json::Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "url": {
+                    "type": "string",
+                    "description": "URL to request"
+                },
+                "method": {
+                    "type": "string",
+                    "enum": ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
+                    "default": "GET"
+                },
+                "headers": {
+                    "type": "object",
+                    "description": "HTTP headers as key-value pairs"
+                },
+                "body": {
+                    "type": ["string", "object"],
+                    "description": "Request body (for POST, PUT, PATCH)"
+                },
+                "timeout": {
+                    "type": "integer",
+                    "description": "Timeout in seconds (default: 30)",
+                    "minimum": 1,
+                    "maximum": 300
+                }
+            },
+            "required": ["url"]
+        })
+    }
+
+    fn requires_network(&self) -> bool {
+        true
+    }
+
+    async fn execute(&self, args: serde_json::Value) -> anyhow::Result<serde_json::Value> {
+        let url = args
+            .get("url")
+            .and_then(|v| v.as_str())
+            .ok_or_else(|| anyhow::anyhow!("Missing 'url' parameter"))?;
+
+        let method = args
+            .get("method")
+            .and_then(|v| v.as_str())
+            .unwrap_or("GET");
+
+        let timeout_secs = args
+            .get("timeout")
+            .and_then(|v| v.as_u64())
+            .unwrap_or(DEFAULT_TIMEOUT_SECS);
+
+        let client = reqwest::Client::builder()
+            .timeout(Duration::from_secs(timeout_secs))
+            .build()?;
+
+        let mut request = match method.to_uppercase().as_str() {
+            "GET" => client.get(url),
+            "POST" => client.post(url),
+            "PUT" => client.put(url),
+            "DELETE" => client.delete(url),
+            "PATCH" => client.patch(url),
+            "HEAD" => client.head(url),
+            _ => client.get(url),
+        };
+
+        // Add headers
+        if let Some(headers) = args.get("headers").and_then(|h| h.as_object()) {
+            for (key, value) in headers {
+                if let Some(val_str) = value.as_str() {
+                    request = request.header(key, val_str);
+                }
+            }
+        }
+
+        // Add body
+        if let Some(body) = args.get("body") {
+            let body_str = if body.is_object() {
+                serde_json::to_string(body)?
+            } else {
+                body.as_str().unwrap_or("").to_string()
+            };
+            request = request.body(body_str);
+        }
+
+        let response = request.send().await?;
+        let status = response.status();
+        let headers: HashMap<String, String> = response
+            .headers()
+            .iter()
+            .filter_map(|(k, v)| {
+                v.to_str()
+                    .ok()
+                    .map(|v| (k.to_string(), v.to_string()))
+            })
+            .collect();
+
+        let content_type = response
+            .headers()
+            .get("content-type")
+            .and_then(|v| v.to_str().ok())
+            .unwrap_or("")
+            .to_lowercase();
+
+        // Read body with size limit
+        let body_bytes = response.bytes().await?;
+        if body_bytes.len() > MAX_RESPONSE_SIZE {
+            anyhow::bail!(
+                "Response too large: {} bytes (max: {})",
+                body_bytes.len(),
+                MAX_RESPONSE_SIZE
+            );
+        }
+
+        // Try to parse as JSON, fallback to text
+        let body = if content_type.contains("application/json") {
+            match serde_json::from_slice::<serde_json::Value>(&body_bytes) {
+                Ok(json) => json,
+                Err(_) => {
+                    serde_json::Value::String(
+                        String::from_utf8_lossy(&body_bytes).to_string()
+                    )
+                }
+            }
+        } else {
+            serde_json::Value::String(String::from_utf8_lossy(&body_bytes).to_string())
+        };
+
+        Ok(json!({
+            "success": status.is_success(),
+            "status_code": status.as_u16(),
+            "status_text": status.canonical_reason(),
+            "headers": headers,
+            "body": body,
+            "url": url,
+            "method": method
+        }))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_http_get() {
+        let tool = HttpRequestTool::new();
+        let result = tool
+            .execute(json!({
+                "url": "https://httpbin.org/get",
+                "method": "GET"
+            }))
+            .await;
+
+        // May fail if no network
+        if let Ok(response) = result {
+            assert_eq!(response["success"], true);
+            assert_eq!(response["status_code"], 200);
+        }
+    }
+
+    #[tokio::test]
+    async fn test_http_post() {
+        let tool = HttpRequestTool::new();
+        let result = tool
+            .execute(json!({
+                "url": "https://httpbin.org/post",
+                "method": "POST",
+                "body": { "test": "data" }
+            }))
+            .await;
+
+        if let Ok(response) = result {
+            assert_eq!(response["success"], true);
+            assert_eq!(response["status_code"], 200);
+        }
+    }
+}

package/crates/enact-core/src/tool/mod.rs

@@ -0,0 +1,51 @@
+//! Tool module - Tool trait and policy-aware execution
+//!
+//! ## Key Invariant: All tool execution must go through ToolExecutor
+//!
+//! The ToolExecutor ensures that every tool invocation passes through
+//! ToolPolicy::evaluate() before execution. This is the security boundary.
+//!
+//! ```ignore
+//! // CORRECT: Use ToolExecutor for all tool calls
+//! let executor = ToolExecutor::new(policy);
+//! let result = executor.execute(&tool, args, &ctx).await?;
+//!
+//! // WRONG: Direct tool.execute() bypasses policy!
+//! // let result = tool.execute(args).await?; // Don't do this!
+//! ```
+
+mod agent_tool;
+mod discovery;
+mod dispatcher;
+mod function;
+mod r#trait;
+
+pub mod browser;
+pub mod cost;
+pub mod filesystem;
+pub mod git;
+pub mod http;
+pub mod mcp;
+pub mod reasoning;
+pub mod sandbox;
+pub mod shell;
+pub mod web_search;
+
+// Tool trait
+pub use r#trait::{DynTool, Tool};
+
+// Tool implementations
+pub use cost::{CostMetrics, CostTool, CostTracker};
+pub use filesystem::{FileReadTool, FileWriteTool};
+pub use function::FunctionTool;
+pub use git::GitTool;
+pub use http::HttpRequestTool;
+pub use shell::ShellTool;
+pub use web_search::WebSearchTool;
+
+// AgentTool - privileged adapter (see agent_tool.rs for security warnings)
+// Note: AgentTool is available but should only be used by trusted runtime components
+pub use agent_tool::AgentTool;
+
+// Policy-aware executor (REQUIRED for all tool invocations)
+pub use dispatcher::{ToolExecutionContext, ToolExecutionError, ToolExecutor};

package/crates/enact-core/src/tool/shell.rs

@@ -0,0 +1,147 @@
+//! Shell command execution tool
+
+use crate::tool::Tool;
+use async_trait::async_trait;
+use serde_json::json;
+use std::time::Duration;
+use tokio::process::Command;
+
+const SHELL_TIMEOUT_SECS: u64 = 60;
+const MAX_OUTPUT_BYTES: usize = 1_048_576; // 1MB
+
+/// Shell command execution tool
+pub struct ShellTool;
+
+impl ShellTool {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl Default for ShellTool {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl Tool for ShellTool {
+    fn name(&self) -> &str {
+        "shell"
+    }
+
+    fn description(&self) -> &str {
+        "Execute a shell command in the workspace directory"
+    }
+
+    fn parameters_schema(&self) -> serde_json::Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "command": {
+                    "type": "string",
+                    "description": "The shell command to execute"
+                },
+                "timeout": {
+                    "type": "integer",
+                    "description": "Timeout in seconds (default: 60)",
+                    "minimum": 1,
+                    "maximum": 300
+                }
+            },
+            "required": ["command"]
+        })
+    }
+
+    fn requires_network(&self) -> bool {
+        false // Shell can work offline, though commands might need network
+    }
+
+    async fn execute(&self, args: serde_json::Value) -> anyhow::Result<serde_json::Value> {
+        let command = args
+            .get("command")
+            .and_then(|v| v.as_str())
+            .ok_or_else(|| anyhow::anyhow!("Missing 'command' parameter"))?;
+
+        let timeout_secs = args
+            .get("timeout")
+            .and_then(|v| v.as_u64())
+            .unwrap_or(SHELL_TIMEOUT_SECS);
+
+        let timeout = Duration::from_secs(timeout_secs.min(300));
+
+        // Use sh -c for shell commands
+        let output = tokio::time::timeout(
+            timeout,
+            Command::new("sh")
+                .arg("-c")
+                .arg(command)
+                .output(),
+        )
+        .await
+        .map_err(|_| anyhow::anyhow!("Command timed out after {} seconds", timeout_secs))??;
+
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let stderr = String::from_utf8_lossy(&output.stderr);
+
+        // Truncate if too large
+        let stdout = if stdout.len() > MAX_OUTPUT_BYTES {
+            format!("{}... [truncated]", &stdout[..MAX_OUTPUT_BYTES])
+        } else {
+            stdout.to_string()
+        };
+
+        let stderr = if stderr.len() > MAX_OUTPUT_BYTES {
+            format!("{}... [truncated]", &stderr[..MAX_OUTPUT_BYTES])
+        } else {
+            stderr.to_string()
+        };
+
+        Ok(json!({
+            "success": output.status.success(),
+            "stdout": stdout,
+            "stderr": stderr,
+            "exit_code": output.status.code(),
+            "command": command
+        }))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_shell_echo() {
+        let tool = ShellTool::new();
+        let result = tool.execute(json!({
+            "command": "echo 'Hello World'"
+        })).await.unwrap();
+
+        assert_eq!(result["success"], true);
+        assert!(result["stdout"].as_str().unwrap().contains("Hello World"));
+    }
+
+    #[tokio::test]
+    async fn test_shell_error() {
+        let tool = ShellTool::new();
+        let result = tool.execute(json!({
+            "command": "exit 1"
+        })).await.unwrap();
+
+        assert_eq!(result["success"], false);
+        assert_eq!(result["exit_code"], 1);
+    }
+
+    #[tokio::test]
+    async fn test_shell_timeout() {
+        let tool = ShellTool::new();
+        let result = tool.execute(json!({
+            "command": "sleep 10",
+            "timeout": 1
+        })).await;
+
+        assert!(result.is_err());
+        assert!(result.unwrap_err().to_string().contains("timed out"));
+    }
+}

package/crates/enact-core/src/tool/trait.rs

@@ -0,0 +1,33 @@
+//! Tool trait definition
+
+use async_trait::async_trait;
+use serde_json::Value;
+use std::sync::Arc;
+
+/// Tool trait - all tools implement this
+#[async_trait]
+pub trait Tool: Send + Sync {
+    /// Tool name
+    fn name(&self) -> &str;
+
+    /// Tool description
+    fn description(&self) -> &str;
+
+    /// JSON schema for tool parameters
+    fn parameters_schema(&self) -> Value {
+        serde_json::json!({})
+    }
+
+    /// Whether this tool requires network access.
+    /// Default is `true` (conservative).
+    /// Override to `false` for local-only tools (e.g., file, calculator).
+    fn requires_network(&self) -> bool {
+        true
+    }
+
+    /// Execute the tool with the given arguments
+    async fn execute(&self, args: Value) -> anyhow::Result<Value>;
+}
+
+/// Boxed tool for dynamic dispatch
+pub type DynTool = Arc<dyn Tool>;