claude-mpm 4.3.22__py3-none-any.whl → 4.4.0__py3-none-any.whl

claude_mpm/services/unified/unified_deployment.py

@@ -0,0 +1,470 @@
+"""
+Unified Deployment Service Implementation
+=========================================
+
+This module implements the unified deployment service that consolidates all
+deployment-related services using the strategy pattern. It replaces multiple
+specialized deployment services with a single, extensible service.
+
+Consolidates:
+- AgentDeploymentService
+- ConfigDeploymentService
+- ResourceDeploymentService
+- TemplateDeploymentService
+- And other deployment-related services
+
+Features:
+- Strategy-based deployment for different resource types
+- Rollback support with versioning
+- Batch deployment operations
+- Deployment validation and pre-flight checks
+- Metrics and monitoring integration
+"""
+
+import asyncio
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from claude_mpm.core.logging_utils import get_logger
+
+from .interfaces import (
+    DeploymentResult,
+    IDeploymentService,
+    IUnifiedService,
+    ServiceCapability,
+    ServiceMetadata,
+)
+from .strategies import (
+    DeploymentStrategy,
+    StrategyContext,
+    get_strategy_registry,
+)
+
+
+class UnifiedDeploymentService(IDeploymentService, IUnifiedService):
+    """
+    Unified deployment service using strategy pattern.
+
+    This service consolidates all deployment operations through a
+    pluggable strategy system, reducing code duplication and improving
+    maintainability.
+    """
+
+    def __init__(self):
+        """Initialize unified deployment service."""
+        self._logger = get_logger(f"{__name__}.UnifiedDeploymentService")
+        self._registry = get_strategy_registry()
+        self._deployments: Dict[str, Dict[str, Any]] = {}
+        self._deployment_counter = 0
+        self._metrics = {
+            "total_deployments": 0,
+            "successful_deployments": 0,
+            "failed_deployments": 0,
+            "rollbacks": 0,
+        }
+        self._initialized = False
+
+    def get_metadata(self) -> ServiceMetadata:
+        """
+        Get service metadata.
+
+        Returns:
+            ServiceMetadata: Service metadata
+        """
+        return ServiceMetadata(
+            name="UnifiedDeploymentService",
+            version="1.0.0",
+            capabilities={
+                ServiceCapability.ASYNC_OPERATIONS,
+                ServiceCapability.BATCH_PROCESSING,
+                ServiceCapability.VALIDATION,
+                ServiceCapability.ROLLBACK,
+                ServiceCapability.METRICS,
+                ServiceCapability.HEALTH_CHECK,
+            },
+            dependencies=["StrategyRegistry", "LoggingService"],
+            description="Unified service for all deployment operations",
+            tags={"deployment", "unified", "strategy-pattern"},
+            deprecated_services=[
+                "AgentDeploymentService",
+                "ConfigDeploymentService",
+                "ResourceDeploymentService",
+                "TemplateDeploymentService",
+            ],
+        )
+
+    async def initialize(self) -> bool:
+        """
+        Initialize the service.
+
+        Returns:
+            bool: True if initialization successful
+        """
+        try:
+            self._logger.info("Initializing UnifiedDeploymentService")
+
+            # Load deployment history if exists
+            await self._load_deployment_history()
+
+            # Register default strategies
+            self._register_default_strategies()
+
+            self._initialized = True
+            self._logger.info("UnifiedDeploymentService initialized successfully")
+            return True
+
+        except Exception as e:
+            self._logger.error(f"Failed to initialize: {str(e)}")
+            return False
+
+    async def shutdown(self) -> None:
+        """Gracefully shutdown the service."""
+        self._logger.info("Shutting down UnifiedDeploymentService")
+
+        # Save deployment history
+        await self._save_deployment_history()
+
+        # Clear deployments
+        self._deployments.clear()
+
+        self._initialized = False
+        self._logger.info("UnifiedDeploymentService shutdown complete")
+
+    def health_check(self) -> Dict[str, Any]:
+        """
+        Perform health check.
+
+        Returns:
+            Dict[str, Any]: Health status
+        """
+        strategies = self._registry.list_strategies(DeploymentStrategy)
+
+        return {
+            "service": "UnifiedDeploymentService",
+            "status": "healthy" if self._initialized else "unhealthy",
+            "initialized": self._initialized,
+            "registered_strategies": len(strategies),
+            "active_deployments": len(self._deployments),
+            "metrics": self.get_metrics(),
+        }
+
+    def get_metrics(self) -> Dict[str, Any]:
+        """
+        Get service metrics.
+
+        Returns:
+            Dict[str, Any]: Service metrics
+        """
+        success_rate = 0.0
+        if self._metrics["total_deployments"] > 0:
+            success_rate = (
+                self._metrics["successful_deployments"]
+                / self._metrics["total_deployments"]
+            ) * 100
+
+        return {
+            **self._metrics,
+            "success_rate": success_rate,
+            "active_deployments": len(self._deployments),
+        }
+
+    def reset(self) -> None:
+        """Reset service to initial state."""
+        self._logger.info("Resetting UnifiedDeploymentService")
+        self._deployments.clear()
+        self._deployment_counter = 0
+        self._metrics = {
+            "total_deployments": 0,
+            "successful_deployments": 0,
+            "failed_deployments": 0,
+            "rollbacks": 0,
+        }
+
+    def validate_deployment(
+        self, target: Union[str, Path], config: Dict[str, Any]
+    ) -> List[str]:
+        """
+        Validate deployment configuration.
+
+        Args:
+            target: Deployment target
+            config: Deployment configuration
+
+        Returns:
+            List[str]: Validation errors
+        """
+        errors = []
+
+        # Basic validation
+        if not target:
+            errors.append("Deployment target is required")
+
+        if not config:
+            errors.append("Deployment configuration is required")
+
+        # Get deployment type from config
+        deployment_type = config.get("type", "unknown")
+
+        # Select appropriate strategy
+        context = StrategyContext(
+            target_type=deployment_type,
+            operation="validate",
+            parameters={"target": target, "config": config},
+        )
+
+        strategy = self._registry.select_strategy(DeploymentStrategy, context)
+
+        if not strategy:
+            errors.append(f"No strategy available for deployment type: {deployment_type}")
+        else:
+            # Delegate validation to strategy
+            strategy_errors = strategy.validate_input(config)
+            errors.extend(strategy_errors)
+
+        return errors
+
+    def deploy(
+        self,
+        source: Union[str, Path],
+        target: Union[str, Path],
+        config: Optional[Dict[str, Any]] = None,
+        force: bool = False,
+    ) -> DeploymentResult:
+        """
+        Execute deployment.
+
+        Args:
+            source: Deployment source
+            target: Deployment target
+            config: Deployment configuration
+            force: Force deployment
+
+        Returns:
+            DeploymentResult: Deployment result
+        """
+        config = config or {}
+        self._metrics["total_deployments"] += 1
+
+        try:
+            # Validate deployment
+            errors = self.validate_deployment(target, config)
+            if errors and not force:
+                self._metrics["failed_deployments"] += 1
+                return DeploymentResult(
+                    success=False,
+                    message=f"Validation failed: {'; '.join(errors)}",
+                )
+
+            # Get deployment type
+            deployment_type = config.get("type", "generic")
+
+            # Select deployment strategy
+            context = StrategyContext(
+                target_type=deployment_type,
+                operation="deploy",
+                parameters={
+                    "source": source,
+                    "target": target,
+                    "config": config,
+                    "force": force,
+                },
+            )
+
+            strategy = self._registry.select_strategy(DeploymentStrategy, context)
+
+            if not strategy:
+                self._metrics["failed_deployments"] += 1
+                return DeploymentResult(
+                    success=False,
+                    message=f"No strategy available for deployment type: {deployment_type}",
+                )
+
+            # Execute deployment using strategy
+            self._logger.info(
+                f"Deploying {source} to {target} using {strategy.metadata.name}"
+            )
+
+            result = strategy.deploy(source, target, config)
+
+            # Create deployment record
+            deployment_id = self._generate_deployment_id()
+            rollback_info = strategy.prepare_rollback(result)
+
+            self._deployments[deployment_id] = {
+                "id": deployment_id,
+                "source": str(source),
+                "target": str(target),
+                "type": deployment_type,
+                "strategy": strategy.metadata.name,
+                "config": config,
+                "result": result,
+                "rollback_info": rollback_info,
+                "timestamp": self._get_timestamp(),
+            }
+
+            # Update metrics
+            if result.get("success", False):
+                self._metrics["successful_deployments"] += 1
+                deployed_path = Path(target) / Path(source).name
+
+                return DeploymentResult(
+                    success=True,
+                    deployed_path=deployed_path,
+                    message=f"Successfully deployed using {strategy.metadata.name}",
+                    metadata=result,
+                    rollback_info=rollback_info,
+                )
+            else:
+                self._metrics["failed_deployments"] += 1
+                return DeploymentResult(
+                    success=False,
+                    message=result.get("error", "Deployment failed"),
+                    metadata=result,
+                )
+
+        except Exception as e:
+            self._logger.error(f"Deployment error: {str(e)}")
+            self._metrics["failed_deployments"] += 1
+            return DeploymentResult(
+                success=False,
+                message=f"Deployment failed: {str(e)}",
+            )
+
+    def rollback(
+        self, deployment_id: str, rollback_info: Dict[str, Any]
+    ) -> DeploymentResult:
+        """
+        Rollback deployment.
+
+        Args:
+            deployment_id: Deployment to rollback
+            rollback_info: Rollback information
+
+        Returns:
+            DeploymentResult: Rollback result
+        """
+        self._metrics["rollbacks"] += 1
+
+        deployment = self._deployments.get(deployment_id)
+        if not deployment:
+            return DeploymentResult(
+                success=False,
+                message=f"Deployment {deployment_id} not found",
+            )
+
+        try:
+            # Get the strategy used for deployment
+            strategy_name = deployment["strategy"]
+            strategy = self._registry.get_strategy(
+                DeploymentStrategy, strategy_name
+            )
+
+            if not strategy:
+                return DeploymentResult(
+                    success=False,
+                    message=f"Strategy {strategy_name} not available for rollback",
+                )
+
+            # Execute rollback
+            self._logger.info(f"Rolling back deployment {deployment_id}")
+
+            # Clean up deployed artifacts
+            success = strategy.cleanup(deployment["target"])
+
+            if success:
+                # Mark deployment as rolled back
+                deployment["rolled_back"] = True
+                deployment["rollback_timestamp"] = self._get_timestamp()
+
+                return DeploymentResult(
+                    success=True,
+                    message=f"Successfully rolled back deployment {deployment_id}",
+                )
+            else:
+                return DeploymentResult(
+                    success=False,
+                    message="Rollback failed",
+                )
+
+        except Exception as e:
+            self._logger.error(f"Rollback error: {str(e)}")
+            return DeploymentResult(
+                success=False,
+                message=f"Rollback failed: {str(e)}",
+            )
+
+    def list_deployments(
+        self, target: Optional[Union[str, Path]] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        List deployments.
+
+        Args:
+            target: Optional filter by target
+
+        Returns:
+            List[Dict[str, Any]]: Deployment list
+        """
+        deployments = list(self._deployments.values())
+
+        if target:
+            target_str = str(target)
+            deployments = [
+                d for d in deployments if d["target"] == target_str
+            ]
+
+        return deployments
+
+    def get_deployment_status(self, deployment_id: str) -> Dict[str, Any]:
+        """
+        Get deployment status.
+
+        Args:
+            deployment_id: Deployment identifier
+
+        Returns:
+            Dict[str, Any]: Deployment status
+        """
+        deployment = self._deployments.get(deployment_id)
+        if not deployment:
+            return {"error": f"Deployment {deployment_id} not found"}
+
+        return {
+            "id": deployment_id,
+            "status": "rolled_back" if deployment.get("rolled_back") else "active",
+            "type": deployment["type"],
+            "strategy": deployment["strategy"],
+            "source": deployment["source"],
+            "target": deployment["target"],
+            "timestamp": deployment["timestamp"],
+            "rollback_available": bool(deployment.get("rollback_info")),
+        }
+
+    # Private helper methods
+
+    def _register_default_strategies(self) -> None:
+        """Register default deployment strategies."""
+        # Default strategies would be registered here
+        # This would be extended with actual strategy implementations
+        self._logger.debug("Default strategies registered")
+
+    async def _load_deployment_history(self) -> None:
+        """Load deployment history from persistent storage."""
+        # Implementation would load from database or file
+        self._logger.debug("Deployment history loaded")
+
+    async def _save_deployment_history(self) -> None:
+        """Save deployment history to persistent storage."""
+        # Implementation would save to database or file
+        self._logger.debug("Deployment history saved")
+
+    def _generate_deployment_id(self) -> str:
+        """Generate unique deployment ID."""
+        self._deployment_counter += 1
+        return f"deploy_{self._deployment_counter:06d}"
+
+    def _get_timestamp(self) -> str:
+        """Get current timestamp."""
+        from datetime import datetime
+
+        return datetime.now().isoformat()

{claude_mpm-4.3.22.dist-info → claude_mpm-4.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.3.22
+Version: 4.4.0
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team

{claude_mpm-4.3.22.dist-info → claude_mpm-4.4.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 claude_mpm/BUILD_NUMBER,sha256=toytnNjkIKPgQaGwDqQdC1rpNTAdSEc6Vja50d7Ovug,4
-claude_mpm/VERSION,sha256=zvccwnBVVw9AaTMuRg9TMmHZyBBTqM3_bRbraHZcyCs,7
+claude_mpm/VERSION,sha256=1OTU6BLh2vxOdg9e4SxI73b4r0HSfL878v8GVQW5z-Y,6
 claude_mpm/__init__.py,sha256=lyTZAYGH4DTaFGLRNWJKk5Q5oTjzN5I6AXmfVX-Jff0,1512
 claude_mpm/__main__.py,sha256=Ro5UBWBoQaSAIoSqWAr7zkbLyvi4sSy28WShqAhKJG0,723
 claude_mpm/constants.py,sha256=cChN3myrAcF3jC-6DvHnBFTEnwlDk-TAsIXPvUZr_yw,5953
@@ -79,7 +79,7 @@ claude_mpm/cli/commands/configure.py,sha256=i5_glZmlSTgUEkbVqWBRQE3T-y4AJhPNsUnP
 claude_mpm/cli/commands/configure_tui.py,sha256=p158vDexkwL7csWO8_fxt-XAMEoBDN24gf75hIfAlXs,66857
 claude_mpm/cli/commands/dashboard.py,sha256=0f8_JaXo854kZgcqzZ3cm3VG8muhSsV7JqIzjdSJLcc,11420
 claude_mpm/cli/commands/debug.py,sha256=qEfmBG9slmOY6a8snoytM1OWCdWwBALzN1lqV7ElIBU,47130
-claude_mpm/cli/commands/doctor.py,sha256=A39BXEQ174SnfCCZmguyuk6KroCsc2YozgKe_kC6BmQ,5801
+claude_mpm/cli/commands/doctor.py,sha256=zbCrfTmxJ-DuYFgAjLhuCNse4qVuRVAtqBSr3hOOuUE,5809
 claude_mpm/cli/commands/info.py,sha256=uiZ2GMkfr-4aeme2l6QhzxyawuhtuyVulfCi66yyvOs,7404
 claude_mpm/cli/commands/mcp.py,sha256=kgmJVTAi0G7SAnIpYHddU25HqAdIY9mMmTH-C3DSCsY,7221
 claude_mpm/cli/commands/mcp_command_router.py,sha256=8rTMZLxU3R3Izit9ia1Z_pIOq3bn2QjMPH4uvf1X9XY,6001
@@ -352,7 +352,7 @@ claude_mpm/generators/agent_profile_generator.py,sha256=8h3yjhnpNmgILzSddzPjFstG
 claude_mpm/hooks/__init__.py,sha256=FzgybZlNaDR8q3NJqWc6Ai55rCeg836sIkfE9RT4cGg,167
 claude_mpm/hooks/base_hook.py,sha256=YUIjSOsGrSMqFJX2gZ16af96ohRpJnOs3mZLq63MQcA,5025
 claude_mpm/hooks/instruction_reinforcement.py,sha256=9DeJ8JABi2phn5BeIjgz4og4uQRVpk3Oqg6lvM2b3BQ,11058
-claude_mpm/hooks/memory_integration_hook.py,sha256=6dEDu13om331mZ9LmVfvMlZ4IKvIlmGq759VWMyrH2Y,16645
+claude_mpm/hooks/memory_integration_hook.py,sha256=VAazT6soMWoPVlDzP17psft-TDTVdblXNR2pjYpfnh4,16652
 claude_mpm/hooks/tool_call_interceptor.py,sha256=k3Ghe2KvUs3y-5PcS63uHmBAxtUYraqq1bX9GN0QliU,7462
 claude_mpm/hooks/validation_hooks.py,sha256=VWQX3eKb9-nx20irK9FcyrJgdid2mm3XhSBVOCU1IVw,6464
 claude_mpm/hooks/claude_hooks/__init__.py,sha256=b4mud_g3S-3itHY_Dzpbb_SmdMEcJwtUU8fTcqpLqqs,130
@@ -495,11 +495,11 @@ claude_mpm/services/agents/management/agent_management_service.py,sha256=aj8ADCH
 claude_mpm/services/agents/memory/__init__.py,sha256=cu8XUsFeI06NjPwDIysofA0dSpALEKd1f3_E_hJ9wyI,608
 claude_mpm/services/agents/memory/agent_memory_manager.py,sha256=ewmfS80ZqLGdoalGCVNxlpPVBp5qf1uGUfUpqPtwtOA,31721
 claude_mpm/services/agents/memory/agent_persistence_service.py,sha256=1_wMyoXRdAo82xg8yLBd4vR1nl-hze0gECOJDOPwsZc,2757
-claude_mpm/services/agents/memory/content_manager.py,sha256=KrT9O-hddQxTk_-J4yXF1GNrTqyklT3WYGmVH8MA6Lw,16419
+claude_mpm/services/agents/memory/content_manager.py,sha256=tWm9GLeKZDWGIJbGFpaKqV7YVb2q9HER9quNkqDyaTs,16468
 claude_mpm/services/agents/memory/memory_categorization_service.py,sha256=kHReO2lKPLctCzVj_yCfsQizElDS66dnHVIzeZcdHoo,4746
-claude_mpm/services/agents/memory/memory_file_service.py,sha256=blkOqTW0KchAR5qh3Hz2gdmk54JCSZ3YUXQp3mqlzSU,4370
+claude_mpm/services/agents/memory/memory_file_service.py,sha256=LKvAOLHLvRun6sykD9yC2cB7oy4g3yPdAlgQtGaMdSc,4430
 claude_mpm/services/agents/memory/memory_format_service.py,sha256=vQzCsESjfgnsaj4Ybd2lwDT0kx8aCWYf2Mx9HElbceI,6170
-claude_mpm/services/agents/memory/memory_limits_service.py,sha256=CyWmsVL5iZb6XKZiVJYFf7lTg5DqWYCg6QUMckaPouo,3329
+claude_mpm/services/agents/memory/memory_limits_service.py,sha256=2l--CgKkyNeZt6hFkWWWsJsdaPej33_IsaCzN98kmUA,3389
 claude_mpm/services/agents/memory/template_generator.py,sha256=oJuryic9ZhEWb-JLHtNNo4RkHi5SEh9G_IQixqMx1YI,2581
 claude_mpm/services/agents/registry/__init__.py,sha256=ROBX82Ac4iLHEE7-aFUy7mT3NSz5eIub19ck5Q81NHQ,681
 claude_mpm/services/agents/registry/deployed_agent_discovery.py,sha256=WqJOCnSrwdUGC0gL5YDj_7gv4kl75mN9d-sN_pDBERc,10244
@@ -691,6 +691,25 @@ claude_mpm/services/ticket_services/formatter_service.py,sha256=MQ981yaFuvXWUDLp
 claude_mpm/services/ticket_services/search_service.py,sha256=CHDITcE6Dqu_98LOeb55qxr4yNpA7iBYSlnWXMg8KAI,9918
 claude_mpm/services/ticket_services/validation_service.py,sha256=5Wo4YHLjQmZ1Ey9sYHyTjmtWqidywcV16B1T4zS_d-c,8623
 claude_mpm/services/ticket_services/workflow_service.py,sha256=qbFMHaV3PlZ6J-YD2RVUugJ6WLVzAy_xCT0xMSPx1SY,7803
+claude_mpm/services/unified/__init__.py,sha256=N5VKRC47hyTZrJkV00bOpTkSQxrix4mzaJNrZS0RFnI,1795
+claude_mpm/services/unified/interfaces.py,sha256=zzplADK3lZLBJ68Tk8z5LUUpmfxvOqsd50UmfShI_Q8,13596
+claude_mpm/services/unified/migration.py,sha256=Ih2UgGxOSdXDYwqco1QOFm5f7t6TLdIUKiTHU9kSa9c,17101
+claude_mpm/services/unified/strategies.py,sha256=tNRghWxAIPRLwP06Hn6dao3-7u4aMnrG94SunIWe4yo,15096
+claude_mpm/services/unified/unified_analyzer.py,sha256=7lmF3eSMpTabspEf70pPGTDGce6ihSdS3mfNjWR510c,17053
+claude_mpm/services/unified/unified_config.py,sha256=-ZjVMoZv0BKxqNePYeks4gpXTwl-Y3oAjROdMLO_phA,22026
+claude_mpm/services/unified/unified_deployment.py,sha256=nR54oKbcM4Q23YpKSNiC8NMYReONvVfKVVlxUZ5NQEw,15052
+claude_mpm/services/unified/analyzer_strategies/__init__.py,sha256=H7xGr81UMJCJxM13S9Y-VpCmamJQ2ttSdootCOC86vQ,1368
+claude_mpm/services/unified/analyzer_strategies/code_analyzer.py,sha256=y_oXFAVXfxPdJEZ7Ewv8vFTtTikqwe9fkYm9SAvKVxo,17065
+claude_mpm/services/unified/analyzer_strategies/dependency_analyzer.py,sha256=JkLEhZu6rLoJTyQQQOEDwuy7PoFZwZBP1udIFbxfES4,23673
+claude_mpm/services/unified/analyzer_strategies/performance_analyzer.py,sha256=q2Y8CJCCfImIKp4w_ekExWkrk06EfXBlhEXHDbK2nnc,31607
+claude_mpm/services/unified/analyzer_strategies/security_analyzer.py,sha256=yrJm_zQ13Y_Q12V05wS024lBI8dRHj4YaTfyENsTgfg,25089
+claude_mpm/services/unified/analyzer_strategies/structure_analyzer.py,sha256=AHLUhVkh8mc556eemIo8UzpoXHnUHdTI1U8f6nJITqQ,24810
+claude_mpm/services/unified/deployment_strategies/__init__.py,sha256=8aBt4x3WPllGEPEae89Dn5wLzJfumI6z51oqfW497UY,2985
+claude_mpm/services/unified/deployment_strategies/base.py,sha256=Rhg2olx377C_cg0tDn99buQ8HKy7QJzd63LvqtwbGQs,17656
+claude_mpm/services/unified/deployment_strategies/cloud_strategies.py,sha256=HcF9h0aDTiHx48Uclm1xHCswD7hxLPngVYZ6y9CI1dg,18370
+claude_mpm/services/unified/deployment_strategies/local.py,sha256=eydq9r6IiFpSTiydDJB2RJ9BltHe6rvbpijLKtc4kdI,20798
+claude_mpm/services/unified/deployment_strategies/utils.py,sha256=n01KIhfTwomYP-3c2ALk5Nit0435GllwyaLhNeW2UnY,18914
+claude_mpm/services/unified/deployment_strategies/vercel.py,sha256=5RBEReTej2hsDomqoF5OthUCjrNArdPnCma2I7qJgQo,15366
 claude_mpm/services/version_control/__init__.py,sha256=U3bFV1upF3FgNrQGFld0GZt0vb3Eunm71mscgTg7zD0,1510
 claude_mpm/services/version_control/branch_strategy.py,sha256=IhRDt4qIspvNyeONPJJfVKjtbKVVPTGHjGVgGApxj_Q,23190
 claude_mpm/services/version_control/conflict_resolution.py,sha256=D7MCcrMifBic-My4CvWPpM0gn84rgYOAhnmpKs7R67Q,26061
@@ -730,9 +749,9 @@ claude_mpm/utils/subprocess_utils.py,sha256=ASpi6jh8vEjaYoIJ-xfvnmI3GSwOLBxVdoeb
 claude_mpm/validation/__init__.py,sha256=YZhwE3mhit-lslvRLuwfX82xJ_k4haZeKmh4IWaVwtk,156
 claude_mpm/validation/agent_validator.py,sha256=4jbD3F1isinPTCve4DadwpZ-p5omGFVPRe-oJdVzcDc,20915
 claude_mpm/validation/frontmatter_validator.py,sha256=u8g4Eyd_9O6ugj7Un47oSGh3kqv4wMkuks2i_CtWRvM,7028
-claude_mpm-4.3.22.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
-claude_mpm-4.3.22.dist-info/METADATA,sha256=yMOa2NqWVszM56y-g7UO3i-5jqZPo9wWfxO5F7OvgLM,16150
-claude_mpm-4.3.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-4.3.22.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
-claude_mpm-4.3.22.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-4.3.22.dist-info/RECORD,,
+claude_mpm-4.4.0.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
+claude_mpm-4.4.0.dist-info/METADATA,sha256=9a2hiNWE67yPaIAg5EpT6meugBXq8h7nhGytn_WaBmw,16149
+claude_mpm-4.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-4.4.0.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
+claude_mpm-4.4.0.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-4.4.0.dist-info/RECORD,,