@elizaos/sweagent-root 2.0.0-alpha

package/rust/src/utils/config.rs

@@ -0,0 +1,105 @@
+//! Configuration utilities for SWE-agent
+
+use crate::exceptions::{Result, SWEAgentError};
+use std::collections::HashMap;
+use std::env;
+use std::path::{Path, PathBuf};
+
+/// Load environment variables from a .env file
+pub fn load_environment_variables(path: Option<&Path>) -> Result<()> {
+    if let Some(p) = path {
+        if p.exists() {
+            dotenvy::from_path(p).map_err(|e| {
+                SWEAgentError::ConfigurationError(format!("Failed to load env file: {}", e))
+            })?;
+        }
+    } else {
+        // Try to load from default locations
+        let _ = dotenvy::dotenv();
+    }
+    Ok(())
+}
+
+/// Convert a path relative to repo root to absolute path
+pub fn convert_path_relative_to_repo_root(path: &str, repo_root: &Path) -> PathBuf {
+    if Path::new(path).is_absolute() {
+        PathBuf::from(path)
+    } else {
+        repo_root.join(path)
+    }
+}
+
+/// Convert a path to absolute path
+pub fn convert_path_to_abspath(path: &str, base: &Path) -> PathBuf {
+    let p = Path::new(path);
+    if p.is_absolute() {
+        p.to_path_buf()
+    } else {
+        base.join(p)
+    }
+}
+
+/// Strip absolute path prefixes from dictionary values
+pub fn strip_abspath_from_dict(
+    dict: &HashMap<String, String>,
+    prefix: &str,
+) -> HashMap<String, String> {
+    dict.iter()
+        .map(|(k, v)| {
+            let new_v = if v.starts_with(prefix) {
+                v.strip_prefix(prefix).unwrap_or(v).to_string()
+            } else {
+                v.clone()
+            };
+            (k.clone(), new_v)
+        })
+        .collect()
+}
+
+/// Check if a string could be a file path
+pub fn could_be_a_path(s: &str) -> bool {
+    // Check for common path indicators
+    s.contains('/') || s.contains('\\') || s.starts_with('.') || s.contains('.')
+}
+
+/// Get an environment variable with optional default
+pub fn get_env_var(name: &str, default: Option<&str>) -> Option<String> {
+    env::var(name).ok().or_else(|| default.map(String::from))
+}
+
+/// Get an API key from environment
+pub fn get_api_key(provider: &str) -> Option<String> {
+    let key_name = format!("{}_API_KEY", provider.to_uppercase().replace('-', "_"));
+    env::var(&key_name).ok()
+}
+
+/// Parse API keys that may be separated by :::
+pub fn parse_api_keys(key_string: &str) -> Vec<String> {
+    key_string
+        .split(":::")
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty())
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_could_be_a_path() {
+        assert!(could_be_a_path("/home/user/file.txt"));
+        assert!(could_be_a_path("./relative/path"));
+        assert!(could_be_a_path("file.py"));
+        assert!(!could_be_a_path("simple_string"));
+    }
+
+    #[test]
+    fn test_parse_api_keys() {
+        let keys = parse_api_keys("key1:::key2:::key3");
+        assert_eq!(keys, vec!["key1", "key2", "key3"]);
+
+        let single = parse_api_keys("single_key");
+        assert_eq!(single, vec!["single_key"]);
+    }
+}

package/rust/src/utils/files.rs

