refactor: rename driver to image, first pass

mcontainer/config.py

@@ -1,29 +1,30 @@
-import yaml
 from pathlib import Path
 from typing import Dict, Optional
 
-from .models import Config, Driver
+import yaml
+
+from .models import Config, Image
 
 DEFAULT_CONFIG_DIR = Path.home() / ".config" / "mc"
 DEFAULT_CONFIG_FILE = DEFAULT_CONFIG_DIR / "config.yaml"
-DEFAULT_DRIVERS_DIR = Path.home() / ".config" / "mc" / "drivers"
+DEFAULT_IMAGES_DIR = Path.home() / ".config" / "mc" / "images"
 PROJECT_ROOT = Path(__file__).parent.parent
-BUILTIN_DRIVERS_DIR = Path(__file__).parent / "drivers"  # mcontainer/drivers
+BUILTIN_IMAGES_DIR = Path(__file__).parent / "images"  # mcontainer/images
 
-# Dynamically loaded from drivers directory at runtime
-DEFAULT_DRIVERS = {}
+# Dynamically loaded from images directory at runtime
+DEFAULT_IMAGES = {}
 
 
 class ConfigManager:
     def __init__(self, config_path: Optional[Path] = None):
         self.config_path = config_path or DEFAULT_CONFIG_FILE
         self.config_dir = self.config_path.parent
-        self.drivers_dir = DEFAULT_DRIVERS_DIR
+        self.images_dir = DEFAULT_IMAGES_DIR
         self.config = self._load_or_create_config()
 
-        # Always load package drivers on initialization
+        # Always load package images on initialization
         # These are separate from the user config
-        self.builtin_drivers = self._load_package_drivers()
+        self.builtin_images = self._load_package_images()
 
     def _load_or_create_config(self) -> Config:
         """Load existing config or create a new one with defaults"""
@@ -38,10 +39,10 @@ class ConfigManager:
                     defaults=config_data.get("defaults", {}),
                 )
 
-                # Add drivers
-                if "drivers" in config_data:
-                    for driver_name, driver_data in config_data["drivers"].items():
-                        config.drivers[driver_name] = Driver.model_validate(driver_data)
+                # Add images
+                if "images" in config_data:
+                    for image_name, image_data in config_data["images"].items():
+                        config.images[image_name] = Image.model_validate(image_data)
 
                 return config
             except Exception as e:
@@ -53,16 +54,16 @@ class ConfigManager:
     def _create_default_config(self) -> Config:
         """Create a default configuration"""
         self.config_dir.mkdir(parents=True, exist_ok=True)
-        self.drivers_dir.mkdir(parents=True, exist_ok=True)
+        self.images_dir.mkdir(parents=True, exist_ok=True)
 
-        # Initial config without drivers
+        # Initial config without images
         config = Config(
             docker={
                 "socket": "/var/run/docker.sock",
                 "network": "mc-network",
             },
             defaults={
-                "driver": "goose",
+                "image": "goose",
             },
         )
 
@@ -83,92 +84,90 @@ class ConfigManager:
         with open(self.config_path, "w") as f:
             yaml.dump(config_dict, f)
 
-    def get_driver(self, name: str) -> Optional[Driver]:
-        """Get a driver by name, checking builtin drivers first, then user-configured ones"""
-        # Check builtin drivers first (package drivers take precedence)
-        if name in self.builtin_drivers:
-            return self.builtin_drivers[name]
-        # If not found, check user-configured drivers
-        return self.config.drivers.get(name)
+    def get_image(self, name: str) -> Optional[Image]:
+        """Get an image by name, checking builtin images first, then user-configured ones"""
+        # Check builtin images first (package images take precedence)
+        if name in self.builtin_images:
+            return self.builtin_images[name]
+        # If not found, check user-configured images
+        return self.config.images.get(name)
 
-    def list_drivers(self) -> Dict[str, Driver]:
-        """List all available drivers (both builtin and user-configured)"""
-        # Start with user config drivers
-        all_drivers = dict(self.config.drivers)
+    def list_images(self) -> Dict[str, Image]:
+        """List all available images (both builtin and user-configured)"""
+        # Start with user config images
+        all_images = dict(self.config.images)
 
