mini-swe-agent 1.1.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" / "local2.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,118 @@
+#!/usr/bin/env python3
+
+"""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]
+"""
+
+import os
+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 Environment, Model, global_config_dir
+from minisweagent.agents.interactive import InteractiveAgent
+from minisweagent.agents.interactive_textual import AgentApp
+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
+
+DEFAULT_CONFIG = Path(os.getenv("MSWEA_LOCAL_CONFIG_PATH", builtin_config_dir / "local.yaml"))
+console = Console(highlight=False)
+app = typer.Typer(rich_markup_mode="rich")
+prompt_session = PromptSession(history=FileHistory(global_config_dir / "mini_task_history.txt"))
+
+
+def run_interactive(model: Model, env: Environment, agent_config: dict, task: str, output: Path | None = None) -> Any:
+    agent = InteractiveAgent(
+        model,
+        env,
+        **agent_config,
+    )
+
+    exit_status, result = None, None
+    try:
+        exit_status, result = agent.run(task)
+    except KeyboardInterrupt:
+        console.print("\n[bold red]KeyboardInterrupt -- goodbye[/bold red]")
+    finally:
+        if output:
+            save_traj(agent, output, exit_status=exit_status, result=result)
+    return agent
+
+
+def run_textual(model: Model, env: Environment, agent_config: dict, task: str, output: Path | None = None) -> Any:
+    agent_app = AgentApp(
+        model,
+        env,
+        task,
+        **agent_config,
+    )
+    try:
+        agent_app.run()
+    except KeyboardInterrupt:
+        typer.echo("\nKeyboardInterrupt -- goodbye")
+    finally:
+        save_traj(agent_app.agent, Path("traj.json"), exit_status=agent_app.exit_status, result=agent_app.result)
+
+
+@app.command(help=__doc__)
+def main(
+    visual: bool = typer.Option(False, "-v", "--visual", help="Use visual (pager-style) UI (Textual)"),
+    model_name: str | None = typer.Option(
+        None,
+        "-m",
+        "--model",
+        help="Model to use",
+    ),
+    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(None, "-o", "--output", help="Output file"),
+) -> Any:
+    configure_if_first_time()
+    config = yaml.safe_load(get_config_path(config_spec).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]")
+
+    config["agent"]["mode"] = "confirm" if not yolo else "yolo"
+    if cost_limit:
+        config["agent"]["cost_limit"] = cost_limit
+    model = get_model(model_name, config.get("model", {}))
+    env = LocalEnvironment(**config.get("env", {}))
+
+    if visual:
+        return run_textual(model, env, config["agent"], task, output)  # type: ignore[arg-type]
+    else:
+        return run_interactive(model, env, config["agent"], task, output)  # type: ignore[arg-type]
+
+
+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,35 @@
+import json
+from pathlib import Path
+
+from minisweagent import Agent
+
+
+def save_traj(
+    agent: Agent | None,
+    path: Path,
+    *,
+    exit_status: str | None = None,
+    result: str | None = None,
+    extra_info: dict | None = None,
+    **kwargs,
+):
+    data = {
+        "info": {
+            "exit_status": exit_status,
+            "submission": result,
+            "model_stats": {
+                "instance_cost": 0.0,
+                "api_calls": 0,
+            },
+        },
+        "messages": [],
+    } | 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
+    if extra_info:
+        data["info"].update(extra_info)
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2))