@elizaos/sweagent-root 2.0.0-alpha

package/python/sweagent/environment/hooks/abstract.py

@@ -0,0 +1,60 @@
+from sweagent.environment.repo import Repo, RepoConfig
+
+
+class EnvHook:
+    """Hook to be used in `SWEEnv`.
+
+    Subclass this class, add functionality and add it with `SWEEEnv.add_hook(hook)`.
+    This allows to inject custom functionality at different stages of the environment
+    lifecycle, in particular to connect SWE-agent to a new interface (like a GUI).
+    """
+
+    def on_init(self, *, env) -> None:
+        """Gets called when the hook is added"""
+
+    def on_copy_repo_started(self, repo: RepoConfig | Repo) -> None:
+        """Gets called when the repository is being cloned to the container"""
+
+    def on_start_deployment(self) -> None:
+        """Gets called when the deployment is being started"""
+
+    def on_install_env_started(self) -> None:
+        """Called when we start installing the environment"""
+
+    def on_close(self):
+        """Called when the environment is closed"""
+
+    def on_environment_startup(self) -> None:
+        """Called when the environment is started"""
+
+
+class CombinedEnvHooks(EnvHook):
+    def __init__(self):
+        self._hooks = []
+
+    def add_hook(self, hook: EnvHook) -> None:
+        self._hooks.append(hook)
+
+    def on_init(self, *, env) -> None:
+        for hook in self._hooks:
+            hook.on_init(env=env)
+
+    def on_copy_repo_started(self, repo: RepoConfig | Repo) -> None:
+        for hook in self._hooks:
+            hook.on_copy_repo_started(repo=repo)
+
+    def on_start_deployment(self) -> None:
+        for hook in self._hooks:
+            hook.on_start_deployment()
+
+    def on_install_env_started(self) -> None:
+        for hook in self._hooks:
+            hook.on_install_env_started()
+
+    def on_close(self):
+        for hook in self._hooks:
+            hook.on_close()
+
+    def on_environment_startup(self) -> None:
+        for hook in self._hooks:
+            hook.on_environment_startup()

package/python/sweagent/environment/hooks/status.py

@@ -0,0 +1,28 @@
+from collections.abc import Callable
+
+from sweagent.environment.hooks.abstract import EnvHook
+from sweagent.environment.repo import Repo, RepoConfig
+
+
+class SetStatusEnvironmentHook(EnvHook):
+    def __init__(self, id: str, callable: Callable[[str, str], None]):
+        self._callable = callable
+        self._id = id
+
+    def _update(self, message: str):
+        self._callable(self._id, message)
+
+    def on_copy_repo_started(self, repo: RepoConfig | Repo):
+        self._update(f"Copying repo {repo.repo_name}")
+
+    def on_start_deployment(self):
+        self._update("Starting deployment")
+
+    def on_install_env_started(self):
+        self._update("Installing environment")
+
+    def on_environment_startup(self):
+        self._update("Starting environment")
+
+    def on_close(self):
+        self._update("Closing environment")

package/python/sweagent/environment/repo.py

