@elizaos/sweagent-root 2.0.0-alpha

package/rust/src/run/run_single.rs

@@ -0,0 +1,196 @@
+//! Single instance runner for SWE-agent
+
+use super::hooks::{CombinedRunHook, RunHook};
+use crate::agent::problem_statement::{
+    create_problem_statement, ProblemStatement, ProblemStatementConfig,
+};
+use crate::agent::{get_agent_from_config, Agent, AgentConfig};
+use crate::environment::{EnvironmentConfig, SWEEnv};
+use crate::exceptions::Result;
+use crate::types::AgentRunResult;
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+
+/// Actions to perform after agent run
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct RunSingleActionConfig {
+    #[serde(default)]
+    pub open_pr: bool,
+    #[serde(default)]
+    pub apply_patch_locally: bool,
+}
+
+/// Configuration for running a single instance
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RunSingleConfig {
+    #[serde(default)]
+    pub agent: AgentConfig,
+    #[serde(default)]
+    pub env: EnvironmentConfig,
+    #[serde(default)]
+    pub problem_statement: ProblemStatementConfig,
+    #[serde(default = "default_output_dir")]
+    pub output_dir: String,
+    #[serde(default)]
+    pub actions: RunSingleActionConfig,
+}
+
+fn default_output_dir() -> String {
+    "./trajectories".to_string()
+}
+
+impl Default for RunSingleConfig {
+    fn default() -> Self {
+        Self {
+            agent: AgentConfig::default(),
+            env: EnvironmentConfig::default(),
+            problem_statement: ProblemStatementConfig::Empty,
+            output_dir: default_output_dir(),
+            actions: RunSingleActionConfig::default(),
+        }
+    }
+}
+
+/// Runner for a single problem instance
+pub struct RunSingle {
+    agent: Box<dyn Agent>,
+    env: SWEEnv,
+    problem_statement: Box<dyn ProblemStatement>,
+    output_dir: PathBuf,
+    actions: RunSingleActionConfig,
+    hooks: CombinedRunHook,
+}
+
+impl RunSingle {
+    pub fn new(
+        agent: Box<dyn Agent>,
+        env: SWEEnv,
+        problem_statement: Box<dyn ProblemStatement>,
+        output_dir: impl Into<PathBuf>,
+        actions: RunSingleActionConfig,
+    ) -> Self {
+        Self {
+            agent,
+            env,
+            problem_statement,
+            output_dir: output_dir.into(),
+            actions,
+            hooks: CombinedRunHook::new(),
+        }
+    }
+
+    /// Create from configuration
+    pub fn from_config(config: RunSingleConfig) -> Result<Self> {
+        let agent = get_agent_from_config(config.agent)?;
+        let env = SWEEnv::from_config(config.env)?;
+        let problem_statement = create_problem_statement(&config.problem_statement)?;
+
+        Ok(Self::new(
+            agent,
+            env,
+            problem_statement,
+            config.output_dir,
+            config.actions,
+        ))
+    }
+
+    /// Add a hook
+    pub fn add_hook(&mut self, hook: Box<dyn RunHook>) {
+        self.hooks.add_hook(hook);
+    }
+
+    /// Run the agent on the problem instance
+    pub async fn run(&mut self) -> Result<AgentRunResult> {
+        // Ensure output directory exists
+        std::fs::create_dir_all(&self.output_dir)?;
+
+        self.hooks.on_start();
+        self.hooks.on_instance_start(0, self.problem_statement.id());
+
+        // Start the environment
+        self.env.start().await?;
+
+        // Create a new problem statement for the agent (since we need to move it)
+        let ps_config = ProblemStatementConfig::Text {
+            text: self.problem_statement.get_problem_statement(),
+            id: self.problem_statement.id().to_string(),
+        };
+        let ps_for_agent = create_problem_statement(&ps_config)?;
+
+        // Run the agent
+        let result = match self
+            .agent
+            .run(&mut self.env, ps_for_agent, &self.output_dir)
+            .await
+        {
+            Ok(r) => r,
+            Err(e) => {
+                tracing::error!(error = %e, "Agent run failed");
+                self.env.stop().await?;
+                return Err(e);
+            }
+        };
+
+        // Stop the environment
+        self.env.stop().await?;
+
+        self.hooks.on_instance_completed(&result);
+        self.hooks.on_end();
+
+        // Handle post-run actions
+        if self.actions.apply_patch_locally {
+            self.apply_patch_locally(&result).await?;
+        }
+
+        if self.actions.open_pr {
+            self.open_pr(&result).await?;
+        }
+
+        Ok(result)
+    }
+
+    async fn apply_patch_locally(&self, result: &AgentRunResult) -> Result<()> {
+        if let Some(ref submission) = result.info.submission {
+            tracing::info!("Applying patch locally");
+            // In a full implementation, would apply the patch using git
+            let patch_path = self.output_dir.join("local.patch");
+            std::fs::write(&patch_path, submission)?;
+            tracing::info!(path = ?patch_path, "Patch saved");
+        }
+        Ok(())
+    }
+
+    async fn open_pr(&self, result: &AgentRunResult) -> Result<()> {
+        if result.info.submission.is_some() {
+            tracing::info!("Opening PR");
+            // In a full implementation, would create a GitHub PR
+        }
+        Ok(())
+    }
+}
+
+/// Run from configuration (convenience function)
+pub async fn run_from_config(config: RunSingleConfig) -> Result<AgentRunResult> {
+    let mut runner = RunSingle::from_config(config)?;
+    runner.run().await
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::environment::DeploymentConfig;
+
+    #[tokio::test]
+    async fn test_run_single_creation() {
+        let config = RunSingleConfig {
+            env: EnvironmentConfig {
+                deployment: DeploymentConfig::Mock,
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+
+        let runner = RunSingle::from_config(config);
+        assert!(runner.is_ok());
+    }
+}

package/rust/src/tools/bundle.rs

@@ -0,0 +1,224 @@
+//! Tool bundle definitions
+
+use crate::exceptions::Result;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// A command bundle defining a tool
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Bundle {
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub end_name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub install_script: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default)]
+    pub arguments: Vec<Argument>,
+    #[serde(flatten)]
+    pub extra: HashMap<String, serde_json::Value>,
+}
+
+impl Bundle {
+    pub fn new(name: impl Into<String>) -> Self {
+        Self {
+            name: name.into(),
+            end_name: None,
+            install_script: None,
+            signature: None,
+            description: None,
+            arguments: Vec::new(),
+            extra: HashMap::new(),
+        }
+    }
+
+    pub fn with_end_name(mut self, end_name: impl Into<String>) -> Self {
+        self.end_name = Some(end_name.into());
+        self
+    }
+
+    pub fn with_install_script(mut self, script: impl Into<String>) -> Self {
+        self.install_script = Some(script.into());
+        self
+    }
+
+    pub fn with_description(mut self, desc: impl Into<String>) -> Self {
+        self.description = Some(desc.into());
+        self
+    }
+
+    pub fn with_signature(mut self, sig: impl Into<String>) -> Self {
+        self.signature = Some(sig.into());
+        self
+    }
+
+    pub fn with_argument(mut self, arg: Argument) -> Self {
+        self.arguments.push(arg);
+        self
+    }
+
+    /// Generate documentation for this command
+    pub fn generate_docs(&self) -> String {
+        let mut docs = String::new();
+
+        docs.push_str(&format!("## {}\n\n", self.name));
+
+        if let Some(ref desc) = self.description {
+            docs.push_str(&format!("{}\n\n", desc));
+        }
+
+        if let Some(ref sig) = self.signature {
+            docs.push_str(&format!("**Signature:** `{}`\n\n", sig));
+        }
+
+        if !self.arguments.is_empty() {
+            docs.push_str("**Arguments:**\n\n");
+            for arg in &self.arguments {
+                let required = if arg.required { " (required)" } else { "" };
+                docs.push_str(&format!(
+                    "- `{}`: {}{}\n",
+                    arg.name,
+                    arg.description.as_deref().unwrap_or(""),
+                    required
+                ));
+            }
+            docs.push('\n');
+        }
+
+        docs
+    }
+}
+
+/// An argument for a command
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Argument {
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default)]
+    pub required: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub default_value: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub arg_type: Option<String>,
+}
+
+impl Argument {
+    pub fn new(name: impl Into<String>) -> Self {
+        Self {
+            name: name.into(),
+            description: None,
+            required: false,
+            default_value: None,
+            arg_type: None,
+        }
+    }
+
+    pub fn required(mut self) -> Self {
+        self.required = true;
+        self
+    }
+
+    pub fn with_description(mut self, desc: impl Into<String>) -> Self {
+        self.description = Some(desc.into());
+        self
+    }
+
+    pub fn with_default(mut self, default: impl Into<String>) -> Self {
+        self.default_value = Some(default.into());
+        self
+    }
+
+    pub fn with_type(mut self, arg_type: impl Into<String>) -> Self {
+        self.arg_type = Some(arg_type.into());
+        self
+    }
+}
+
+/// Configuration for creating a bundle
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct BundleConfig {
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub end_name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub install_script: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default)]
+    pub arguments: Vec<Argument>,
+}
+
+/// Create a bundle from configuration
+pub fn create_bundle(config: &BundleConfig) -> Result<Bundle> {
+    let mut bundle = Bundle::new(&config.name);
+
+    if let Some(ref end_name) = config.end_name {
+        bundle = bundle.with_end_name(end_name);
+    }
+
+    if let Some(ref script) = config.install_script {
+        bundle = bundle.with_install_script(script);
+    }
+
+    if let Some(ref sig) = config.signature {
+        bundle = bundle.with_signature(sig);
+    }
+
+    if let Some(ref desc) = config.description {
+        bundle = bundle.with_description(desc);
+    }
+
+    bundle.arguments = config.arguments.clone();
+
+    Ok(bundle)
+}
+
+/// Generate documentation for all commands
+pub fn generate_command_docs(bundles: &[Bundle]) -> String {
+    let mut docs = String::new();
+    docs.push_str("# Available Commands\n\n");
+
+    for bundle in bundles {
+        docs.push_str(&bundle.generate_docs());
+    }
+
+    docs
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_bundle_creation() {
+        let bundle = Bundle::new("edit")
+            .with_end_name("ENDEDIT")
+            .with_description("Edit a file")
+            .with_argument(
+                Argument::new("file")
+                    .required()
+                    .with_description("The file to edit"),
+            );
+
+        assert_eq!(bundle.name, "edit");
+        assert_eq!(bundle.end_name, Some("ENDEDIT".to_string()));
+        assert_eq!(bundle.arguments.len(), 1);
+    }
+
+    #[test]
+    fn test_generate_docs() {
+        let bundle = Bundle::new("test")
+            .with_description("A test command")
+            .with_signature("test <arg>");
+
+        let docs = bundle.generate_docs();
+        assert!(docs.contains("## test"));
+        assert!(docs.contains("A test command"));
+    }
+}

