Single player mode initial version

Author: klieret

codeclash/agents/abstract.py

@@ -1,4 +1,5 @@
 import os
+import uuid
 from abc import ABC, abstractmethod
 
 from dotenv import load_dotenv
@@ -18,9 +19,11 @@ def __init__(
         config: dict,
         environment: Environment,
         game_context: GameContext,
-    ):
+    ) -> None:
         self.config = config
         self.name = config["name"]
+        self._player_unique_id = uuid.uuid4()
+        """Unique ID that doesn't clash even accross multiple games. Used for git tags."""
         self.environment = environment
         self.game_context = game_context
         self.game_context.render_and_set_prompts()
@@ -29,28 +32,39 @@ def __init__(
             log_path=self.game_context.log_local / f"{self.name}.log",
             emoji="👤",
         )
+        self._metadata = {
+            "name": self.name,
+            "player_unique_id": self._player_unique_id,
+            "diff": {},  # mapping round -> diff
+            "incremental_diff": {},  # mapping round -> diff
+        }
 
-    @property
-    def branch_name(self):
-        """Get the branch name for the agent's codebase."""
-        return f"{self.game_context.id}.{self.name}"
-
-    def commit(self):
-        """Commit changes to the agent's codebase."""
-        r, rounds = self.game_context.round, self.game_context.rounds
-        for cmd in [
-            "git add -A",
-            f"git commit --allow-empty -m 'Round {r}/{rounds} Update'",
-        ]:
-            assert_zero_exit_code(self.environment.execute(cmd), logger=self.logger)
-        self.logger.info(f"Committed changes for {self.name} for round {r}/{rounds}")
+    # --- Main methods ---
 
-    def on_round_update(self, new_round: int):
-        """Update the agent's round to match the game round."""
+    def pre_run_hook(self, *, new_round: int) -> None:
+        """Should be called before we call the run method."""
+        if new_round == 1:
+            self._tag_round(0)
         self.game_context.round = new_round
         self.game_context.render_and_set_prompts()
 
-    def push(self):
+    def post_run_hook(self, *, round: int) -> None:
+        """Should be called after we called the run method."""
+        self._commit()
+        self._metadata["diff"][round] = self._get_round_diff(round)
+        self._metadata["incremental_diff"][round] = self._get_round_diff(
+            round, incremental=True
+        )
+
+    @abstractmethod
+    def run(self) -> None:
+        """Given the observation / recap, update the codebase"""
+
+    def get_metadata(self) -> dict:
+        """Get metadata for the agent."""
+        return self._metadata
+
+    def push(self) -> None:
         """Push codebase to a branch on the game's remote repository."""
         token = os.getenv("GITHUB_TOKEN")
         if not token:
@@ -59,13 +73,61 @@ def push(self):
         for cmd in [
             "git remote remove origin",
             f"git remote add origin https://x-access-token:{token}@github.com/{GH_ORG}/{self.game_context.name}.git",
-            f"git push origin {self.branch_name}",
+            f"git push origin {self._branch_name}",
+            "git push origin --tags",
         ]:
             assert_zero_exit_code(self.environment.execute(cmd), logger=self.logger)
         self.logger.info(
-            f"Pushed {self.name} commit history to remote repository (branch {self.branch_name})"
+            f"Pushed {self.name} commit history to remote repository (branch {self._branch_name})"
         )
 
-    @abstractmethod
-    def run(self):
-        """Given the observation / recap, update the codebase"""
+    # --- Helper methods ---
+
+    def _tag_round(self, round: int) -> None:
+        """Git tag the codebase at the given round."""
+        assert_zero_exit_code(
+            self.environment.execute(
+                f"git tag -a {self._get_round_tag_name(round)} -m 'Round {round} Update'"
+            ),
+            logger=self.logger,
+        )
+
+    @property
+    def _branch_name(self) -> str:
+        """Get the branch name for the agent's codebase."""
+        return f"{self.game_context.id}.{self.name}"
+
+    def _get_round_tag_name(self, round: int) -> str:
+        """Get git tag name for the version of the codebase at the given round."""
+        return f"{self._player_unique_id}-round-{round}"
+
+    def _commit(self) -> None:
+        """Commit changes to the agent's codebase."""
+        r = self.game_context.round
+        for cmd in [
+            "git add -A",
+            f"git commit --allow-empty -m 'Round {r} Update'",
+        ]:
+            assert_zero_exit_code(self.environment.execute(cmd), logger=self.logger)
+        self._tag_round(r)
+        self.logger.info(f"Committed changes for {self.name} for round {r}")
+
+    def _get_round_diff(self, round: int, *, incremental: bool = False) -> str:
+        """Get the diff between the round and initial version (round 0).
+        If incremental is True, get the diff between the round and the previous round.
+        Returns empty string if round is 0.
+        """
+        if round == 0:
+            return ""
+        if incremental:
+            previous_round_tag = self._get_round_tag_name(round - 1)
+        else:
+            previous_round_tag = self._get_round_tag_name(0)
+        current_round_tag = self._get_round_tag_name(round)
+        out = assert_zero_exit_code(
+            self.environment.execute(
+                f"git diff {previous_round_tag}..{current_round_tag}"
+            ),
+            logger=self.logger,
+        )
+        return out["output"]

