claude-mpm 4.4.3__py3-none-any.whl → 4.4.5__py3-none-any.whl

claude_mpm/services/unified/deployment_strategies/local.py

@@ -22,7 +22,12 @@ import yaml
 from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.services.unified.strategies import StrategyMetadata, StrategyPriority
 
-from .base import DeploymentContext, DeploymentResult, DeploymentStrategy, DeploymentType
+from .base import (
+    DeploymentContext,
+    DeploymentResult,
+    DeploymentStrategy,
+    DeploymentType,
+)
 
 
 class LocalDeploymentStrategy(DeploymentStrategy):
@@ -83,13 +88,14 @@ class LocalDeploymentStrategy(DeploymentStrategy):
                 target_parent.mkdir(parents=True, exist_ok=True)
                 target_parent.rmdir()  # Clean up test directory
             except PermissionError:
-                errors.append(f"No permission to create target directory: {target_parent}")
-        else:
-            # Check write permissions
-            if not target_parent.is_dir():
-                errors.append(f"Target parent is not a directory: {target_parent}")
-            elif not self._check_write_permission(target_parent):
-                errors.append(f"No write permission for target: {target_parent}")
+                errors.append(
+                    f"No permission to create target directory: {target_parent}"
+                )
+        # Check write permissions
+        elif not target_parent.is_dir():
+            errors.append(f"Target parent is not a directory: {target_parent}")
+        elif not self._check_write_permission(target_parent):
+            errors.append(f"No write permission for target: {target_parent}")
 
         # Validate deployment type specific requirements
         if context.deployment_type == DeploymentType.AGENT:
@@ -209,16 +215,14 @@ class LocalDeploymentStrategy(DeploymentStrategy):
         # Type-specific verification
         if context.deployment_type == DeploymentType.AGENT:
             return self._verify_agent_deployment(deployed_path, context)
-        elif context.deployment_type == DeploymentType.CONFIG:
+        if context.deployment_type == DeploymentType.CONFIG:
             return self._verify_config_deployment(deployed_path, context)
-        elif context.deployment_type == DeploymentType.TEMPLATE:
+        if context.deployment_type == DeploymentType.TEMPLATE:
             return self._verify_template_deployment(deployed_path, context)
 
         return True
 
-    def rollback(
-        self, context: DeploymentContext, result: DeploymentResult
-    ) -> bool:
+    def rollback(self, context: DeploymentContext, result: DeploymentResult) -> bool:
         """
         Rollback local deployment.
 
@@ -252,12 +256,10 @@ class LocalDeploymentStrategy(DeploymentStrategy):
             return True
 
         except Exception as e:
-            self._logger.error(f"Rollback failed: {str(e)}")
+            self._logger.error(f"Rollback failed: {e!s}")
             return False
 
-    def get_health_status(
-        self, deployment_info: Dict[str, Any]
-    ) -> Dict[str, Any]:
+    def get_health_status(self, deployment_info: Dict[str, Any]) -> Dict[str, Any]:
         """
         Get health status of local deployment.
 
@@ -307,7 +309,9 @@ class LocalDeploymentStrategy(DeploymentStrategy):
 
     def _generate_deployment_id(self) -> str:
         """Generate unique deployment ID."""
-        return f"local_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{id(self) % 10000:04d}"
+        return (
+            f"local_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{id(self) % 10000:04d}"
+        )
 
     def _create_backup(self, context: DeploymentContext) -> Optional[Path]:
         """Create backup of target before deployment."""
@@ -333,7 +337,7 @@ class LocalDeploymentStrategy(DeploymentStrategy):
             return backup_path
 
         except Exception as e:
-            self._logger.warning(f"Failed to create backup: {str(e)}")
+            self._logger.warning(f"Failed to create backup: {e!s}")
             return None
 
     def _write_version_file(self, target_path: Path, version: str) -> None:
@@ -354,9 +358,11 @@ class LocalDeploymentStrategy(DeploymentStrategy):
                 errors.append(f"Invalid agent file format: {source_path.suffix}")
         elif source_path.is_dir():
             # Check for agent definition files
