claude-mpm 3.9.11__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/services/agents/deployment/config/__init__.py

@@ -0,0 +1,13 @@
+"""Configuration management for agent deployment.
+
+This module provides configuration management specifically for agent deployment,
+including loading, validation, and processing of deployment-specific settings.
+"""
+
+from .deployment_config import DeploymentConfig
+from .deployment_config_manager import DeploymentConfigManager
+
+__all__ = [
+    "DeploymentConfigManager",
+    "DeploymentConfig",
+]

claude_mpm/services/agents/deployment/config/deployment_config.py

@@ -0,0 +1,182 @@
+"""Deployment configuration data class."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class DeploymentConfig:
+    """Configuration for agent deployment operations.
+
+    This class encapsulates all configuration settings related to
+    agent deployment, providing a clean interface for accessing
+    deployment-specific settings.
+    """
+
+    # Agent exclusion settings
+    excluded_agents: List[str] = field(default_factory=list)
+    case_sensitive_exclusion: bool = True
+    user_excluded_agents: List[str] = field(default_factory=list)
+
+    # Deployment behavior settings
+    force_rebuild: bool = False
+    deployment_mode: str = "update"  # "update" or "project"
+    use_async: bool = False
+
+    # Directory settings
+    target_dir: Optional[Path] = None
+    templates_dir: Optional[Path] = None
+    base_agent_path: Optional[Path] = None
+    working_directory: Optional[Path] = None
+
+    # System instructions settings
+    deploy_system_instructions: bool = True
+    deploy_user_instructions: bool = True
+
+    # Validation and repair settings
+    repair_existing_agents: bool = True
+    validate_agents: bool = True
+
+    # Metrics and logging settings
+    collect_metrics: bool = True
+    log_level: str = "INFO"
+
+    # Performance settings
+    max_concurrent_operations: int = 10
+    timeout_seconds: int = 300
+
+    # Environment settings
+    environment: str = "production"  # "development", "testing", "production"
+
+    # Additional settings
+    extra_settings: Dict[str, Any] = field(default_factory=dict)
+
+    def is_development_mode(self) -> bool:
+        """Check if running in development mode.
+
+        Returns:
+            True if in development mode
+        """
+        return self.environment == "development"
+
+    def is_testing_mode(self) -> bool:
+        """Check if running in testing mode.
+
+        Returns:
+            True if in testing mode
+        """
+        return self.environment == "testing"
+
+    def is_production_mode(self) -> bool:
+        """Check if running in production mode.
+
+        Returns:
+            True if in production mode
+        """
+        return self.environment == "production"
+
+    def should_exclude_agent(self, agent_name: str) -> bool:
+        """Check if an agent should be excluded from deployment.
+
+        Args:
+            agent_name: Name of the agent to check
+
+        Returns:
+            True if the agent should be excluded
+        """
+        if self.case_sensitive_exclusion:
+            return agent_name in self.excluded_agents
+        else:
+            return agent_name.lower() in [name.lower() for name in self.excluded_agents]
+
+    def get_effective_excluded_agents(self) -> List[str]:
+        """Get the effective list of excluded agents.
+
+        Combines regular excluded agents with user-specific exclusions.
+
+        Returns:
+            List of all excluded agent names
+        """
+        all_excluded = self.excluded_agents.copy()
+        all_excluded.extend(self.user_excluded_agents)
+        return list(set(all_excluded))  # Remove duplicates
+
+    def merge_with_dict(self, config_dict: Dict[str, Any]) -> "DeploymentConfig":
+        """Merge this config with a dictionary of settings.
+
+        Args:
+            config_dict: Dictionary of configuration settings
+
+        Returns:
+            New DeploymentConfig with merged settings
+        """
+        # Create a copy of current config
+        new_config = DeploymentConfig(
+            excluded_agents=self.excluded_agents.copy(),
+            case_sensitive_exclusion=self.case_sensitive_exclusion,
+            user_excluded_agents=self.user_excluded_agents.copy(),
+            force_rebuild=self.force_rebuild,
+            deployment_mode=self.deployment_mode,
+            use_async=self.use_async,
+            target_dir=self.target_dir,
+            templates_dir=self.templates_dir,
+            base_agent_path=self.base_agent_path,
+            working_directory=self.working_directory,
+            deploy_system_instructions=self.deploy_system_instructions,
+            deploy_user_instructions=self.deploy_user_instructions,
+            repair_existing_agents=self.repair_existing_agents,
+            validate_agents=self.validate_agents,
+            collect_metrics=self.collect_metrics,
+            log_level=self.log_level,
+            max_concurrent_operations=self.max_concurrent_operations,
+            timeout_seconds=self.timeout_seconds,
+            environment=self.environment,
+            extra_settings=self.extra_settings.copy(),
+        )
+
+        # Update with values from dictionary
+        for key, value in config_dict.items():
+            if hasattr(new_config, key):
+                setattr(new_config, key, value)
+            else:
+                new_config.extra_settings[key] = value
+
+        return new_config
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert configuration to dictionary.
+
+        Returns:
+            Dictionary representation of the configuration
+        """
+        result = {
+            "excluded_agents": self.excluded_agents,
+            "case_sensitive_exclusion": self.case_sensitive_exclusion,
+            "user_excluded_agents": self.user_excluded_agents,
+            "force_rebuild": self.force_rebuild,
+            "deployment_mode": self.deployment_mode,
+            "use_async": self.use_async,
+            "target_dir": str(self.target_dir) if self.target_dir else None,
+            "templates_dir": str(self.templates_dir) if self.templates_dir else None,
+            "base_agent_path": str(self.base_agent_path)
+            if self.base_agent_path
+            else None,
+            "working_directory": str(self.working_directory)
+            if self.working_directory
+            else None,
+            "deploy_system_instructions": self.deploy_system_instructions,
+            "deploy_user_instructions": self.deploy_user_instructions,
+            "repair_existing_agents": self.repair_existing_agents,
+            "validate_agents": self.validate_agents,
+            "collect_metrics": self.collect_metrics,
+            "log_level": self.log_level,
+            "max_concurrent_operations": self.max_concurrent_operations,
+            "timeout_seconds": self.timeout_seconds,
+            "environment": self.environment,
+        }
+
+        # Add extra settings
+        result.update(self.extra_settings)
+
+        return result

