@elizaos/sweagent-root 2.0.0-alpha

package/python/sweagent/run/remove_unfinished.py

@@ -0,0 +1,63 @@
+"""Remove unfinished trajectories."""
+
+import argparse
+import shutil
+from pathlib import Path
+
+from sweagent.utils.files import load_file
+from sweagent.utils.log import get_logger
+
+logger = get_logger("remove_unfinished")
+
+
+def remove_unfinished(base_dir: Path, dry_run: bool = True) -> None:
+    """Remove unfinished trajectories."""
+    to_remove = []
+    for directory in base_dir.iterdir():
+        if not directory.is_dir():
+            continue
+        if "__" not in directory.name:
+            continue
+        trajs = list(directory.glob("*.traj"))
+        if not trajs:
+            logger.info("No trajectories found in %s", directory)
+            continue
+        if len(trajs) > 1:
+            logger.warning("Found multiple trajectories in %s. Skipping.", directory)
+            continue
+        try:
+            traj = load_file(trajs[0])
+        except Exception as e:
+            logger.warning("Error loading trajectory %s: %s. Adding to remove list.", trajs[0], e)
+            to_remove.append(directory)
+            continue
+        submission = traj.get("info", {}).get("submission", None)
+        if submission is None:
+            logger.warning("No submission found in %s. Adding to remove list.", directory)
+            to_remove.append(directory)
+            continue
+    if dry_run:
+        logger.info("Would remove %d unfinished trajectories.", len(to_remove))
+        for directory in to_remove:
+            logger.info(directory)
+    else:
+        for directory in to_remove:
+            logger.info("Removing %s", directory)
+            shutil.rmtree(directory)
+
+
+def get_cli_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--base_dir", type=Path, help="Base directory", default=Path("."))
+    parser.add_argument("--remove", action="store_true", help="Remove unfinished trajectories")
+    return parser
+
+
+def run_from_cli(args: list[str] | None = None) -> None:
+    cli_parser = get_cli_parser()
+    cli_args = cli_parser.parse_args(args)
+    remove_unfinished(cli_args.base_dir, dry_run=not cli_args.remove)
+
+
+if __name__ == "__main__":
+    run_from_cli()

package/python/sweagent/run/rich_test.py

@@ -0,0 +1,91 @@
+import logging
+import time
+from concurrent.futures import ThreadPoolExecutor
+from random import random
+from threading import Lock
+
+from rich.console import Group
+from rich.live import Live
+from rich.logging import RichHandler
+from rich.progress import (
+    BarColumn,
+    Progress,
+    SpinnerColumn,
+    TaskID,
+    TaskProgressColumn,
+    TextColumn,
+    TimeElapsedColumn,
+    TimeRemainingColumn,
+)
+
+logging.basicConfig(level="NOTSET", handlers=[RichHandler(level="NOTSET")])
+logger = logging.getLogger("rich")
+
+# Lock for thread-safe progress updates
+progress_lock = Lock()
+
+
+class RunBatch:
+    def __init__(self):
+        self.tasks = list(range(10))  # Reduced to 10 tasks for example clarity
+        self._main_progress_bar: Progress | None = None
+        self._task_progress_bar: Progress | None = None
+        self._spinner_tasks: dict[TaskID, TaskID] = {}
+
+    def do_task(self, task_id: TaskID):
+        assert self._main_progress_bar is not None
+        assert self._task_progress_bar is not None
+
+        # Create a spinner for this task
+        with progress_lock:
+            spinner_task_id = self._task_progress_bar.add_task(f"Task {task_id}", total=None)
+
+        logger.info("Starting task %d", task_id)
+        # Startup
+        time.sleep(random() * 4.5)
+        # Work
+        with progress_lock:
+            self._task_progress_bar.update(spinner_task_id, description=f"Task {task_id} (working)")
+        time.sleep(random() * 4.5 + 2)
+        logger.info("Finished task %d", task_id)
+
+        # Remove spinner and update main progress
+        with progress_lock:
+            self._task_progress_bar.remove_task(spinner_task_id)
+            self._main_progress_bar.update(TaskID(0), advance=1)
+
+    def main(self):
+        # Custom progress columns
+        self._main_progress_bar = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            TimeElapsedColumn(),
+            TimeRemainingColumn(),
+        )
+        self._task_progress_bar = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            TimeElapsedColumn(),
+        )
+
+        group = Group(self._main_progress_bar, self._task_progress_bar)
+
+        with Live(group):
+            # Add main progress bar
+            self._main_task_id = self._main_progress_bar.add_task("[cyan]Overall Progress", total=len(self.tasks))
+
+            # Create thread pool and run tasks
+            with ThreadPoolExecutor(max_workers=5) as executor:
+                # Submit all tasks
+                futures = [executor.submit(self.do_task, task_id) for task_id in self.tasks]
+
+                # Wait for all tasks to complete
+                for future in futures:
+                    future.result()
+
+
+if __name__ == "__main__":
+    run_batch = RunBatch()
+    run_batch.main()

package/python/sweagent/run/run.py

