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

claude_mpm/services/agents/deployment/pipeline/steps/configuration_step.py

@@ -0,0 +1,79 @@
+"""Configuration loading step for deployment pipeline."""
+
+import time
+
+from claude_mpm.core.config import Config
+
+from .base_step import BaseDeploymentStep, StepResult, StepStatus
+
+
+class ConfigurationLoadStep(BaseDeploymentStep):
+    """Step to load and process deployment configuration."""
+
+    def __init__(self):
+        super().__init__(
+            name="Configuration Loading",
+            description="Load and process deployment configuration settings",
+        )
+
+    def execute(self, context) -> StepResult:
+        """Execute configuration loading step.
+
+        Args:
+            context: Pipeline context
+
+        Returns:
+            Result of configuration loading
+        """
+        start_time = time.time()
+
+        try:
+            # Load configuration if not provided
+            if context.config is None:
+                self.logger.debug("Loading default configuration")
+                context.config = Config()
+
+            # Extract excluded agents
+            context.excluded_agents = context.config.get(
+                "agent_deployment.excluded_agents", []
+            )
+
+            # Extract case sensitivity setting
+            context.case_sensitive_exclusion = context.config.get(
+                "agent_deployment.case_sensitive_exclusion", True
+            )
+
+            # Log configuration details
+            self.logger.info(
+                f"Loaded configuration with {len(context.excluded_agents)} excluded agents"
+            )
+            if context.excluded_agents:
+                self.logger.debug(f"Excluded agents: {context.excluded_agents}")
+
+            execution_time = time.time() - start_time
+            context.step_timings[self.name] = execution_time
+
+            return StepResult(
+                status=StepStatus.SUCCESS,
+                message=f"Configuration loaded successfully in {execution_time:.3f}s",
+                execution_time=execution_time,
+            )
+
+        except Exception as e:
+            execution_time = time.time() - start_time
+            context.step_timings[self.name] = execution_time
+
+            error_msg = f"Failed to load configuration: {str(e)}"
+            self.logger.error(error_msg)
+            context.add_error(error_msg)
+
+            return StepResult(
+                status=StepStatus.FAILURE,
+                message=error_msg,
+                error=e,
+                execution_time=execution_time,
+            )
+
+    def can_continue_on_failure(self) -> bool:
+        """Configuration loading failure should stop the pipeline."""
+        return False

claude_mpm/services/agents/deployment/pipeline/steps/target_directory_step.py

@@ -0,0 +1,90 @@
+"""Target directory setup step for deployment pipeline."""
+
+import time
+from pathlib import Path
+
+from .base_step import BaseDeploymentStep, StepResult, StepStatus
+
+
+class TargetDirectorySetupStep(BaseDeploymentStep):
+    """Step to determine and setup the target directory for deployment."""
+
+    def __init__(self):
+        super().__init__(
+            name="Target Directory Setup",
+            description="Determine and create the target directory for agent deployment",
+        )
+
+    def execute(self, context) -> StepResult:
+        """Execute target directory setup step.
+
+        Args:
+            context: Pipeline context
+
+        Returns:
+            Result of target directory setup
+        """
+        start_time = time.time()
+
+        try:
+            # Use strategy to determine target directory
+            if context.strategy:
+                context.actual_target_dir = context.strategy.determine_target_directory(
+                    context  # Pass the context which has the DeploymentContext interface
+                )
+            else:
+                # Fallback logic if no strategy is set
+                if context.target_dir:
+                    context.actual_target_dir = context.target_dir
+                else:
+                    # Default to user's home .claude/agents directory
+                    context.actual_target_dir = Path.home() / ".claude" / "agents"
+
+            # Create target directory if it doesn't exist
+            context.actual_target_dir.mkdir(parents=True, exist_ok=True)
+
+            # Verify directory is writable
+            test_file = context.actual_target_dir / ".write_test"
+            try:
+                test_file.write_text("test")
+                test_file.unlink()
+            except Exception as e:
+                raise PermissionError(
+                    f"Target directory is not writable: {context.actual_target_dir}"
+                )
+
+            self.logger.info(f"Target directory set up: {context.actual_target_dir}")
+
+            execution_time = time.time() - start_time
+            context.step_timings[self.name] = execution_time
+
+            return StepResult(
+                status=StepStatus.SUCCESS,
+                message=f"Target directory set up at {context.actual_target_dir} in {execution_time:.3f}s",
+                execution_time=execution_time,
+            )
+
+        except Exception as e:
+            execution_time = time.time() - start_time
+            context.step_timings[self.name] = execution_time
+
+            error_msg = f"Failed to set up target directory: {str(e)}"
+            self.logger.error(error_msg)
+            context.add_error(error_msg)
+
+            return StepResult(
+                status=StepStatus.FAILURE,
+                message=error_msg,
+                error=e,
+                execution_time=execution_time,
+            )
+
+    def can_continue_on_failure(self) -> bool:
+        """Target directory setup failure should stop the pipeline."""
+        return False
+
+    def get_dependencies(self) -> list:
+        """This step depends on configuration loading."""
+        from .configuration_step import ConfigurationLoadStep
+
+        return [ConfigurationLoadStep]