@@ -0,0 +1,219 @@
+import asyncio
+import os
+import shlex
+from pathlib import Path
+from typing import Any, Literal, Protocol
+
+from git import InvalidGitRepositoryError
+from git import Repo as GitRepo
+from pydantic import BaseModel, ConfigDict, Field
+from swerex.deployment.abstract import AbstractDeployment
+from swerex.runtime.abstract import Command, UploadRequest
+from typing_extensions import Self
+
+from sweagent.utils.github import _parse_gh_repo_url
+from sweagent.utils.log import get_logger
+
+logger = get_logger("swea-config", emoji="🔧")
+
+
+class Repo(Protocol):
+    """Protocol for repository configurations."""
+
+    base_commit: str
+    repo_name: str
+
+    def copy(self, deployment: AbstractDeployment): ...
+
+    def get_reset_commands(self) -> list[str]: ...
+
+
+def _get_git_reset_commands(base_commit: str) -> list[str]:
+    return [
+        "git fetch",
+        "git status",
+        "git restore .",
+        "git reset --hard",
+        f"git checkout {shlex.quote(base_commit)}",
+        "git clean -fdq",
+    ]
+
+
+class PreExistingRepoConfig(BaseModel):
+    """Use this to specify a repository that already exists on the deployment.
+    This is important because we need to cd to the repo before running the agent.
+
+    Note: The repository must be at the root of the deployment.
+    """
+
+    repo_name: str
+    """The repo name (the repository must be located at the root of the deployment)."""
+    base_commit: str = Field(default="HEAD")
+    """The commit to reset the repository to. The default is HEAD,
+    i.e., the latest commit. You can also set this to a branch name (e.g., `dev`),
+    a tag (e.g., `v0.1.0`), or a commit hash (e.g., `a4464baca1f`).
+    SWE-agent will then start from this commit when trying to solve the problem.
+    """
+
+    type: Literal["preexisting"] = "preexisting"
+    """Discriminator for (de)serialization/CLI. Do not change."""
+
+    reset: bool = True
+    """If True, reset the repository to the base commit after the copy operation."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    def copy(self, deployment: AbstractDeployment):
+        """Does nothing."""
+        pass
+
+    def get_reset_commands(self) -> list[str]:
+        """Issued after the copy operation or when the environment is reset."""
+        if self.reset:
+            return _get_git_reset_commands(self.base_commit)
+        return []
+
+
+class LocalRepoConfig(BaseModel):
+    path: Path
+    base_commit: str = Field(default="HEAD")
+    """The commit to reset the repository to. The default is HEAD,
+    i.e., the latest commit. You can also set this to a branch name (e.g., `dev`),
+    a tag (e.g., `v0.1.0`), or a commit hash (e.g., `a4464baca1f`).
+    SWE-agent will then start from this commit when trying to solve the problem.
+    """
+
+    type: Literal["local"] = "local"
+    """Discriminator for (de)serialization/CLI. Do not change."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    @property
+    def repo_name(self) -> str:
+        """Set automatically based on the repository name. Cannot be set."""
+        return Path(self.path).resolve().name.replace(" ", "-").replace("'", "")
+
+    # Let's not make this a model validator, because it leads to cryptic errors.
+    # Let's just check during copy instead.
+    def check_valid_repo(self) -> Self:
+        try:
+            repo = GitRepo(self.path, search_parent_directories=True)
+        except InvalidGitRepositoryError as e:
+            msg = f"Could not find git repository at {self.path=}."
+            raise ValueError(msg) from e
+        if repo.is_dirty() and "PYTEST_CURRENT_TEST" not in os.environ:
+            msg = f"Local git repository {self.path} is dirty. Please commit or stash changes."
+            raise ValueError(msg)
+        return self
+
+    def copy(self, deployment: AbstractDeployment):
+        self.check_valid_repo()
+        asyncio.run(
+            deployment.runtime.upload(UploadRequest(source_path=str(self.path), target_path=f"/{self.repo_name}"))
+        )
+        r = asyncio.run(
+            deployment.runtime.execute(Command(command=f"chown -R root:root /{self.repo_name}", shell=True))
+        )
+        if r.exit_code != 0:
+            msg = f"Failed to change permissions on copied repository (exit code: {r.exit_code}, stdout: {r.stdout}, stderr: {r.stderr})"
+            raise RuntimeError(msg)
+
+    def get_reset_commands(self) -> list[str]:
+        """Issued after the copy operation or when the environment is reset."""
+        return _get_git_reset_commands(self.base_commit)
+
+
+class GithubRepoConfig(BaseModel):
+    github_url: str
+
+    base_commit: str = Field(default="HEAD")
+    """The commit to reset the repository to. The default is HEAD,
+    i.e., the latest commit. You can also set this to a branch name (e.g., `dev`),
+    a tag (e.g., `v0.1.0`), or a commit hash (e.g., `a4464baca1f`).
+    SWE-agent will then start from this commit when trying to solve the problem.
+    """
+
+    clone_timeout: float = 500
+    """Timeout for git clone operation."""
+
+    type: Literal["github"] = "github"
+    """Discriminator for (de)serialization/CLI. Do not change."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    def model_post_init(self, __context: Any) -> None:
+        if self.github_url.count("/") == 1:
+            self.github_url = f"https://github.com/{self.github_url}"
+
+    @property
+    def repo_name(self) -> str:
+        org, repo = _parse_gh_repo_url(self.github_url)
+        return f"{org}__{repo}"
+
+    def _get_url_with_token(self, token: str) -> str:
+        """Prepend github token to URL"""
+        if not token:
+            return self.github_url
+        if "@" in self.github_url:
+            logger.warning("Cannot prepend token to URL. '@' found in URL")
+            return self.github_url
+        _, _, url_no_protocol = self.github_url.partition("://")
+        return f"https://{token}@{url_no_protocol}"
+
+    def copy(self, deployment: AbstractDeployment):
+        """Clones the repository to the sandbox."""
+        base_commit = self.base_commit
+        github_token = os.getenv("GITHUB_TOKEN", "")
+        url = self._get_url_with_token(github_token)
+        asyncio.run(
+            deployment.runtime.execute(
+                Command(
+                    command=" && ".join(
+                        (
+                            f"mkdir /{self.repo_name}",
+                            f"cd /{self.repo_name}",
+                            "git init",
+                            f"git remote add origin {shlex.quote(url)}",
+                            f"git fetch --depth 1 origin {shlex.quote(base_commit)}",
+                            "git checkout FETCH_HEAD",
+                            "cd ..",
+                        )
+                    ),
+                    timeout=self.clone_timeout,
+                    shell=True,
+                    check=True,
+                )
+            ),
+        )
+
+    def get_reset_commands(self) -> list[str]:
+        """Issued after the copy operation or when the environment is reset."""
+        return _get_git_reset_commands(self.base_commit)
+
+
+RepoConfig = LocalRepoConfig | GithubRepoConfig | PreExistingRepoConfig
+
+
+def repo_from_simplified_input(
+    *, input: str, base_commit: str = "HEAD", type: Literal["local", "github", "preexisting", "auto"] = "auto"
+) -> RepoConfig:
+    """Get repo config from a simplified input.
+
+    Args:
+        input: Local path or GitHub URL
+        type: The type of repo. Set to "auto" to automatically detect the type
+            (does not work for preexisting repos).
+    """
+    if type == "local":
+        return LocalRepoConfig(path=Path(input), base_commit=base_commit)
+    if type == "github":
+        return GithubRepoConfig(github_url=input, base_commit=base_commit)
+    if type == "preexisting":
+        return PreExistingRepoConfig(repo_name=input, base_commit=base_commit)
+    if type == "auto":
+        if input.startswith("https://github.com/"):
+            return GithubRepoConfig(github_url=input, base_commit=base_commit)
+        else:
+            return LocalRepoConfig(path=Path(input), base_commit=base_commit)
+    msg = f"Unknown repo type: {type}"
+    raise ValueError(msg)

package/python/sweagent/environment/swe_env.py

@@ -0,0 +1,276 @@
+import asyncio
+import logging
+import shlex
+from pathlib import PurePath
+from typing import Literal, Self
+
+from pydantic import BaseModel, ConfigDict, Field
+from swerex.deployment.abstract import AbstractDeployment
+from swerex.deployment.config import DeploymentConfig, DockerDeploymentConfig, get_deployment
+from swerex.runtime.abstract import (
+    BashAction,
+    BashInterruptAction,
+    CreateBashSessionRequest,
+    ReadFileRequest,
+    WriteFileRequest,
+)
+from swerex.runtime.abstract import Command as RexCommand
+
+from sweagent.environment.hooks.abstract import CombinedEnvHooks, EnvHook
+from sweagent.environment.repo import Repo, RepoConfig
+from sweagent.utils.log import get_logger
+
+
+class EnvironmentConfig(BaseModel):
+    """Configure data sources and setup instructions for the environment in which we solve the tasks."""
+
+    deployment: DeploymentConfig = Field(
+        default_factory=lambda: DockerDeploymentConfig(image="python:3.11", python_standalone_dir="/root"),
+        description="Deployment options.",
+    )
+    repo: RepoConfig | None = Field(
+        default=None,
+        description="Repository options.",
+    )
+    post_startup_commands: list[str] = []
+    """Execute these commands before starting to run the agent but after all other setup steps.
+    They will be executed in the same shell as the agent.
+    Note: Every command is passed as a string, not a list of arguments.
+    """
+    post_startup_command_timeout: int = 500
+    """Timeout for the post-startup commands.
+    NOTE: The timeout applies to every command in `post_startup_commands` separately.
+    """
+
+    # pydantic config
+    model_config = ConfigDict(extra="forbid")
+
+    name: str = "main"
+
+
+class SWEEnv:
+    def __init__(
+        self,
+        *,
+        deployment: AbstractDeployment,
+        repo: Repo | RepoConfig | None,
+        post_startup_commands: list[str],
+        post_startup_command_timeout: int = 500,
+        hooks: list[EnvHook] | None = None,
+        name: str = "main",
+    ):
+        """This class represents the environment in which we solve the tasks.
+
+        Args:
+            deployment: SWE-ReX deployment instance
+            repo: Repository configuration object, or anything following the `Repo` protocol
+            post_startup_commands: Commands to execute before starting the agent
+            hooks: Environment hooks (used to inject custom functionality)
+                Equivalent to calling `add_hook` for each hook after initialization.
+            name: Name of the environment
+        """
+        super().__init__()
+        self.deployment = deployment
+        self.repo = repo
+        self._post_startup_commands = post_startup_commands
+        self.post_startup_command_timeout = post_startup_command_timeout
+        self.logger = get_logger("swea-env", emoji="🪴")
+        self.name = name
+        self.clean_multi_line_functions = lambda x: x
+        self._chook = CombinedEnvHooks()
+        for hook in hooks or []:
+            self.add_hook(hook)
+
+    @classmethod
+    def from_config(cls, config: EnvironmentConfig) -> Self:
+        """Create an environment instance from a configuration object.
+        This is the recommended way to create an environment instance, unless you need
+        more flexibility.
+        """
+        # Always copy config to avoid shared state between different instances
+        config = config.model_copy(deep=True)
+        return cls(
+            deployment=get_deployment(config.deployment),
+            repo=config.repo,
+            post_startup_commands=config.post_startup_commands,
+            post_startup_command_timeout=config.post_startup_command_timeout,
+            name=config.name,
+        )
+
+    def add_hook(self, hook: EnvHook) -> None:
+        """Add `EnvHook` to the environment.
+
+        This allows to inject custom functionality at different stages of the environment
+        lifecycle, in particular to connect SWE-agent to a new interface (like a GUI).
+        """
+        hook.on_init(env=self)
+        self._chook.add_hook(hook)
+
+    def start(self) -> None:
+        """Start the environment and reset it to a clean state."""
+        self._init_deployment()
+        self.reset()
+        for command in self._post_startup_commands:
+            self.communicate(command, check="raise", timeout=self.post_startup_command_timeout)
+
+    def _copy_repo(self) -> None:
+        """Clone/copy repository/codebase in container"""
+        if self.repo is None:
+            return
+
+        folders = self.communicate(input="ls", check="raise").split("\n")
+        if self.repo.repo_name in folders:
+            return
+
+        self._chook.on_copy_repo_started(repo=self.repo)
+        self.repo.copy(self.deployment)
+
+    def hard_reset(self):
+        """Resets the environment and deployment, i.e., completely restarts the
+        deployment.
+        """
+        self.close()
+        self.start()
+
+    def reset(self):
+        """Reset the environment to a clean state.
+        Gets called by `start`, but can also be called independently to reset the
+        environment to a clean state before a new attempt.
+
+        Returns:
+            observation: output from container
+            info: additional information (e.g. debugging information)
+        """
+        self.communicate(input="cd /", check="raise")
+        self._copy_repo()
+        self._reset_repository()
+        self._chook.on_environment_startup()
+
+    def _reset_repository(self) -> None:
+        """Clean repository of any modifications + Checkout base commit"""
+        if self.repo is not None:
+            self.logger.debug("Resetting repository %s to commit %s", self.repo.repo_name, self.repo.base_commit)
+            # todo: Currently has swe-ft specific change: The original repo.copy isn't called, because the repo is already
+            # present. However, reset --hard <BRANCH> also doesn't work. So modified it here to do a checkout instead.
+            startup_commands = [
+                f"cd /{self.repo.repo_name}",
+                "export ROOT=$(pwd -P)",
+                *self.repo.get_reset_commands(),
+            ]
+            self.communicate(
+                input=" && ".join(startup_commands),
+                check="raise",
+                error_msg="Failed to clean repository",
+                # Sometimes this is slow because it rebuilds some index
+                timeout=120,
+            )
+
+    def close(self) -> None:
+        """Shutdown SWE-ReX deployment etc."""
+        self.logger.info("Beginning environment shutdown...")
+        asyncio.run(self.deployment.stop())
+        self._chook.on_close()
+
+    # MARK: Helper functions #
+
+    def _init_deployment(
+        self,
+    ) -> None:
+        """Handles container initialization. Defines container name and creates it.
+        If cached_image is provided, it will use that image name instead of the default.
+        """
+        self._chook.on_start_deployment()
+        asyncio.run(self.deployment.start())
+        asyncio.run(
+            self.deployment.runtime.create_session(
+                CreateBashSessionRequest(startup_source=["/root/.bashrc"], startup_timeout=10)
+            )
+        )
+        self.set_env_variables({"LANG": "C.UTF-8", "LC_ALL": "C.UTF-8", "PIP_PROGRESS_BAR": "off", "PAGER": "cat"})
+        self.logger.info("Environment Initialized")
+
+    def interrupt_session(self):
+        self.logger.info("Interrupting session")
+        asyncio.run(self.deployment.runtime.run_in_session(BashInterruptAction()))
+
+    # todo: return exit code?
+    def communicate(
+        self,
+        input: str,
+        timeout: int | float = 25,
+        *,
+        check: Literal["warn", "ignore", "raise"] = "ignore",
+        error_msg: str = "Command failed",
+    ) -> str:
+        """Executes a command in the running shell. The details of this are handled by
+        the SWE-ReX deployment/runtime.
+
+        Args:
+            input: input to send to container
+            timeout_duration: duration to wait for output
+            check: `ignore`: do not extract exit code (more stable), `warn`: extract exit code and log error if
+                exit code is non-zero, `raise`: raise error if exit code is non-zero
+            error_msg: error message to raise if the command fails
+
+        Returns:
+            output: output from container
+        """
+        self.logger.log(logging.TRACE, "Input:\n%s", input)  # type: ignore
+        rex_check = "silent" if check else "ignore"
+        r = asyncio.run(
+            self.deployment.runtime.run_in_session(BashAction(command=input, timeout=timeout, check=rex_check))
+        )
+        output = r.output
+        self.logger.log(logging.TRACE, "Output:\n%s", output)  # type: ignore
+        if check != "ignore" and r.exit_code != 0:
+            self.logger.error(f"{error_msg}:\n{output}")
+            msg = f"Command {input!r} failed ({r.exit_code=}): {error_msg}"
+            self.logger.error(msg)
+            if check == "raise":
+                self.close()
+                raise RuntimeError(msg)
+        return output
+
+    def read_file(self, path: str | PurePath, encoding: str | None = None, errors: str | None = None) -> str:
+        """Read file contents from container
+
+        Args:
+            path: Absolute path to file
+            encoding: Encoding to use when reading the file. None means default encoding.
+                This is the same as the `encoding` argument of `Path.read_text()`
+            errors: Error handling to use when reading the file. None means default error handling.
+                This is the same as the `errors` argument of `Path.read_text()`
+
+        Returns:
+            file_contents: Contents of file as string
+        """
+        r = asyncio.run(
+            self.deployment.runtime.read_file(ReadFileRequest(path=str(path), encoding=encoding, errors=errors))
+        )
+        return r.content
+
+    def write_file(self, path: str | PurePath, content: str) -> None:
+        """Write content to file in container"""
+        asyncio.run(self.deployment.runtime.write_file(WriteFileRequest(path=str(path), content=content)))
+
+    def set_env_variables(self, env_variables: dict[str, str]) -> None:
+        """Set environment variables in the environment."""
+        if not env_variables:
+            self.logger.debug("No environment variables to set")
+            return
+        _env_setters = [f"export {k}={shlex.quote(str(v))}" for k, v in env_variables.items()]
+        command = " && ".join(_env_setters)
+        self.communicate(command, check="raise")
+
+    def execute_command(
+        self,
+        command: str,
+        shell: bool = True,
+        check: bool = False,
+        env: dict[str, str] | None = None,
+        cwd: str | None = None,
+    ) -> None:
+        """Execute a command in the environment independent of the session (i.e., as a subprocess)"""
+        asyncio.run(
+            self.deployment.runtime.execute(RexCommand(command=command, shell=shell, check=check, env=env, cwd=cwd))
+        )

package/python/sweagent/exceptions.py

@@ -0,0 +1,54 @@
+from typing import Any, Literal
+
+"""This module contains all custom exceptions used by the SWE-agent."""
+
+
+class FormatError(Exception):
+    """Raised when the model response cannot properly be parsed into thought and actions."""
+
+
+class FunctionCallingFormatError(FormatError):
+    """Format error exception used by the function
+    calling parser."""
+
+    def __init__(
+        self,
+        message: str,
+        error_code: Literal[
+            "missing", "multiple", "incorrect_args", "invalid_json", "invalid_command", "missing_arg", "unexpected_arg"
+        ],
+        **extra_info: Any,
+    ):
+        super().__init__(message + f" [error_code={error_code}]")
+        self.message = message
+        self.extra_info = {"error_code": error_code, **extra_info}
+
+
+class ContextWindowExceededError(Exception):
+    """Raised when the context window of a LM is exceeded"""
+
+
+class CostLimitExceededError(Exception):
+    """Raised when we exceed a cost limit"""
+
+
+class InstanceCostLimitExceededError(CostLimitExceededError):
+    """Raised when we exceed the cost limit set for one task instance"""
+
+
+class TotalCostLimitExceededError(CostLimitExceededError):
+    """Raised when we exceed the total cost limit"""
+
+
+class InstanceCallLimitExceededError(CostLimitExceededError):
+    """Raised when we exceed the per instance call limit"""
+
+
+class ContentPolicyViolationError(Exception):
+    """Raised when the model response violates a content policy"""
+
+
+class ModelConfigurationError(Exception):
+    """Raised when the model configuration is invalid/no further retries
+    should be made.
+    """

package/python/sweagent/inspector/README.md

@@ -0,0 +1,6 @@
+🔗 For more information on the trajectory inspector, visit [our documentation website][docs].
+
+You can also find the corresponding markdown files in the [`docs/` folder][source].
+
+[docs]: https://swe-agent.com/latest/usage/inspector/
+[source]: https://github.com/SWE-agent/SWE-agent/tree/main/docs