-            agent_files = list(source_path.glob("*.json")) + \
-                         list(source_path.glob("*.yaml")) + \
-                         list(source_path.glob("*.yml"))
+            agent_files = (
+                list(source_path.glob("*.json"))
+                + list(source_path.glob("*.yaml"))
+                + list(source_path.glob("*.yml"))
+            )
             if not agent_files:
                 errors.append(f"No agent definition files found in: {source_path}")
 
@@ -397,8 +403,9 @@ class LocalDeploymentStrategy(DeploymentStrategy):
     ) -> bool:
         """Verify agent deployment."""
         # Check for valid YAML structure
-        yaml_files = list(deployed_path.glob("*.yaml")) + \
-                    list(deployed_path.glob("*.yml"))
+        yaml_files = list(deployed_path.glob("*.yaml")) + list(
+            deployed_path.glob("*.yml")
+        )
 
         for yaml_file in yaml_files:
             try:
@@ -411,7 +418,7 @@ class LocalDeploymentStrategy(DeploymentStrategy):
                         self._logger.error(f"Agent missing 'name' field: {yaml_file}")
                         return False
             except Exception as e:
-                self._logger.error(f"Invalid agent YAML: {yaml_file}: {str(e)}")
+                self._logger.error(f"Invalid agent YAML: {yaml_file}: {e!s}")
                 return False
 
         return True
@@ -436,7 +443,14 @@ class LocalDeploymentStrategy(DeploymentStrategy):
 
         if source_path.is_file():
             # Validate config file format
-            if source_path.suffix not in [".json", ".yaml", ".yml", ".toml", ".ini", ".env"]:
+            if source_path.suffix not in [
+                ".json",
+                ".yaml",
+                ".yml",
+                ".toml",
+                ".ini",
+                ".env",
+            ]:
                 errors.append(f"Unsupported config format: {source_path.suffix}")
 
         return errors
@@ -496,15 +510,16 @@ class LocalDeploymentStrategy(DeploymentStrategy):
 
         # Process template with variables
         if source_path.is_file():
-            processed = self._process_template(source_path, context.config.get("variables", {}))
+            processed = self._process_template(
+                source_path, context.config.get("variables", {})
+            )
             artifacts.append(processed)
         else:
             # Process all template files in directory
             for template_file in source_path.rglob("*"):
                 if template_file.is_file():
                     processed = self._process_template(
-                        template_file,
-                        context.config.get("variables", {})
+                        template_file, context.config.get("variables", {})
                     )
                     artifacts.append(processed)
 
@@ -552,9 +567,7 @@ class LocalDeploymentStrategy(DeploymentStrategy):
 
         return True
 
-    def _process_template(
-        self, template_path: Path, variables: Dict[str, Any]
-    ) -> Path:
+    def _process_template(self, template_path: Path, variables: Dict[str, Any]) -> Path:
         """Process template file with variables."""
         content = template_path.read_text()
 
@@ -578,7 +591,9 @@ class LocalDeploymentStrategy(DeploymentStrategy):
 
         for artifact in artifacts:
             if artifact.is_file():
-                dest = target_path / artifact.name if target_path.is_dir() else target_path
+                dest = (
+                    target_path / artifact.name if target_path.is_dir() else target_path
+                )
                 shutil.copy2(artifact, dest)
                 deployed.append(dest)
             elif artifact.is_dir():
@@ -591,4 +606,4 @@ class LocalDeploymentStrategy(DeploymentStrategy):
 
             self._logger.info(f"Deployed resource: {deployed[-1]}")
 
-        return deployed
+        return deployed

claude_mpm/services/unified/deployment_strategies/utils.py

@@ -16,7 +16,6 @@ This module reduces ~5000 LOC of duplicated utility functions across:
 
 import hashlib
 import json
-import os
 import shutil
 import subprocess
 import tempfile
@@ -24,8 +23,6 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
 
-import yaml
-
 from claude_mpm.core.logging_utils import get_logger
 
 logger = get_logger(__name__)
@@ -34,6 +31,7 @@ logger = get_logger(__name__)
 # Validation Utilities
 # ====================
 
