@elizaos/sweagent-root 2.0.0-alpha

package/rust/src/environment/hooks/mod.rs

@@ -0,0 +1,114 @@
+//! Environment hooks for monitoring and extending environment behavior
+
+use async_trait::async_trait;
+
+/// Abstract hook for environment events
+#[async_trait]
+pub trait EnvironmentHook: Send + Sync {
+    /// Called when environment is initialized
+    fn on_init(&mut self) {}
+
+    /// Called when environment starts
+    fn on_start(&mut self) {}
+
+    /// Called when environment stops
+    fn on_stop(&mut self) {}
+
+    /// Called when a command is executed
+    fn on_command_executed(&mut self, _command: &str, _output: &str) {}
+
+    /// Called when environment is reset
+    fn on_reset(&mut self) {}
+}
+
+/// Combined hook that wraps multiple hooks
+pub struct CombinedEnvironmentHook {
+    hooks: Vec<Box<dyn EnvironmentHook>>,
+}
+
+impl CombinedEnvironmentHook {
+    pub fn new() -> Self {
+        Self { hooks: Vec::new() }
+    }
+
+    pub fn add_hook(&mut self, hook: Box<dyn EnvironmentHook>) {
+        self.hooks.push(hook);
+    }
+}
+
+impl Default for CombinedEnvironmentHook {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl EnvironmentHook for CombinedEnvironmentHook {
+    fn on_init(&mut self) {
+        for hook in &mut self.hooks {
+            hook.on_init();
+        }
+    }
+
+    fn on_start(&mut self) {
+        for hook in &mut self.hooks {
+            hook.on_start();
+        }
+    }
+
+    fn on_stop(&mut self) {
+        for hook in &mut self.hooks {
+            hook.on_stop();
+        }
+    }
+
+    fn on_command_executed(&mut self, command: &str, output: &str) {
+        for hook in &mut self.hooks {
+            hook.on_command_executed(command, output);
+        }
+    }
+
+    fn on_reset(&mut self) {
+        for hook in &mut self.hooks {
+            hook.on_reset();
+        }
+    }
+}
+
+/// Status hook for logging environment events
+pub struct EnvironmentStatusHook {
+    pub show_commands: bool,
+}
+
+impl EnvironmentStatusHook {
+    pub fn new(show_commands: bool) -> Self {
+        Self { show_commands }
+    }
+}
+
+impl Default for EnvironmentStatusHook {
+    fn default() -> Self {
+        Self::new(false)
+    }
+}
+
+#[async_trait]
+impl EnvironmentHook for EnvironmentStatusHook {
+    fn on_start(&mut self) {
+        tracing::info!("Environment started");
+    }
+
+    fn on_stop(&mut self) {
+        tracing::info!("Environment stopped");
+    }
+
+    fn on_command_executed(&mut self, command: &str, output: &str) {
+        if self.show_commands {
+            tracing::debug!(
+                command = command,
+                output_len = output.len(),
+                "Command executed"
+            );
+        }
+    }
+}

package/rust/src/environment/mod.rs

@@ -0,0 +1,16 @@
+//! Environment module for SWE-agent
+//!
+//! This module provides the runtime environment for agent execution,
+//! including Docker deployment and repository management.
+
+pub mod deployment;
+pub mod hooks;
+pub mod repo;
+pub mod runtime;
+pub mod swe_env;
+
+pub use deployment::*;
+pub use hooks::*;
+pub use repo::*;
+pub use runtime::*;
+pub use swe_env::*;

package/rust/src/environment/repo.rs

@@ -0,0 +1,265 @@
+//! Repository management for SWE-agent
+
+use crate::exceptions::{Result, SWEAgentError};
+use crate::utils::github::{parse_github_repo_url, GithubRepoInfo};
+use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+
+/// Trait for repository sources
+pub trait Repo: Send + Sync {
+    /// Get the repository name
+    fn repo_name(&self) -> &str;
+
+    /// Get the clone URL if available
+    fn clone_url(&self) -> Option<&str>;
+
+    /// Get the local path if available
+    fn local_path(&self) -> Option<&Path>;
+
+    /// Get the base commit if specified
+    fn base_commit(&self) -> Option<&str>;
+}
+
+/// Pre-existing repository already in the environment
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PreExistingRepo {
+    pub repo_name: String,
+    pub path: PathBuf,
+}
+
+impl PreExistingRepo {
+    pub fn new(repo_name: impl Into<String>, path: impl Into<PathBuf>) -> Self {
+        Self {
+            repo_name: repo_name.into(),
+            path: path.into(),
+        }
+    }
+}
+
+impl Repo for PreExistingRepo {
+    fn repo_name(&self) -> &str {
+        &self.repo_name
+    }
+
+    fn clone_url(&self) -> Option<&str> {
+        None
+    }
+
+    fn local_path(&self) -> Option<&Path> {
+        Some(&self.path)
+    }
+
+    fn base_commit(&self) -> Option<&str> {
+        None
+    }
+}
+
+/// Local repository on the filesystem
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LocalRepo {
+    pub path: PathBuf,
+    pub repo_name: String,
+    pub base_commit: Option<String>,
+}
+
+impl LocalRepo {
+    pub fn new(path: impl Into<PathBuf>) -> Result<Self> {
+        let path = path.into();
+        let repo_name = path
+            .file_name()
+            .and_then(|n| n.to_str())
+            .unwrap_or("local-repo")
+            .to_string();
+
+        if !path.exists() {
+            return Err(SWEAgentError::FileNotFound(format!(
+                "Repository path does not exist: {}",
+                path.display()
+            )));
+        }
+
+        Ok(Self {
+            path,
+            repo_name,
+            base_commit: None,
+        })
+    }
+
+    pub fn with_base_commit(mut self, commit: impl Into<String>) -> Self {
+        self.base_commit = Some(commit.into());
+        self
+    }
+}
+
+impl Repo for LocalRepo {
+    fn repo_name(&self) -> &str {
+        &self.repo_name
+    }
+
+    fn clone_url(&self) -> Option<&str> {
+        None
+    }
+
+    fn local_path(&self) -> Option<&Path> {
+        Some(&self.path)
+    }
+
+    fn base_commit(&self) -> Option<&str> {
+        self.base_commit.as_deref()
+    }
+}
+
+/// GitHub repository
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GithubRepo {
+    pub github_url: String,
+    pub info: Option<GithubRepoInfo>,
+    pub base_commit: Option<String>,
+    pub clone_timeout: u64,
+}
+
+impl GithubRepo {
+    pub fn new(github_url: impl Into<String>) -> Result<Self> {
+        let url = github_url.into();
+        let info = parse_github_repo_url(&url)?;
+
+        Ok(Self {
+            github_url: url,
+            info: Some(info),
+            base_commit: None,
+            clone_timeout: 300,
+        })
+    }
+
+    pub fn with_base_commit(mut self, commit: impl Into<String>) -> Self {
+        self.base_commit = Some(commit.into());
+        self
+    }
+
+    pub fn with_clone_timeout(mut self, timeout: u64) -> Self {
+        self.clone_timeout = timeout;
+        self
+    }
+}
+
+impl Repo for GithubRepo {
+    fn repo_name(&self) -> &str {
+        self.info
+            .as_ref()
+            .map(|i| i.full_name.as_str())
+            .unwrap_or("unknown")
+    }
+
+    fn clone_url(&self) -> Option<&str> {
+        Some(&self.github_url)
+    }
+
+    fn local_path(&self) -> Option<&Path> {
+        None
+    }
+
+    fn base_commit(&self) -> Option<&str> {
+        self.base_commit.as_deref()
+    }
+}
+
+/// Configuration for pre-existing repository
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PreExistingRepoConfig {
+    pub repo_name: String,
+    pub path: String,
+}
+
+/// Configuration for local repository
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LocalRepoConfig {
+    pub path: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub base_commit: Option<String>,
+}
+
+/// Configuration for GitHub repository
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GithubRepoConfig {
+    pub github_url: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub base_commit: Option<String>,
+    #[serde(default = "default_clone_timeout")]
+    pub clone_timeout: u64,
+}
+
+fn default_clone_timeout() -> u64 {
+    300
+}
+
+/// Union type for repository configurations
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum RepoConfig {
+    PreExisting(PreExistingRepoConfig),
+    Local(LocalRepoConfig),
+    Github(GithubRepoConfig),
+}
+
+/// Create a repository from simplified input
+pub fn repo_from_simplified_input(input: &str) -> Result<Box<dyn Repo>> {
+    // Check if it's a GitHub URL
+    if input.starts_with("https://github.com/") || input.starts_with("git@github.com:") {
+        return Ok(Box::new(GithubRepo::new(input)?));
+    }
+
+    // Check if it's a local path
+    let path = Path::new(input);
+    if path.exists() {
+        return Ok(Box::new(LocalRepo::new(path)?));
+    }
+
+    Err(SWEAgentError::InvalidConfiguration(format!(
+        "Could not parse repository input: {}",
+        input
+    )))
+}
+
+/// Create a repository from configuration
+pub fn create_repo(config: &RepoConfig) -> Result<Box<dyn Repo>> {
+    match config {
+        RepoConfig::PreExisting(cfg) => Ok(Box::new(PreExistingRepo::new(
+            cfg.repo_name.clone(),
+            &cfg.path,
+        ))),
+        RepoConfig::Local(cfg) => {
+            let mut repo = LocalRepo::new(&cfg.path)?;
+            if let Some(ref commit) = cfg.base_commit {
+                repo = repo.with_base_commit(commit.clone());
+            }
+            Ok(Box::new(repo))
+        }
+        RepoConfig::Github(cfg) => {
+            let mut repo = GithubRepo::new(&cfg.github_url)?;
+            if let Some(ref commit) = cfg.base_commit {
+                repo = repo.with_base_commit(commit.clone());
+            }
+            repo = repo.with_clone_timeout(cfg.clone_timeout);
+            Ok(Box::new(repo))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_github_repo() {
+        let repo = GithubRepo::new("https://github.com/elizaos/eliza").unwrap();
+        assert_eq!(repo.repo_name(), "elizaos/eliza");
+        assert!(repo.clone_url().is_some());
+    }
+
+    #[test]
+    fn test_pre_existing_repo() {
+        let repo = PreExistingRepo::new("test-repo", "/tmp/test");
+        assert_eq!(repo.repo_name(), "test-repo");
+        assert!(repo.local_path().is_some());
+    }
+}

package/rust/src/environment/runtime.rs

@@ -0,0 +1,237 @@
+//! Runtime abstractions for command execution
+
+use crate::exceptions::{Result, SWEAgentError};
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+
+/// A bash action to execute
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BashAction {
+    pub command: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cwd: Option<String>,
+}
+
+impl BashAction {
+    pub fn new(command: impl Into<String>) -> Self {
+        Self {
+            command: command.into(),
+            timeout: None,
+            cwd: None,
+        }
+    }
+
+    pub fn with_timeout(mut self, timeout: u64) -> Self {
+        self.timeout = Some(timeout);
+        self
+    }
+
+    pub fn with_cwd(mut self, cwd: impl Into<String>) -> Self {
+        self.cwd = Some(cwd.into());
+        self
+    }
+}
+
+/// Result of a bash action
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BashActionResult {
+    pub output: String,
+    pub exit_code: i32,
+    pub timed_out: bool,
+}
+
+impl BashActionResult {
+    pub fn success(output: impl Into<String>) -> Self {
+        Self {
+            output: output.into(),
+            exit_code: 0,
+            timed_out: false,
+        }
+    }
+
+    pub fn failure(output: impl Into<String>, exit_code: i32) -> Self {
+        Self {
+            output: output.into(),
+            exit_code,
+            timed_out: false,
+        }
+    }
+
+    pub fn timeout(output: impl Into<String>) -> Self {
+        Self {
+            output: output.into(),
+            exit_code: -1,
+            timed_out: true,
+        }
+    }
+}
+
+/// Bash interrupt action
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BashInterruptAction;
+
+/// Request to create a bash session
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CreateBashSessionRequest {
+    pub session_id: String,
+}
+
+/// A command to execute
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Command {
+    pub command: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub args: Option<Vec<String>>,
+}
+
+impl Command {
+    pub fn new(command: impl Into<String>) -> Self {
+        Self {
+            command: command.into(),
+            args: None,
+        }
+    }
+
+    pub fn with_args(mut self, args: Vec<String>) -> Self {
+        self.args = Some(args);
+        self
+    }
+}
+
+/// Result of a command execution
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CommandResult {
+    pub stdout: String,
+    pub stderr: String,
+    pub exit_code: i32,
+}
+
+/// Request to read a file
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ReadFileRequest {
+    pub path: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+
+/// Response from reading a file
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ReadFileResponse {
+    pub content: String,
+    pub size: u64,
+}
+
+/// Request to write a file
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WriteFileRequest {
+    pub path: String,
+    pub content: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mode: Option<u32>,
+}
+
+/// Request to upload a file
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct UploadRequest {
+    pub local_path: String,
+    pub remote_path: String,
+}
+
+/// Abstract runtime trait
+#[async_trait]
+pub trait Runtime: Send + Sync {
+    /// Execute a bash command
+    async fn execute_bash(&self, action: BashAction) -> Result<BashActionResult>;
+
+    /// Interrupt the current bash command
+    async fn interrupt_bash(&self) -> Result<()>;
+
+    /// Read a file
+    async fn read_file(&self, path: &str) -> Result<String>;
+
+    /// Write a file
+    async fn write_file(&self, path: &str, content: &str) -> Result<()>;
+
+    /// Upload a file to the runtime
+    async fn upload_file(&self, local_path: &str, remote_path: &str) -> Result<()>;
+
+    /// Get current working directory
+    fn get_cwd(&self) -> Option<String>;
+
+    /// Check if runtime is alive
+    fn is_alive(&self) -> bool;
+}
+
+/// Simple local runtime for testing
+pub struct LocalRuntime {
+    cwd: String,
+    alive: bool,
+}
+
+impl LocalRuntime {
+    pub fn new(cwd: impl Into<String>) -> Self {
+        Self {
+            cwd: cwd.into(),
+            alive: true,
+        }
+    }
+}
+
+#[async_trait]
+impl Runtime for LocalRuntime {
+    async fn execute_bash(&self, action: BashAction) -> Result<BashActionResult> {
+        use std::process::Command;
+
+        let output = Command::new("sh")
+            .arg("-c")
+            .arg(&action.command)
+            .current_dir(action.cwd.as_ref().unwrap_or(&self.cwd))
+            .output()
+            .map_err(|e| SWEAgentError::RuntimeError(e.to_string()))?;
+
+        let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+
+        Ok(BashActionResult {
+            output: if stderr.is_empty() {
+                stdout
+            } else {
+                format!("{}\n{}", stdout, stderr)
+            },
+            exit_code: output.status.code().unwrap_or(-1),
+            timed_out: false,
+        })
+    }
+
+    async fn interrupt_bash(&self) -> Result<()> {
+        // Not applicable for local runtime
+        Ok(())
+    }
+
+    async fn read_file(&self, path: &str) -> Result<String> {
+        std::fs::read_to_string(path).map_err(|e| SWEAgentError::IoError(e.to_string()))
+    }
+
+    async fn write_file(&self, path: &str, content: &str) -> Result<()> {
+        std::fs::write(path, content).map_err(|e| SWEAgentError::IoError(e.to_string()))
+    }
+
+    async fn upload_file(&self, local_path: &str, remote_path: &str) -> Result<()> {
+        std::fs::copy(local_path, remote_path)
+            .map(|_| ())
+            .map_err(|e| SWEAgentError::IoError(e.to_string()))
+    }
+
+    fn get_cwd(&self) -> Option<String> {
+        Some(self.cwd.clone())
+    }
+
+    fn is_alive(&self) -> bool {
+        self.alive
+    }
+}
+
+// Re-export
+pub use LocalRuntime as AbstractRuntime;