claude_mpm/services/agents/deployment/config/deployment_config_manager.py

@@ -0,0 +1,200 @@
+"""Deployment configuration manager."""
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from claude_mpm.core.config import Config
+from claude_mpm.core.logger import get_logger
+
+from .deployment_config import DeploymentConfig
+
+
+class DeploymentConfigManager:
+    """Manager for deployment configuration.
+
+    This class handles loading, processing, and validation of
+    deployment-specific configuration settings.
+    """
+
+    def __init__(self):
+        """Initialize the deployment configuration manager."""
+        self.logger = get_logger(__name__)
+
+    def load_deployment_config(
+        self, config: Optional[Config] = None, **overrides
+    ) -> DeploymentConfig:
+        """Load deployment configuration from various sources.
+
+        Args:
+            config: Optional Config object to load from
+            **overrides: Configuration overrides
+
+        Returns:
+            DeploymentConfig object with loaded settings
+        """
+        # Start with default configuration
+        deployment_config = DeploymentConfig()
+
+        # Load from Config object if provided
+        if config:
+            config_dict = self._extract_deployment_config(config)
+            deployment_config = deployment_config.merge_with_dict(config_dict)
+
+        # Apply overrides
+        if overrides:
+            deployment_config = deployment_config.merge_with_dict(overrides)
+
+        # Validate configuration
+        self._validate_config(deployment_config)
+
+        self.logger.debug(
+            f"Loaded deployment configuration: {deployment_config.environment} mode"
+        )
+        return deployment_config
+
+    def _extract_deployment_config(self, config: Config) -> Dict[str, Any]:
+        """Extract deployment-specific configuration from Config object.
+
+        Args:
+            config: Config object to extract from
+
+        Returns:
+            Dictionary of deployment configuration settings
+        """
+        config_dict = {}
+
+        # Extract agent deployment settings
+        config_dict["excluded_agents"] = config.get(
+            "agent_deployment.excluded_agents", []
+        )
+        config_dict["case_sensitive_exclusion"] = config.get(
+            "agent_deployment.case_sensitive_exclusion", True
+        )
+        config_dict["user_excluded_agents"] = config.get(
+            "agent_deployment.user_excluded_agents", []
+        )
+
+        # Extract system instruction settings
+        config_dict["deploy_system_instructions"] = config.get(
+            "agent_deployment.deploy_system_instructions", True
+        )
+        config_dict["deploy_user_instructions"] = config.get(
+            "agent_deployment.deploy_user_instructions", True
+        )
+
+        # Extract validation settings
+        config_dict["repair_existing_agents"] = config.get(
+            "agent_deployment.repair_existing_agents", True
+        )
+        config_dict["validate_agents"] = config.get(
+            "agent_deployment.validate_agents", True
+        )
+
+        # Extract performance settings
+        config_dict["use_async"] = config.get("agent_deployment.use_async", False)
+        config_dict["max_concurrent_operations"] = config.get(
+            "agent_deployment.max_concurrent_operations", 10
+        )
+        config_dict["timeout_seconds"] = config.get(
+            "agent_deployment.timeout_seconds", 300
+        )
+
+        # Extract environment settings
+        config_dict["environment"] = config.get("environment", "production")
+        config_dict["log_level"] = config.get("logging.level", "INFO")
+
+        # Extract metrics settings
+        config_dict["collect_metrics"] = config.get(
+            "agent_deployment.collect_metrics", True
+        )
+
+        return config_dict
+
+    def _validate_config(self, config: DeploymentConfig) -> None:
+        """Validate deployment configuration.
+
+        Args:
+            config: Configuration to validate
+
+        Raises:
+            ValueError: If configuration is invalid
+        """
+        # Validate deployment mode
+        valid_modes = ["update", "project"]
+        if config.deployment_mode not in valid_modes:
+            raise ValueError(
+                f"Invalid deployment mode: {config.deployment_mode}. Must be one of: {valid_modes}"
+            )
+
+        # Validate environment
+        valid_environments = ["development", "testing", "production"]
+        if config.environment not in valid_environments:
+            raise ValueError(
+                f"Invalid environment: {config.environment}. Must be one of: {valid_environments}"
+            )
+
+        # Validate paths if provided
+        if config.target_dir and not isinstance(config.target_dir, Path):
+            try:
+                config.target_dir = Path(config.target_dir)
+            except Exception as e:
+                raise ValueError(f"Invalid target_dir path: {config.target_dir}") from e
+
+        if config.templates_dir and not isinstance(config.templates_dir, Path):
+            try:
+                config.templates_dir = Path(config.templates_dir)
+            except Exception as e:
+                raise ValueError(
+                    f"Invalid templates_dir path: {config.templates_dir}"
+                ) from e
+
+        if config.base_agent_path and not isinstance(config.base_agent_path, Path):
+            try:
+                config.base_agent_path = Path(config.base_agent_path)
+            except Exception as e:
+                raise ValueError(
+                    f"Invalid base_agent_path: {config.base_agent_path}"
+                ) from e
+
+        if config.working_directory and not isinstance(config.working_directory, Path):
+            try:
+                config.working_directory = Path(config.working_directory)
+            except Exception as e:
+                raise ValueError(
+                    f"Invalid working_directory path: {config.working_directory}"
+                ) from e
+
+        # Validate numeric settings
+        if config.max_concurrent_operations <= 0:
+            raise ValueError("max_concurrent_operations must be positive")
+
+        if config.timeout_seconds <= 0:
+            raise ValueError("timeout_seconds must be positive")
+
+        self.logger.debug("Configuration validation passed")
+
+    def create_config_from_context(self, context) -> DeploymentConfig:
+        """Create deployment config from pipeline context.
+
+        Args:
+            context: Pipeline context or deployment context
+
+        Returns:
+            DeploymentConfig object
+        """
+        config_dict = {
+            "target_dir": getattr(context, "target_dir", None),
+            "force_rebuild": getattr(context, "force_rebuild", False),
+            "deployment_mode": getattr(context, "deployment_mode", "update"),
+            "use_async": getattr(context, "use_async", False),
+            "working_directory": getattr(context, "working_directory", None),
+            "templates_dir": getattr(context, "templates_dir", None),
+            "base_agent_path": getattr(context, "base_agent_path", None),
+        }
+
+        # Remove None values
+        config_dict = {k: v for k, v in config_dict.items() if v is not None}
+
+        return self.load_deployment_config(
+            config=getattr(context, "config", None), **config_dict
+        )