codeclash/agents/dummy.py

@@ -5,4 +5,5 @@ class Dummy(Player):
     """A dummy player that does nothing. Mainly for testing purposes."""
 
     def run(self):
-        self.commit()
+        pass
+        # self.commit()  # now called in post_round_hook

codeclash/agents/minisweagent.py

@@ -110,4 +110,4 @@ def run(self):
                 traj_path,
                 self.game_context.log_env / traj_path.name,
             )
-            self.commit()
+            # self.commit()  # now called in post_round_hook

codeclash/games/abstract.py

@@ -41,7 +41,7 @@ def __init__(self, config: dict):
             self.name, log_path=self.log_local / "game.log", emoji="🏓"
         )
         self.environment: DockerEnvironment = self.get_environment()
-        assert len(config["players"]) >= 2, "At least two players are required"
+        # assert len(config["players"]) >= 2, "At least two players are required"
 
     @property
     def image_name(self) -> str:
@@ -124,9 +124,6 @@ def _pre_round_setup(self, agents: list[Player]):
         """Copy agent codebases into game's container and make round log file"""
         self.round += 1
         # Notify agents of round update
-        for agent in agents:
-            if hasattr(agent, "on_round_update"):
-                agent.on_round_update(self.round)
         self.logger.info(f"▶️ Running {self.name} round {self.round}...")
 
         # Copy agent codebases into game's container

codeclash/utils/environment.py

@@ -113,3 +113,23 @@ def copy_file_from_container(
             f"Failed to copy {container.container_id}:{src_path} to {dest_path}: {result.stdout}{result.stderr}"
         )
     return result
+
+
+def create_file_on_container(
+    container: DockerEnvironment,
+    *,
+    content: str,
+    dest_path: str | Path,
+):
+    """
+    Create a file with given content on a Docker container.
+    Uses a temporary file on the local filesystem for the transfer.
+    """
+    with tempfile.NamedTemporaryFile(mode="w", delete=False) as tmp_file:
+        tmp_file.write(content)
+        tmp_file_path = Path(tmp_file.name)
+
+    try:
+        copy_file_to_container(container, tmp_file_path, dest_path)
+    finally:
+        tmp_file_path.unlink()  # Clean up the temporary file

configs/battlesnake_single_player.yaml

@@ -0,0 +1,23 @@
+game:
+  name: BattleSnake
+  rounds: 5
+  args:
+    width: 11
+    height: 11
+    browser: false
+player:
+  agent: mini
+  config: configs/mini/default.yaml
+  model: openai/gpt-5-mini
+  name: main
+prompts:
+  game_description: |
+    You are a software developer ({{player_id}}) competing in a coding game called BattleSnake.
+    Your bot (`main.py`) controls a snake on a grid-based board.
+    Snakes collect food, avoid collisions, and try to outlast their opponents.
+
+    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 `main.py`, located in {{working_dir}}.
+    {{working_dir}} is your codebase, which contains both your bot and supporting assets.

configs/mini/default.yaml

@@ -1,6 +1,11 @@
 agent:
   system_template: |
-    You are a helpful assistant editing a codebase to play a programming game.
+    You are a helpful assistant interacting continuously with a computer by submitting commands.
+    You'll be editing a codebase to play a programming game.
+
+    <important>
+    This is an interactive process where you will think and issue ONE command, see its result, then think and issue your next command.
+    </important>
 
     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.
@@ -142,8 +147,8 @@ agent:
 
     Note: In rare cases, if you need to reference a similar format in your command, you might have
     to proceed in two steps, first writing TRIPLEBACKTICKSBASH, then replacing them with ```bash.
-  step_limit: 0.
-  cost_limit: 0.
+  step_limit: 30
+  cost_limit: 1.
 environment:
   env:
     PAGER: cat

main.py

@@ -17,10 +17,12 @@ def main(config_path: str, cleanup: bool = False, push_agent: bool = False):
         agents.append(get_agent(agent_conf, config["prompts"], game))
 
     try:
-        for _ in range(game.rounds):
+        for round in range(1, game.rounds + 1):
             game.run_round(agents)
             for agent in agents:
+                agent.pre_run_hook(new_round=round)
                 agent.run()
+                agent.post_run_hook(round=round)
     finally:
         game.end(cleanup)
         if push_agent: