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

minisweagent/agents/interactive.py

@@ -0,0 +1,148 @@
+"""A small generalization of the default agent that puts the user in the loop.
+
+There are three modes:
+- human: commands issued by the user are executed immediately
+- confirm: commands issued by the LM but not whitelisted are confirmed by the user
+- yolo: commands issued by the LM are executed immediately without confirmation
+"""
+
+import re
+from dataclasses import dataclass, field
+from typing import Literal
+
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.shortcuts import PromptSession
+from rich.console import Console
+from rich.rule import Rule
+
+from minisweagent import global_config_dir
+from minisweagent.agents.default import AgentConfig, DefaultAgent, LimitsExceeded, NonTerminatingException, Submitted
+
+console = Console(highlight=False)
+prompt_session = PromptSession(history=FileHistory(global_config_dir / "interactive_history.txt"))
+
+
+@dataclass
+class InteractiveAgentConfig(AgentConfig):
+    mode: Literal["human", "confirm", "yolo"] = "confirm"
+    """Whether to confirm actions."""
+    whitelist_actions: list[str] = field(default_factory=list)
+    """Never confirm actions that match these regular expressions."""
+
+
+class InteractiveAgent(DefaultAgent):
+    _MODE_COMMANDS_MAPPING = {"/u": "human", "/c": "confirm", "/y": "yolo"}
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, config_class=InteractiveAgentConfig, **kwargs)
+        self.cost_last_confirmed = 0.0
+
+    def add_message(self, role: str, content: str):
+        # Extend supermethod to print messages
+        super().add_message(role, content)
+        if role == "assistant":
+            console.print(
+                f"\n[red][bold]mini-swe-agent[/bold] (step [bold]{self.model.n_calls}[/bold], [bold]${self.model.cost:.2f}[/bold]):[/red]\n",
+                end="",
+                highlight=False,
+            )
+        else:
+            console.print(f"\n[bold green]{role.capitalize()}[/bold green]:\n", end="", highlight=False)
+        console.print(content, highlight=False, markup=False)
+
+    def query(self) -> dict:
+        # Extend supermethod to handle human mode
+        if self.config.mode == "human":
+            match command := self._prompt_and_handle_special("[bold yellow]>[/bold yellow] "):
+                case "/y" | "/c":  # Just go to the super query, which queries the LM for the next action
+                    pass
+                case _:
+                    return {"content": f"\n```bash\n{command}\n```"}
+        try:
+            with console.status("Waiting for the LM to respond..."):
+                return super().query()
+        except LimitsExceeded:
+            console.print(
+                f"Limits exceeded. Limits: {self.config.step_limit} steps, ${self.config.cost_limit}.\n"
+                f"Current spend: {self.model.n_calls} steps, ${self.model.cost:.2f}."
+            )
+            self.config.step_limit = int(input("New step limit: "))
+            self.config.cost_limit = float(input("New cost limit: "))
+            return super().query()
+
+    def step(self) -> dict:
+        # Override the step method to handle user interruption
+        try:
+            console.print(Rule())
+            return super().step()
+        except KeyboardInterrupt:
+            # We always add a message about the interrupt and then just proceed to the next step
+            interruption_message = self._prompt_and_handle_special(
+                "\n\n[bold yellow]Interrupted.[/bold yellow] "
+                "[green]Type a comment/command[/green] (/h for available commands)"
+                "\n[bold yellow]>[/bold yellow] "
+            ).strip()
+            if not interruption_message or interruption_message in self._MODE_COMMANDS_MAPPING:
+                interruption_message = "Temporary interruption caught."
+            raise NonTerminatingException(f"Interrupted by user: {interruption_message}")
+
+    def execute_action(self, action: dict) -> dict:
+        # Override the execute_action method to handle user confirmation
+        if self.should_ask_confirmation(action["action"]):
+            self.ask_confirmation()
+        return super().execute_action(action)
+
+    def should_ask_confirmation(self, action: str) -> bool:
+        return self.config.mode == "confirm" and not any(re.match(r, action) for r in self.config.whitelist_actions)
+
+    def ask_confirmation(self) -> None:
+        prompt = (
+            "[bold yellow]Execute?[/bold yellow] [green][bold]Enter[/bold] to confirm[/green], "
+            "or [green]Type a comment/command[/green] (/h for available commands)\n"
+            "[bold yellow]>[/bold yellow] "
+        )
+        match user_input := self._prompt_and_handle_special(prompt).strip():
+            case "" | "/y":
+                pass  # confirmed, do nothing
+            case "/u":  # Skip execution action and get back to query
+                raise NonTerminatingException("Command not executed. Switching to human mode")
+            case _:
+                raise NonTerminatingException(
+                    f"Command not executed. The user rejected your command with the following message: {user_input}"
+                )
+
+    def _prompt_and_handle_special(self, prompt: str) -> str:
+        """Prompts the user, takes care of /h (followed by requery) and sets the mode. Returns the user input."""
+        console.print(prompt, end="")
+        user_input = prompt_session.prompt("")
+        if user_input == "/h":
+            console.print(
+                f"Current mode: [bold green]{self.config.mode}[/bold green]\n"
+                f"[bold green]/y[/bold green] to switch to [bold yellow]yolo[/bold yellow] mode (execute LM commands without confirmation)\n"
+                f"[bold green]/c[/bold green] to switch to [bold yellow]confirmation[/bold yellow] mode (ask for confirmation before executing LM commands)\n"
+                f"[bold green]/u[/bold green] to switch to [bold yellow]human[/bold yellow] mode (execute commands issued by the user)\n"
+            )
+            return self._prompt_and_handle_special(prompt)
+        if user_input in self._MODE_COMMANDS_MAPPING:
+            if self.config.mode == self._MODE_COMMANDS_MAPPING[user_input]:
+                return self._prompt_and_handle_special(
+                    f"[bold red]Already in {self.config.mode} mode.[/bold red]\n{prompt}"
+                )
+            self.config.mode = self._MODE_COMMANDS_MAPPING[user_input]
+            console.print(f"Switched to [bold green]{self.config.mode}[/bold green] mode.")
+            return user_input
+        return user_input
+
+    def has_finished(self, output: dict[str, str]):
+        try:
+            return super().has_finished(output)
+        except Submitted as e:
+            console.print(
+                "[bold green]Agent wants to finish.[/bold green] "
+                "[green]Type a comment to give it a new task or press enter to quit.\n"
+                "[bold yellow]>[/bold yellow] ",
+                end="",
+            )
+            if new_task := self._prompt_and_handle_special("").strip():
+                raise NonTerminatingException(f"The user added a new task: {new_task}")
+            raise e