claude_mpm/services/agents/deployment/pipeline/steps/validation_step.py

@@ -0,0 +1,100 @@
+"""Validation step for deployment pipeline."""
+
+import time
+
+from claude_mpm.services.agents.deployment.validation import DeploymentValidator
+
+from .base_step import BaseDeploymentStep, StepResult, StepStatus
+
+
+class ValidationStep(BaseDeploymentStep):
+    """Step to validate deployment context and templates."""
+
+    def __init__(self):
+        super().__init__(
+            name="Validation",
+            description="Validate deployment environment, templates, and configuration",
+        )
+        self.validator = DeploymentValidator()
+
+    def execute(self, context) -> StepResult:
+        """Execute validation step.
+
+        Args:
+            context: Pipeline context
+
+        Returns:
+            Result of validation
+        """
+        start_time = time.time()
+
+        try:
+            # Validate deployment context
+            validation_result = self.validator.validate_deployment_context(context)
+
+            # Update context with validation results
+            if not validation_result.is_valid:
+                for error in validation_result.errors:
+                    context.add_error(str(error))
+
+            for warning in validation_result.warnings:
+                context.add_warning(str(warning))
+
+            # Store validation metadata
+            context.results["validation"] = validation_result.to_dict()
+
+            # Calculate execution time
+            execution_time = time.time() - start_time
+            context.step_timings[self.name] = execution_time
+
+            # Determine step status
+            if not validation_result.is_valid:
+                status = StepStatus.FAILURE
+                message = f"Validation failed with {validation_result.error_count} errors in {execution_time:.3f}s"
+            elif validation_result.has_warnings:
+                status = StepStatus.WARNING
+                message = f"Validation completed with {validation_result.warning_count} warnings in {execution_time:.3f}s"
+            else:
+                status = StepStatus.SUCCESS
+                message = f"Validation passed successfully in {execution_time:.3f}s"
+
+            self.logger.info(message)
+
+            return StepResult(
+                status=status, message=message, execution_time=execution_time
+            )
+
+        except Exception as e:
+            execution_time = time.time() - start_time
+            context.step_timings[self.name] = execution_time
+
+            error_msg = f"Validation step failed: {str(e)}"
+            self.logger.error(error_msg, exc_info=True)
+            context.add_error(error_msg)
+
+            return StepResult(
+                status=StepStatus.FAILURE,
+                message=error_msg,
+                error=e,
+                execution_time=execution_time,
+            )
+
+    def can_continue_on_failure(self) -> bool:
+        """Validation failures should stop the pipeline.
+
+        If validation fails, it's not safe to continue with deployment.
+
+        Returns:
+            False - stop pipeline on validation failure
+        """
+        return False
+
+    def get_dependencies(self) -> list:
+        """This step depends on target directory setup.
+
+        Returns:
+            List of required step classes
+        """
+        from .target_directory_step import TargetDirectorySetupStep
+
+        return [TargetDirectorySetupStep]

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

@@ -0,0 +1,15 @@
+"""Agent processing components for deployment.
+
+This module provides classes for processing individual agents during deployment,
+including building, validation, and deployment logic.
+"""
+
+from .agent_deployment_context import AgentDeploymentContext
+from .agent_deployment_result import AgentDeploymentResult
+from .agent_processor import AgentProcessor
+
+__all__ = [
+    "AgentProcessor",
+    "AgentDeploymentContext",
+    "AgentDeploymentResult",
+]

claude_mpm/services/agents/deployment/processors/agent_deployment_context.py

@@ -0,0 +1,98 @@
+"""Agent deployment context for individual agent processing."""
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class AgentDeploymentContext:
+    """Context for deploying a single agent.
+
+    This context contains all the information needed to process
+    and deploy a single agent template.
+    """
+
+    # Agent identification
+    agent_name: str
+    template_file: Path
+    target_file: Path
+
+    # Deployment configuration
+    force_rebuild: bool = False
+    deployment_mode: str = "update"
+
+    # Base agent data
+    base_agent_data: Optional[Dict[str, Any]] = None
+    base_agent_version: Optional[tuple] = None
+
+    # Target directory
+    agents_dir: Path = None
+
+    # Processing flags
+    validate_before_deployment: bool = True
+    collect_metrics: bool = True
+
+    def __post_init__(self):
+        """Post-initialization validation."""
+        if self.agents_dir is None and self.target_file:
+            self.agents_dir = self.target_file.parent
+
+        if self.agent_name is None and self.template_file:
+            self.agent_name = self.template_file.stem
+
+        if self.target_file is None and self.agents_dir and self.agent_name:
+            self.target_file = self.agents_dir / f"{self.agent_name}.md"
+
+    @classmethod
+    def from_template_file(
+        cls,
+        template_file: Path,
+        agents_dir: Path,
+        base_agent_data: Dict[str, Any],
+        base_agent_version: tuple,
+        force_rebuild: bool = False,
+        deployment_mode: str = "update",
+    ) -> "AgentDeploymentContext":
+        """Create context from template file.
+
+        Args:
+            template_file: Agent template file
+            agents_dir: Target agents directory
+            base_agent_data: Base agent data
+            base_agent_version: Base agent version
+            force_rebuild: Whether to force rebuild
+            deployment_mode: Deployment mode
+
+        Returns:
+            AgentDeploymentContext instance
+        """
+        agent_name = template_file.stem
+        target_file = agents_dir / f"{agent_name}.md"
+
+        return cls(
+            agent_name=agent_name,
+            template_file=template_file,
+            target_file=target_file,
+            force_rebuild=force_rebuild,
+            deployment_mode=deployment_mode,
+            base_agent_data=base_agent_data,
+            base_agent_version=base_agent_version,
+            agents_dir=agents_dir,
+        )
+
+    def is_update(self) -> bool:
+        """Check if this is an update (target file exists).
+
+        Returns:
+            True if target file exists
+        """
+        return self.target_file.exists()
+
+    def is_project_deployment(self) -> bool:
+        """Check if this is a project deployment.
+
+        Returns:
+            True if deployment mode is project
+        """
+        return self.deployment_mode == "project"

claude_mpm/services/agents/deployment/processors/agent_deployment_result.py

@@ -0,0 +1,235 @@
+"""Agent deployment result for individual agent processing."""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+class AgentDeploymentStatus(Enum):
+    """Status of agent deployment."""
+
+    DEPLOYED = "deployed"
+    UPDATED = "updated"
+    MIGRATED = "migrated"
+    SKIPPED = "skipped"
+    FAILED = "failed"
+
+
+@dataclass
+class AgentDeploymentResult:
+    """Result of deploying a single agent.
+
+    This class encapsulates the result of processing and deploying
+    a single agent template.
+    """
+
+    # Agent identification
+    agent_name: str
+    template_file: Path
+    target_file: Path
+
+    # Deployment status
+    status: AgentDeploymentStatus
+
+    # Timing information
+    deployment_time_ms: float = 0.0
+    start_time: Optional[float] = None
+    end_time: Optional[float] = None
+
+    # Status details
+    reason: Optional[str] = None
+    error_message: Optional[str] = None
+
+    # Flags
+    was_update: bool = False
+    was_migration: bool = False
+    was_skipped: bool = False
+
+    # Additional metadata
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def deployed(
+        cls,
+        agent_name: str,
+        template_file: Path,
+        target_file: Path,
+        deployment_time_ms: float = 0.0,
+    ) -> "AgentDeploymentResult":
+        """Create a deployed result.
+
+        Args:
+            agent_name: Name of the agent
+            template_file: Template file path
+            target_file: Target file path
+            deployment_time_ms: Deployment time in milliseconds
+
+        Returns:
+            AgentDeploymentResult with deployed status
+        """
+        return cls(
+            agent_name=agent_name,
+            template_file=template_file,
+            target_file=target_file,
+            status=AgentDeploymentStatus.DEPLOYED,
+            deployment_time_ms=deployment_time_ms,
+        )
+
+    @classmethod
+    def updated(
+        cls,
+        agent_name: str,
+        template_file: Path,
+        target_file: Path,
+        deployment_time_ms: float = 0.0,
+        reason: Optional[str] = None,
+    ) -> "AgentDeploymentResult":
+        """Create an updated result.
+
+        Args:
+            agent_name: Name of the agent
+            template_file: Template file path
+            target_file: Target file path
+            deployment_time_ms: Deployment time in milliseconds
+            reason: Reason for update
+
+        Returns:
+            AgentDeploymentResult with updated status
+        """
+        return cls(
+            agent_name=agent_name,
+            template_file=template_file,
+            target_file=target_file,
+            status=AgentDeploymentStatus.UPDATED,
+            deployment_time_ms=deployment_time_ms,
+            reason=reason,
+            was_update=True,
+        )
+
+    @classmethod
+    def migrated(
+        cls,
+        agent_name: str,
+        template_file: Path,
+        target_file: Path,
+        deployment_time_ms: float = 0.0,
+        reason: Optional[str] = None,
+    ) -> "AgentDeploymentResult":
+        """Create a migrated result.
+
+        Args:
+            agent_name: Name of the agent
+            template_file: Template file path
+            target_file: Target file path
+            deployment_time_ms: Deployment time in milliseconds
+            reason: Reason for migration
+
+        Returns:
+            AgentDeploymentResult with migrated status
+        """
+        return cls(
+            agent_name=agent_name,
+            template_file=template_file,
+            target_file=target_file,
+            status=AgentDeploymentStatus.MIGRATED,
+            deployment_time_ms=deployment_time_ms,
+            reason=reason,
+            was_migration=True,
+        )
+
+    @classmethod
+    def skipped(
+        cls,
+        agent_name: str,
+        template_file: Path,
+        target_file: Path,
+        reason: Optional[str] = None,
+    ) -> "AgentDeploymentResult":
+        """Create a skipped result.
+
+        Args:
+            agent_name: Name of the agent
+            template_file: Template file path
+            target_file: Target file path
+            reason: Reason for skipping
+
+        Returns:
+            AgentDeploymentResult with skipped status
+        """
+        return cls(
+            agent_name=agent_name,
+            template_file=template_file,
+            target_file=target_file,
+            status=AgentDeploymentStatus.SKIPPED,
+            reason=reason,
+            was_skipped=True,
+        )
+
+    @classmethod
+    def failed(
+        cls,
+        agent_name: str,
+        template_file: Path,
+        target_file: Path,
+        error_message: str,
+        deployment_time_ms: float = 0.0,
+    ) -> "AgentDeploymentResult":
+        """Create a failed result.
+
+        Args:
+            agent_name: Name of the agent
+            template_file: Template file path
+            target_file: Target file path
+            error_message: Error message
+            deployment_time_ms: Deployment time in milliseconds
+
+        Returns:
+            AgentDeploymentResult with failed status
+        """
+        return cls(
+            agent_name=agent_name,
+            template_file=template_file,
+            target_file=target_file,
+            status=AgentDeploymentStatus.FAILED,
+            deployment_time_ms=deployment_time_ms,
+            error_message=error_message,
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert result to dictionary.
+
+        Returns:
+            Dictionary representation of the result
+        """
+        result = {
+            "name": self.agent_name,
+            "template": str(self.template_file),
+            "target": str(self.target_file),
+            "status": self.status.value,
+            "deployment_time_ms": self.deployment_time_ms,
+        }
+
+        if self.reason:
+            result["reason"] = self.reason
+
+        if self.error_message:
+            result["error"] = self.error_message
+
+        if self.metadata:
+            result["metadata"] = self.metadata
+
+        return result
+
+    def is_successful(self) -> bool:
+        """Check if deployment was successful.
+
+        Returns:
+            True if status is deployed, updated, migrated, or skipped
+        """
+        return self.status in [
+            AgentDeploymentStatus.DEPLOYED,
+            AgentDeploymentStatus.UPDATED,
+            AgentDeploymentStatus.MIGRATED,
+            AgentDeploymentStatus.SKIPPED,
+        ]