@@ -0,0 +1,137 @@
+//! File utilities for SWE-agent
+
+use crate::exceptions::{Result, SWEAgentError};
+use std::fs;
+use std::path::Path;
+
+/// Load a file's contents as a string
+pub fn load_file(path: &Path) -> Result<String> {
+    fs::read_to_string(path)
+        .map_err(|e| SWEAgentError::FileNotFound(format!("{}: {}", path.display(), e)))
+}
+
+/// Write contents to a file
+pub fn write_file(path: &Path, contents: &str) -> Result<()> {
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    fs::write(path, contents)?;
+    Ok(())
+}
+
+/// Check if a file exists
+pub fn file_exists(path: &Path) -> bool {
+    path.exists() && path.is_file()
+}
+
+/// Check if a directory exists
+pub fn dir_exists(path: &Path) -> bool {
+    path.exists() && path.is_dir()
+}
+
+/// Create a directory and all parent directories
+pub fn ensure_dir(path: &Path) -> Result<()> {
+    fs::create_dir_all(path)?;
+    Ok(())
+}
+
+/// Get the extension of a file
+pub fn get_extension(path: &Path) -> Option<String> {
+    path.extension().and_then(|e| e.to_str()).map(String::from)
+}
+
+/// Read a JSON file and deserialize it
+pub fn load_json<T: serde::de::DeserializeOwned>(path: &Path) -> Result<T> {
+    let contents = load_file(path)?;
+    serde_json::from_str(&contents).map_err(|e| {
+        SWEAgentError::SerializationError(format!(
+            "Failed to parse JSON from {}: {}",
+            path.display(),
+            e
+        ))
+    })
+}
+
+/// Read a YAML file and deserialize it
+pub fn load_yaml<T: serde::de::DeserializeOwned>(path: &Path) -> Result<T> {
+    let contents = load_file(path)?;
+    serde_yaml::from_str(&contents).map_err(|e| {
+        SWEAgentError::SerializationError(format!(
+            "Failed to parse YAML from {}: {}",
+            path.display(),
+            e
+        ))
+    })
+}
+
+/// Save an object as JSON to a file
+pub fn save_json<T: serde::Serialize>(path: &Path, data: &T) -> Result<()> {
+    let contents = serde_json::to_string_pretty(data)?;
+    write_file(path, &contents)
+}
+
+/// Save an object as YAML to a file
+pub fn save_yaml<T: serde::Serialize>(path: &Path, data: &T) -> Result<()> {
+    let contents = serde_yaml::to_string(data)?;
+    write_file(path, &contents)
+}
+
+/// Find files matching a glob pattern
+pub fn find_files(base_dir: &Path, pattern: &str) -> Result<Vec<std::path::PathBuf>> {
+    let full_pattern = base_dir.join(pattern);
+    let pattern_str = full_pattern.to_string_lossy();
+
+    glob::glob(&pattern_str)
+        .map_err(|e| SWEAgentError::IoError(format!("Invalid glob pattern: {}", e)))?
+        .filter_map(|entry| entry.ok())
+        .collect::<Vec<_>>()
+        .pipe(Ok)
+}
+
+trait Pipe: Sized {
+    fn pipe<T, F: FnOnce(Self) -> T>(self, f: F) -> T {
+        f(self)
+    }
+}
+
+impl<T> Pipe for T {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_write_and_load_file() {
+        let dir = TempDir::new().unwrap();
+        let path = dir.path().join("test.txt");
+
+        write_file(&path, "hello world").unwrap();
+        let contents = load_file(&path).unwrap();
+
+        assert_eq!(contents, "hello world");
+    }
+
+    #[test]
+    fn test_file_exists() {
+        let dir = TempDir::new().unwrap();
+        let path = dir.path().join("test.txt");
+
+        assert!(!file_exists(&path));
+        write_file(&path, "test").unwrap();
+        assert!(file_exists(&path));
+    }
+
+    #[test]
+    fn test_get_extension() {
+        assert_eq!(
+            get_extension(Path::new("file.txt")),
+            Some("txt".to_string())
+        );
+        assert_eq!(
+            get_extension(Path::new("file.tar.gz")),
+            Some("gz".to_string())
+        );
+        assert_eq!(get_extension(Path::new("file")), None);
+    }
+}

package/rust/src/utils/github.rs

