mini-swe-agent 1.17.4__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

minisweagent/run/{extra → benchmarks}/swebench.py

@@ -13,19 +13,17 @@ import traceback
 from pathlib import Path
 
 import typer
-import yaml
-from datasets import load_dataset
 from jinja2 import StrictUndefined, Template
 from rich.live import Live
 
 from minisweagent import Environment
 from minisweagent.agents.default import DefaultAgent
-from minisweagent.config import builtin_config_dir, get_config_path
+from minisweagent.config import builtin_config_dir, get_config_from_spec
 from minisweagent.environments import get_environment
 from minisweagent.models import get_model
-from minisweagent.run.extra.utils.batch_progress import RunBatchProgressManager
-from minisweagent.run.utils.save import save_traj
+from minisweagent.run.benchmarks.utils.batch_progress import RunBatchProgressManager
 from minisweagent.utils.log import add_file_handler, logger
+from minisweagent.utils.serialize import UNSET, recursive_merge
 
 _HELP_TEXT = """Run mini-SWE-agent on SWEBench instances.
 
@@ -34,7 +32,23 @@ More information about the usage: [bold green]https://mini-swe-agent.com/latest/
 [/not dim]
 """
 
-app = typer.Typer(rich_markup_mode="rich", add_completion=False)
+_CONFIG_SPEC_HELP_TEXT = """Path to config files, filenames, or key-value pairs.
+
+[bold red]IMPORTANT:[/bold red] [red]If you set this option, the default config file will not be used.[/red]
+So you need to explicitly set it e.g., with [bold green]-c swebench.yaml <other options>[/bold green]
+
+Multiple configs will be recursively merged.
+
+Examples:
+
+[bold red]-c model.model_kwargs.temperature=0[/bold red] [red]You forgot to add the default config file! See above.[/red]
+
+[bold green]-c swebench.yaml -c model.model_kwargs.temperature=0.5[/bold green]
+
+[bold green]-c swebench.yaml -c agent.max_iterations=50[/bold green]
+"""
+
+DEFAULT_CONFIG_FILE = builtin_config_dir / "benchmarks" / "swebench.yaml"
 
 DATASET_MAPPING = {
     "full": "princeton-nlp/SWE-Bench",
@@ -46,7 +60,7 @@ DATASET_MAPPING = {
     "_test": "klieret/swe-bench-dummy-test-dataset",
 }
 
-
+app = typer.Typer(rich_markup_mode="rich", add_completion=False)
 _OUTPUT_FILE_LOCK = threading.Lock()
 
 
@@ -60,9 +74,7 @@ class ProgressTrackingAgent(DefaultAgent):
 
     def step(self) -> dict:
         """Override step to provide progress updates."""
-        self.progress_manager.update_instance_status(
-            self.instance_id, f"Step {self.model.n_calls + 1:3d} (${self.model.cost:.2f})"
-        )
+        self.progress_manager.update_instance_status(self.instance_id, f"Step {self.n_calls + 1:3d} (${self.cost:.2f})")
         return super().step()
 
 
@@ -81,7 +93,7 @@ def get_sb_environment(config: dict, instance: dict) -> Environment:
     env_config = config.setdefault("environment", {})
     env_config["environment_class"] = env_config.get("environment_class", "docker")
     image_name = get_swebench_docker_image_name(instance)
-    if env_config["environment_class"] == "docker":
+    if env_config["environment_class"] in ["docker", "swerex_modal"]:
         env_config["image"] = image_name
     elif env_config["environment_class"] == "singularity":
         env_config["image"] = "docker://" + image_name
@@ -138,7 +150,9 @@ def process_instance(
     progress_manager.update_instance_status(instance_id, "Pulling/starting docker")
 
     agent = None
-    extra_info = None
+    exit_status = None
+    result = None
+    extra_info = {}
 
     try:
         env = get_sb_environment(config, instance)
@@ -149,21 +163,28 @@ def process_instance(
             instance_id=instance_id,
             **config.get("agent", {}),
         )
-        exit_status, result = agent.run(task)
+        info = agent.run(task)
+        exit_status = info.get("exit_status")
+        result = info.get("submission")
     except Exception as e:
         logger.error(f"Error processing instance {instance_id}: {e}", exc_info=True)
-        exit_status, result = type(e).__name__, str(e)
-        extra_info = {"traceback": traceback.format_exc()}
+        exit_status, result = type(e).__name__, ""
+        extra_info = {"traceback": traceback.format_exc(), "exception_str": str(e)}
     finally:
-        save_traj(
-            agent,
-            instance_dir / f"{instance_id}.traj.json",
-            exit_status=exit_status,
-            result=result,
-            extra_info=extra_info,
-            instance_id=instance_id,
-            print_fct=logger.info,
-        )
+        if agent is not None:
+            traj_path = instance_dir / f"{instance_id}.traj.json"
+            agent.save(
+                traj_path,
+                {
+                    "info": {
+                        "exit_status": exit_status,
+                        "submission": result,
+                        **extra_info,
+                    },
+                    "instance_id": instance_id,
+                },
+            )
+            logger.info(f"Saved trajectory to '{traj_path}'")
         update_preds_file(output_dir / "preds.json", instance_id, model.config.model_name, result)
         progress_manager.on_instance_end(instance_id, exit_status)
 
@@ -199,10 +220,10 @@ def main(
     output: str = typer.Option("", "-o", "--output", help="Output directory", rich_help_panel="Basic"),
     workers: int = typer.Option(1, "-w", "--workers", help="Number of worker threads for parallel processing", rich_help_panel="Basic"),
     model: str | None = typer.Option(None, "-m", "--model", help="Model to use", rich_help_panel="Basic"),
-    model_class: str | None = typer.Option(None, "-c", "--model-class", help="Model class to use (e.g., 'anthropic' or 'minisweagent.models.anthropic.AnthropicModel')", rich_help_panel="Advanced"),
+    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"),
     redo_existing: bool = typer.Option(False, "--redo-existing", help="Redo existing instances", rich_help_panel="Data selection"),
-    config_spec: Path = typer.Option( builtin_config_dir / "extra" / "swebench.yaml", "-c", "--config", help="Path to a config file", rich_help_panel="Basic"),
-    environment_class: str | None = typer.Option( None, "--environment-class", help="Environment type to use. Recommended are docker or singularity", rich_help_panel="Advanced"),
+    config_spec: list[str] = typer.Option([str(DEFAULT_CONFIG_FILE)], "-c", "--config", help=_CONFIG_SPEC_HELP_TEXT, rich_help_panel="Basic"),
+    environment_class: str | None = typer.Option(None, "--environment-class", help="Environment type to use. Recommended are docker or singularity", rich_help_panel="Advanced"),
 ) -> None:
     # fmt: on
     output_path = Path(output)
@@ -210,6 +231,8 @@ def main(
     logger.info(f"Results will be saved to {output_path}")
     add_file_handler(output_path / "minisweagent.log")
 
+    from datasets import load_dataset
+
     dataset_path = DATASET_MAPPING.get(subset, subset)
     logger.info(f"Loading dataset {dataset_path}, split {split}...")
     instances = list(load_dataset(dataset_path, split=split))
@@ -221,15 +244,13 @@ def main(
         instances = [instance for instance in instances if instance["instance_id"] not in existing_instances]
     logger.info(f"Running on {len(instances)} instances...")
 
-    config_path = get_config_path(config_spec)
-    logger.info(f"Loading agent config from '{config_path}'")
-    config = yaml.safe_load(config_path.read_text())
-    if environment_class is not None:
-        config.setdefault("environment", {})["environment_class"] = environment_class
-    if model is not None:
-        config.setdefault("model", {})["model_name"] = model
-    if model_class is not None:
-        config.setdefault("model", {})["model_class"] = model_class
+    logger.info(f"Building agent config from specs: {config_spec}")
+    configs = [get_config_from_spec(spec) for spec in config_spec]
+    configs.append({
+        "environment": {"environment_class": environment_class or UNSET},
+        "model": {"model_name": model or UNSET, "model_class": model_class or UNSET},
+    })
+    config = recursive_merge(*configs)
 
     progress_manager = RunBatchProgressManager(len(instances), output_path / f"exit_statuses_{time.time()}.yaml")
 

minisweagent/run/benchmarks/swebench_single.py

@@ -0,0 +1,89 @@
+"""Run on a single SWE-Bench instance."""
+
+from pathlib import Path
+
+import typer
+from datasets import load_dataset
+
+from minisweagent import global_config_dir
+from minisweagent.agents.interactive import InteractiveAgent
+from minisweagent.config import builtin_config_dir, get_config_from_spec
+from minisweagent.models import get_model
+from minisweagent.run.benchmarks.swebench import (
+    DATASET_MAPPING,
+    get_sb_environment,
+)
+from minisweagent.utils.log import logger
+from minisweagent.utils.serialize import recursive_merge
+
+DEFAULT_OUTPUT_FILE = global_config_dir / "last_swebench_single_run.traj.json"
+DEFAULT_CONFIG_FILE = builtin_config_dir / "benchmarks" / "swebench.yaml"
+
+app = typer.Typer(add_completion=False)
+
+_CONFIG_SPEC_HELP_TEXT = """Path to config files, filenames, or key-value pairs.
+
+[bold red]IMPORTANT:[/bold red] [red]If you set this option, the default config file will not be used.[/red]
+So you need to explicitly set it e.g., with [bold green]-c swebench.yaml <other options>[/bold green]
+
+Multiple configs will be recursively merged.
+
+Examples:
+
+[bold red]-c model.model_kwargs.temperature=0[/bold red] [red]You forgot to add the default config file! See above.[/red]
+
+[bold green]-c swebench.yaml -c model.model_kwargs.temperature=0.5[/bold green]
+
+[bold green]-c swebench.yaml -c agent.mode=yolo[/bold green]
+"""
+
+
+# fmt: off
+@app.command()
+def main(
+    subset: str = typer.Option("lite", "--subset", help="SWEBench subset to use or path to a dataset", rich_help_panel="Data selection"),
+    split: str = typer.Option("dev", "--split", help="Dataset split", rich_help_panel="Data selection"),
+    instance_spec: str = typer.Option(0, "-i", "--instance", help="SWE-Bench instance ID or index", rich_help_panel="Data selection"),
+    model_name: str | None = typer.Option(None, "-m", "--model", help="Model to use", rich_help_panel="Basic"),
+    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"),
+    config_spec: list[str] = typer.Option([str(DEFAULT_CONFIG_FILE)], "-c", "--config", help=_CONFIG_SPEC_HELP_TEXT, rich_help_panel="Basic"),
+    environment_class: str | None = typer.Option(None, "--environment-class", rich_help_panel="Advanced"),
+    exit_immediately: bool = typer.Option( False, "--exit-immediately", help="Exit immediately when the agent wants to finish instead of prompting.", rich_help_panel="Basic"),
+    output: Path = typer.Option(DEFAULT_OUTPUT_FILE, "-o", "--output", help="Output trajectory file", rich_help_panel="Basic"),
+) -> None:
+    # fmt: on
+    """Run on a single SWE-Bench instance."""
+    dataset_path = DATASET_MAPPING.get(subset, subset)
+    logger.info(f"Loading dataset from {dataset_path}, split {split}...")
+    instances = {
+        inst["instance_id"]: inst  # type: ignore
+        for inst in load_dataset(dataset_path, split=split)
+    }
+    if instance_spec.isnumeric():
+        instance_spec = sorted(instances.keys())[int(instance_spec)]
+    instance: dict = instances[instance_spec]  # type: ignore
+
+    logger.info(f"Building agent config from specs: {config_spec}")
+    configs = [get_config_from_spec(spec) for spec in config_spec]
+    configs.append({"agent": {"mode": "yolo"}})
+    if environment_class is not None:
+        configs.append({"environment": {"environment_class": environment_class}})
+    if model_class is not None:
+        configs.append({"model": {"model_class": model_class}})
+    if model_name is not None:
+        configs.append({"model": {"model_name": model_name}})
+    if exit_immediately:
+        configs.append({"agent": {"confirm_exit": False}})
+    config = recursive_merge(*configs)
+
+    env = get_sb_environment(config, instance)
+    agent = InteractiveAgent(
+        get_model(config=config.get("model", {})),
+        env,
+        **config.get("agent", {}),
+    )
+    agent.run(instance["problem_statement"])
+
+
+if __name__ == "__main__":
+    app()

minisweagent/run/{extra → benchmarks}/utils/batch_progress.py

@@ -143,8 +143,8 @@ class RunBatchProgressManager:
             )
 
     def on_instance_end(self, instance_id: str, exit_status: str | None) -> None:
-        self._instances_by_exit_status[exit_status].append(instance_id)
         with self._lock:
+            self._instances_by_exit_status[exit_status].append(instance_id)
             try:
                 self._task_progress_bar.remove_task(self._spinner_tasks[instance_id])
             except KeyError:

minisweagent/run/hello_world.py

@@ -1,3 +1,8 @@
+"""This is the simplest possible example of how to use mini-SWE-agent with python bindings.
+For a more complete example, see mini.py
+"""
+
+import logging
 import os
 from pathlib import Path
 
@@ -23,6 +28,7 @@ def main(
         prompt="What model do you want to use?",
     ),
 ) -> DefaultAgent:
+    logging.basicConfig(level=logging.DEBUG)
     agent = DefaultAgent(
         LitellmModel(model_name=model_name),
         LocalEnvironment(),

minisweagent/run/mini.py

@@ -4,103 +4,94 @@
 # 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.agents.interactive import InteractiveAgent, _multiline_prompt
+from minisweagent.config import builtin_config_dir, get_config_from_spec
 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
+from minisweagent.run.utilities.config import configure_if_first_time
+from minisweagent.utils.serialize import UNSET, recursive_merge
 
-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.
+DEFAULT_CONFIG_FILE = Path(os.getenv("MSWEA_MINI_CONFIG_PATH", builtin_config_dir / "mini.yaml"))
+DEFAULT_OUTPUT_FILE = global_config_dir / "last_mini_run.traj.json"
 
-[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)
+_HELP_TEXT = """Run mini-SWE-agent in your local environment.
 
+[not dim]
 More information about the usage: [bold green]https://mini-swe-agent.com/latest/usage/mini/[/bold green]
 [/not dim]
 """
 
+_CONFIG_SPEC_HELP_TEXT = """Path to config files, filenames, or key-value pairs.
+
+[bold red]IMPORTANT:[/bold red] [red]If you set this option, the default config file will not be used.[/red]
+So you need to explicitly set it e.g., with [bold green]-c mini.yaml <other options>[/bold green]
+
+Multiple configs will be recursively merged.
+
+Examples:
+
+[bold red]-c model.model_kwargs.temperature=0[/bold red] [red]You forgot to add the default config file! See above.[/red]
+
+[bold green]-c mini.yaml -c model.model_kwargs.temperature=0.5[/bold green]
+
+[bold green]-c swebench.yaml agent.mode=yolo[/bold green]
+"""
+
+console = Console(highlight=False)
+app = typer.Typer(rich_markup_mode="rich")
+
 
 # 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_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"),
+    config_spec: list[str] = typer.Option([str(DEFAULT_CONFIG_FILE)], "-c", "--config", help=_CONFIG_SPEC_HELP_TEXT),
+    output: Path | None = typer.Option(DEFAULT_OUTPUT_FILE, "-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())
+
+    # Build the config from the command line arguments
+    console.print(f"Building agent config from specs: [bold green]{config_spec}[/bold green]")
+    configs = [get_config_from_spec(spec) for spec in config_spec]
+    configs.append({
+        "agent": {
+            "mode": "yolo" if yolo else UNSET,
+            "cost_limit": cost_limit or UNSET,
+            "confirm_exit": False if exit_immediately else UNSET,
+            "output_path": output or UNSET,
+        },
+        "model": {
+            "model_class": model_class or UNSET,
+            "model_name": model_name or UNSET,
+        },
+    })
+    config = recursive_merge(*configs)
 
     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>"
-            ),
-        )
+        task = _multiline_prompt()
         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", {}))
+    model = get_model(config=config.get("model", {}))
     env = LocalEnvironment(**config.get("environment", {}))
-
-    # 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]
+    agent = InteractiveAgent(model, env, **config.get("agent", {}))
+    agent.run(task)  # type: ignore[arg-type]
+    if output:
+        console.print(f"Saved trajectory to [bold green]'{output}'[/bold green]")
     return agent
 
 

minisweagent/run/utilities/__init__.py

@@ -0,0 +1 @@
+"""Utility modules for mini-SWE-agent (config management, inspector, etc.)."""

minisweagent/run/{extra → utilities}/config.py

@@ -1,3 +1,5 @@
+#!/usr/bin/env python3
+
 """Utility to manage the global config file.
 
 You can also directly edit the `.env` file in the config directory.

minisweagent/run/{inspector.py → utilities/inspector.py}

@@ -7,36 +7,92 @@ More information about the usage: [bold green] https://mini-swe-agent.com/latest
 
 import json
 import os
+import subprocess
+import tempfile
 from pathlib import Path
 
 import typer
 from rich.text import Text
 from textual.app import App, ComposeResult
 from textual.binding import Binding
+from textual.command import DiscoveryHit, Hit, Hits, Provider
 from textual.containers import Container, Vertical, VerticalScroll
 from textual.widgets import Footer, Header, Static
 
-from minisweagent.agents.interactive_textual import _messages_to_steps
+from minisweagent.models.utils.content_string import get_content_string
+
+
+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:
+        # Start new step with new tool uses
+        if message.get("extra", {}).get("actions") or message.get("role") == "assistant":
+            steps.append(current_step)
+            current_step = [message]
+        else:
+            current_step.append(message)
+    if current_step:
+        steps.append(current_step)
+    return steps
+
 
 app = typer.Typer(rich_markup_mode="rich", add_completion=False)
 
 
+class BindingCommandProvider(Provider):
+    """Provide bindings as commands in the palette."""
+
+    COMMAND_DESCRIPTIONS = {
+        "next_step": "Next step in the current trajectory",
+        "previous_step": "Previous step in the current trajectory",
+        "first_step": "First step in the current trajectory",
+        "last_step": "Last step in the current trajectory",
+        "scroll_down": "Scroll down",
+        "scroll_up": "Scroll up",
+        "next_trajectory": "Next trajectory",
+        "previous_trajectory": "Previous trajectory",
+        "open_in_jless": "Open the current step in jless",
+        "open_in_jless_all": "Open the entire trajectory in jless",
+        "quit": "Quit the inspector",
+    }
+
+    async def discover(self) -> Hits:
+        app = self.app
+        for binding in app.BINDINGS:
+            desc = self.COMMAND_DESCRIPTIONS.get(binding.action, binding.description)
+            yield DiscoveryHit(desc, lambda b=binding: app.run_action(b.action))
+
+    async def search(self, query: str) -> Hits:
+        matcher = self.matcher(query)
+        app = self.app
+        for binding in app.BINDINGS:
+            desc = self.COMMAND_DESCRIPTIONS.get(binding.action, binding.description)
+            score = matcher.match(desc)
+            if score > 0:
+                yield Hit(score, matcher.highlight(desc), lambda b=binding: app.run_action(b.action))
+
+
 class TrajectoryInspector(App):
+    COMMANDS = {BindingCommandProvider}
     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("j,down", "scroll_down", "↓"),
+        Binding("k,up", "scroll_up", "↑"),
+        Binding("L", "next_trajectory", "Traj++"),
+        Binding("H", "previous_trajectory", "Traj--"),
+        Binding("e", "open_in_jless", "Jless"),
+        Binding("E", "open_in_jless_all", "Jless (all)"),
         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")
+            "MSWEA_INSPECTOR_STYLE_PATH", str(Path(__file__).parent.parent.parent / "config" / "inspector.tcss")
         )
         self.__class__.CSS = Path(css_path).read_text()
 
@@ -142,13 +198,10 @@ class TrajectoryInspector(App):
             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"])
+            content_str = get_content_string(message)
             message_container = Vertical(classes="message-container")
             container.mount(message_container)
-            role = message["role"].replace("assistant", "mini-swe-agent")
+            role = message.get("role") or message.get("type") or "unknown"
             message_container.mount(Static(role.upper(), classes="message-header"))
             message_container.mount(Static(Text(content_str, no_wrap=False), classes="message-content"))
 
@@ -186,6 +239,32 @@ class TrajectoryInspector(App):
         vs = self.query_one(VerticalScroll)
         vs.scroll_to(y=vs.scroll_target_y - 15)
 
+    def _open_in_jless(self, path: Path) -> None:
+        """Open file in jless."""
+        with self.suspend():
+            try:
+                subprocess.run(["jless", path])
+            except FileNotFoundError:
+                self.notify("jless not found. Install with: `brew install jless`", severity="error")
+
+    def action_open_in_jless(self) -> None:
+        """Open the current step's messages in jless."""
+        if not self.steps:
+            self.notify("No messages to display", severity="warning")
+            return
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+            json.dump(self.steps[self.i_step], f, indent=2)
+            temp_path = Path(f.name)
+        self._open_in_jless(temp_path)
+        temp_path.unlink()
+
+    def action_open_in_jless_all(self) -> None:
+        """Open the entire trajectory in jless."""
+        if not self.trajectory_files:
+            self.notify("No trajectory to display", severity="warning")
+            return
+        self._open_in_jless(self.trajectory_files[self.i_trajectory])
+
 
 @app.command(help=__doc__)
 def main(

minisweagent/run/{mini_extra.py → utilities/mini_extra.py}

@@ -1,16 +1,20 @@
 #!/usr/bin/env python3
 
+"""This is the central entry point to the mini-extra script. Use subcommands
+to invoke other command line utilities like running on benchmarks, editing config,
+inspecting trajectories, etc.
+"""
+
 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)"),
+    ("minisweagent.run.utilities.config", ["config"], "Manage the global config file"),
+    ("minisweagent.run.utilities.inspector", ["inspect", "i", "inspector"], "Run inspector (browse trajectories)"),
+    ("minisweagent.run.benchmarks.swebench", ["swebench"], "Evaluate on SWE-bench (batch mode)"),
+    ("minisweagent.run.benchmarks.swebench_single", ["swebench-single"], "Evaluate on SWE-bench (single instance)"),
 ]