@elizaos/sweagent-root 2.0.0-alpha

package/rust/src/environment/swe_env.rs

@@ -0,0 +1,248 @@
+//! SWE-agent environment implementation
+
+use super::deployment::{get_deployment, Deployment, DeploymentConfig};
+use super::hooks::{CombinedEnvironmentHook, EnvironmentHook};
+use super::repo::{create_repo, Repo, RepoConfig};
+use crate::exceptions::Result;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// Configuration for the SWE environment
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EnvironmentConfig {
+    #[serde(default)]
+    pub deployment: DeploymentConfig,
+    #[serde(default)]
+    pub post_startup_commands: Vec<String>,
+    #[serde(default = "default_post_startup_timeout")]
+    pub post_startup_command_timeout: u64,
+    #[serde(default)]
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub repo: Option<RepoConfig>,
+}
+
+fn default_post_startup_timeout() -> u64 {
+    120
+}
+
+impl Default for EnvironmentConfig {
+    fn default() -> Self {
+        Self {
+            deployment: DeploymentConfig::default(),
+            post_startup_commands: Vec::new(),
+            post_startup_command_timeout: default_post_startup_timeout(),
+            name: "swe-env".to_string(),
+            repo: None,
+        }
+    }
+}
+
+/// The main SWE-agent environment
+pub struct SWEEnv {
+    pub name: String,
+    deployment: Box<dyn Deployment>,
+    repo: Option<Box<dyn Repo>>,
+    post_startup_commands: Vec<String>,
+    post_startup_command_timeout: u64,
+    hooks: CombinedEnvironmentHook,
+    env_variables: HashMap<String, String>,
+    open_files: Vec<String>,
+}
+
+impl Default for SWEEnv {
+    fn default() -> Self {
+        Self {
+            name: "swe-env".to_string(),
+            deployment: get_deployment(DeploymentConfig::default()),
+            repo: None,
+            post_startup_commands: Vec::new(),
+            post_startup_command_timeout: default_post_startup_timeout(),
+            hooks: CombinedEnvironmentHook::new(),
+            env_variables: HashMap::new(),
+            open_files: Vec::new(),
+        }
+    }
+}
+
+impl SWEEnv {
+    pub fn new(config: EnvironmentConfig) -> Result<Self> {
+        let deployment = get_deployment(config.deployment);
+        let repo = config.repo.as_ref().map(create_repo).transpose()?;
+
+        Ok(Self {
+            name: config.name,
+            deployment,
+            repo,
+            post_startup_commands: config.post_startup_commands,
+            post_startup_command_timeout: config.post_startup_command_timeout,
+            hooks: CombinedEnvironmentHook::new(),
+            env_variables: HashMap::new(),
+            open_files: Vec::new(),
+        })
+    }
+
+    pub fn from_config(config: EnvironmentConfig) -> Result<Self> {
+        Self::new(config)
+    }
+
+    /// Add a hook to the environment
+    pub fn add_hook(&mut self, hook: Box<dyn EnvironmentHook>) {
+        self.hooks.add_hook(hook);
+    }
+
+    /// Start the environment
+    pub async fn start(&mut self) -> Result<()> {
+        self.hooks.on_start();
+        self.deployment.start().await?;
+
+        // Run post-startup commands
+        for cmd in &self.post_startup_commands.clone() {
+            self.communicate(cmd, Some(self.post_startup_command_timeout))
+                .await?;
+        }
+
+        Ok(())
+    }
+
+    /// Stop the environment
+    pub async fn stop(&mut self) -> Result<()> {
+        self.hooks.on_stop();
+        self.deployment.stop().await
+    }
+
+    /// Check if the environment is running
+    pub fn is_running(&self) -> bool {
+        self.deployment.is_running()
+    }
+
+    /// Execute a command in the environment
+    pub async fn communicate(&self, command: &str, timeout: Option<u64>) -> Result<String> {
+        let output = self.deployment.execute(command, timeout).await?;
+        // Note: hooks require mut self, but we're in a shared context
+        // In production, use Arc<Mutex<CombinedEnvironmentHook>> for proper mutability
+        Ok(output)
+    }
+
+    /// Read a file from the environment
+    pub async fn read_file(&self, path: &str) -> Result<String> {
+        self.deployment.read_file(path).await
+    }
+
+    /// Write a file to the environment
+    pub async fn write_file(&self, path: &str, content: &str) -> Result<()> {
+        self.deployment.write_file(path, content).await
+    }
+
+    /// Set environment variables
+    pub async fn set_env_variables(&mut self, vars: HashMap<String, String>) -> Result<()> {
+        self.env_variables.extend(vars.clone());
+
+        // Export variables in the shell
+        for (key, value) in vars {
+            let cmd = format!("export {}='{}'", key, value);
+            self.communicate(&cmd, Some(5)).await?;
+        }
+
+        Ok(())
+    }
+
+    /// Interrupt the current session
+    pub async fn interrupt_session(&self) -> Result<()> {
+        self.deployment.interrupt().await
+    }
+
+    /// Get the current working directory
+    pub fn get_cwd(&self) -> Option<String> {
+        self.deployment.get_cwd()
+    }
+
+    /// Get the list of open files
+    pub fn get_open_files(&self) -> &[String] {
+        &self.open_files
+    }
+
+    /// Add a file to the open files list
+    pub fn add_open_file(&mut self, file: impl Into<String>) {
+        let f = file.into();
+        if !self.open_files.contains(&f) {
+            self.open_files.push(f);
+        }
+    }
+
+    /// Remove a file from the open files list
+    pub fn remove_open_file(&mut self, file: &str) {
+        self.open_files.retain(|f| f != file);
+    }
+
+    /// Get git status
+    pub async fn get_git_status(&self) -> Result<String> {
+        self.communicate("git status --porcelain", Some(30)).await
+    }
+
+    /// Get git diff
+    pub async fn get_git_diff(&self) -> Result<String> {
+        self.communicate("git diff", Some(60)).await
+    }
+
+    /// Hard reset the environment
+    pub async fn hard_reset(&mut self) -> Result<()> {
+        self.hooks.on_reset();
+
+        // Reset git state if in a repo
+        if self.repo.is_some() {
+            self.communicate("git checkout .", Some(30)).await?;
+            self.communicate("git clean -fd", Some(30)).await?;
+        }
+
+        // Clear open files
+        self.open_files.clear();
+
+        Ok(())
+    }
+
+    /// Get repository name if available
+    pub fn repo_name(&self) -> Option<&str> {
+        self.repo.as_ref().map(|r| r.repo_name())
+    }
+
+    /// Check if environment is alive
+    pub fn is_alive(&self) -> bool {
+        self.deployment.is_running()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_swe_env_creation() {
+        let config = EnvironmentConfig {
+            deployment: DeploymentConfig::Mock,
+            ..Default::default()
+        };
+
+        let mut env = SWEEnv::new(config).unwrap();
+        env.start().await.unwrap();
+
+        assert!(env.is_running());
+
+        env.stop().await.unwrap();
+        assert!(!env.is_running());
+    }
+
+    #[tokio::test]
+    async fn test_swe_env_communicate() {
+        let config = EnvironmentConfig {
+            deployment: DeploymentConfig::Mock,
+            ..Default::default()
+        };
+
+        let mut env = SWEEnv::new(config).unwrap();
+        env.start().await.unwrap();
+
+        let output = env.communicate("pwd", Some(5)).await.unwrap();
+        assert!(!output.is_empty());
+    }
+}

package/rust/src/exceptions.rs

@@ -0,0 +1,228 @@
+//! Error types for SWE-agent
+//!
+//! This module defines all error types used throughout the SWE-agent implementation.
+
+use thiserror::Error;
+
+/// Main error type for SWE-agent operations
+#[derive(Error, Debug)]
+pub enum SWEAgentError {
+    // Cost and limit errors
+    #[error("Instance cost limit exceeded: {0}")]
+    InstanceCostLimitExceeded(String),
+
+    #[error("Total cost limit exceeded: {0}")]
+    TotalCostLimitExceeded(String),
+
+    #[error("Instance call limit exceeded: {0}")]
+    InstanceCallLimitExceeded(String),
+
+    #[error("Context window exceeded: {0}")]
+    ContextWindowExceeded(String),
+
+    // Format and parsing errors
+    #[error("Format error: {0}")]
+    FormatError(String),
+
+    #[error("Invalid action format: {0}")]
+    InvalidActionFormat(String),
+
+    #[error("Blocked action: {0}")]
+    BlockedAction(String),
+
+    #[error("Bash syntax error: {0}")]
+    BashIncorrectSyntax(String),
+
+    // Execution errors
+    #[error("Command timeout after {timeout}s: {command}")]
+    CommandTimeout { timeout: u64, command: String },
+
+    #[error("Total execution time exceeded")]
+    TotalExecutionTimeExceeded,
+
+    #[error("Environment error: {0}")]
+    EnvironmentError(String),
+
+    #[error("Docker error: {0}")]
+    DockerError(String),
+
+    #[error("Runtime error: {0}")]
+    RuntimeError(String),
+
+    // Agent control flow
+    #[error("Retry with output")]
+    RetryWithOutput,
+
+    #[error("Retry without output")]
+    RetryWithoutOutput,
+
+    #[error("Exit forfeit")]
+    ExitForfeit,
+
+    #[error("End of file")]
+    EOF,
+
+    // API and network errors
+    #[error("API error: {0}")]
+    ApiError(String),
+
+    #[error("Content policy violation: {0}")]
+    ContentPolicyViolation(String),
+
+    #[error("Network error: {0}")]
+    NetworkError(String),
+
+    // Configuration errors
+    #[error("Configuration error: {0}")]
+    ConfigurationError(String),
+
+    #[error("Invalid configuration: {0}")]
+    InvalidConfiguration(String),
+
+    #[error("Missing required field: {0}")]
+    MissingField(String),
+
+    // File and IO errors
+    #[error("File not found: {0}")]
+    FileNotFound(String),
+
+    #[error("IO error: {0}")]
+    IoError(String),
+
+    #[error("Serialization error: {0}")]
+    SerializationError(String),
+
+    // Git errors
+    #[error("Git error: {0}")]
+    GitError(String),
+
+    #[error("Invalid GitHub URL: {0}")]
+    InvalidGithubUrl(String),
+
+    // Template errors
+    #[error("Template error: {0}")]
+    TemplateError(String),
+
+    // Generic errors
+    #[error("Unknown error: {0}")]
+    Unknown(String),
+
+    #[error(transparent)]
+    Other(#[from] anyhow::Error),
+}
+
+impl SWEAgentError {
+    /// Check if this error should trigger a retry
+    pub fn should_retry(&self) -> bool {
+        matches!(
+            self,
+            SWEAgentError::RetryWithOutput
+                | SWEAgentError::RetryWithoutOutput
+                | SWEAgentError::FormatError(_)
+                | SWEAgentError::BlockedAction(_)
+                | SWEAgentError::BashIncorrectSyntax(_)
+        )
+    }
+
+    /// Check if this error should cause immediate exit
+    pub fn should_exit(&self) -> bool {
+        matches!(
+            self,
+            SWEAgentError::ExitForfeit
+                | SWEAgentError::TotalExecutionTimeExceeded
+                | SWEAgentError::InstanceCostLimitExceeded(_)
+                | SWEAgentError::TotalCostLimitExceeded(_)
+                | SWEAgentError::InstanceCallLimitExceeded(_)
+                | SWEAgentError::ContextWindowExceeded(_)
+        )
+    }
+
+    /// Get exit status string for this error
+    pub fn exit_status(&self) -> &'static str {
+        match self {
+            SWEAgentError::ExitForfeit => "exit_forfeit",
+            SWEAgentError::TotalExecutionTimeExceeded => "exit_total_execution_time",
+            SWEAgentError::CommandTimeout { .. } => "exit_command_timeout",
+            SWEAgentError::ContextWindowExceeded(_) => "exit_context",
+            SWEAgentError::InstanceCostLimitExceeded(_)
+            | SWEAgentError::TotalCostLimitExceeded(_)
+            | SWEAgentError::InstanceCallLimitExceeded(_) => "exit_cost",
+            SWEAgentError::RuntimeError(_) | SWEAgentError::EnvironmentError(_) => {
+                "exit_environment_error"
+            }
+            SWEAgentError::FormatError(_)
+            | SWEAgentError::InvalidActionFormat(_)
+            | SWEAgentError::BashIncorrectSyntax(_) => "exit_format",
+            _ => "exit_error",
+        }
+    }
+}
+
+impl From<std::io::Error> for SWEAgentError {
+    fn from(err: std::io::Error) -> Self {
+        SWEAgentError::IoError(err.to_string())
+    }
+}
+
+impl From<serde_json::Error> for SWEAgentError {
+    fn from(err: serde_json::Error) -> Self {
+        SWEAgentError::SerializationError(err.to_string())
+    }
+}
+
+impl From<serde_yaml::Error> for SWEAgentError {
+    fn from(err: serde_yaml::Error) -> Self {
+        SWEAgentError::SerializationError(err.to_string())
+    }
+}
+
+impl From<reqwest::Error> for SWEAgentError {
+    fn from(err: reqwest::Error) -> Self {
+        SWEAgentError::NetworkError(err.to_string())
+    }
+}
+
+impl From<handlebars::RenderError> for SWEAgentError {
+    fn from(err: handlebars::RenderError) -> Self {
+        SWEAgentError::TemplateError(err.to_string())
+    }
+}
+
+/// Result type alias for SWE-agent operations
+pub type Result<T> = std::result::Result<T, SWEAgentError>;
+
+/// Special tokens used in observations to signal control flow
+pub mod tokens {
+    pub const RETRY_WITH_OUTPUT: &str = "###SWE-AGENT-RETRY-WITH-OUTPUT###";
+    pub const RETRY_WITHOUT_OUTPUT: &str = "###SWE-AGENT-RETRY-WITHOUT-OUTPUT###";
+    pub const EXIT_FORFEIT: &str = "###SWE-AGENT-EXIT-FORFEIT###";
+    pub const SUBMISSION_MARKER: &str = "<<SWE_AGENT_SUBMISSION>>";
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_should_retry() {
+        assert!(SWEAgentError::RetryWithOutput.should_retry());
+        assert!(SWEAgentError::FormatError("test".to_string()).should_retry());
+        assert!(!SWEAgentError::ExitForfeit.should_retry());
+    }
+
+    #[test]
+    fn test_should_exit() {
+        assert!(SWEAgentError::ExitForfeit.should_exit());
+        assert!(SWEAgentError::TotalExecutionTimeExceeded.should_exit());
+        assert!(!SWEAgentError::FormatError("test".to_string()).should_exit());
+    }
+
+    #[test]
+    fn test_exit_status() {
+        assert_eq!(SWEAgentError::ExitForfeit.exit_status(), "exit_forfeit");
+        assert_eq!(
+            SWEAgentError::ContextWindowExceeded("test".to_string()).exit_status(),
+            "exit_context"
+        );
+    }
+}

package/rust/src/lib.rs

@@ -0,0 +1,68 @@
+//! SWE-agent: Software Engineering Agent
+//!
+//! This crate provides a Rust implementation of SWE-agent, an AI-powered
+//! software engineering agent that can autonomously solve coding tasks.
+//!
+//! # Features
+//!
+//! - `native` - Native runtime with full async support (default)
+//! - `wasm` - WebAssembly support for browser environments
+//!
+//! # Example
+//!
+//! ```rust,no_run
+//! use elizaos_sweagent::run::{RunSingle, RunSingleConfig};
+//!
+//! #[tokio::main]
+//! async fn main() -> anyhow::Result<()> {
+//!     // Configure and run the agent
+//!     let config = RunSingleConfig::default();
+//!     let mut runner = RunSingle::from_config(config)?;
+//!     runner.run().await?;
+//!     Ok(())
+//! }
+//! ```
+
+pub mod agent;
+pub mod environment;
+pub mod exceptions;
+pub mod monitoring;
+pub mod run;
+pub mod tools;
+pub mod types;
+pub mod utils;
+
+// Re-export main types for convenience
+pub use agent::{
+    AbstractAgentHook, AgentConfig, DefaultAgent, DefaultAgentConfig, RetryAgent, RetryAgentConfig,
+};
+pub use environment::{
+    Deployment, DeploymentConfig, DockerDeployment, DockerDeploymentConfig, EnvironmentConfig,
+    LocalDeployment, LocalDeploymentConfig, RepoConfig, SWEEnv,
+};
+pub use exceptions::SWEAgentError;
+pub use monitoring::{
+    health_check, AgentMetrics, Alert, AlertHandler, AlertSeverity, AlertThresholds, HealthStatus,
+    MetricsMonitor, MetricsSnapshot,
+};
+pub use run::{RunBatch, RunBatchConfig, RunSingle, RunSingleConfig};
+pub use tools::{Bundle, BundleConfig, ParseFunction, ToolConfig, ToolHandler};
+pub use types::AgentRunResult;
+pub use types::{History, HistoryItem, StepOutput, Trajectory, TrajectoryStep};
+
+/// Version of the SWE-agent library
+pub const VERSION: &str = "1.1.0";
+
+/// Get the agent version information string
+pub fn get_agent_version_info() -> String {
+    format!("SWE-agent Rust implementation version {}", VERSION)
+}
+
+#[cfg(feature = "wasm")]
+use wasm_bindgen::prelude::*;
+
+#[cfg(feature = "wasm")]
+#[wasm_bindgen]
+pub fn wasm_version() -> String {
+    VERSION.to_string()
+}