+
 def validate_deployment_config(config: Dict[str, Any]) -> List[str]:
     """
     Validate deployment configuration.
@@ -57,8 +55,16 @@ def validate_deployment_config(config: Dict[str, Any]) -> List[str]:
     # Type validation
     if "type" in config:
         valid_types = [
-            "local", "vercel", "railway", "aws", "docker", "git",
-            "agent", "config", "template", "resource"
+            "local",
+            "vercel",
+            "railway",
+            "aws",
+            "docker",
+            "git",
+            "agent",
+            "config",
+            "template",
+            "resource",
         ]
         if config["type"] not in valid_types:
             errors.append(f"Invalid deployment type: {config['type']}")
@@ -133,10 +139,11 @@ def validate_path_security(path: Path, base_path: Path) -> bool:
 # Artifact Preparation
 # ====================
 
+
 def prepare_deployment_artifact(
     source: Union[str, Path],
     artifact_type: str = "auto",
-    config: Optional[Dict[str, Any]] = None
+    config: Optional[Dict[str, Any]] = None,
 ) -> Tuple[Path, Dict[str, Any]]:
     """
     Prepare deployment artifact from source.
@@ -230,10 +237,11 @@ def create_tar_artifact(source: Path, output_dir: Path) -> Path:
 # Health Check Utilities
 # ======================
 
+
 def verify_deployment_health(
     deployment_type: str,
     deployment_info: Dict[str, Any],
-    checks: Optional[List[str]] = None
+    checks: Optional[List[str]] = None,
 ) -> Dict[str, Any]:
     """
     Perform health checks on deployment.
@@ -275,8 +283,7 @@ def verify_deployment_health(
         if "integrity" in checks:
             if "checksum" in deployment_info:
                 health["checks"]["integrity"] = verify_checksum(
-                    deployment_info.get("deployed_path"),
-                    deployment_info["checksum"]
+                    deployment_info.get("deployed_path"), deployment_info["checksum"]
                 )
 
         # Service-specific checks
@@ -285,9 +292,7 @@ def verify_deployment_health(
                 deployment_info.get("container_id")
             )
         elif deployment_type == "aws":
-            health["checks"]["aws_status"] = check_aws_deployment(
-                deployment_info
-            )
+            health["checks"]["aws_status"] = check_aws_deployment(deployment_info)
 
         # Determine overall status
         if all(health["checks"].values()):
@@ -308,6 +313,7 @@ def check_url_accessibility(url: str, timeout: int = 10) -> bool:
     """Check if URL is accessible."""
     try:
         import urllib.request
+
         with urllib.request.urlopen(url, timeout=timeout) as response:
             return response.status < 400
     except Exception:
@@ -340,10 +346,11 @@ def check_aws_deployment(deployment_info: Dict[str, Any]) -> bool:
 # Rollback Utilities
 # ==================
 
+
 def rollback_deployment(
     deployment_type: str,
     deployment_info: Dict[str, Any],
-    backup_info: Optional[Dict[str, Any]] = None
+    backup_info: Optional[Dict[str, Any]] = None,
 ) -> bool:
     """
     Rollback deployment to previous state.
@@ -361,22 +368,20 @@ def rollback_deployment(
     try:
         if deployment_type == "local":
             return rollback_local_deployment(deployment_info, backup_info)
-        elif deployment_type == "docker":
+        if deployment_type == "docker":
             return rollback_docker_deployment(deployment_info)
-        elif deployment_type == "git":
+        if deployment_type == "git":
             return rollback_git_deployment(deployment_info)
-        else:
-            logger.warning(f"No rollback strategy for type: {deployment_type}")
-            return False
+        logger.warning(f"No rollback strategy for type: {deployment_type}")
+        return False
 
     except Exception as e:
-        logger.error(f"Rollback failed: {str(e)}")
+        logger.error(f"Rollback failed: {e!s}")
         return False
 
 
 def rollback_local_deployment(
-    deployment_info: Dict[str, Any],
-    backup_info: Optional[Dict[str, Any]] = None
+    deployment_info: Dict[str, Any], backup_info: Optional[Dict[str, Any]] = None
 ) -> bool:
     """Rollback local filesystem deployment."""
     deployed_path = Path(deployment_info.get("deployed_path", ""))
@@ -413,8 +418,7 @@ def rollback_docker_deployment(deployment_info: Dict[str, Any]) -> bool:
     # Restore previous container if specified
     if "previous_container" in deployment_info:
         subprocess.run(
-            ["docker", "start", deployment_info["previous_container"]],
-            check=True
+            ["docker", "start", deployment_info["previous_container"]], check=True
         )
 
     return True
@@ -426,11 +430,7 @@ def rollback_git_deployment(deployment_info: Dict[str, Any]) -> bool:
     previous_commit = deployment_info.get("previous_commit")
 
     if repo_path.exists() and previous_commit:
-        subprocess.run(
-            ["git", "checkout", previous_commit],
-            cwd=repo_path,
-            check=True
-        )
+        subprocess.run(["git", "checkout", previous_commit], cwd=repo_path, check=True)
         return True
 
     return False
@@ -439,6 +439,7 @@ def rollback_git_deployment(deployment_info: Dict[str, Any]) -> bool:
 # Version Management
 # ==================
 
+
 def get_version_info(path: Union[str, Path]) -> Dict[str, Any]:
     """
     Extract version information from deployment.
@@ -474,6 +475,7 @@ def get_version_info(path: Union[str, Path]) -> Dict[str, Any]:
             elif version_file in ["setup.py", "pyproject.toml"]:
                 # Simple regex extraction
                 import re
+
                 content = file_path.read_text()
                 match = re.search(r'version\s*=\s*["\'](.*?)["\']', content)
                 if match:
@@ -491,9 +493,7 @@ def get_version_info(path: Union[str, Path]) -> Dict[str, Any]:
 
 
 def update_version(
-    path: Union[str, Path],
-    new_version: str,
-    create_backup: bool = True
+    path: Union[str, Path], new_version: str, create_backup: bool = True
 ) -> bool:
     """
     Update version in deployment.
@@ -520,13 +520,14 @@ def update_version(
         return True
 
     except Exception as e:
-        logger.error(f"Failed to update version: {str(e)}")
+        logger.error(f"Failed to update version: {e!s}")
         return False
 
 
 # Checksum and Integrity
 # ======================
 
+
 def calculate_checksum(path: Union[str, Path], algorithm: str = "sha256") -> str:
     """
     Calculate checksum of file or directory.
@@ -558,9 +559,7 @@ def calculate_checksum(path: Union[str, Path], algorithm: str = "sha256") -> str
 
 
 def verify_checksum(
-    path: Union[str, Path],
-    expected_checksum: str,
-    algorithm: str = "sha256"
+    path: Union[str, Path], expected_checksum: str, algorithm: str = "sha256"
 ) -> bool:
     """
     Verify checksum of file or directory.
@@ -594,19 +593,19 @@ def get_size(path: Union[str, Path]) -> int:
 
     if path.is_file():
         return path.stat().st_size
-    elif path.is_dir():
+    if path.is_dir():
         total_size = 0
         for file_path in path.rglob("*"):
             if file_path.is_file():
                 total_size += file_path.stat().st_size
         return total_size
-    else:
-        return 0
+    return 0
 
 
 # Environment Management
 # =====================
 
+
 def load_env_file(env_file: Union[str, Path]) -> Dict[str, str]:
     """
     Load environment variables from file.
@@ -650,10 +649,7 @@ def merge_environments(*env_dicts: Dict[str, str]) -> Dict[str, str]:
     return merged
 
 
-def export_env_to_file(
-    env_vars: Dict[str, str],
-    output_file: Union[str, Path]
-) -> None:
+def export_env_to_file(env_vars: Dict[str, str], output_file: Union[str, Path]) -> None:
     """
     Export environment variables to file.
 
@@ -669,4 +665,4 @@ def export_env_to_file(
             # Escape special characters in value
             if " " in value or '"' in value:
                 value = f'"{value}"'
-            f.write(f"{key}={value}\n")
+            f.write(f"{key}={value}\n")

claude_mpm/services/unified/deployment_strategies/vercel.py

@@ -16,7 +16,11 @@ from typing import Any, Dict, List, Optional
 from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.services.unified.strategies import StrategyMetadata, StrategyPriority
 
-from .base import DeploymentContext, DeploymentResult, DeploymentStrategy, DeploymentType
+from .base import (
+    DeploymentContext,
+    DeploymentResult,
+    DeploymentStrategy,
+)
 
 
 class VercelDeploymentStrategy(DeploymentStrategy):
@@ -117,11 +121,13 @@ class VercelDeploymentStrategy(DeploymentStrategy):
             # Single file deployment (e.g., serverless function)
             deploy_file = deploy_dir / source_path.name
             import shutil
+
             shutil.copy2(source_path, deploy_file)
             artifacts.append(deploy_file)
         else:
             # Directory deployment
             import shutil
+
             shutil.copytree(source_path, deploy_dir / "app", dirs_exist_ok=True)
             artifacts.append(deploy_dir / "app")
 
@@ -200,8 +206,7 @@ class VercelDeploymentStrategy(DeploymentStrategy):
                     "stdout": result.stdout,
                     "timestamp": datetime.now().isoformat(),
                 }
-            else:
-                raise Exception("Could not parse deployment URL from Vercel output")
+            raise Exception("Could not parse deployment URL from Vercel output")
 
         except subprocess.CalledProcessError as e:
             self._logger.error(f"Vercel deployment failed: {e.stderr}")
@@ -235,18 +240,15 @@ class VercelDeploymentStrategy(DeploymentStrategy):
                 if response.status == 200:
                     self._logger.info(f"Deployment verified: {deployment_url}")
                     return True
-                else:
-                    self._logger.error(f"Deployment returned status: {response.status}")
-                    return False
+                self._logger.error(f"Deployment returned status: {response.status}")
+                return False
 
         except Exception as e:
-            self._logger.error(f"Failed to verify deployment: {str(e)}")
+            self._logger.error(f"Failed to verify deployment: {e!s}")
             # May still be building, check via CLI
             return self._check_deployment_status(deployment_info.get("deployment_id"))
 
-    def rollback(
-        self, context: DeploymentContext, result: DeploymentResult
-    ) -> bool:
+    def rollback(self, context: DeploymentContext, result: DeploymentResult) -> bool:
         """
         Rollback Vercel deployment.
 
@@ -280,23 +282,20 @@ class VercelDeploymentStrategy(DeploymentStrategy):
                     check=True,
                 )
 
-                self._logger.info(f"Rolled back to previous deployment")
+                self._logger.info("Rolled back to previous deployment")
                 return True
 
-            else:
-                self._logger.warning(
-                    "No previous deployment ID available for rollback. "
-                    "Manual rollback required via Vercel dashboard."
-                )
-                return False
+            self._logger.warning(
+                "No previous deployment ID available for rollback. "
+                "Manual rollback required via Vercel dashboard."
+            )
+            return False
 
         except Exception as e:
-            self._logger.error(f"Rollback failed: {str(e)}")
+            self._logger.error(f"Rollback failed: {e!s}")
             return False
 
-    def get_health_status(
-        self, deployment_info: Dict[str, Any]
-    ) -> Dict[str, Any]:
+    def get_health_status(self, deployment_info: Dict[str, Any]) -> Dict[str, Any]:
         """
         Get health status of Vercel deployment.
 
@@ -325,7 +324,9 @@ class VercelDeploymentStrategy(DeploymentStrategy):
             # Check main deployment URL
             with urllib.request.urlopen(deployment_url) as response:
                 health["checks"]["main_url"] = response.status == 200
-                health["response_time_ms"] = response.info().get("X-Vercel-Trace", "N/A")
+                health["response_time_ms"] = response.info().get(
+                    "X-Vercel-Trace", "N/A"
+                )
 
             # Check functions if configured
             if deployment_info.get("functions"):
@@ -333,7 +334,9 @@ class VercelDeploymentStrategy(DeploymentStrategy):
                     func_url = f"{deployment_url}/api/{func_name}"
                     try:
                         with urllib.request.urlopen(func_url) as response:
-                            health["checks"][f"function_{func_name}"] = response.status < 500
+                            health["checks"][f"function_{func_name}"] = (
+                                response.status < 500
+                            )
                     except:
                         health["checks"][f"function_{func_name}"] = False
 
@@ -443,6 +446,7 @@ class VercelDeploymentStrategy(DeploymentStrategy):
             if "https://" in line:
                 # Extract URL
                 import re
+
                 url_match = re.search(r"https://[^\s]+", line)
                 if url_match:
                     return url_match.group(0)
@@ -468,4 +472,6 @@ class VercelDeploymentStrategy(DeploymentStrategy):
 
     def _generate_deployment_id(self) -> str:
         """Generate unique deployment ID."""
-        return f"vercel_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{id(self) % 10000:04d}"
+        return (
+            f"vercel_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{id(self) % 10000:04d}"
+        )