claude_mpm/services/agents/deployment/deployment_config_loader.py

@@ -0,0 +1,54 @@
+"""Deployment configuration loading for agent deployment service.
+
+This module handles loading and processing of deployment configuration.
+Extracted from AgentDeploymentService to reduce complexity and improve maintainability.
+"""
+
+import logging
+from typing import Optional, Tuple
+
+from claude_mpm.core.config import Config
+
+
+class DeploymentConfigLoader:
+    """Handles loading and processing of deployment configuration."""
+
+    def __init__(self, logger: logging.Logger):
+        """Initialize the config loader with a logger."""
+        self.logger = logger
+
+    def load_deployment_config(self, config: Optional[Config]) -> Tuple[Config, list]:
+        """
+        Load and process deployment configuration.
+
+        Centralized configuration loading reduces duplication
+        and ensures consistent handling of exclusion settings.
+
+        Args:
+            config: Optional configuration object
+
+        Returns:
+            Tuple of (config, excluded_agents)
+        """
+        # Load configuration if not provided
+        if config is None:
+            config = Config()
+
+        # Get agent exclusion configuration
+        excluded_agents = config.get("agent_deployment.excluded_agents", [])
+        case_sensitive = config.get("agent_deployment.case_sensitive", False)
+        exclude_dependencies = config.get(
+            "agent_deployment.exclude_dependencies", False
+        )
+
+        # Normalize excluded agents list for comparison
+        if not case_sensitive:
+            excluded_agents = [agent.lower() for agent in excluded_agents]
+
+        # Log exclusion configuration if agents are being excluded
+        if excluded_agents:
+            self.logger.info(f"Excluding agents from deployment: {excluded_agents}")
+            self.logger.debug(f"Case sensitive matching: {case_sensitive}")
+            self.logger.debug(f"Exclude dependencies: {exclude_dependencies}")
+
+        return config, excluded_agents

