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

minisweagent/run/inspector.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+"""
+Simple trajectory inspector for browsing agent conversation trajectories.
+
+[not dim]
+More information about the usage: [bold green]https://mini-swe-agent.com/latest/usage/inspector/[/bold green]
+[/not dim]
+"""
+
+import json
+import os
+from pathlib import Path
+
+import typer
+from rich.text import Text
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Container, Vertical, VerticalScroll
+from textual.widgets import Footer, Header, Static
+
+from minisweagent.agents.interactive_textual import _messages_to_steps
+
+app = typer.Typer(rich_markup_mode="rich", add_completion=False)
+
+
+class TrajectoryInspector(App):
+    BINDINGS = [
+        Binding("right,l", "next_step", "Step++"),
+        Binding("left,h", "previous_step", "Step--"),
+        Binding("0", "first_step", "Step=0"),
+        Binding("$", "last_step", "Step=-1"),
+        Binding("j,down", "scroll_down", "Scroll down"),
+        Binding("k,up", "scroll_up", "Scroll up"),
+        Binding("L", "next_trajectory", "Next trajectory"),
+        Binding("H", "previous_trajectory", "Previous trajectory"),
+        Binding("q", "quit", "Quit"),
+    ]
+
+    def __init__(self, trajectory_files: list[Path]):
+        css_path = os.environ.get(
+            "MSWEA_INSPECTOR_STYLE_PATH", str(Path(__file__).parent.parent / "config" / "mini.tcss")
+        )
+        self.__class__.CSS = Path(css_path).read_text()
+
+        super().__init__()
+        self.trajectory_files = trajectory_files
+        self._i_trajectory = 0
+        self._i_step = 0
+        self.messages = []
+        self.steps = []
+
+        if trajectory_files:
+            self._load_current_trajectory()
+
+    # --- Basics ---
+
+    @property
+    def i_step(self) -> int:
+        """Current step index."""
+        return self._i_step
+
+    @i_step.setter
+    def i_step(self, value: int) -> None:
+        """Set current step index, automatically clamping to valid bounds."""
+        if value != self._i_step and self.n_steps > 0:
+            self._i_step = max(0, min(value, self.n_steps - 1))
+            self.query_one(VerticalScroll).scroll_to(y=0, animate=False)
+            self.update_content()
+
+    @property
+    def n_steps(self) -> int:
+        """Number of steps in current trajectory."""
+        return len(self.steps)
+
+    @property
+    def i_trajectory(self) -> int:
+        """Current trajectory index."""
+        return self._i_trajectory
+
+    @i_trajectory.setter
+    def i_trajectory(self, value: int) -> None:
+        """Set current trajectory index, automatically clamping to valid bounds."""
+        if value != self._i_trajectory and self.n_trajectories > 0:
+            self._i_trajectory = max(0, min(value, self.n_trajectories - 1))
+            self._load_current_trajectory()
+            self.query_one(VerticalScroll).scroll_to(y=0, animate=False)
+            self.update_content()
+
+    @property
+    def n_trajectories(self) -> int:
+        """Number of trajectory files."""
+        return len(self.trajectory_files)
+
+    def _load_current_trajectory(self) -> None:
+        """Load the currently selected trajectory file."""
+        if not self.trajectory_files:
+            self.messages = []
+            self.steps = []
+            return
+
+        trajectory_file = self.trajectory_files[self.i_trajectory]
+        try:
+            data = json.loads(trajectory_file.read_text())
+
+            if isinstance(data, list):
+                self.messages = data
+            elif isinstance(data, dict) and "messages" in data:
+                self.messages = data["messages"]
+            else:
+                raise ValueError("Unrecognized trajectory format")
+
+            self.steps = _messages_to_steps(self.messages)
+            self._i_step = 0
+        except (json.JSONDecodeError, FileNotFoundError, ValueError) as e:
+            self.messages = []
+            self.steps = []
+            self.notify(f"Error loading {trajectory_file.name}: {e}", severity="error")
+
+    @property
+    def current_trajectory_name(self) -> str:
+        """Get the name of the current trajectory file."""
+        if not self.trajectory_files:
+            return "No trajectories"
+        return self.trajectory_files[self.i_trajectory].name
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Container(id="main"):
+            with VerticalScroll():
+                yield Vertical(id="content")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.update_content()
+
+    def update_content(self) -> None:
+        """Update the displayed content."""
+        container = self.query_one("#content", Vertical)
+        container.remove_children()
+
+        if not self.steps:
+            container.mount(Static("No trajectory loaded or empty trajectory"))
+            self.title = "Trajectory Inspector - No Data"
+            return
+
+        for message in self.steps[self.i_step]:
+            if isinstance(message["content"], list):
+                content_str = "\n".join([item["text"] for item in message["content"]])
+            else:
+                content_str = str(message["content"])
+            message_container = Vertical(classes="message-container")
+            container.mount(message_container)
+            role = message["role"].replace("assistant", "mini-swe-agent")
+            message_container.mount(Static(role.upper(), classes="message-header"))
+            message_container.mount(Static(Text(content_str, no_wrap=False), classes="message-content"))
+
+        self.title = (
+            f"Trajectory {self.i_trajectory + 1}/{self.n_trajectories} - "
+            f"{self.current_trajectory_name} - "
+            f"Step {self.i_step + 1}/{self.n_steps}"
+        )
+
+    # --- Navigation actions ---
+
+    def action_next_step(self) -> None:
+        self.i_step += 1
+
+    def action_previous_step(self) -> None:
+        self.i_step -= 1
+
+    def action_first_step(self) -> None:
+        self.i_step = 0
+
+    def action_last_step(self) -> None:
+        self.i_step = self.n_steps - 1
+
+    def action_next_trajectory(self) -> None:
+        self.i_trajectory += 1
+
+    def action_previous_trajectory(self) -> None:
+        self.i_trajectory -= 1
+
+    def action_scroll_down(self) -> None:
+        vs = self.query_one(VerticalScroll)
+        vs.scroll_to(y=vs.scroll_target_y + 15)
+
+    def action_scroll_up(self) -> None:
+        vs = self.query_one(VerticalScroll)
+        vs.scroll_to(y=vs.scroll_target_y - 15)
+
+
+@app.command(help=__doc__)
+def main(
+    path: str = typer.Argument(".", help="Directory to search for trajectory files or specific trajectory file"),
+) -> None:
+    path_obj = Path(path)
+
+    if path_obj.is_file():
+        trajectory_files = [path_obj]
+    elif path_obj.is_dir():
+        trajectory_files = sorted(path_obj.rglob("*.traj.json"))
+        if not trajectory_files:
+            raise typer.BadParameter(f"No trajectory files found in '{path}'")
+    else:
+        raise typer.BadParameter(f"Error: Path '{path}' does not exist")
+
+    inspector = TrajectoryInspector(trajectory_files)
+    inspector.run()
+
+
+if __name__ == "__main__":
+    app()

