feat: add logic to load/save strategy manifest

Author: S1M0N38

src/balatrollm/bot.py

@@ -19,7 +19,7 @@
 )
 from openai.types.chat import ChatCompletion
 
-from .config import Config, load_model_config
+from .config import Config, StrategyManifest, load_model_config
 from .data_collection import ChatCompletionError, ChatCompletionResponse, StatsCollector
 from .strategies import StrategyManager
 
@@ -390,6 +390,13 @@ async def _init_game(self, base_dir: Path = Path.cwd()) -> dict[str, Any]:
         """
         self.data_collector = StatsCollector(self.config, base_dir)
         self.config.to_config_file(self.data_collector.run_dir / "config.json")
+
+        # Load and save strategy manifest
+        strategy_manifest = StrategyManifest.from_manifest_file(self.config.strategy)
+        strategy_manifest.to_strategy_file(
+            self.data_collector.run_dir / "strategy.json"
+        )
+
         logger.info(f"Run data will be saved to: {self.data_collector.run_dir}")
 
         # Set up logging to write to run.log file

src/balatrollm/config.py

@@ -1,7 +1,7 @@
 """Configuration management for BalatroLLM."""
 
 import json
-from dataclasses import asdict, dataclass, field
+from dataclasses import asdict, dataclass
 from pathlib import Path
 from typing import Any
 
@@ -62,12 +62,91 @@ def load_model_config(
     return final_config
 
 
+@dataclass
+class StrategyManifest:
+    """Strategy metadata from manifest.json.
+
+    Stores all metadata for a game strategy including name, description,
+    author, version, and tags.
+
+    Attributes:
+        name: Human-readable strategy name (e.g., 'Default', 'Aggressive').
+        description: Strategy description.
+        author: Strategy author identifier.
+        version: Strategy version (distinct from BalatroLLM version).
+        tags: List of tags for categorization.
+    """
+
+    name: str
+    description: str
+    author: str
+    version: str
+    tags: list[str]
+
+    @classmethod
+    def from_manifest_file(
+        cls, strategy: str, strategies_dir: Path = Path("src/balatrollm/strategies")
+    ) -> "StrategyManifest":
+        """Load strategy metadata from manifest.json.
+
+        Reads the manifest.json file for a given strategy to retrieve metadata.
+
+        Args:
+            strategy: Strategy name (e.g., 'default', 'aggressive')
+            strategies_dir: Base directory containing strategy folders
+
+        Returns:
+            StrategyManifest instance loaded from the JSON file.
+
+        Raises:
+            FileNotFoundError: If manifest.json doesn't exist for the strategy
+            json.JSONDecodeError: If manifest.json is malformed
+            ValueError: If manifest.json is missing required fields
+        """
+        manifest_path = strategies_dir / strategy / "manifest.json"
+        if not manifest_path.exists():
+            raise FileNotFoundError(
+                f"Manifest not found for strategy '{strategy}': {manifest_path}"
+            )
+
+        with manifest_path.open() as f:
+            data = json.load(f)
+
+        # Validate required fields
+        required_fields = {"name", "description", "author", "version", "tags"}
+        missing_fields = required_fields - set(data.keys())
+        if missing_fields:
+            raise ValueError(
+                f"Manifest for strategy '{strategy}' missing required fields: {missing_fields}"
+            )
+
+        return cls(**data)
+
+    def to_strategy_file(self, strategy_path: Path) -> None:
+        """Write strategy metadata to a JSON file.
+
+        Saves the current strategy manifest to a JSON file with proper
+        formatting.
+
+        Args:
+            strategy_path: Path to the strategy file to write.
+        """
+        # Convert dataclass to dictionary
+        strategy_data = asdict(self)
+
+        # Create parent directory if it doesn't exist
+        strategy_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with strategy_path.open("w") as f:
+            json.dump(strategy_data, f, indent=2)
+
+
 @dataclass
 class Config:
     """Configuration for LLMBot.
 
     Stores all configuration parameters for bot execution including
-    model settings, game parameters, and metadata.
+    model settings and game parameters.
 
     Attributes:
         model: LLM model identifier (e.g., 'openai/gpt-oss-20b').
@@ -78,11 +157,7 @@ class Config:
         challenge: Optional challenge mode identifier.
         take_screenshots: Whether to take screenshots during gameplay (default: True).
         use_default_paths: Whether to use BalatroBot's default storage paths (default: False).
-        version: Software version string.
-        name: Human-readable configuration name.
-        description: Configuration description.
-        author: Configuration author identifier.
-        tags: List of tags for categorization.
+        version: BalatroLLM version string (separate from strategy version).
     """
 
     model: str
@@ -94,10 +169,6 @@ class Config:
     take_screenshots: bool = True
     use_default_paths: bool = False
     version: str = __version__
-    name: str = "Unknown Name"
-    description: str = "Unknown Description"
-    author: str = "BalatroBench"
-    tags: list[str] = field(default_factory=list)
 
     @classmethod
     def from_defaults(cls) -> "Config":
@@ -115,11 +186,6 @@ def from_defaults(cls) -> "Config":
             challenge=None,
             take_screenshots=True,
             use_default_paths=False,
-            version="",
-            name="Unknown Name",
-            description="Unknown Description",
-            author="BalatroBench",
-            tags=[],
         )
 
     @classmethod