claude_mpm/services/agents/deployment/deployment_type_detector.py

@@ -0,0 +1,124 @@
+"""Deployment type detection for agent deployment service.
+
+This module provides utilities to detect the type of agent deployment
+(system, project-specific, or user custom) based on template directory paths.
+Extracted from AgentDeploymentService to reduce complexity.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+from claude_mpm.config.paths import paths
+
+
+class DeploymentTypeDetector:
+    """Detects the type of agent deployment based on template directory."""
+
+    @staticmethod
+    def is_system_agent_deployment(templates_dir: Optional[Path]) -> bool:
+        """
+        Check if this is a deployment of system agents.
+
+        System agents are those provided by the claude-mpm package itself,
+        located in the package's agents/templates directory.
+
+        Args:
+            templates_dir: Directory containing agent templates
+
+        Returns:
+            True if deploying system agents, False otherwise
+        """
+        # Check if templates_dir points to the system templates
+        if templates_dir and templates_dir.exists():
+            # System agents are in the package's agents/templates directory
+            try:
+                # Check if templates_dir is within the claude_mpm package structure
+                templates_str = str(templates_dir.resolve())
+                return (
+                    "site-packages/claude_mpm" in templates_str
+                    or "src/claude_mpm/agents/templates" in templates_str
+                    or (paths.agents_dir / "templates").resolve()
+                    == templates_dir.resolve()
+                )
+            except Exception:
+                pass
+        return False
+
+    @staticmethod
+    def is_project_specific_deployment(
+        templates_dir: Optional[Path], working_directory: Path
+    ) -> bool:
+        """
+        Check if deploying project-specific agents.
+
+        Project-specific agents are those found in the project's
+        .claude-mpm/agents/ directory.
+
+        Args:
+            templates_dir: Directory containing agent templates
+            working_directory: Current working directory
+
+        Returns:
+            True if deploying project-specific agents, False otherwise
+        """
+        # Check if we're in a project directory with .claude-mpm/agents
+        project_agents_dir = working_directory / ".claude-mpm" / "agents"
+        if project_agents_dir.exists():
+            # Check if templates_dir points to project agents
+            if templates_dir and templates_dir.exists():
+                try:
+                    return project_agents_dir.resolve() == templates_dir.resolve()
+                except Exception:
+                    pass
+        return False
+
+    @staticmethod
+    def is_user_custom_deployment(templates_dir: Optional[Path]) -> bool:
+        """
+        Check if deploying user custom agents.
+
+        User custom agents are those in ~/.claude-mpm/agents/
+
+        Args:
+            templates_dir: Directory containing agent templates
+
+        Returns:
+            True if deploying user custom agents, False otherwise
+        """
+        user_agents_dir = Path.home() / ".claude-mpm" / "agents"
+        if user_agents_dir.exists():
+            # Check if templates_dir points to user agents
+            if templates_dir and templates_dir.exists():
+                try:
+                    return user_agents_dir.resolve() == templates_dir.resolve()
+                except Exception:
+                    pass
+        return False
+
+    @staticmethod
+    def determine_source_tier(templates_dir: Optional[Path]) -> str:
+        """
+        Determine the source tier for logging.
+
+        Understanding which tier (SYSTEM/USER/PROJECT) agents
+        are being deployed from helps with debugging and auditing.
+
+        Args:
+            templates_dir: Directory containing agent templates
+
+        Returns:
+            Source tier string: "SYSTEM", "USER", or "PROJECT"
+        """
+        if templates_dir:
+            templates_str = str(templates_dir)
+            if (
+                ".claude-mpm/agents" in templates_str
+                and "/templates" not in templates_str
+            ):
+                return "PROJECT"
+            elif (
+                "/.claude-mpm/agents" in templates_str
+                and "/templates" not in templates_str
+            ):
+                return "USER"
+        return "SYSTEM"

claude_mpm/services/agents/deployment/facade/__init__.py

@@ -0,0 +1,18 @@
+"""Deployment facade for handling async/sync deployment modes.
+
+This module provides a clean facade pattern for handling different
+deployment execution modes (async vs sync) without cluttering the
+main deployment logic with conditional complexity.
+"""
+
+from .async_deployment_executor import AsyncDeploymentExecutor
+from .deployment_executor import DeploymentExecutor
+from .deployment_facade import DeploymentFacade
+from .sync_deployment_executor import SyncDeploymentExecutor
+
+__all__ = [
+    "DeploymentExecutor",
+    "DeploymentFacade",
+    "AsyncDeploymentExecutor",
+    "SyncDeploymentExecutor",
+]