minisweagent/agents/interactive_textual.py

@@ -0,0 +1,324 @@
+"""
+Extension of the `default.py` agent that uses Textual for an interactive TUI.
+For a simpler version of an interactive UI that does not require threading and more, see `interactive.py`.
+"""
+
+import logging
+import os
+import re
+import threading
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Literal
+
+from rich.spinner import Spinner
+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.css.query import NoMatches
+from textual.events import Key
+from textual.widgets import Footer, Header, Static, TextArea
+
+from minisweagent.agents.default import AgentConfig, DefaultAgent, NonTerminatingException
+
+
+@dataclass
+class TextualAgentConfig(AgentConfig):
+    mode: Literal["confirm", "yolo"] = "confirm"
+    """Mode for action execution: 'confirm' requires user confirmation, 'yolo' executes immediately."""
+    whitelist_actions: list[str] = field(default_factory=list)
+    """Never confirm actions that match these regular expressions."""
+
+
+class TextualAgent(DefaultAgent):
+    def __init__(self, app: "AgentApp", *args, **kwargs):
+        """Connects the DefaultAgent to the TextualApp."""
+        self.app = app
+        super().__init__(*args, config_class=TextualAgentConfig, **kwargs)
+
+    def add_message(self, role: str, content: str):
+        super().add_message(role, content)
+        if self.app.agent_state != "UNINITIALIZED":
+            self.app.call_from_thread(self.app.on_message_added)
+
+    def run(self, task: str) -> tuple[str, str]:
+        try:
+            exit_status, result = super().run(task)
+        except Exception as e:
+            result = str(e)
+            self.app.call_from_thread(self.app.on_agent_finished, "ERROR", result)
+            return "ERROR", result
+        else:
+            self.app.call_from_thread(self.app.on_agent_finished, exit_status, result)
+        return exit_status, result
+
+    def execute_action(self, action: dict) -> dict:
+        if self.config.mode == "confirm" and not any(
+            re.match(r, action["action"]) for r in self.config.whitelist_actions
+        ):
+            if result := self.app.confirmation_container.request_confirmation(action["action"]):
+                raise NonTerminatingException(f"Command not executed: {result}")
+        return super().execute_action(action)
+
+
+class AddLogEmitCallback(logging.Handler):
+    def __init__(self, callback):
+        """Custom log handler that forwards messages via callback."""
+        super().__init__()
+        self.callback = callback
+
+    def emit(self, record: logging.LogRecord):
+        self.callback(record)  # type: ignore[attr-defined]
+
+
+def _messages_to_steps(messages: list[dict]) -> list[list[dict]]:
+    """Group messages into "pages" as shown by the UI."""
+    steps = []
+    current_step = []
+    for message in messages:
+        current_step.append(message)
+        if message["role"] == "user":
+            steps.append(current_step)
+            current_step = []
+    if current_step:
+        steps.append(current_step)
+    return steps
+
+
+class ConfirmationPromptContainer(Container):
+    def __init__(self, app: "AgentApp"):
+        """This class is responsible for handling the action execution confirmation."""
+        super().__init__(id="confirmation-container")
+        self._app = app
+        self.rejecting = False
+        self.can_focus = True
+        self.display = False
+
+        self._pending_action: str | None = None
+        self._confirmation_event = threading.Event()
+        self._confirmation_result: str | None = None
+
+    def compose(self) -> ComposeResult:
+        yield Static(
+            "Press [bold]ENTER[/bold] to confirm action or [bold]BACKSPACE[/bold] to reject (or [bold]y[/bold] to toggle YOLO mode)",
+            classes="confirmation-prompt",
+        )
+        yield TextArea(id="rejection-input")
+        rejection_help = Static(
+            "Press [bold]Ctrl+D[/bold] to submit rejection message",
+            id="rejection-help",
+            classes="rejection-help",
+        )
+        rejection_help.display = False
+        yield rejection_help
+
+    def request_confirmation(self, action: str) -> str | None:
+        """Request confirmation for an action. Returns rejection message or None."""
+        self._confirmation_event.clear()
+        self._confirmation_result = None
+        self._pending_action = action
+        self._app.call_from_thread(self._app.update_content)
+        self._confirmation_event.wait()
+        return self._confirmation_result
+
+    def _complete_confirmation(self, rejection_message: str | None):
+        """Internal method to complete the confirmation process."""
+        self._confirmation_result = rejection_message
+        self._pending_action = None
+        self.display = False
+        self.rejecting = False
+        rejection_input = self.query_one("#rejection-input", TextArea)
+        rejection_input.display = False
+        rejection_input.text = ""
+        rejection_help = self.query_one("#rejection-help", Static)
+        rejection_help.display = False
+        # Reset agent state to RUNNING after confirmation is completed
+        if rejection_message is None:
+            self._app.agent_state = "RUNNING"
+        self._confirmation_event.set()
+        self._app.update_content()
+
+    def on_key(self, event: Key) -> None:
+        if self.rejecting and event.key == "ctrl+d":
+            event.prevent_default()
+            rejection_input = self.query_one("#rejection-input", TextArea)
+            self._complete_confirmation(rejection_input.text)
+            return
+        if not self.rejecting:
+            if event.key == "enter":
+                event.prevent_default()
+                self._complete_confirmation(None)
+            elif event.key == "backspace":
+                event.prevent_default()
+                self.rejecting = True
+                rejection_input = self.query_one("#rejection-input", TextArea)
+                rejection_input.display = True
+                rejection_input.focus()
+                rejection_help = self.query_one("#rejection-help", Static)
+                rejection_help.display = True
+
+
+class AgentApp(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("q", "quit", "Quit"),
+        Binding("y", "yolo", "Switch to YOLO Mode"),
+        Binding("c", "confirm", "Switch to Confirm Mode"),
+    ]
+
+    def __init__(self, model, env, task: str, **kwargs):
+        css_path = os.environ.get(
+            "MSWEA_LOCAL2_STYLE_PATH", str(Path(__file__).parent.parent / "config" / "local2.tcss")
+        )
+        self.__class__.CSS = Path(css_path).read_text()
+        super().__init__()
+        self.agent_state = "UNINITIALIZED"
+        self.agent_task = task
+        self.agent = TextualAgent(self, model=model, env=env, **kwargs)
+        self._i_step = 0
+        self.n_steps = 1
+        self.confirmation_container = ConfirmationPromptContainer(self)
+        self.log_handler = AddLogEmitCallback(lambda record: self.call_from_thread(self.on_log_message_emitted, record))
+        logging.getLogger().addHandler(self.log_handler)
+        self._spinner = Spinner("dots")
+        self.exit_status: str | None = None
+        self.result: str | None = None
+
+    # --- 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:
+            self._i_step = max(0, min(value, self.n_steps - 1))
+            self.query_one(VerticalScroll).scroll_to(y=0, animate=False)
+            self.update_content()
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Container(id="main"):
+            with VerticalScroll():
+                yield Vertical(id="content")
+            yield self.confirmation_container
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.agent_state = "RUNNING"
+        self.update_content()
+        self.set_interval(1 / 8, self._update_headers)
+        threading.Thread(target=lambda: self.agent.run(self.agent_task), daemon=True).start()
+
+    # --- Reacting to events ---
+
+    def on_message_added(self) -> None:
+        vs = self.query_one(VerticalScroll)
+        auto_follow = self.i_step == self.n_steps - 1 and vs.scroll_target_y <= 1
+        self.n_steps = len(_messages_to_steps(self.agent.messages))
+        self.update_content()
+        if auto_follow:
+            self.action_last_step()
+
+    def on_log_message_emitted(self, record: logging.LogRecord) -> None:
+        """Handle log messages of warning level or higher by showing them as notifications."""
+        if record.levelno >= logging.WARNING:
+            self.notify(f"[{record.levelname}] {record.getMessage()}", severity="warning")
+
+    def on_unmount(self) -> None:
+        """Clean up the log handler when the app shuts down."""
+        if hasattr(self, "log_handler"):
+            logging.getLogger().removeHandler(self.log_handler)
+
+    def on_agent_finished(self, exit_status: str, result: str):
+        self.agent_state = "STOPPED"
+        self.notify(f"Agent finished with status: {exit_status}")
+        self.exit_status = exit_status
+        self.result = result
+        self.update_content()
+
+    # --- UI update logic ---
+
+    def update_content(self) -> None:
+        container = self.query_one("#content", Vertical)
+        container.remove_children()
+        items = _messages_to_steps(self.agent.messages)
+
+        if not items:
+            container.mount(Static("Waiting for agent to start..."))
+            return
+
+        for message in items[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"))
+
+        if self.confirmation_container._pending_action is not None:
+            self.agent_state = "AWAITING_CONFIRMATION"
+        self.confirmation_container.display = (
+            self.confirmation_container._pending_action is not None and self.i_step == len(items) - 1
+        )
+        if self.confirmation_container.display:
+            self.confirmation_container.focus()
+
+        self._update_headers()
+        self.refresh()
+
+    def _update_headers(self) -> None:
+        """Update just the title with current state and spinner if needed."""
+        status_text = self.agent_state
+        if self.agent_state == "RUNNING":
+            spinner_frame = str(self._spinner.render(time.time())).strip()
+            status_text = f"{self.agent_state} {spinner_frame}"
+        self.title = f"Step {self.i_step + 1}/{self.n_steps} - {status_text} - Cost: ${self.agent.model.cost:.2f}"
+        try:
+            self.query_one("Header").set_class(self.agent_state == "RUNNING", "running")
+        except NoMatches:  # might be called when shutting down
+            pass
+
+    # --- Textual bindings ---
+
+    def action_yolo(self):
+        self.agent.config.mode = "yolo"
+        self.confirmation_container._complete_confirmation(None)
+        self.notify("YOLO mode enabled - actions will execute immediately")
+
+    def action_confirm(self):
+        self.agent.config.mode = "confirm"
+        self.notify("Confirm mode enabled - actions will require confirmation")
+
+    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_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)