minisweagent/run/mini.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+
+"""Run mini-SWE-agent in your local environment. This is the default executable `mini`."""
+# Read this first: https://mini-swe-agent.com/latest/usage/mini/  (usage)
+
+import os
+import traceback
+from pathlib import Path
+from typing import Any
+
+import typer
+import yaml
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.shortcuts import PromptSession
+from rich.console import Console
+
+from minisweagent import global_config_dir
+from minisweagent.agents.interactive import InteractiveAgent
+from minisweagent.agents.interactive_textual import TextualAgent
+from minisweagent.config import builtin_config_dir, get_config_path
+from minisweagent.environments.local import LocalEnvironment
+from minisweagent.models import get_model
+from minisweagent.run.extra.config import configure_if_first_time
+from minisweagent.run.utils.save import save_traj
+from minisweagent.utils.log import logger
+
+DEFAULT_CONFIG = Path(os.getenv("MSWEA_MINI_CONFIG_PATH", builtin_config_dir / "mini.yaml"))
+DEFAULT_OUTPUT = global_config_dir / "last_mini_run.traj.json"
+console = Console(highlight=False)
+app = typer.Typer(rich_markup_mode="rich")
+prompt_session = PromptSession(history=FileHistory(global_config_dir / "mini_task_history.txt"))
+_HELP_TEXT = """Run mini-SWE-agent in your local environment.
+
+[not dim]
+There are two different user interfaces:
+
+[bold green]mini[/bold green] Simple REPL-style interface
+[bold green]mini -v[/bold green] Pager-style interface (Textual)
+
+More information about the usage: [bold green]https://mini-swe-agent.com/latest/usage/mini/[/bold green]
+[/not dim]
+"""
+
+
+# fmt: off
+@app.command(help=_HELP_TEXT)
+def main(
+    visual: bool = typer.Option(False, "-v", "--visual", help="Toggle (pager-style) UI (Textual) depending on the MSWEA_VISUAL_MODE_DEFAULT environment setting",),
+    model_name: str | None = typer.Option( None, "-m", "--model", help="Model to use",),
+    model_class: str | None = typer.Option(None, "--model-class", help="Model class to use (e.g., 'anthropic' or 'minisweagent.models.anthropic.AnthropicModel')", rich_help_panel="Advanced"),
+    task: str | None = typer.Option(None, "-t", "--task", help="Task/problem statement", show_default=False),
+    yolo: bool = typer.Option(False, "-y", "--yolo", help="Run without confirmation"),
+    cost_limit: float | None = typer.Option(None, "-l", "--cost-limit", help="Cost limit. Set to 0 to disable."),
+    config_spec: Path = typer.Option(DEFAULT_CONFIG, "-c", "--config", help="Path to config file"),
+    output: Path | None = typer.Option(DEFAULT_OUTPUT, "-o", "--output", help="Output trajectory file"),
+    exit_immediately: bool = typer.Option( False, "--exit-immediately", help="Exit immediately when the agent wants to finish instead of prompting.", rich_help_panel="Advanced"),
+) -> Any:
+    # fmt: on
+    configure_if_first_time()
+    config_path = get_config_path(config_spec)
+    console.print(f"Loading agent config from [bold green]'{config_path}'[/bold green]")
+    config = yaml.safe_load(config_path.read_text())
+
+    if not task:
+        console.print("[bold yellow]What do you want to do?")
+        task = prompt_session.prompt(
+            "",
+            multiline=True,
+            bottom_toolbar=HTML(
+                "Submit task: <b fg='yellow' bg='black'>Esc+Enter</b> | "
+                "Navigate history: <b fg='yellow' bg='black'>Arrow Up/Down</b> | "
+                "Search history: <b fg='yellow' bg='black'>Ctrl+R</b>"
+            ),
+        )
+        console.print("[bold green]Got that, thanks![/bold green]")
+
+    if yolo:
+        config.setdefault("agent", {})["mode"] = "yolo"
+    if cost_limit is not None:
+        config.setdefault("agent", {})["cost_limit"] = cost_limit
+    if exit_immediately:
+        config.setdefault("agent", {})["confirm_exit"] = False
+    if model_class is not None:
+        config.setdefault("model", {})["model_class"] = model_class
+    model = get_model(model_name, config.get("model", {}))
+    env = LocalEnvironment(**config.get("env", {}))
+
+    # Both visual flag and the MSWEA_VISUAL_MODE_DEFAULT flip the mode, so it's essentially a XOR
+    agent_class = InteractiveAgent
+    if visual == (os.getenv("MSWEA_VISUAL_MODE_DEFAULT", "false") == "false"):
+        agent_class = TextualAgent
+
+    agent = agent_class(model, env, **config.get("agent", {}))
+    exit_status, result, extra_info = None, None, None
+    try:
+        exit_status, result = agent.run(task)  # type: ignore[arg-type]
+    except Exception as e:
+        logger.error(f"Error running agent: {e}", exc_info=True)
+        exit_status, result = type(e).__name__, str(e)
+        extra_info = {"traceback": traceback.format_exc()}
+    finally:
+        save_traj(agent, output, exit_status=exit_status, result=result, extra_info=extra_info)  # type: ignore[arg-type]
+    return agent
+
+
+if __name__ == "__main__":
+    app()

