@elizaos/sweagent-root 2.0.0-alpha

package/python/sweagent/run/run_shell.py

@@ -0,0 +1,155 @@
+"""[cyan][bold]Run SWE-agent in semi-interactive mode.[/bold][/cyan]
+
+[cyan][bold]sweagen-sh is EXPERIMENTAL[/bold][/cyan]
+
+[cyan][bold]=== BASIC OPTIONS ===[/bold][/cyan]
+
+  -h --help           Show help text and exit
+  --help_option      Print specific help text and exit
+  --config CONFIG     Load additional config files. Use this option multiple times to load
+                      multiple files, e.g., --config config1.yaml --config config2.yaml
+
+"""
+
+import argparse
+import logging
+from pathlib import Path
+
+import yaml
+from rich.prompt import Prompt
+from swerex.deployment.config import DockerDeploymentConfig
+
+from sweagent import CONFIG_DIR
+from sweagent.agent.agents import AbstractAgent, ShellAgentConfig
+from sweagent.agent.extra.shell_agent import ShellAgent
+from sweagent.agent.problem_statement import (
+    GithubIssue,
+    ProblemStatement,
+    ProblemStatementConfig,
+    TextProblemStatement,
+)
+from sweagent.environment.repo import PreExistingRepoConfig
+from sweagent.environment.swe_env import EnvironmentConfig, SWEEnv
+from sweagent.run.common import save_predictions
+from sweagent.run.hooks.abstract import CombinedRunHooks, RunHook
+from sweagent.utils.config import load_environment_variables
+from sweagent.utils.github import _is_github_issue_url
+from sweagent.utils.log import add_file_handler, get_logger, set_stream_handler_levels
+
+
+class RunShell:
+    def __init__(
+        self,
+        env: SWEEnv,
+        agent: AbstractAgent,
+        problem_statement: ProblemStatement | ProblemStatementConfig,
+        *,
+        output_dir: Path = Path("."),
+        hooks: list[RunHook] | None = None,
+    ):
+        """Note: When initializing this class, make sure to add the hooks that are required by your actions.
+        See `from_config` for an example.
+        """
+        self.logger = get_logger("swea-run", emoji="🏃")
+        instance_id = problem_statement.id
+        _log_filename_template = f"{instance_id}.{{level}}.log"
+        for level in ["trace", "debug", "info"]:
+            add_file_handler(
+                output_dir / instance_id / _log_filename_template.format(level=level),
+                level=level,
+                id_=f"{instance_id}-{level}",
+            )
+        self.env = env
+        self.agent = agent
+        self.output_dir = output_dir
+        self._hooks = []
+        self._chooks = CombinedRunHooks()
+        self.problem_statement = problem_statement
+        for hook in hooks or []:
+            self.add_hook(hook)
+
+    @property
+    def hooks(self) -> list[RunHook]:
+        return self._chooks.hooks
+
+    def add_hook(self, hook: RunHook) -> None:
+        hook.on_init(run=self)
+        self._chooks.add_hook(hook)
+
+    def run(self):
+        self._chooks.on_start()
+        self.logger.info("Starting environment")
+        self.env.start()
+        self.logger.info("Running agent")
+        self._chooks.on_instance_start(index=0, env=self.env, problem_statement=self.problem_statement)
+        output_dir = self.output_dir / self.problem_statement.id
+        output_dir.mkdir(parents=True, exist_ok=True)
+        result = self.agent.run(
+            problem_statement=self.problem_statement,
+            env=self.env,
+            output_dir=output_dir,
+        )
+        self._chooks.on_instance_completed(result=result)
+        self.logger.info("Done")
+        self._chooks.on_end()
+        save_predictions(self.output_dir, self.problem_statement.id, result)
+        self.env.close()
+
+
+def get_cli():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("-r", "--repo", type=Path, help="Path to the repository.", default=None)
+    # parser.add_argument(dest="--model", type=str, help="Model to use.", default="claude-sonnet-4-20250514")
+    parser.add_argument(
+        "--config",
+        type=Path,
+        help="Path to the agent config file.",
+        default=CONFIG_DIR / "exotic" / "default_shell.yaml",
+    )
+    parser.add_argument(
+        "-p",
+        type=str,
+        help="Problem statement.",
+        default="",
+    )
+    return parser
+
+
+def run_from_cli(args: list[str] | None = None):
+    set_stream_handler_levels(logging.INFO)
+    cli_args = get_cli().parse_args(args)
+    try:
+        load_environment_variables(Path(".env"))
+    except FileNotFoundError:
+        print("Env file .env not found, please set API key as env variables.")
+    env_config = EnvironmentConfig(
+        repo=PreExistingRepoConfig(repo_name="repo", reset=False),
+        deployment=DockerDeploymentConfig(
+            image="python:3.11",
+            docker_args=[
+                "-v",
+                f"{cli_args.repo}:/repo",
+            ],
+            python_standalone_dir="/root",
+        ),
+    )
+    agent_config = ShellAgentConfig.model_validate(yaml.safe_load(cli_args.config.read_text())["agent"])
+    agent = ShellAgent.from_config(agent_config)
+    env = SWEEnv.from_config(env_config)
+    if cli_args.repo is None:
+        cli_args.repo = Path(Prompt.ask("[cyan]Repository path[/cyan]", default="", show_default=False))
+    problem_input = cli_args.p
+    if not problem_input:
+        problem_input = Prompt.ask("[cyan]Problem statement or GitHub issue URL[/cyan]", default="", show_default=False)
+    if _is_github_issue_url(problem_input):
+        problem_statement = GithubIssue(github_url=problem_input)
+    else:
+        problem_statement = TextProblemStatement(
+            text=problem_input,
+        )
+    run_shell = RunShell(env, agent, problem_statement=problem_statement, output_dir=Path.home() / "sweagent_shell")
+    run_shell.run()
+
+
+if __name__ == "__main__":
+    run_from_cli()