minisweagent/config/README.md

@@ -0,0 +1,9 @@
+# Configs
+
+* `local.yaml` - Default config for `mini`/`agents/interactive.py` or `mini -v`/`agents/interactive_textual.py` agent.
+* `default.yaml` - Default config for the `default.py` agent.
+* `github_issue.yaml` - Config for the `run/github_issue.py` entry point.
+
+## Extras
+
+* `extra/swebench.yaml` - Config for the `run/extra/swebench.py` entry point.

minisweagent/config/__init__.py

@@ -0,0 +1,24 @@
+"""Configuration files and utilities for mini-SWE-agent."""
+
+import os
+from pathlib import Path
+
+builtin_config_dir = Path(__file__).parent
+
+
+def get_config_path(config_spec: str | Path) -> Path:
+    """Get the path to a config file."""
+    candidates = [
+        Path(config_spec),
+        Path(os.getenv("MSWEA_CONFIG_DIR", ".")) / config_spec,
+        builtin_config_dir / config_spec,
+        builtin_config_dir / "extra" / config_spec,
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+
+    raise FileNotFoundError(f"Could not find config file for {config_spec} (tried: {candidates})")
+
+
+__all__ = ["builtin_config_dir", "get_config_path"]

minisweagent/config/default.yaml

@@ -0,0 +1,143 @@
+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.
+    To finish, issue the following command: `echo MINI_SWE_AGENT_FINAL_OUTPUT`
+    without any other command.
+  instance_template: |
+    Please solve this issue: {{task}}
+
+    You can execute bash commands and edit files to implement the necessary changes.
+
+    ## Recommended Workflow
+    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
+
+    ## 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
+    4. To finish, issue the following command: `echo MINI_SWE_AGENT_FINAL_OUTPUT`.
+       Do not combine it with any other command.
+
+    ## 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:
+
+    ```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 MINI_SWE_AGENT_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>
+  step_limit: 0.
+  cost_limit: 0.
+environment:
+  env:
+    PAGER: cat
+    MANPAGER: cat
+    LESS: -R
+    PIP_PROGRESS_BAR: 'off'
+    TQDM_DISABLE: '1'
+model:
+  model_kwargs:
+    temperature: 0.0
+    drop_params: true

minisweagent/config/extra/__init__.py

@@ -0,0 +1 @@
+"""Extra configuration files for mini-SWE-agent."""