package/rust/src/tools/commands.rs

@@ -0,0 +1,173 @@
+//! Command definitions and utilities
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// A parsed command with its arguments
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Command {
+    pub name: String,
+    pub args: Vec<String>,
+    pub kwargs: HashMap<String, String>,
+    pub raw: String,
+}
+
+impl Command {
+    pub fn new(name: impl Into<String>) -> Self {
+        Self {
+            name: name.into(),
+            args: Vec::new(),
+            kwargs: HashMap::new(),
+            raw: String::new(),
+        }
+    }
+
+    pub fn with_arg(mut self, arg: impl Into<String>) -> Self {
+        self.args.push(arg.into());
+        self
+    }
+
+    pub fn with_kwarg(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
+        self.kwargs.insert(key.into(), value.into());
+        self
+    }
+
+    pub fn with_raw(mut self, raw: impl Into<String>) -> Self {
+        self.raw = raw.into();
+        self
+    }
+
+    /// Get the first argument or None
+    pub fn first_arg(&self) -> Option<&str> {
+        self.args.first().map(|s| s.as_str())
+    }
+
+    /// Check if a flag is present
+    pub fn has_flag(&self, flag: &str) -> bool {
+        self.kwargs.contains_key(flag) || self.args.contains(&flag.to_string())
+    }
+}
+
+/// Parse a command string into a Command struct
+pub fn parse_command(input: &str) -> Option<Command> {
+    let input = input.trim();
+    if input.is_empty() {
+        return None;
+    }
+
+    let parts: Vec<&str> = input.split_whitespace().collect();
+    if parts.is_empty() {
+        return None;
+    }
+
+    let name = parts[0].to_string();
+    let mut args = Vec::new();
+    let mut kwargs = HashMap::new();
+
+    let mut i = 1;
+    while i < parts.len() {
+        let part = parts[i];
+
+        if part.starts_with("--") {
+            // Long flag
+            let key = part.trim_start_matches("--");
+            if let Some(eq_pos) = key.find('=') {
+                let (k, v) = key.split_at(eq_pos);
+                kwargs.insert(k.to_string(), v[1..].to_string());
+            } else if i + 1 < parts.len() && !parts[i + 1].starts_with('-') {
+                kwargs.insert(key.to_string(), parts[i + 1].to_string());
+                i += 1;
+            } else {
+                kwargs.insert(key.to_string(), "true".to_string());
+            }
+        } else if part.starts_with('-') && part.len() == 2 {
+            // Short flag
+            let key = part.trim_start_matches('-');
+            if i + 1 < parts.len() && !parts[i + 1].starts_with('-') {
+                kwargs.insert(key.to_string(), parts[i + 1].to_string());
+                i += 1;
+            } else {
+                kwargs.insert(key.to_string(), "true".to_string());
+            }
+        } else {
+            args.push(part.to_string());
+        }
+
+        i += 1;
+    }
+
+    Some(Command {
+        name,
+        args,
+        kwargs,
+        raw: input.to_string(),
+    })
+}
+
+/// Quote a string for shell usage
+pub fn shell_quote(s: &str) -> String {
+    if s.contains(' ') || s.contains('\'') || s.contains('"') || s.contains('\\') {
+        format!("'{}'", s.replace('\'', "'\\''"))
+    } else {
+        s.to_string()
+    }
+}
+
+/// Check if a string needs quoting
+pub fn should_quote(s: &str) -> bool {
+    s.contains(' ')
+        || s.contains('\'')
+        || s.contains('"')
+        || s.contains('\\')
+        || s.contains('$')
+        || s.contains('!')
+        || s.contains('*')
+        || s.contains('?')
+}
+
+/// Get the signature of a command
+pub fn get_signature(name: &str, args: &[&str]) -> String {
+    let mut sig = name.to_string();
+    for arg in args {
+        sig.push(' ');
+        if arg.starts_with('[') || arg.starts_with('<') {
+            sig.push_str(arg);
+        } else {
+            sig.push_str(&format!("<{}>", arg));
+        }
+    }
+    sig
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_command() {
+        let cmd = parse_command("git commit -m message").unwrap();
+        assert_eq!(cmd.name, "git");
+        assert_eq!(cmd.args, vec!["commit"]);
+        assert_eq!(cmd.kwargs.get("m"), Some(&"message".to_string()));
+    }
+
+    #[test]
+    fn test_parse_command_with_flags() {
+        let cmd = parse_command("ls --color=auto").unwrap();
+        assert_eq!(cmd.name, "ls");
+        assert_eq!(cmd.kwargs.get("color"), Some(&"auto".to_string()));
+    }
+
+    #[test]
+    fn test_shell_quote() {
+        assert_eq!(shell_quote("simple"), "simple");
+        assert_eq!(shell_quote("with space"), "'with space'");
+        assert_eq!(shell_quote("with'quote"), "'with'\\''quote'");
+    }
+
+    #[test]
+    fn test_get_signature() {
+        let sig = get_signature("edit", &["file", "[start_line]", "[end_line]"]);
+        assert_eq!(sig, "edit <file> [start_line] [end_line]");
+    }
+}