package/python/sweagent/run/run_single.py

@@ -0,0 +1,225 @@
+"""[cyan][bold]Run SWE-agent on a single instance taken from github or similar.[/bold][/cyan]
+
+[cyan][bold]=== BASIC OPTIONS ===[/bold][/cyan]
+
+  -h --help           Show help text and exit
+  --help_option      Print specific help text and exit
+  --config CONFIG     Load additional config files. Use this option multiple times to load
+                      multiple files, e.g., --config config1.yaml --config config2.yaml
+
+[cyan][bold]=== EXAMPLES ===[/bold][/cyan]
+
+Basic usage: Run over a [bold][cyan]github issue[/bold][/cyan][green]:
+
+sweagent run --config config/default.yaml --agent.model.name "gpt-4o" \\
+    --env.repo.github_url=https://github.com/SWE-agent/test-repo/ \\
+    --problem_statement.github_url=https://github.com/SWE-agent/test-repo/issues/1
+[/green]
+
+By default this will start a docker container and run the agent in there.
+You can set the image with [green]--env.docker.image[/green].
+
+Here's an example that uses [bold][cyan]modal[/bold][/cyan] instead of docker and also a [bold][cyan]local repository[/bold][/cyan]:
+
+[green]sweagent run --config config/default.yaml --agent.model.name "gpt-4o" \\
+    --env.deployment.type=modal --env.repo.path /path/to/repo \\
+    --problem_statement.path=path/to/problem_statement.md
+[/green]
+"""
+
+import getpass
+import sys
+from pathlib import Path
+from typing import Self
+
+import yaml
+from pydantic import BaseModel, ConfigDict, Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from sweagent.agent.agents import AbstractAgent, AgentConfig, get_agent_from_config
+from sweagent.agent.problem_statement import (
+    EmptyProblemStatement,
+    ProblemStatement,
+    ProblemStatementConfig,
+)
+from sweagent.environment.swe_env import EnvironmentConfig, SWEEnv
+from sweagent.run.common import AutoCorrectSuggestion as ACS
+from sweagent.run.common import BasicCLI, ConfigHelper, save_predictions
+from sweagent.run.hooks.abstract import CombinedRunHooks, RunHook
+from sweagent.run.hooks.apply_patch import SaveApplyPatchHook
+from sweagent.run.hooks.open_pr import OpenPRConfig, OpenPRHook
+from sweagent.utils.config import load_environment_variables
+from sweagent.utils.log import add_file_handler, get_logger
+
+
+class RunSingleActionConfig(BaseModel):
+    """Run real-life actions (opening PRs, etc.) if we can solve the issue."""
+
+    # Open a PR with the patch if we can solve the issue
+    open_pr: bool = False
+    pr_config: OpenPRConfig = Field(default_factory=OpenPRConfig)
+    # When working with local repository: Apply patch
+    apply_patch_locally: bool = False
+
+    # pydantic config
+    model_config = ConfigDict(extra="forbid")
+
+
+def _get_default_output_dir(output_dir: Path, problem_statement: ProblemStatement, agent: AgentConfig) -> Path:
+    if output_dir == Path("DEFAULT"):
+        user_id = getpass.getuser()
+        problem_id = problem_statement.id
+        try:
+            model_id = agent.model.id  # type: ignore[attr-defined]
+        except AttributeError:
+            model_id = "unknown_model"
+        config_file = getattr(agent, "_config_files", ["no_config"])[0]
+        if isinstance(config_file, Path):
+            config_file = config_file.stem
+        return Path.cwd() / "trajectories" / user_id / f"{config_file}__{model_id}___{problem_id}"
+    return output_dir
+
+
+class RunSingleConfig(BaseSettings, cli_implicit_flags=False):
+    env: EnvironmentConfig = Field(default_factory=EnvironmentConfig, description="Environment options.")
+    agent: AgentConfig = Field(description="Agent options.")
+    problem_statement: ProblemStatementConfig = Field(
+        default_factory=EmptyProblemStatement, description="Problem statement options."
+    )
+    output_dir: Path = Field(default=Path("DEFAULT"), description="Output directory.")
+
+    actions: RunSingleActionConfig = Field(default_factory=RunSingleActionConfig)
+
+    env_var_path: Path | None = None
+    """Path to a .env file to load environment variables from."""
+
+    # pydantic config
+    model_config = SettingsConfigDict(extra="forbid", env_prefix="SWE_AGENT_")
+
+    def set_default_output_dir(self) -> None:
+        # Needs to be called explicitly, because self._config_files will be setup
+        # post-init.
+        self.output_dir = _get_default_output_dir(self.output_dir, self.problem_statement, self.agent)
+
+    @classmethod
+    def _get_auto_correct(cls) -> list[ACS]:
+        return [
+            ACS("model", "agent.model.name"),
+            ACS("agent.model", "agent.model.name"),
+            ACS("model.name", "agent.model.name"),
+            ACS("per_instance_cost_limit", "agent.model.per_instance_cost_limit"),
+            ACS("model.per_instance_cost_limit", "agent.model.per_instance_cost_limit"),
+            ACS("config_file", "config"),
+            ACS(
+                "data_path",
+                help="--data_path is no longer support for SWE-A 1.0. Please check the tutorial and use one of the --problem_statement options, e.g., --problem_statement.github_url or --problem_statement.path",
+            ),
+            ACS(
+                "repo_path",
+                help="--repo_path is no longer support for SWE-A 1.0. Please check the tutorial and use one of the --env.repo options, e.g., --env.repo.github_url or --env.repo.path",
+            ),
+            ACS("repo.path", "env.repo.path"),
+        ]
+
+
+class RunSingle:
+    def __init__(
+        self,
+        env: SWEEnv,
+        agent: AbstractAgent,
+        problem_statement: ProblemStatement | ProblemStatementConfig,
+        *,
+        output_dir: Path = Path("."),
+        hooks: list[RunHook] | None = None,
+        actions: RunSingleActionConfig | None = None,
+    ):
+        """Note: When initializing this class, make sure to add the hooks that are required by your actions.
+        See `from_config` for an example.
+        """
+        self.logger = get_logger("swea-run", emoji="🏃")
+        instance_id = problem_statement.id
+        _log_filename_template = f"{instance_id}.{{level}}.log"
+        for level in ["trace", "debug", "info"]:
+            add_file_handler(
+                output_dir / instance_id / _log_filename_template.format(level=level),
+                level=level,
+                id_=f"{instance_id}-{level}",
+            )
+        self.env = env
+        self.agent = agent
+        self.output_dir = output_dir
+        self._hooks = []
+        if actions is not None:
+            actions = RunSingleActionConfig()
+        self.actions = actions
+        self._chooks = CombinedRunHooks()
+        self.problem_statement = problem_statement
+        for hook in hooks or []:
+            self.add_hook(hook)
+
+    @property
+    def hooks(self) -> list[RunHook]:
+        return self._chooks.hooks
+
+    @classmethod
+    def from_config(cls, config: RunSingleConfig) -> Self:
+        load_environment_variables(config.env_var_path)
+        config.set_default_output_dir()
+        config.output_dir.mkdir(parents=True, exist_ok=True)
+        agent = get_agent_from_config(config.agent)
+        agent.replay_config = config  # type: ignore[attr-defined]
+        self = cls(
+            env=SWEEnv.from_config(config.env),
+            agent=agent,
+            problem_statement=config.problem_statement,
+            output_dir=config.output_dir,
+            actions=config.actions,
+        )
+        self.add_hook(SaveApplyPatchHook(apply_patch_locally=config.actions.apply_patch_locally))
+        if config.actions.open_pr:
+            self.logger.debug("Adding OpenPRHook")
+            self.add_hook(OpenPRHook(config.actions.pr_config))
+        return self
+
+    def add_hook(self, hook: RunHook) -> None:
+        hook.on_init(run=self)
+        self._chooks.add_hook(hook)
+
+    def run(self):
+        self._chooks.on_start()
+        self.logger.info("Starting environment")
+        self.env.start()
+        self.logger.info("Running agent")
+        self._chooks.on_instance_start(index=0, env=self.env, problem_statement=self.problem_statement)
+        output_dir = self.output_dir / self.problem_statement.id
+        output_dir.mkdir(parents=True, exist_ok=True)
+        if self.agent.replay_config is not None:  # type: ignore[attr-defined]
+            (output_dir / "config.yaml").write_text(yaml.dump(self.agent.replay_config.model_dump_json(), indent=2))  # type: ignore[attr-defined]
+        result = self.agent.run(
+            problem_statement=self.problem_statement,
+            env=self.env,
+            output_dir=output_dir,
+        )
+        self._chooks.on_instance_completed(result=result)
+        self.logger.info("Done")
+        self._chooks.on_end()
+        save_predictions(self.output_dir, self.problem_statement.id, result)
+        self.env.close()
+
+
+def run_from_config(config: RunSingleConfig):
+    RunSingle.from_config(config).run()
+
+
+def run_from_cli(args: list[str] | None = None):
+    if args is None:
+        args = sys.argv[1:]
+    assert __doc__ is not None
+    help_text = (  # type: ignore
+        __doc__ + "\n[cyan][bold]=== ALL THE OPTIONS ===[/bold][/cyan]\n\n" + ConfigHelper().get_help(RunSingleConfig)
+    )
+    run_from_config(BasicCLI(RunSingleConfig, help_text=help_text).get_config(args))  # type: ignore
+
+
+if __name__ == "__main__":
+    run_from_cli()

