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

claude_mpm/services/agents/deployment/pipeline/pipeline_context.py

@@ -0,0 +1,159 @@
+"""Pipeline context for deployment operations."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from claude_mpm.core.config import Config
+
+from ..strategies.base_strategy import BaseDeploymentStrategy
+
+
+@dataclass
+class PipelineContext:
+    """Context object that flows through the deployment pipeline.
+
+    This context contains all the data needed for deployment and is
+    passed between pipeline steps. Each step can read from and modify
+    the context as needed.
+    """
+
+    # Input parameters
+    target_dir: Optional[Path] = None
+    force_rebuild: bool = False
+    deployment_mode: str = "update"
+    config: Optional[Config] = None
+    use_async: bool = False
+    working_directory: Optional[Path] = None
+    templates_dir: Optional[Path] = None
+    base_agent_path: Optional[Path] = None
+
+    # Strategy and execution context
+    strategy: Optional[BaseDeploymentStrategy] = None
+    actual_target_dir: Optional[Path] = None
+    actual_templates_dir: Optional[Path] = None
+    actual_base_agent_path: Optional[Path] = None
+
+    # Configuration and exclusions
+    excluded_agents: List[str] = field(default_factory=list)
+    case_sensitive_exclusion: bool = True
+
+    # Template and agent data
+    template_files: List[Path] = field(default_factory=list)
+    base_agent_data: Optional[Dict[str, Any]] = None
+    base_agent_version: Optional[tuple] = None
+
+    # Deployment results
+    results: Dict[str, Any] = field(default_factory=dict)
+
+    # Metrics and timing
+    deployment_start_time: Optional[float] = None
+    step_timings: Dict[str, float] = field(default_factory=dict)
+
+    # Error handling
+    errors: List[str] = field(default_factory=list)
+    warnings: List[str] = field(default_factory=list)
+
+    # Step control flags
+    should_deploy_system_instructions: bool = True
+    should_collect_metrics: bool = True
+    should_repair_existing_agents: bool = True
+
+    def add_error(self, error: str) -> None:
+        """Add an error to the context.
+
+        Args:
+            error: Error message to add
+        """
+        self.errors.append(error)
+        if "errors" not in self.results:
+            self.results["errors"] = []
+        self.results["errors"].append(error)
+
+    def add_warning(self, warning: str) -> None:
+        """Add a warning to the context.
+
+        Args:
+            warning: Warning message to add
+        """
+        self.warnings.append(warning)
+        if "warnings" not in self.results:
+            self.results["warnings"] = []
+        self.results["warnings"].append(warning)
+
+    def has_errors(self) -> bool:
+        """Check if there are any errors in the context.
+
+        Returns:
+            True if there are errors
+        """
+        return len(self.errors) > 0
+
+    def get_error_count(self) -> int:
+        """Get the number of errors.
+
+        Returns:
+            Number of errors
+        """
+        return len(self.errors)
+
+    def get_warning_count(self) -> int:
+        """Get the number of warnings.
+
+        Returns:
+            Number of warnings
+        """
+        return len(self.warnings)
+
+    def initialize_results(self) -> None:
+        """Initialize the results dictionary with default structure."""
+        if not self.results:
+            self.results = {
+                "target_dir": str(self.actual_target_dir)
+                if self.actual_target_dir
+                else "",
+                "deployed": [],
+                "updated": [],
+                "migrated": [],
+                "skipped": [],
+                "errors": [],
+                "warnings": [],
+                "repaired": [],
+                "total": 0,
+                "deployment_time": 0.0,
+                "strategy_used": self.strategy.name if self.strategy else "Unknown",
+            }
+
+    def finalize_results(self, end_time: float) -> Dict[str, Any]:
+        """Finalize the results dictionary.
+
+        Args:
+            end_time: End time of deployment
+
+        Returns:
+            Final results dictionary
+        """
+        if self.deployment_start_time:
+            self.results["deployment_time"] = end_time - self.deployment_start_time
+
+        # Add step timings if available
+        if self.step_timings:
+            self.results["step_timings"] = self.step_timings.copy()
+
+        # Ensure all required fields are present
+        for field in [
+            "deployed",
+            "updated",
+            "migrated",
+            "skipped",
+            "errors",
+            "warnings",
+            "repaired",
+        ]:
+            if field not in self.results:
+                self.results[field] = []
+
+        if "total" not in self.results:
+            self.results["total"] = len(self.template_files)
+
+        return self.results.copy()

claude_mpm/services/agents/deployment/pipeline/pipeline_executor.py

@@ -0,0 +1,169 @@
+"""Pipeline executor for running deployment pipelines."""
+
+import time
+from typing import Any, Dict, List
+
+from claude_mpm.core.logger import get_logger
+
+from .pipeline_context import PipelineContext
+from .steps.base_step import BaseDeploymentStep, StepResult, StepStatus
+
+
+class DeploymentPipelineExecutor:
+    """Executor for running deployment pipelines.
+
+    This executor runs a series of deployment steps in order,
+    handling errors and collecting results.
+    """
+
+    def __init__(self):
+        """Initialize the pipeline executor."""
+        self.logger = get_logger(__name__)
+
+    def execute(
+        self, steps: List[BaseDeploymentStep], context: PipelineContext
+    ) -> Dict[str, Any]:
+        """Execute a deployment pipeline.
+
+        Args:
+            steps: List of deployment steps to execute
+            context: Pipeline context containing deployment data
+
+        Returns:
+            Dictionary with execution results
+        """
+        self.logger.info(f"Starting deployment pipeline with {len(steps)} steps")
+
+        # Initialize context
+        if context.deployment_start_time is None:
+            context.deployment_start_time = time.time()
+
+        context.initialize_results()
+
+        # Execute steps
+        executed_steps = []
+        failed_steps = []
+        skipped_steps = []
+
+        for i, step in enumerate(steps):
+            step_start_time = time.time()
+
+            try:
+                # Check if step should be executed
+                if not step.should_execute(context):
+                    self.logger.info(f"Skipping step {i+1}/{len(steps)}: {step.name}")
+                    skipped_steps.append(step.name)
+                    continue
+
+                self.logger.info(f"Executing step {i+1}/{len(steps)}: {step.name}")
+
+                # Execute the step
+                result = step.execute(context)
+
+                # Log result
+                if result.is_success:
+                    self.logger.info(f"Step completed successfully: {step.name}")
+                    executed_steps.append(step.name)
+                elif result.is_warning:
+                    self.logger.warning(
+                        f"Step completed with warnings: {step.name} - {result.message}"
+                    )
+                    executed_steps.append(step.name)
+                elif result.is_failure:
+                    self.logger.error(f"Step failed: {step.name} - {result.message}")
+                    failed_steps.append(step.name)
+
+                    # Check if we can continue
+                    if not step.can_continue_on_failure():
+                        self.logger.error(
+                            f"Critical step failed, stopping pipeline: {step.name}"
+                        )
+                        break
+                elif result.is_skipped:
+                    self.logger.info(
+                        f"Step was skipped: {step.name} - {result.message}"
+                    )
+                    skipped_steps.append(step.name)
+
+                # Record timing
+                step_execution_time = time.time() - step_start_time
+                context.step_timings[step.name] = step_execution_time
+
+            except Exception as e:
+                step_execution_time = time.time() - step_start_time
+                context.step_timings[step.name] = step_execution_time
+
+                error_msg = f"Unexpected error in step {step.name}: {str(e)}"
+                self.logger.error(error_msg, exc_info=True)
+                context.add_error(error_msg)
+                failed_steps.append(step.name)
+
+                # Check if we can continue
+                if not step.can_continue_on_failure():
+                    self.logger.error(
+                        f"Critical step failed with exception, stopping pipeline: {step.name}"
+                    )
+                    break
+
+        # Finalize results
+        end_time = time.time()
+        final_results = context.finalize_results(end_time)
+
+        # Add pipeline execution metadata
+        final_results.update(
+            {
+                "pipeline_execution": {
+                    "total_steps": len(steps),
+                    "executed_steps": executed_steps,
+                    "failed_steps": failed_steps,
+                    "skipped_steps": skipped_steps,
+                    "success": len(failed_steps) == 0,
+                    "total_execution_time": end_time - context.deployment_start_time,
+                }
+            }
+        )
+
+        # Log final results
+        if len(failed_steps) == 0:
+            self.logger.info(
+                f"Pipeline completed successfully in {final_results['deployment_time']:.3f}s"
+            )
+        else:
+            self.logger.error(
+                f"Pipeline completed with {len(failed_steps)} failed steps"
+            )
+
+        return final_results
+
+    def validate_pipeline(self, steps: List[BaseDeploymentStep]) -> List[str]:
+        """Validate a pipeline before execution.
+
+        Args:
+            steps: List of deployment steps to validate
+
+        Returns:
+            List of validation errors (empty if valid)
+        """
+        errors = []
+
+        if not steps:
+            errors.append("Pipeline cannot be empty")
+            return errors
+
+        # Check for duplicate step names
+        step_names = [step.name for step in steps]
+        duplicates = set([name for name in step_names if step_names.count(name) > 1])
+        if duplicates:
+            errors.append(f"Duplicate step names found: {duplicates}")
+
+        # Validate dependencies (simplified check)
+        for step in steps:
+            dependencies = step.get_dependencies()
+            for dep_class in dependencies:
+                # Check if any step in the pipeline is of the required type
+                if not any(isinstance(s, dep_class) for s in steps):
+                    errors.append(
+                        f"Step {step.name} requires {dep_class.__name__} but it's not in the pipeline"
+                    )
+
+        return errors

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

@@ -0,0 +1,19 @@
+"""Deployment pipeline steps.
+
+This module contains all the individual steps that make up the
+deployment pipeline. Each step is responsible for a specific
+part of the deployment process.
+"""
+
+from .agent_processing_step import AgentProcessingStep
+from .base_step import BaseDeploymentStep, StepResult
+from .configuration_step import ConfigurationLoadStep
+from .target_directory_step import TargetDirectorySetupStep
+
+__all__ = [
+    "BaseDeploymentStep",
+    "StepResult",
+    "ConfigurationLoadStep",
+    "TargetDirectorySetupStep",
+    "AgentProcessingStep",
+]

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

@@ -0,0 +1,195 @@
+"""Agent processing step for deployment pipeline."""
+
+import time
+
+from claude_mpm.services.agents.deployment.processors import (
+    AgentDeploymentContext,
+    AgentDeploymentResult,
+    AgentProcessor,
+)
+
+from .base_step import BaseDeploymentStep, StepResult, StepStatus
+
+
+class AgentProcessingStep(BaseDeploymentStep):
+    """Step to process and deploy individual agents."""
+
+    def __init__(self, template_builder, version_manager):
+        super().__init__(
+            name="Agent Processing",
+            description="Process and deploy individual agent templates",
+        )
+        self.processor = AgentProcessor(template_builder, version_manager)
+
+    def execute(self, context) -> StepResult:
+        """Execute agent processing step.
+
+        Args:
+            context: Pipeline context
+
+        Returns:
+            Result of agent processing
+        """
+        start_time = time.time()
+
+        try:
+            if not context.template_files:
+                self.logger.warning("No template files to process")
+                return StepResult(
+                    status=StepStatus.SKIPPED,
+                    message="No template files found to process",
+                    execution_time=time.time() - start_time,
+                )
+
+            # Initialize results tracking
+            processed_count = 0
+            failed_count = 0
+
+            # Process each template file
+            for template_file in context.template_files:
+                try:
+                    # Create agent deployment context
+                    agent_context = AgentDeploymentContext.from_template_file(
+                        template_file=template_file,
+                        agents_dir=context.actual_target_dir,
+                        base_agent_data=context.base_agent_data or {},
+                        base_agent_version=context.base_agent_version or (1, 0, 0),
+                        force_rebuild=context.force_rebuild,
+                        deployment_mode=context.deployment_mode,
+                    )
+
+                    # Validate agent if requested
+                    if context.should_repair_existing_agents:
+                        if not self.processor.validate_agent(agent_context):
+                            self.logger.warning(
+                                f"Agent validation failed: {agent_context.agent_name}"
+                            )
+                            context.add_warning(
+                                f"Agent validation failed: {agent_context.agent_name}"
+                            )
+                            failed_count += 1
+                            continue
+
+                    # Process the agent
+                    result = self.processor.process_agent(agent_context)
+
+                    # Update context results based on outcome
+                    self._update_context_with_result(context, result)
+
+                    if result.is_successful():
+                        processed_count += 1
+                    else:
+                        failed_count += 1
+
+                except Exception as e:
+                    error_msg = (
+                        f"Failed to process agent {template_file.stem}: {str(e)}"
+                    )
+                    self.logger.error(error_msg, exc_info=True)
+                    context.add_error(error_msg)
+                    failed_count += 1
+
+            # Calculate execution time
+            execution_time = time.time() - start_time
+            context.step_timings[self.name] = execution_time
+
+            # Determine step status
+            if failed_count == 0:
+                status = StepStatus.SUCCESS
+                message = f"Successfully processed {processed_count} agents in {execution_time:.3f}s"
+            elif processed_count > 0:
+                status = StepStatus.WARNING
+                message = f"Processed {processed_count} agents with {failed_count} failures in {execution_time:.3f}s"
+            else:
+                status = StepStatus.FAILURE
+                message = f"Failed to process any agents ({failed_count} failures) 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"Agent processing 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 _update_context_with_result(
+        self, context, result: AgentDeploymentResult
+    ) -> None:
+        """Update pipeline context with agent deployment result.
+
+        Args:
+            context: Pipeline context
+            result: Agent deployment result
+        """
+        # Ensure results structure exists
+        if "deployed" not in context.results:
+            context.results["deployed"] = []
+        if "updated" not in context.results:
+            context.results["updated"] = []
+        if "migrated" not in context.results:
+            context.results["migrated"] = []
+        if "skipped" not in context.results:
+            context.results["skipped"] = []
+        if "errors" not in context.results:
+            context.results["errors"] = []
+
+        # Add result to appropriate list
+        result_dict = result.to_dict()
+
+        if result.status.value == "deployed":
+            context.results["deployed"].append(result_dict)
+        elif result.status.value == "updated":
+            context.results["updated"].append(result_dict)
+        elif result.status.value == "migrated":
+            context.results["migrated"].append(result_dict)
+        elif result.status.value == "skipped":
+            context.results["skipped"].append(result.agent_name)
+        elif result.status.value == "failed":
+            context.results["errors"].append(
+                result.error_message or f"Failed to deploy {result.agent_name}"
+            )
+
+    def should_execute(self, context) -> bool:
+        """Check if this step should be executed.
+
+        Args:
+            context: Pipeline context
+
+        Returns:
+            True if there are template files to process
+        """
+        return bool(context.template_files)
+
+    def can_continue_on_failure(self) -> bool:
+        """Agent processing failures should not stop the pipeline.
+
+        Individual agent failures are tracked but don't prevent
+        other agents from being processed.
+
+        Returns:
+            True - continue on failure
+        """
+        return True
+
+    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/pipeline/steps/base_step.py

@@ -0,0 +1,119 @@
+"""Base deployment step interface."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+
+from claude_mpm.core.logger import get_logger
+
+
+class StepStatus(Enum):
+    """Status of a pipeline step execution."""
+
+    SUCCESS = "success"
+    FAILURE = "failure"
+    SKIPPED = "skipped"
+    WARNING = "warning"
+
+
+@dataclass
+class StepResult:
+    """Result of executing a pipeline step."""
+
+    status: StepStatus
+    message: Optional[str] = None
+    error: Optional[Exception] = None
+    execution_time: Optional[float] = None
+
+    @property
+    def is_success(self) -> bool:
+        """Check if the step was successful."""
+        return self.status == StepStatus.SUCCESS
+
+    @property
+    def is_failure(self) -> bool:
+        """Check if the step failed."""
+        return self.status == StepStatus.FAILURE
+
+    @property
+    def is_skipped(self) -> bool:
+        """Check if the step was skipped."""
+        return self.status == StepStatus.SKIPPED
+
+    @property
+    def is_warning(self) -> bool:
+        """Check if the step completed with warnings."""
+        return self.status == StepStatus.WARNING
+
+
+class BaseDeploymentStep(ABC):
+    """Base class for all deployment pipeline steps.
+
+    Each step in the deployment pipeline should inherit from this class
+    and implement the execute method. Steps can read from and modify
+    the pipeline context as needed.
+    """
+
+    def __init__(self, name: str, description: str = ""):
+        """Initialize the deployment step.
+
+        Args:
+            name: Human-readable name for this step
+            description: Optional description of what this step does
+        """
+        self.name = name
+        self.description = description
+        self.logger = get_logger(f"{__name__}.{self.__class__.__name__}")
+
+    @abstractmethod
+    def execute(self, context) -> StepResult:
+        """Execute this deployment step.
+
+        Args:
+            context: Pipeline context containing deployment data
+
+        Returns:
+            Result of executing this step
+        """
+        pass
+
+    def should_execute(self, context) -> bool:
+        """Check if this step should be executed.
+
+        Override this method to add conditional execution logic.
+
+        Args:
+            context: Pipeline context
+
+        Returns:
+            True if this step should be executed
+        """
+        return True
+
+    def can_continue_on_failure(self) -> bool:
+        """Check if pipeline can continue if this step fails.
+
+        Override this method for steps that are not critical.
+
+        Returns:
+            True if pipeline can continue after this step fails
+        """
+        return False
+
+    def get_dependencies(self) -> list:
+        """Get list of step classes this step depends on.
+
+        Override this method to specify dependencies.
+
+        Returns:
+            List of step classes that must execute before this step
+        """
+        return []
+
+    def __str__(self) -> str:
+        """String representation of the step."""
+        return f"{self.name}"
+
+    def __repr__(self) -> str:
+        """Detailed string representation of the step."""
+        return f"{self.__class__.__name__}(name='{self.name}', description='{self.description}')"