minisweagent/run/mini_extra.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+
+import sys
+from importlib import import_module
+
+from rich.console import Console
+
+subcommands = [
+    ("minisweagent.run.extra.config", ["config"], "Manage the global config file"),
+    ("minisweagent.run.inspector", ["inspect", "i", "inspector"], "Run inspector (browse trajectories)"),
+    ("minisweagent.run.github_issue", ["github-issue", "gh"], "Run on a GitHub issue"),
+    ("minisweagent.run.extra.swebench", ["swebench"], "Evaluate on SWE-bench (batch mode)"),
+    ("minisweagent.run.extra.swebench_single", ["swebench-single"], "Evaluate on SWE-bench (single instance)"),
+]
+
+
+def get_docstring() -> str:
+    lines = [
+        "This is the [yellow]central entry point for all extra commands[/yellow] from mini-swe-agent.",
+        "",
+        "Available sub-commands:",
+        "",
+    ]
+    for _, aliases, description in subcommands:
+        alias_text = " or ".join(f"[bold green]{alias}[/bold green]" for alias in aliases)
+        lines.append(f"  {alias_text}: {description}")
+    return "\n".join(lines)
+
+
+def main():
+    args = sys.argv[1:]
+
+    if len(args) == 0 or len(args) == 1 and args[0] in ["-h", "--help"]:
+        return Console().print(get_docstring())
+
+    for module_path, aliases, _ in subcommands:
+        if args[0] in aliases:
+            return import_module(module_path).app(args[1:], prog_name=f"mini-extra {aliases[0]}")
+
+    return Console().print(get_docstring())
+
+
+if __name__ == "__main__":
+    main()