package/python/sweagent/run/run_traj_to_demo.py

@@ -0,0 +1,85 @@
+"""Convert a trajectory file to a yaml file for editing of demos.
+You can then load the yaml file with `run_replay.py` to replay the actions in an environment to get
+environment output.
+"""
+
+from __future__ import annotations
+
+import json
+from argparse import ArgumentParser
+from pathlib import Path
+
+from sweagent.utils.log import get_logger
+from sweagent.utils.serialization import _yaml_serialization_with_linebreaks
+
+logger = get_logger("traj2demo")
+
+DEMO_COMMENT = """# This is a demo file generated from trajectory file:
+# {traj_path}
+# You can use this demo file to replay the actions in the trajectory with run_replay.py.
+# You can edit the content of the actions in this file to modify the replay behavior.
+# NOTICE:
+#         Only the actions of the assistant will be replayed.
+#         You do not need to modify the observation's contents or any other fields.
+#         You can add or remove actions to modify the replay behavior."""
+
+
+def save_demo(data: str | dict | list, file: Path, traj_path: Path) -> None:
+    """Save demo data as a yaml file. Takes care of multi-line strings and adds a header."""
+    content = _yaml_serialization_with_linebreaks(data)
+    header = DEMO_COMMENT.format(traj_path=str(traj_path))
+    with open(file, "w") as f:
+        f.write(f"{header}\n{content}")
+
+
+def convert_traj_to_action_demo(traj_path: Path, output_file: Path, include_user: bool = False) -> None:
+    with open(traj_path) as file:
+        traj = json.load(file)
+    replay_config = traj["replay_config"]
+    if isinstance(traj["replay_config"], str):
+        replay_config = json.loads(traj["replay_config"])
+    history = traj["history"]
+
+    copy_fields = {"content", "role", "tool_calls", "agent", "message_type", "tool_call_ids"}
+
+    admissible_roles = {"assistant", "user", "tool"} if include_user else {"assistant"}
+    filtered_history = [
+        {k: v for k, v in step.items() if k in copy_fields}
+        for step in history
+        if step["role"] in admissible_roles
+        and step.get("agent", "main") in {"main", "primary"}
+        and not step.get("is_demo")
+    ]
+
+    output_data = {"history": filtered_history, "replay_config": replay_config}
+    save_demo(output_data, output_file, traj_path)
+    logger.info(f"Saved demo to {output_file}")
+
+
+def main(traj_path: Path, output_dir: Path, suffix: str = "", overwrite: bool = False, include_user: bool = False):
+    output_file = output_dir / (traj_path.parent.name + suffix) / (traj_path.stem.removesuffix(".traj") + ".demo.yaml")
+    if output_file.exists() and not overwrite:
+        msg = f"Output file already exists: {output_file}. Use --overwrite to overwrite."
+        raise FileExistsError(msg)
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    convert_traj_to_action_demo(traj_path, output_file, include_user)
+
+
+def run_from_cli(args: list[str] | None = None):
+    """Convert a trajectory file to a demo file."""
+    parser = ArgumentParser(description=__doc__)
+    parser.add_argument("traj_path", type=Path, help="Path to trajectory file")
+    parser.add_argument("--output_dir", type=Path, help="Output directory for action demos", default=Path("./demos"))
+    parser.add_argument("--suffix", type=str, help="Suffix for the output file", default="")
+    parser.add_argument("--overwrite", help="Overwrite existing files", action="store_true")
+    parser.add_argument(
+        "--include_user",
+        help="Include user responses (computer)",
+        action="store_true",
+    )
+    parsed_args = parser.parse_args(args)
+    main(**vars(parsed_args))
+
+
+if __name__ == "__main__":
+    run_from_cli()