-        # Add builtin drivers, overriding any user drivers with the same name
-        # This ensures that package-provided drivers always take precedence
-        all_drivers.update(self.builtin_drivers)
+        # Add builtin images, overriding any user images with the same name
+        # This ensures that package-provided images always take precedence
+        all_images.update(self.builtin_images)
 
-        return all_drivers
+        return all_images
 
     # Session management has been moved to SessionManager in session.py
 
-    def load_driver_from_dir(self, driver_dir: Path) -> Optional[Driver]:
-        """Load a driver configuration from a directory"""
-        # Try with mc-driver.yaml first (new format), then mai-driver.yaml (legacy)
-        yaml_path = driver_dir / "mc-driver.yaml"
+    def load_image_from_dir(self, image_dir: Path) -> Optional[Image]:
+        """Load an image configuration from a directory"""
+        # Check for image config file
+        yaml_path = image_dir / "mc-image.yaml"
         if not yaml_path.exists():
-            yaml_path = driver_dir / "mai-driver.yaml"  # Backward compatibility
-            if not yaml_path.exists():
-                return None
+            return None
 
         try:
             with open(yaml_path, "r") as f:
-                driver_data = yaml.safe_load(f)
+                image_data = yaml.safe_load(f)
 
             # Extract required fields
             if not all(
-                k in driver_data
+                k in image_data
                 for k in ["name", "description", "version", "maintainer"]
             ):
-                print(f"Driver config {yaml_path} missing required fields")
+                print(f"Image config {yaml_path} missing required fields")
                 return None
 
-            # Use Driver.model_validate to handle all fields from YAML
-            # This will map all fields according to the Driver model structure
+            # Use Image.model_validate to handle all fields from YAML
+            # This will map all fields according to the Image model structure
             try:
                 # Ensure image field is set if not in YAML
-                if "image" not in driver_data:
-                    driver_data["image"] = f"monadical/mc-{driver_data['name']}:latest"
+                if "image" not in image_data:
+                    image_data["image"] = f"monadical/mc-{image_data['name']}:latest"
 
-                driver = Driver.model_validate(driver_data)
-                return driver
+                image = Image.model_validate(image_data)
+                return image
             except Exception as validation_error:
                 print(
-                    f"Error validating driver data from {yaml_path}: {validation_error}"
+                    f"Error validating image data from {yaml_path}: {validation_error}"
                 )
                 return None
 
         except Exception as e:
-            print(f"Error loading driver from {yaml_path}: {e}")
+            print(f"Error loading image from {yaml_path}: {e}")
             return None
 
-    def _load_package_drivers(self) -> Dict[str, Driver]:
-        """Load all package drivers from the mcontainer/drivers directory"""
-        drivers = {}
+    def _load_package_images(self) -> Dict[str, Image]:
+        """Load all package images from the mcontainer/images directory"""
+        images = {}
 
-        if not BUILTIN_DRIVERS_DIR.exists():
-            return drivers
+        if not BUILTIN_IMAGES_DIR.exists():
+            return images
 
-        # Search for mc-driver.yaml files in each subdirectory
-        for driver_dir in BUILTIN_DRIVERS_DIR.iterdir():
-            if driver_dir.is_dir():
-                driver = self.load_driver_from_dir(driver_dir)
-                if driver:
-                    drivers[driver.name] = driver
+        # Search for mc-image.yaml files in each subdirectory
+        for image_dir in BUILTIN_IMAGES_DIR.iterdir():
+            if image_dir.is_dir():
+                image = self.load_image_from_dir(image_dir)
+                if image:
+                    images[image.name] = image
 
-        return drivers
+        return images
 
-    def get_driver_path(self, driver_name: str) -> Optional[Path]:
-        """Get the directory path for a driver"""
-        # Check package drivers first (these are the bundled ones)
-        package_path = BUILTIN_DRIVERS_DIR / driver_name
+    def get_image_path(self, image_name: str) -> Optional[Path]:
+        """Get the directory path for an image"""
+        # Check package images first (these are the bundled ones)
+        package_path = BUILTIN_IMAGES_DIR / image_name
         if package_path.exists() and package_path.is_dir():
             return package_path
 
-        # Then check user drivers
-        user_path = self.drivers_dir / driver_name
+        # Then check user images
+        user_path = self.images_dir / image_name
         if user_path.exists() and user_path.is_dir():
             return user_path