mini-swe-agent 1.16.0__py3-none-any.whl

minisweagent/config/mini_no_temp.yaml

@@ -0,0 +1,158 @@
+# Identical config file to mini.yaml, but without temperature=0.0
+agent:
+  system_template: |
+    You are a helpful assistant that can interact with a computer.
+
+    Your response must contain exactly ONE bash code block with ONE command (or commands connected with && or ||).
+    Include a THOUGHT section before your command where you explain your reasoning process.
+    Format your response as shown in <format_example>.
+
+    <format_example>
+    Your reasoning and analysis here. Explain why you want to perform the action.
+
+    ```bash
+    your_command_here
+    ```
+    </format_example>
+
+    Failure to follow these rules will cause your response to be rejected.
+  instance_template: |
+    Please solve this issue: {{task}}
+
+    You can execute bash commands and edit files to implement the necessary changes.
+
+    ## Recommended Workflow
+
+    This workflows should be done step-by-step so that you can iterate on your changes and any possible problems.
+
+    1. Analyze the codebase by finding and reading relevant files
+    2. Create a script to reproduce the issue
+    3. Edit the source code to resolve the issue
+    4. Verify your fix works by running your script again
+    5. Test edge cases to ensure your fix is robust
+    6. Submit your changes and finish your work by issuing the following command: `echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT`.
+       Do not combine it with any other command. <important>After this command, you cannot continue working on this task.</important>
+
+    ## Important Rules
+
+    1. Every response must contain exactly one action
+    2. The action must be enclosed in triple backticks
+    3. Directory or environment variable changes are not persistent. Every action is executed in a new subshell.
+       However, you can prefix any action with `MY_ENV_VAR=MY_VALUE cd /path/to/working/dir && ...` or write/load environment variables from files
+
+    <system_information>
+    {{system}} {{release}} {{version}} {{machine}}
+    </system_information>
+
+    ## Formatting your response
+
+    Here is an example of a correct response:
+
+    <example_response>
+    THOUGHT: I need to understand the structure of the repository first. Let me check what files are in the current directory to get a better understanding of the codebase.
+
+    ```bash
+    ls -la
+    ```
+    </example_response>
+
+    ## Useful command examples
+
+    ### Create a new file:
+
+    ```bash
+    cat <<'EOF' > newfile.py
+    import numpy as np
+    hello = "world"
+    print(hello)
+    EOF
+    ```
+
+    ### Edit files with sed:
+
+    {%- if system == "Darwin" -%}
+    <important>
+    You are on MacOS. For all the below examples, you need to use `sed -i ''` instead of `sed -i`.
+    </important>
+    {%- endif -%}
+
+    ```bash
+    # Replace all occurrences
+    sed -i 's/old_string/new_string/g' filename.py
+
+    # Replace only first occurrence
+    sed -i 's/old_string/new_string/' filename.py
+
+    # Replace first occurrence on line 1
+    sed -i '1s/old_string/new_string/' filename.py
+
+    # Replace all occurrences in lines 1-10
+    sed -i '1,10s/old_string/new_string/g' filename.py
+    ```
+
+    ### View file content:
+
+    ```bash
+    # View specific lines with numbers
+    nl -ba filename.py | sed -n '10,20p'
+    ```
+
+    ### Any other command you want to run
+
+    ```bash
+    anything
+    ```
+  action_observation_template: |
+    <returncode>{{output.returncode}}</returncode>
+    {% if output.output | length < 10000 -%}
+    <output>
+    {{ output.output -}}
+    </output>
+    {%- else -%}
+    <warning>
+    The output of your last command was too long.
+    Please try a different command that produces less output.
+    If you're looking at a file you can try use head, tail or sed to view a smaller number of lines selectively.
+    If you're using grep or find and it produced too much output, you can use a more selective search pattern.
+    If you really need to see something from the full command's output, you can redirect output to a file and then search in that file.
+    </warning>
+    {%- set elided_chars = output.output | length - 10000 -%}
+    <output_head>
+    {{ output.output[:5000] }}
+    </output_head>
+    <elided_chars>
+    {{ elided_chars }} characters elided
+    </elided_chars>
+    <output_tail>
+    {{ output.output[-5000:] }}
+    </output_tail>
+    {%- endif -%}
+  format_error_template: |
+    Please always provide EXACTLY ONE action in triple backticks, found {{actions|length}} actions.
+    If you want to end the task, please issue the following command: `echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT`
+    without any other command.
+    Else, please format your response exactly as follows:
+
+    <response_example>
+    Here are some thoughts about why you want to perform the action.
+
+    ```bash
+    <action>
+    ```
+    </response_example>
+
+    Note: In rare cases, if you need to reference a similar format in your command, you might have
+    to proceed in two steps, first writing TRIPLEBACKTICKSBASH, then replacing them with ```bash.
+  step_limit: 0.
+  cost_limit: 3.
+  mode: confirm
+environment:
+  env:
+    PAGER: cat
+    MANPAGER: cat
+    LESS: -R
+    PIP_PROGRESS_BAR: 'off'
+    TQDM_DISABLE: '1'
+model:
+  model_kwargs:
+    drop_params: true

minisweagent/environments/__init__.py

@@ -0,0 +1,31 @@
+"""Environment implementations for mini-SWE-agent."""
+
+import copy
+import importlib
+
+from minisweagent import Environment
+
+_ENVIRONMENT_MAPPING = {
+    "docker": "minisweagent.environments.docker.DockerEnvironment",
+    "singularity": "minisweagent.environments.singularity.SingularityEnvironment",
+    "local": "minisweagent.environments.local.LocalEnvironment",
+    "swerex_docker": "minisweagent.environments.extra.swerex_docker.SwerexDockerEnvironment",
+    "bubblewrap": "minisweagent.environments.extra.bubblewrap.BubblewrapEnvironment",
+}
+
+
+def get_environment_class(spec: str) -> type[Environment]:
+    full_path = _ENVIRONMENT_MAPPING.get(spec, spec)
+    try:
+        module_name, class_name = full_path.rsplit(".", 1)
+        module = importlib.import_module(module_name)
+        return getattr(module, class_name)
+    except (ValueError, ImportError, AttributeError):
+        msg = f"Unknown environment type: {spec} (resolved to {full_path}, available: {_ENVIRONMENT_MAPPING})"
+        raise ValueError(msg)
+
+
+def get_environment(config: dict, *, default_type: str = "") -> Environment:
+    config = copy.deepcopy(config)
+    environment_class = config.pop("environment_class", default_type)
+    return get_environment_class(environment_class)(**config)

minisweagent/environments/docker.py

@@ -0,0 +1,114 @@
+import logging
+import os
+import shlex
+import subprocess
+import uuid
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+
+@dataclass
+class DockerEnvironmentConfig:
+    image: str
+    cwd: str = "/"
+    """Working directory in which to execute commands."""
+    env: dict[str, str] = field(default_factory=dict)
+    """Environment variables to set in the container."""
+    forward_env: list[str] = field(default_factory=list)
+    """Environment variables to forward to the container.
+    Variables are only forwarded if they are set in the host environment.
+    In case of conflict with `env`, the `env` variables take precedence.
+    """
+    timeout: int = 30
+    """Timeout for executing commands in the container."""
+    executable: str = os.getenv("MSWEA_DOCKER_EXECUTABLE", "docker")
+    """Path to the docker/container executable."""
+    run_args: list[str] = field(default_factory=lambda: ["--rm"])
+    """Additional arguments to pass to the docker/container executable.
+    Default is ["--rm"], which removes the container after it exits.
+    """
+    container_timeout: str = "2h"
+    """Max duration to keep container running. Uses the same format as the sleep command."""
+    pull_timeout: int = 120
+    """Timeout in seconds for pulling images."""
+
+
+class DockerEnvironment:
+    def __init__(
+        self,
+        *,
+        config_class: type = DockerEnvironmentConfig,
+        logger: logging.Logger | None = None,
+        **kwargs,
+    ):
+        """This class executes bash commands in a Docker container using direct docker commands.
+        See `DockerEnvironmentConfig` for keyword arguments.
+        """
+        self.logger = logger or logging.getLogger("minisweagent.environment")
+        self.container_id: str | None = None
+        self.config = config_class(**kwargs)
+        self._start_container()
+
+    def get_template_vars(self) -> dict[str, Any]:
+        return asdict(self.config)
+
+    def _start_container(self):
+        """Start the Docker container and return the container ID."""
+        container_name = f"minisweagent-{uuid.uuid4().hex[:8]}"
+        cmd = [
+            self.config.executable,
+            "run",
+            "-d",
+            "--name",
+            container_name,
+            "-w",
+            self.config.cwd,
+            *self.config.run_args,
+            self.config.image,
+            "sleep",
+            self.config.container_timeout,
+        ]
+        self.logger.debug(f"Starting container with command: {shlex.join(cmd)}")
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=self.config.pull_timeout,  # docker pull might take a while
+            check=True,
+        )
+        self.logger.info(f"Started container {container_name} with ID {result.stdout.strip()}")
+        self.container_id = result.stdout.strip()
+
+    def execute(self, command: str, cwd: str = "", *, timeout: int | None = None) -> dict[str, Any]:
+        """Execute a command in the Docker container and return the result as a dict."""
+        cwd = cwd or self.config.cwd
+        assert self.container_id, "Container not started"
+
+        cmd = [self.config.executable, "exec", "-w", cwd]
+        for key in self.config.forward_env:
+            if (value := os.getenv(key)) is not None:
+                cmd.extend(["-e", f"{key}={value}"])
+        for key, value in self.config.env.items():
+            cmd.extend(["-e", f"{key}={value}"])
+        cmd.extend([self.container_id, "bash", "-lc", command])
+
+        result = subprocess.run(
+            cmd,
+            text=True,
+            timeout=timeout or self.config.timeout,
+            encoding="utf-8",
+            errors="replace",
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+        )
+        return {"output": result.stdout, "returncode": result.returncode}
+
+    def cleanup(self):
+        """Stop and remove the Docker container."""
+        if getattr(self, "container_id", None) is not None:  # if init fails early, container_id might not be set
+            cmd = f"(timeout 60 {self.config.executable} stop {self.container_id} || {self.config.executable} rm -f {self.container_id}) >/dev/null 2>&1 &"
+            subprocess.Popen(cmd, shell=True)
+
+    def __del__(self):
+        """Cleanup container when object is destroyed."""
+        self.cleanup()

minisweagent/environments/extra/bubblewrap.py

@@ -0,0 +1,112 @@
+"""
+[Bubblewrap](https://github.com/containers/bubblewrap) is a low-level, unprivileged sandboxing tool for Linux that enables running applications
+in isolated environments with restricted access to the operating system and user data.
+This environment uses bubblewrap to execute commands in a sandboxed environment.
+
+!!! warning
+    This environment is experimental.
+
+!!! warning
+    This environment is not supported on Windows.
+"""
+
+import logging
+import os
+import platform
+import shutil
+import subprocess
+import tempfile
+import uuid
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class BubblewrapEnvironmentConfig:
+    cwd: str = ""
+    """Working directory for the sandbox."""
+    env: dict[str, str] = field(default_factory=dict)
+    """Dictionary of environment variables to set in the sandbox."""
+    timeout: int = 30
+    """Timeout for the command in seconds."""
+    executable: str = os.getenv("MSWEA_BUBBLEWRAP_EXECUTABLE", "bwrap")
+    """Path to the bubblewrap executable."""
+    wrapper_args: list[str] = field(
+        default_factory=lambda: [
+            "--unshare-user-try",
+            "--ro-bind",
+            "/usr",
+            "/usr",
+            "--ro-bind",
+            "/bin",
+            "/bin",
+            "--ro-bind",
+            "/lib",
+            "/lib",
+            "--ro-bind",
+            "/lib64",
+            "/lib64",
+            "--ro-bind",
+            "/etc",
+            "/etc",
+            "--tmpfs",
+            "/tmp",
+            "--proc",
+            "/proc",
+            "--dev",
+            "/dev",
+            "--new-session",
+            "--setenv",
+            "PATH",
+            "/usr/local/bin:/usr/sbin:/usr/bin:/bin",
+        ]
+    )
+    """Arguments to pass to the bubblewrap executable."""
+
+
+class BubblewrapEnvironment:
+    def __init__(
+        self, *, config_class: type = BubblewrapEnvironmentConfig, logger: logging.Logger | None = None, **kwargs
+    ):
+        """This class executes bash commands in a bubblewrap environment and a separate working
+        directory for each environment. See `BubblewrapEnvironmentConfig` for kwargs.
+        """
+        self.logger = logger or logging.getLogger("minisweagent.environment")
+        self.config = config_class(**kwargs)
+        self.working_dir = Path(tempfile.gettempdir()) / f"minisweagent-{uuid.uuid4().hex[:8]}"
+        self.working_dir.mkdir(parents=True)
+
+    def execute(self, command: str, cwd: str = "", *, timeout: int | None = None) -> dict[str, Any]:
+        """Execute a command in the bubblewrap environment and return the result as a dict."""
+        cwd = cwd or self.config.cwd or str(self.working_dir)
+
+        cmd = [self.config.executable] + self.config.wrapper_args + ["--bind", cwd, cwd, "--chdir", cwd]
+
+        # Add environment variables
+        for key, value in self.config.env.items():
+            cmd.extend(["--setenv", key, value])
+
+        cmd.extend(["bash", "-c", command])
+
+        result = subprocess.run(
+            cmd,
+            text=True,
+            timeout=timeout or self.config.timeout,
+            encoding="utf-8",
+            errors="replace",
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+        )
+        return {"output": result.stdout, "returncode": result.returncode}
+
+    def cleanup(self):
+        if self.working_dir.exists():
+            shutil.rmtree(self.working_dir)
+
+    def __del__(self):
+        """Cleanup working_dir when object is destroyed."""
+        self.cleanup()
+
+    def get_template_vars(self) -> dict[str, Any]:
+        return asdict(self.config) | platform.uname()._asdict()

minisweagent/environments/extra/swerex_docker.py

@@ -0,0 +1,47 @@
+import asyncio
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+from swerex.deployment.docker import DockerDeployment
+from swerex.runtime.abstract import Command as RexCommand
+
+
+@dataclass
+class SwerexDockerEnvironmentConfig:
+    image: str
+    cwd: str = "/"
+    """Working directory in which to execute commands."""
+    timeout: int = 30
+    """Timeout for executing commands in the container."""
+    deployment_extra_kwargs: dict[str, Any] = field(default_factory=dict)
+    """Extra kwargs to pass to DockerDeployment."""
+
+
+class SwerexDockerEnvironment:
+    def __init__(self, **kwargs):
+        """This class executes bash commands in a Docker container using SWE-ReX for sandboxing."""
+        self.config = SwerexDockerEnvironmentConfig(**kwargs)
+        self.deployment = DockerDeployment(image=self.config.image, **self.config.deployment_extra_kwargs)
+        asyncio.run(self.deployment.start())
+
+    def execute(self, command: str, cwd: str = "", *, timeout: int | None = None) -> dict[str, Any]:
+        """Execute a command in the environment and return the raw output."""
+        output = asyncio.run(
+            self.deployment.runtime.execute(
+                RexCommand(
+                    command=command,
+                    shell=True,
+                    check=False,
+                    cwd=cwd or self.config.cwd,
+                    timeout=timeout or self.config.timeout,
+                    merge_output_streams=True,
+                )
+            )
+        )
+        return {
+            "output": output.stdout,
+            "returncode": output.exit_code,
+        }
+
+    def get_template_vars(self) -> dict[str, Any]:
+        return asdict(self.config)

minisweagent/environments/local.py

@@ -0,0 +1,38 @@
+import os
+import platform
+import subprocess
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+
+@dataclass
+class LocalEnvironmentConfig:
+    cwd: str = ""
+    env: dict[str, str] = field(default_factory=dict)
+    timeout: int = 30
+
+
+class LocalEnvironment:
+    def __init__(self, *, config_class: type = LocalEnvironmentConfig, **kwargs):
+        """This class executes bash commands directly on the local machine."""
+        self.config = config_class(**kwargs)
+
+    def execute(self, command: str, cwd: str = "", *, timeout: int | None = None):
+        """Execute a command in the local environment and return the result as a dict."""
+        cwd = cwd or self.config.cwd or os.getcwd()
+        result = subprocess.run(
+            command,
+            shell=True,
+            text=True,
+            cwd=cwd,
+            env=os.environ | self.config.env,
+            timeout=timeout or self.config.timeout,
+            encoding="utf-8",
+            errors="replace",
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+        )
+        return {"output": result.stdout, "returncode": result.returncode}
+
+    def get_template_vars(self) -> dict[str, Any]:
+        return asdict(self.config) | platform.uname()._asdict() | os.environ

minisweagent/environments/singularity.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+
+import logging
+import os
+import shutil
+import subprocess
+import tempfile
+import uuid
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class SingularityEnvironmentConfig:
+    image: str
+    cwd: str = "/"
+    env: dict[str, str] = field(default_factory=dict)
+    """Environment variables to set in the container."""
+    forward_env: list[str] = field(default_factory=list)
+    """Environment variables to forward to the container."""
+    timeout: int = 30
+    """Timeout for executing commands in the container."""
+    executable: str = os.getenv("MSWEA_SINGULARITY_EXECUTABLE", "singularity")
+    """Path to the singularity executable."""
+    sandbox_build_retries: int = 3
+    """Number of retries for building the sandbox if an error occurs."""
+
+
+class SingularityEnvironment:
+    def __init__(
+        self, *, config_class: type = SingularityEnvironmentConfig, logger: logging.Logger | None = None, **kwargs
+    ):
+        """Singularity environment. See `SingularityEnvironmentConfig` for kwargs."""
+        self.logger = logger or logging.getLogger("minisweagent.environment")
+        self.config = config_class(**kwargs)
+        self.sandbox_dir = self._build_sandbox()
+
+    def _build_sandbox(self) -> Path:
+        # Building the sandbox can fail (very rarely), so we retry it
+        max_retries = self.config.sandbox_build_retries
+        for attempt in range(max_retries):
+            sandbox_dir = Path(tempfile.gettempdir()) / f"minisweagent-{uuid.uuid4().hex[:8]}"
+            try:
+                subprocess.run(
+                    [self.config.executable, "build", "--sandbox", sandbox_dir, self.config.image],
+                    check=True,
+                    capture_output=True,
+                )
+                break
+            except subprocess.CalledProcessError as e:
+                shutil.rmtree(sandbox_dir, ignore_errors=True)
+                self.logger.error(
+                    f"Error building image {self.config.image}, stdout: {e.stdout}, stderr: {e.stderr} (attempt {attempt + 1}/{max_retries})"
+                )
+                if attempt == max_retries - 1:
+                    raise
+        return sandbox_dir
+
+    def get_template_vars(self) -> dict[str, Any]:
+        return asdict(self.config)
+
+    def execute(self, command: str, cwd: str = "", *, timeout: int | None = None) -> dict[str, Any]:
+        """Execute a command in a Singularity container and return the result as a dict."""
+        cmd = [self.config.executable, "exec"]
+
+        # Do not inherit directories and env vars from host
+        cmd.extend(["--contain", "--cleanenv"])
+
+        work_dir = cwd or self.config.cwd
+        if work_dir and work_dir != "/":
+            cmd.extend(["--pwd", work_dir])
+
+        for key in self.config.forward_env:
+            if (value := os.getenv(key)) is not None:
+                cmd.extend(["--env", f"{key}={value}"])
+        for key, value in self.config.env.items():
+            cmd.extend(["--env", f"{key}={value}"])
+
+        cmd.extend(["--writable", str(self.sandbox_dir), "bash", "-c", command])
+        result = subprocess.run(
+            cmd,
+            text=True,
+            timeout=timeout or self.config.timeout,
+            encoding="utf-8",
+            errors="replace",
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+        )
+        return {"output": result.stdout, "returncode": result.returncode}
+
+    def cleanup(self):
+        shutil.rmtree(self.sandbox_dir, ignore_errors=True)
+
+    def __del__(self):
+        """Cleanup sandbox when object is destroyed."""
+        self.cleanup()