package/python/sweagent/tools/bundle.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+from pydantic import BaseModel, Field, PrivateAttr, model_validator
+
+from sweagent.tools.commands import Command
+from sweagent.utils.config import _convert_path_to_abspath
+
+
+class BundleConfig(BaseModel):
+    tools: dict[str, dict]
+    state_command: str | None = None
+
+
+class Bundle(BaseModel):
+    path: Path
+    hidden_tools: list[str] = Field(default_factory=list)
+    _config: BundleConfig = PrivateAttr(default=None)
+
+    @model_validator(mode="after")
+    def validate_tools(self):
+        self.path = _convert_path_to_abspath(self.path)
+        if not self.path.exists():
+            msg = f"Bundle path '{self.path}' does not exist."
+            raise ValueError(msg)
+
+        config_path = self.path / "config.yaml"
+        if not config_path.exists():
+            msg = f"Bundle config file '{config_path}' does not exist."
+            raise ValueError(msg)
+
+        config_data = yaml.safe_load(config_path.read_text())
+        self._config = BundleConfig(**config_data)
+
+        invalid_hidden_tools = set(self.hidden_tools) - set(self._config.tools.keys())
+        if invalid_hidden_tools:
+            msg = f"Hidden tools {invalid_hidden_tools} do not exist in available tools"
+            raise ValueError(msg)
+        return self
+
+    @property
+    def state_command(self) -> str | None:
+        return self.config.state_command
+
+    @property
+    def config(self) -> BundleConfig:
+        return self._config
+
+    @property
+    def commands(self) -> list[Command]:
+        return [
+            Command(name=tool, **tool_config.model_dump() if isinstance(tool_config, Command) else tool_config)
+            for tool, tool_config in self.config.tools.items()
+            if tool not in self.hidden_tools
+        ]