minisweagent/run/utils/save.py

@@ -0,0 +1,78 @@
+import dataclasses
+import json
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from minisweagent import Agent, __version__
+
+
+def _get_class_name_with_module(obj: Any) -> str:
+    """Get the full class name with module path."""
+    return f"{obj.__class__.__module__}.{obj.__class__.__name__}"
+
+
+def _asdict(obj: Any) -> dict:
+    """Convert config objects to dicts."""
+    if dataclasses.is_dataclass(obj):
+        return dataclasses.asdict(obj)  # type: ignore[arg-type]
+    return obj  # let's try our luck
+
+
+def save_traj(
+    agent: Agent | None,
+    path: Path | None,
+    *,
+    print_path: bool = True,
+    exit_status: str | None = None,
+    result: str | None = None,
+    extra_info: dict | None = None,
+    print_fct: Callable = print,
+    **kwargs,
+):
+    """Save the trajectory of the agent to a file.
+
+    Args:
+        agent: The agent to save the trajectory of.
+        path: The path to save the trajectory to.
+        print_path: Whether to print confirmation of path to the terminal.
+        exit_status: The exit status of the agent.
+        result: The result/submission of the agent.
+        extra_info: Extra information to save (will be merged into the info dict).
+        **kwargs: Additional information to save (will be merged into top level)
+
+    """
+    if path is None:
+        return
+    data = {
+        "info": {
+            "exit_status": exit_status,
+            "submission": result,
+            "model_stats": {
+                "instance_cost": 0.0,
+                "api_calls": 0,
+            },
+            "mini_version": __version__,
+        },
+        "messages": [],
+        "trajectory_format": "mini-swe-agent-1",
+    } | kwargs
+    if agent is not None:
+        data["info"]["model_stats"]["instance_cost"] = agent.model.cost
+        data["info"]["model_stats"]["api_calls"] = agent.model.n_calls
+        data["messages"] = agent.messages
+        data["info"]["config"] = {
+            "agent": _asdict(agent.config),
+            "model": _asdict(agent.model.config),
+            "environment": _asdict(agent.env.config),
+            "agent_type": _get_class_name_with_module(agent),
+            "model_type": _get_class_name_with_module(agent.model),
+            "environment_type": _get_class_name_with_module(agent.env),
+        }
+    if extra_info:
+        data["info"].update(extra_info)
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2))
+    if print_path:
+        print_fct(f"Saved trajectory to '{path}'")

minisweagent/utils/log.py

@@ -0,0 +1,36 @@
+import logging
+from pathlib import Path
+
+from rich.logging import RichHandler
+
+
+def _setup_root_logger() -> None:
+    logger = logging.getLogger("minisweagent")
+    logger.setLevel(logging.DEBUG)
+    _handler = RichHandler(
+        show_path=False,
+        show_time=False,
+        show_level=False,
+        markup=True,
+    )
+    _formatter = logging.Formatter("%(name)s: %(levelname)s: %(message)s")
+    _handler.setFormatter(_formatter)
+    logger.addHandler(_handler)
+
+
+def add_file_handler(path: Path | str, level: int = logging.DEBUG, *, print_path: bool = True) -> None:
+    logger = logging.getLogger("minisweagent")
+    handler = logging.FileHandler(path)
+    handler.setLevel(level)
+    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    if print_path:
+        print(f"Logging to '{path}'")
+
+
+_setup_root_logger()
+logger = logging.getLogger("minisweagent")
+
+
+__all__ = ["logger"]