Add Huskybench basic scaffolding

Author: john-b-yang

codeclash/games/__init__.py

@@ -5,6 +5,7 @@
 from codeclash.games.corewar.corewar import CoreWarGame
 from codeclash.games.dummy.dummy_game import DummyGame
 from codeclash.games.game import CodeGame
+from codeclash.games.huskybench.huskybench import HuskyBenchGame
 from codeclash.games.robocode.robocode import RoboCodeGame
 from codeclash.games.robotrumble.robotrumble import RobotRumbleGame
 
@@ -18,6 +19,7 @@ def get_game(config: dict, *, tournament_id: str, local_output_dir: Path) -> Cod
             BattleSnakeGame,
             CoreWarGame,
             DummyGame,
+            HuskyBenchGame,
             RoboCodeGame,
             RobotRumbleGame,
         ]

codeclash/games/dummy/main.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+
+from codeclash.agents.player import Player
+from codeclash.games.game import CodeGame, RoundData, RoundStats
+
+
+class HuskyBenchGame(CodeGame):
+    name: str = "HuskyBench"
+
+    def __init__(self, config, *, tournament_id: str, local_output_dir: Path):
+        super().__init__(config, tournament_id=tournament_id, local_output_dir=local_output_dir)
+        self.run_cmd_round: str = (
+            f"python engine/main.py --port 8000 --sim --sim-rounds {self.game_config['sims_per_round']}"
+        )
+        for arg, val in self.game_config.get("args", {}).items():
+            if isinstance(val, bool):
+                if val:
+                    self.run_cmd_round += f" --{arg}"
+            else:
+                self.run_cmd_round += f" --{arg} {val}"
+
+    def get_stats(self, result_outputs: list[str], agents: list[Player]) -> RoundStats:
+        return RoundStats(winner="N/A", scores={})
+
+    def execute_round(self, agents: list[Player]) -> RoundData:
+        try:
+            self.logger.debug("Starting game servers")
+            self.environment.execute(self.run_cmd_round + " > engine/output/std_out.log &")
+            for agent in agents:
+                self.environment.execute("python client/main.py --port 8000 &", cwd=f"/{agent.name}")
+
+            # Save logs to response
+            self.logger.info(self.environment.execute("cat engine/output/std_out.log")["output"])
+
+            return RoundData(logs=[], results=[])
+        finally:
+            # Kill all python servers when done
+            self.environment.execute("pkill -f 'python client/main.py' || true")
+            self.environment.execute("pkill -f 'python engine/main.py' || true")

codeclash/games/huskybench/huskybench.py

@@ -16,10 +16,10 @@
 
 
 class PvpTournament(AbstractTournament):
-    def __init__(self, config: dict, *, cleanup: bool = False, push_agent: bool = False):
+    def __init__(self, config: dict, *, cleanup: bool = False, push: bool = False):
         super().__init__(config, name="PvpTournament")
         self.cleanup_on_end = cleanup
-        self.push_agent = push_agent
+        self.push = push
         self.game: CodeGame = get_game(
             self.config,
             tournament_id=self.tournament_id,
@@ -124,6 +124,6 @@ def end(self) -> None:
         """Save output files, clean up game resources and push agents if requested."""
         (self.local_output_dir / "metadata.json").write_text(json.dumps(self.get_metadata(), indent=2))
         self.game.end(self.cleanup_on_end)
-        if self.push_agent:
+        if self.push:
             for agent in self.agents:
                 agent.push()

codeclash/tournaments/pvp.py

@@ -0,0 +1,21 @@
+tournament:
+  rounds: 3
+game:
+  name: HuskyBench
+  sims_per_round: 1
+players:
+- agent: dummy
+  name: p1
+- agent: dummy
+  name: p2
+prompts:
+  game_description: |
+    You are a software developer ({{player_id}}) competing in a coding game called CoreWar.
+    CoreWar is a programming battle where you write "warriors" in an assembly-like language called Redcode to compete within a virtual machine (MARS), aiming to eliminate your rivals by making their code self-terminate.
+    Victory comes from crafting clever tactics—replicators, scanners, bombers—that exploit memory layout and instruction timing to control the core.
+
+    The game is played in {{rounds}} rounds. For every round, you (and your competitor) edit program code that controls your bot. This is round {{round}}.
+    After you and your competitor finish editing your codebases, the game is run automatically.
+
+    Your task: improve the bot in `warriors/warrior.red`, located in {{working_dir}}.
+    {{working_dir}} is your codebase, which contains both your bot and supporting assets.

configs/test/dummy_huskybench.yaml

@@ -0,0 +1,22 @@
+FROM python:3.10-slim
+
+ARG DEBIAN_FRONTEND=noninteractive
+ENV TZ=Etc/UTC
+
+RUN apt update && apt install -y \
+wget \
+git \
+build-essential \
+unzip \
+&& rm -rf /var/lib/apt/lists/*
+
+ARG GITHUB_TOKEN
+RUN git clone https://${GITHUB_TOKEN}@github.com/emagedoc/HuskyBench.git /testbed \
+    && cd /testbed \
+    && git remote set-url origin https://github.com/emagedoc/HuskyBench.git \
+    && unset GITHUB_TOKEN
+
+WORKDIR /testbed
+
+RUN pip install -r engine/requirements.txt
+RUN mkdir -p /testbed/engine/output

docker/HuskyBench.Dockerfile

@@ -8,11 +8,11 @@
 from codeclash.utils.yaml_utils import resolve_includes
 
 
-def main(config_path: Path, *, cleanup: bool = False, push_agent: bool = False):
+def main(config_path: Path, *, cleanup: bool = False, push: bool = False):
     yaml_content = config_path.read_text()
     preprocessed_yaml = resolve_includes(yaml_content, base_dir=CONFIG_DIR)
     config = yaml.safe_load(preprocessed_yaml)
-    training = PvpTournament(config, cleanup=cleanup, push_agent=push_agent)
+    training = PvpTournament(config, cleanup=cleanup, push=push)
     training.run()
 
 
@@ -31,7 +31,7 @@ def main_cli(argv: list[str] | None = None):
     )
     parser.add_argument(
         "-p",
-        "--push_agent",
+        "--push",
         action="store_true",
         help="If set, push each agent's codebase to a new repository after running.",
     )