@@ -0,0 +1,147 @@
+"""[cyan][bold]Main command line interface for SWE-agent.[/bold][/cyan]
+
+[cyan][bold]=== USAGE ===[/bold][/cyan]
+
+[green]sweagent <command> [options][/green]
+
+Display usage instructions for a specific command:
+
+[green]sweagent <command> [bold]--help[/bold][/green]
+
+[cyan][bold]=== SUBCOMMANDS TO RUN SWE-AGENT ===[/bold][/cyan]
+
+[bold][green]run[/green][/bold] or [bold][green]r[/green][/bold]: Run swe-agent on a single problem statement, for example a github issue.
+[bold][green]run-batch[/green][/bold] or [bold][green]b[/green][/bold]: Run swe-agent on a batch of problem statements, e.g., on SWE-Bench.
+
+[cyan][bold]=== MISC SUBCOMMANDS ===[/bold][/cyan]
+
+[bold][green]merge-preds[/green][/bold]: Merge multiple prediction files into a single file. In most cases
+    [green]run-batch[/green] will already do this, but you can use this to merge predictions
+    from multiple directories.
+[bold][green]inspect[/green][/bold] or [bold][green]i[/green][/bold]: Open a single trajectory file in a terminal-based viewer.
+[bold][green]inspector[/green][/bold] or [bold][green]I[/green][/bold]: Open trajectories in a web-based viewer.
+[bold][green]run-replay[/green][/bold]: Replay a trajectory file or a demo file.
+    This can be useful to fill in environment output when creating demonstrations.
+[bold][green]traj-to-demo[/green][/bold]: Convert a trajectory file to an easy to edit demo file.
+[bold][green]run-api[/green][/bold]: Run swe-agent as a backend for a GUI
+[bold][green]remove-unfinished[/green][/bold] or [bold][green]ru[/green][/bold]: Remove unfinished trajectories
+[bold][green]quick-stats[/green][/bold] or [bold][green]qs[/green][/bold]: Calculate quick stats from a directory of trajectories
+"""
+
+import argparse
+import sys
+
+import rich
+
+
+def get_cli():
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument(
+        "command",
+        choices=[
+            "run",
+            "run-batch",
+            "run-replay",
+            "traj-to-demo",
+            "run-api",
+            "merge-preds",
+            "inspect",
+            "inspector",
+            "r",
+            "b",
+            "i",
+            "I",
+            "extract-pred",
+            "compare-runs",
+            "cr",
+            "remove-unfinished",
+            "ru",
+            "quick-stats",
+            "qs",
+            "shell",
+            "sh",
+        ],
+        nargs="?",
+    )
+    parser.add_argument("-h", "--help", action="store_true", help="Show this help message and exit")
+    return parser
+
+
+def main(args: list[str] | None = None):
+    if args is None:
+        args = sys.argv[1:]
+    cli = get_cli()
+    parsed_args, remaining_args = cli.parse_known_args(args)  # type: ignore
+    command = parsed_args.command
+    show_help = parsed_args.help
+    if show_help:
+        if not command:
+            # Show main help
+            rich.print(__doc__)
+            sys.exit(0)
+        else:
+            # Add to remaining_args
+            remaining_args.append("--help")
+    elif not command:
+        cli.print_help()
+        sys.exit(2)
+    # Defer imports to avoid unnecessary long loading times
+    if command in ["run", "r"]:
+        from sweagent.run.run_single import run_from_cli as run_single_main
+
+        run_single_main(remaining_args)
+    elif command in ["run-batch", "b"]:
+        from sweagent.run.run_batch import run_from_cli as run_batch_main
+
+        run_batch_main(remaining_args)
+    elif command == "run-replay":
+        from sweagent.run.run_replay import run_from_cli as run_replay_main
+
+        run_replay_main(remaining_args)
+    elif command == "traj-to-demo":
+        from sweagent.run.run_traj_to_demo import run_from_cli as convert_traj_to_demo_main
+
+        convert_traj_to_demo_main(remaining_args)
+    elif command == "run-api":
+        from sweagent.api.server import run_from_cli as run_api_main
+
+        run_api_main(remaining_args)
+    elif command == "merge-preds":
+        from sweagent.run.merge_predictions import run_from_cli as merge_predictions_main
+
+        merge_predictions_main(remaining_args)
+    elif command in ["inspector", "I"]:
+        from sweagent.inspector.server import run_from_cli as inspector_main
+
+        inspector_main(remaining_args)
+    elif command in ["inspect", "i"]:
+        from sweagent.run.inspector_cli import main as inspect_main
+
+        inspect_main(remaining_args)
+    elif command == "extract-pred":
+        from sweagent.run.extract_pred import run_from_cli as extract_pred_main
+
+        extract_pred_main(remaining_args)
+    elif command in ["compare-runs", "cr"]:
+        from sweagent.run.compare_runs import run_from_cli as compare_runs_main
+
+        compare_runs_main(remaining_args)
+    elif command in ["remove-unfinished", "ru"]:
+        from sweagent.run.remove_unfinished import run_from_cli as remove_unfinished_main
+
+        remove_unfinished_main(remaining_args)
+    elif command in ["quick-stats", "qs"]:
+        from sweagent.run.quick_stats import run_from_cli as quick_stats_main
+
+        quick_stats_main(remaining_args)
+    elif command in ["shell", "sh"]:
+        from sweagent.run.run_shell import run_from_cli as run_shell_main
+
+        run_shell_main(remaining_args)
+    else:
+        msg = f"Unknown command: {command}"
+        raise ValueError(msg)
+
+
+if __name__ == "__main__":
+    sys.exit(main())