@@ -0,0 +1,171 @@
+//! GitHub utilities for SWE-agent
+
+use crate::exceptions::{Result, SWEAgentError};
+use regex::Regex;
+use serde::{Deserialize, Serialize};
+
+/// Parsed GitHub repository information
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GithubRepoInfo {
+    pub owner: String,
+    pub repo: String,
+    pub full_name: String,
+}
+
+/// Parsed GitHub issue information
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GithubIssueInfo {
+    pub owner: String,
+    pub repo: String,
+    pub issue_number: u64,
+    pub full_name: String,
+}
+
+/// Check if a string is a GitHub repository URL
+pub fn is_github_repo_url(url: &str) -> bool {
+    let patterns = [
+        r"^https?://github\.com/[\w.-]+/[\w.-]+/?$",
+        r"^https?://github\.com/[\w.-]+/[\w.-]+\.git$",
+        r"^git@github\.com:[\w.-]+/[\w.-]+\.git$",
+    ];
+
+    patterns
+        .iter()
+        .any(|p| Regex::new(p).map(|re| re.is_match(url)).unwrap_or(false))
+}
+
+/// Check if a string is a GitHub issue URL
+pub fn is_github_issue_url(url: &str) -> bool {
+    let pattern = r"^https?://github\.com/[\w.-]+/[\w.-]+/issues/\d+$";
+    Regex::new(pattern)
+        .map(|re| re.is_match(url))
+        .unwrap_or(false)
+}
+
+/// Parse a GitHub repository URL
+pub fn parse_github_repo_url(url: &str) -> Result<GithubRepoInfo> {
+    // Handle HTTPS URLs
+    let https_pattern = Regex::new(r"^https?://github\.com/([\w.-]+)/([\w.-]+?)(?:\.git)?/?$")
+        .map_err(|e| SWEAgentError::Unknown(e.to_string()))?;
+
+    if let Some(caps) = https_pattern.captures(url) {
+        let owner = caps.get(1).unwrap().as_str().to_string();
+        let repo = caps.get(2).unwrap().as_str().to_string();
+        return Ok(GithubRepoInfo {
+            full_name: format!("{}/{}", owner, repo),
+            owner,
+            repo,
+        });
+    }
+
+    // Handle SSH URLs
+    let ssh_pattern = Regex::new(r"^git@github\.com:([\w.-]+)/([\w.-]+?)(?:\.git)?$")
+        .map_err(|e| SWEAgentError::Unknown(e.to_string()))?;
+
+    if let Some(caps) = ssh_pattern.captures(url) {
+        let owner = caps.get(1).unwrap().as_str().to_string();
+        let repo = caps.get(2).unwrap().as_str().to_string();
+        return Ok(GithubRepoInfo {
+            full_name: format!("{}/{}", owner, repo),
+            owner,
+            repo,
+        });
+    }
+
+    Err(SWEAgentError::InvalidGithubUrl(format!(
+        "Could not parse GitHub URL: {}",
+        url
+    )))
+}
+
+/// Parse a GitHub issue URL
+pub fn parse_github_issue_url(url: &str) -> Result<GithubIssueInfo> {
+    let pattern = Regex::new(r"^https?://github\.com/([\w.-]+)/([\w.-]+)/issues/(\d+)$")
+        .map_err(|e| SWEAgentError::Unknown(e.to_string()))?;
+
+    if let Some(caps) = pattern.captures(url) {
+        let owner = caps.get(1).unwrap().as_str().to_string();
+        let repo = caps.get(2).unwrap().as_str().to_string();
+        let issue_number: u64 = caps
+            .get(3)
+            .unwrap()
+            .as_str()
+            .parse()
+            .map_err(|_| SWEAgentError::InvalidGithubUrl("Invalid issue number".to_string()))?;
+
+        return Ok(GithubIssueInfo {
+            full_name: format!("{}/{}", owner, repo),
+            owner,
+            repo,
+            issue_number,
+        });
+    }
+
+    Err(SWEAgentError::InvalidGithubUrl(format!(
+        "Could not parse GitHub issue URL: {}",
+        url
+    )))
+}
+
+/// Build a GitHub repository URL from owner and repo
+pub fn build_github_repo_url(owner: &str, repo: &str) -> String {
+    format!("https://github.com/{}/{}", owner, repo)
+}
+
+/// Build a GitHub issue URL
+pub fn build_github_issue_url(owner: &str, repo: &str, issue_number: u64) -> String {
+    format!(
+        "https://github.com/{}/{}/issues/{}",
+        owner, repo, issue_number
+    )
+}
+
+/// Build a GitHub raw content URL
+pub fn build_github_raw_url(owner: &str, repo: &str, branch: &str, path: &str) -> String {
+    format!(
+        "https://raw.githubusercontent.com/{}/{}/{}/{}",
+        owner, repo, branch, path
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_is_github_repo_url() {
+        assert!(is_github_repo_url("https://github.com/owner/repo"));
+        assert!(is_github_repo_url("https://github.com/owner/repo/"));
+        assert!(is_github_repo_url("https://github.com/owner/repo.git"));
+        assert!(is_github_repo_url("git@github.com:owner/repo.git"));
+        assert!(!is_github_repo_url("https://gitlab.com/owner/repo"));
+        assert!(!is_github_repo_url("not a url"));
+    }
+
+    #[test]
+    fn test_is_github_issue_url() {
+        assert!(is_github_issue_url(
+            "https://github.com/owner/repo/issues/123"
+        ));
+        assert!(!is_github_issue_url("https://github.com/owner/repo"));
+        assert!(!is_github_issue_url(
+            "https://github.com/owner/repo/pull/123"
+        ));
+    }
+
+    #[test]
+    fn test_parse_github_repo_url() {
+        let info = parse_github_repo_url("https://github.com/elizaos/eliza").unwrap();
+        assert_eq!(info.owner, "elizaos");
+        assert_eq!(info.repo, "eliza");
+        assert_eq!(info.full_name, "elizaos/eliza");
+    }
+
+    #[test]
+    fn test_parse_github_issue_url() {
+        let info = parse_github_issue_url("https://github.com/elizaos/eliza/issues/42").unwrap();
+        assert_eq!(info.owner, "elizaos");
+        assert_eq!(info.repo, "eliza");
+        assert_eq!(info.issue_number, 42);
+    }
+}

package/rust/src/utils/log.rs

@@ -0,0 +1,65 @@
+//! Logging utilities for SWE-agent
+
+use tracing::{debug, error, info, warn, Level};
+use tracing_subscriber::{fmt, prelude::*, EnvFilter};
+
+/// Initialize the logging system
+pub fn init_logging() {
+    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
+
+    tracing_subscriber::registry()
+        .with(fmt::layer())
+        .with(filter)
+        .init();
+}
+
+/// Initialize logging with a specific level
+pub fn init_logging_with_level(level: Level) {
+    let filter = EnvFilter::new(level.as_str());
+
+    tracing_subscriber::registry()
+        .with(fmt::layer())
+        .with(filter)
+        .init();
+}
+
+/// Log an info message with agent context
+pub fn log_agent_info(agent_name: &str, message: &str) {
+    info!(agent = agent_name, "{}", message);
+}
+
+/// Log a debug message with agent context
+pub fn log_agent_debug(agent_name: &str, message: &str) {
+    debug!(agent = agent_name, "{}", message);
+}
+
+/// Log a warning with agent context
+pub fn log_agent_warn(agent_name: &str, message: &str) {
+    warn!(agent = agent_name, "{}", message);
+}
+
+/// Log an error with agent context
+pub fn log_agent_error(agent_name: &str, message: &str) {
+    error!(agent = agent_name, "{}", message);
+}
+
+/// Log step information
+pub fn log_step(step_num: usize, thought: &str, action: &str) {
+    info!(
+        step = step_num,
+        "💭 THOUGHT\n{}\n\n🎬 ACTION\n{}", thought, action
+    );
+}
+
+/// Log observation
+pub fn log_observation(observation: &str) {
+    debug!(
+        len = observation.len(),
+        "📋 OBSERVATION: {}",
+        if observation.len() > 200 {
+            format!("{}...", &observation[..200])
+        } else {
+            observation.to_string()
+        }
+    );
+}

package/rust/src/utils/mod.rs

@@ -0,0 +1,17 @@
+//! Utility functions and helpers for SWE-agent
+//!
+//! This module contains common utilities used throughout the implementation.
+
+pub mod config;
+pub mod files;
+pub mod github;
+pub mod log;
+pub mod serialization;
+pub mod template;
+
+pub use config::*;
+pub use files::*;
+pub use github::*;
+pub use log::*;
+pub use serialization::*;
+pub use template::*;

package/rust/src/utils/serialization.rs

@@ -0,0 +1,181 @@
+//! Serialization utilities for SWE-agent
+
+use crate::exceptions::{Result, SWEAgentError};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// Convert a value to YAML string with proper line breaks
+pub fn to_yaml_with_linebreaks<T: Serialize>(value: &T) -> Result<String> {
+    serde_yaml::to_string(value).map_err(|e| SWEAgentError::SerializationError(e.to_string()))
+}
+
+/// Convert to YAML literal string (preserving multiline formatting)
+pub fn convert_to_yaml_literal_string(s: &str) -> String {
+    if s.contains('\n') {
+        format!("|\n{}", indent_string(s, 2))
+    } else {
+        serde_yaml::to_string(&s).unwrap_or_else(|_| format!("\"{}\"", s.replace('"', "\\\"")))
+    }
+}
+
+/// Indent a string by a given number of spaces
+fn indent_string(s: &str, spaces: usize) -> String {
+    let indent = " ".repeat(spaces);
+    s.lines()
+        .map(|line| format!("{}{}", indent, line))
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+/// Merge two nested dictionaries
+pub fn merge_nested_dicts(
+    base: &HashMap<String, serde_json::Value>,
+    overlay: &HashMap<String, serde_json::Value>,
+) -> HashMap<String, serde_json::Value> {
+    let mut result = base.clone();
+
+    for (key, value) in overlay {
+        let should_merge = result.get(key).map(|base_value| {
+            matches!(
+                (base_value, value),
+                (serde_json::Value::Object(_), serde_json::Value::Object(_))
+            )
+        });
+
+        match should_merge {
+            Some(true) => {
+                if let (
+                    Some(serde_json::Value::Object(base_obj)),
+                    serde_json::Value::Object(overlay_obj),
+                ) = (result.get(key), value)
+                {
+                    let base_map: HashMap<String, serde_json::Value> = base_obj
+                        .iter()
+                        .map(|(k, v)| (k.clone(), v.clone()))
+                        .collect();
+                    let overlay_map: HashMap<String, serde_json::Value> = overlay_obj
+                        .iter()
+                        .map(|(k, v)| (k.clone(), v.clone()))
+                        .collect();
+                    let merged = merge_nested_dicts(&base_map, &overlay_map);
+                    result.insert(
+                        key.clone(),
+                        serde_json::Value::Object(merged.into_iter().collect()),
+                    );
+                }
+            }
+            Some(false) => {
+                result.insert(key.clone(), value.clone());
+            }
+            None => {
+                result.insert(key.clone(), value.clone());
+            }
+        }
+    }
+
+    result
+}
+
+/// Parse arguments into a nested dictionary
+pub fn parse_args_to_nested_dict(args: &[String]) -> HashMap<String, serde_json::Value> {
+    let mut result = HashMap::new();
+
+    for arg in args {
+        if let Some(eq_pos) = arg.find('=') {
+            let key = &arg[..eq_pos];
+            let value = &arg[eq_pos + 1..];
+
+            // Parse the key path (e.g., "agent.model.name")
+            let parts: Vec<&str> = key.split('.').collect();
+            set_nested_value(&mut result, &parts, value);
+        }
+    }
+
+    result
+}
+
+/// Set a value in a nested dictionary
+fn set_nested_value(dict: &mut HashMap<String, serde_json::Value>, path: &[&str], value: &str) {
+    if path.is_empty() {
+        return;
+    }
+
+    if path.len() == 1 {
+        // Try to parse as JSON, otherwise use as string
+        let json_value = serde_json::from_str(value)
+            .unwrap_or_else(|_| serde_json::Value::String(value.to_string()));
+        dict.insert(path[0].to_string(), json_value);
+    } else {
+        let entry = dict
+            .entry(path[0].to_string())
+            .or_insert_with(|| serde_json::Value::Object(serde_json::Map::new()));
+
+        if let serde_json::Value::Object(obj) = entry {
+            let mut inner: HashMap<String, serde_json::Value> =
+                obj.iter().map(|(k, v)| (k.clone(), v.clone())).collect();
+            set_nested_value(&mut inner, &path[1..], value);
+            *obj = inner.into_iter().collect();
+        }
+    }
+}
+
+/// Shorten a string to a maximum length
+pub fn shorten_string(s: &str, max_len: usize) -> String {
+    if s.len() <= max_len {
+        s.to_string()
+    } else {
+        format!("{}...", &s[..max_len.saturating_sub(3)])
+    }
+}
+
+/// Shorten all strings in a dictionary
+pub fn shorten_strings(dict: &HashMap<String, String>, max_len: usize) -> HashMap<String, String> {
+    dict.iter()
+        .map(|(k, v)| (k.clone(), shorten_string(v, max_len)))
+        .collect()
+}
+
+/// Load a trajectory from a file
+pub fn load_trajectory<T: for<'de> Deserialize<'de>>(path: &std::path::Path) -> Result<T> {
+    let contents = std::fs::read_to_string(path)?;
+    serde_json::from_str(&contents).map_err(|e| SWEAgentError::SerializationError(e.to_string()))
+}
+
+/// Save a trajectory to a file
+pub fn save_trajectory<T: Serialize>(path: &std::path::Path, data: &T) -> Result<()> {
+    let contents = serde_json::to_string_pretty(data)?;
+    std::fs::write(path, contents)?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_shorten_string() {
+        assert_eq!(shorten_string("hello", 10), "hello");
+        assert_eq!(shorten_string("hello world", 8), "hello...");
+    }
+
+    #[test]
+    fn test_convert_to_yaml_literal_string() {
+        let single = convert_to_yaml_literal_string("hello");
+        assert!(!single.starts_with('|'));
+
+        let multi = convert_to_yaml_literal_string("hello\nworld");
+        assert!(multi.starts_with('|'));
+    }
+
+    #[test]
+    fn test_parse_args_to_nested_dict() {
+        let args = vec![
+            "agent.model.name=gpt-4".to_string(),
+            "env.timeout=30".to_string(),
+        ];
+        let dict = parse_args_to_nested_dict(&args);
+
+        assert!(dict.contains_key("agent"));
+        assert!(dict.contains_key("env"));
+    }
+}