claude-mpm 3.4.10__py3-none-any.whl → 5.4.55__py3-none-any.whl

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

@@ -0,0 +1,32 @@
+"""Deployment pipeline for agent deployment.
+
+This module provides a pipeline-based approach to agent deployment,
+breaking down the complex deployment process into discrete, testable steps.
+
+The pipeline pattern allows for:
+- Modular deployment steps that can be tested independently
+- Configurable deployment flows for different scenarios
+- Easy addition of new deployment steps
+- Better error handling and recovery
+- Comprehensive logging and metrics collection
+"""
+
+from .pipeline_builder import DeploymentPipelineBuilder
+from .pipeline_context import PipelineContext
+from .pipeline_executor import DeploymentPipelineExecutor
+from .steps import (
+    BaseDeploymentStep,
+    ConfigurationLoadStep,
+    StepResult,
+    TargetDirectorySetupStep,
+)
+
+__all__ = [
+    "BaseDeploymentStep",
+    "ConfigurationLoadStep",
+    "DeploymentPipelineBuilder",
+    "DeploymentPipelineExecutor",
+    "PipelineContext",
+    "StepResult",
+    "TargetDirectorySetupStep",
+]

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

@@ -0,0 +1,158 @@
+"""Pipeline builder for creating deployment pipelines."""
+
+from typing import Dict, List, Type
+
+from claude_mpm.core.logger import get_logger
+
+from .steps.base_step import BaseDeploymentStep
+from .steps.configuration_step import ConfigurationLoadStep
+from .steps.target_directory_step import TargetDirectorySetupStep
+
+
+class DeploymentPipelineBuilder:
+    """Builder for creating deployment pipelines.
+
+    This builder allows for flexible construction of deployment pipelines
+    with different steps based on deployment requirements.
+    """
+
+    def __init__(self):
+        """Initialize the pipeline builder."""
+        self.logger = get_logger(__name__)
+        self._steps: List[BaseDeploymentStep] = []
+        self._step_registry: Dict[str, Type[BaseDeploymentStep]] = {}
+
+        # Register default steps
+        self._register_default_steps()
+
+    def _register_default_steps(self) -> None:
+        """Register default deployment steps."""
+        self._step_registry.update(
+            {
+                "configuration": ConfigurationLoadStep,
+                "target_directory": TargetDirectorySetupStep,
+                # Additional steps will be registered as they're created
+            }
+        )
+
+    def add_step(self, step: BaseDeploymentStep) -> "DeploymentPipelineBuilder":
+        """Add a step to the pipeline.
+
+        Args:
+            step: The deployment step to add
+
+        Returns:
+            Self for method chaining
+        """
+        self._steps.append(step)
+        self.logger.debug(f"Added step: {step.name}")
+        return self
+
+    def add_step_by_name(self, step_name: str, **kwargs) -> "DeploymentPipelineBuilder":
+        """Add a step by its registered name.
+
+        Args:
+            step_name: Name of the registered step
+            **kwargs: Arguments to pass to the step constructor
+
+        Returns:
+            Self for method chaining
+
+        Raises:
+            ValueError: If step name is not registered
+        """
+        if step_name not in self._step_registry:
+            raise ValueError(f"Unknown step name: {step_name}")
+
+        step_class = self._step_registry[step_name]
+        step = step_class(**kwargs)
+        return self.add_step(step)
+
+    def create_standard_pipeline(self) -> List[BaseDeploymentStep]:
+        """Create a standard deployment pipeline with all common steps.
+
+        Returns:
+            List of deployment steps in execution order
+        """
+        return [
+            ConfigurationLoadStep(),
+            TargetDirectorySetupStep(),
+            # Additional steps will be added as they're implemented
+        ]
+
+    def create_minimal_pipeline(self) -> List[BaseDeploymentStep]:
+        """Create a minimal deployment pipeline with only essential steps.
+
+        Returns:
+            List of essential deployment steps
+        """
+        return [
+            ConfigurationLoadStep(),
+            TargetDirectorySetupStep(),
+        ]
+
+    def create_custom_pipeline(self, step_names: List[str]) -> List[BaseDeploymentStep]:
+        """Create a custom pipeline from step names.
+
+        Args:
+            step_names: List of step names to include in the pipeline
+
+        Returns:
+            List of deployment steps
+
+        Raises:
+            ValueError: If any step name is not registered
+        """
+        steps = []
+        for step_name in step_names:
+            if step_name not in self._step_registry:
+                raise ValueError(f"Unknown step name: {step_name}")
+
+            step_class = self._step_registry[step_name]
+            steps.append(step_class())
+
+        return steps
+
+    def build(self) -> List[BaseDeploymentStep]:
+        """Build the pipeline from added steps.
+
+        Returns:
+            List of deployment steps in the order they were added
+        """
+        if not self._steps:
+            self.logger.warning(
+                "No steps added to pipeline, creating standard pipeline"
+            )
+            return self.create_standard_pipeline()
+
+        # Sort steps based on dependencies (simplified for now)
+        # In a full implementation, this would do topological sorting
+        return self._steps.copy()
+
+    def register_step(self, name: str, step_class: Type[BaseDeploymentStep]) -> None:
+        """Register a new step type.
+
+        Args:
+            name: Name to register the step under
+            step_class: The step class to register
+        """
+        self._step_registry[name] = step_class
+        self.logger.debug(f"Registered step: {name} -> {step_class.__name__}")
+
+    def get_registered_steps(self) -> Dict[str, Type[BaseDeploymentStep]]:
+        """Get all registered step types.
+
+        Returns:
+            Dictionary of step names to step classes
+        """
+        return self._step_registry.copy()
+
+    def clear(self) -> "DeploymentPipelineBuilder":
+        """Clear all added steps.
+
+        Returns:
+            Self for method chaining
+        """
+        self._steps.clear()
+        self.logger.debug("Cleared all steps from pipeline builder")
+        return self

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

@@ -0,0 +1,162 @@
+"""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
+    agent_sources: Dict[str, str] = field(
+        default_factory=dict
+    )  # Maps agent names to sources
+
+    # 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
+
+
+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}: {e!s}"
+                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 = {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__ = [
+    "AgentProcessingStep",
+    "BaseDeploymentStep",
+    "ConfigurationLoadStep",
+    "StepResult",
+    "TargetDirectorySetupStep",
+]