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

claude_mpm/services/unified/deployment_strategies/__init__.py

@@ -29,21 +29,21 @@ Design Principles:
 5. Metrics and monitoring integration
 """
 
-from .base import DeploymentStrategy, DeploymentContext, DeploymentResult
-from .local import LocalDeploymentStrategy
-from .vercel import VercelDeploymentStrategy
+from .base import DeploymentContext, DeploymentResult, DeploymentStrategy
 from .cloud_strategies import (
-    RailwayDeploymentStrategy,
     AWSDeploymentStrategy,
     DockerDeploymentStrategy,
     GitDeploymentStrategy,
+    RailwayDeploymentStrategy,
 )
+from .local import LocalDeploymentStrategy
 from .utils import (
-    validate_deployment_config,
     prepare_deployment_artifact,
-    verify_deployment_health,
     rollback_deployment,
+    validate_deployment_config,
+    verify_deployment_health,
 )
+from .vercel import VercelDeploymentStrategy
 
 __all__ = [
     # Base classes
@@ -94,4 +94,4 @@ def get_deployment_strategy(deployment_type: str) -> type[DeploymentStrategy]:
             f"Unsupported deployment type: {deployment_type}. "
             f"Supported types: {', '.join(DEPLOYMENT_STRATEGIES.keys())}"
         )
-    return strategy_class
+    return strategy_class

claude_mpm/services/unified/deployment_strategies/base.py

@@ -31,6 +31,7 @@ from claude_mpm.services.unified.strategies import (
 
 class DeploymentStatus(Enum):
     """Deployment status enumeration."""
+
     PENDING = "pending"
     VALIDATING = "validating"
     PREPARING = "preparing"
@@ -43,6 +44,7 @@ class DeploymentStatus(Enum):
 
 class DeploymentType(Enum):
     """Types of deployments."""
+
     AGENT = "agent"
     CONFIG = "config"
     RESOURCE = "resource"
@@ -62,6 +64,7 @@ class DeploymentContext:
     - multi_source_deployment_service.py
     - deployment_config_loader.py
     """
+
     # Core deployment info
     source: Union[str, Path]
     target: Union[str, Path]
@@ -110,6 +113,7 @@ class DeploymentResult:
 
     Consolidates result patterns from multiple deployment services.
     """
+
     # Core result
     success: bool
     status: DeploymentStatus
@@ -156,7 +160,9 @@ class DeploymentResult:
             "version": self.version,
             "previous_version": self.previous_version,
             "started_at": self.started_at.isoformat() if self.started_at else None,
-            "completed_at": self.completed_at.isoformat() if self.completed_at else None,
+            "completed_at": (
+                self.completed_at.isoformat() if self.completed_at else None
+            ),
             "duration_seconds": self.duration_seconds,
             "artifacts": [str(a) for a in self.artifacts],
             "logs": self.logs,
@@ -255,7 +261,9 @@ class DeploymentStrategy(BaseDeploymentStrategy):
         try:
             # Validation phase
             result.status = DeploymentStatus.VALIDATING
-            self._logger.info(f"Validating deployment: {context.source} -> {context.target}")
+            self._logger.info(
+                f"Validating deployment: {context.source} -> {context.target}"
+            )
 
             validation_errors = self.validate(context)
             if validation_errors:
@@ -309,7 +317,7 @@ class DeploymentStrategy(BaseDeploymentStrategy):
                 result.message = "Dry run completed successfully"
 
         except Exception as e:
-            self._logger.error(f"Deployment failed: {str(e)}")
+            self._logger.error(f"Deployment failed: {e!s}")
             result.status = DeploymentStatus.FAILED
             result.message = str(e)
             result.errors.append(str(e))
@@ -322,8 +330,8 @@ class DeploymentStrategy(BaseDeploymentStrategy):
                     result.status = DeploymentStatus.ROLLED_BACK
                     result.message += " (rolled back)"
                 except Exception as rollback_error:
-                    self._logger.error(f"Rollback failed: {str(rollback_error)}")
-                    result.errors.append(f"Rollback failed: {str(rollback_error)}")
+                    self._logger.error(f"Rollback failed: {rollback_error!s}")
+                    result.errors.append(f"Rollback failed: {rollback_error!s}")
 
         finally:
             result.completed_at = datetime.now()
@@ -353,7 +361,6 @@ class DeploymentStrategy(BaseDeploymentStrategy):
         Returns:
             List of validation errors (empty if valid)
         """
-        pass
 
     @abstractmethod
     def prepare(self, context: DeploymentContext) -> List[Path]:
@@ -366,7 +373,6 @@ class DeploymentStrategy(BaseDeploymentStrategy):
         Returns:
             List of prepared artifact paths
         """
-        pass
 
     @abstractmethod
     def execute(
@@ -382,7 +388,6 @@ class DeploymentStrategy(BaseDeploymentStrategy):
         Returns:
             Deployment information including deployment_id, deployed_path, etc.
         """
-        pass
 
     @abstractmethod
     def verify(
@@ -398,12 +403,9 @@ class DeploymentStrategy(BaseDeploymentStrategy):
         Returns:
             True if deployment verified successfully
         """
-        pass
 
     @abstractmethod
-    def rollback(
-        self, context: DeploymentContext, result: DeploymentResult
-    ) -> bool:
+    def rollback(self, context: DeploymentContext, result: DeploymentResult) -> bool:
         """
         Rollback failed deployment.
 
@@ -414,12 +416,9 @@ class DeploymentStrategy(BaseDeploymentStrategy):
         Returns:
             True if rollback successful
         """
-        pass
 
     @abstractmethod
-    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 deployment.
 
@@ -429,7 +428,6 @@ class DeploymentStrategy(BaseDeploymentStrategy):
         Returns:
             Health status information
         """
-        pass
 
     # Helper methods
 
@@ -458,14 +456,13 @@ class DeploymentStrategy(BaseDeploymentStrategy):
 
         if "agent" in source_path.name.lower():
             return DeploymentType.AGENT
-        elif "config" in source_path.name.lower():
+        if "config" in source_path.name.lower():
             return DeploymentType.CONFIG
-        elif "template" in source_path.name.lower():
+        if "template" in source_path.name.lower():
             return DeploymentType.TEMPLATE
-        elif source_path.suffix in [".yaml", ".yml", ".json"]:
+        if source_path.suffix in [".yaml", ".yml", ".json"]:
             return DeploymentType.CONFIG
-        else:
-            return DeploymentType.RESOURCE
+        return DeploymentType.RESOURCE
 
     def _collect_metrics(
         self, context: DeploymentContext, result: DeploymentResult
@@ -484,9 +481,7 @@ class DeploymentStrategy(BaseDeploymentStrategy):
             "deployment_type": context.deployment_type.value,
             "source_size": self._get_size(context.source) if context.source else 0,
             "artifact_count": len(result.artifacts),
-            "artifact_total_size": sum(
-                self._get_size(a) for a in result.artifacts
-            ),
+            "artifact_total_size": sum(self._get_size(a) for a in result.artifacts),
             "duration_seconds": result.duration_seconds,
             "error_count": len(result.errors),
             "warning_count": len(result.warnings),
@@ -497,7 +492,7 @@ class DeploymentStrategy(BaseDeploymentStrategy):
         path = Path(path)
         if path.is_file():
             return path.stat().st_size
-        elif path.is_dir():
+        if path.is_dir():
             return sum(f.stat().st_size for f in path.rglob("*") if f.is_file())
         return 0
 
@@ -550,8 +545,9 @@ class DeploymentStrategy(BaseDeploymentStrategy):
                     target_path.unlink()
                 elif target_path.is_dir():
                     import shutil
+
                     shutil.rmtree(target_path)
             return True
         except Exception as e:
-            self._logger.error(f"Cleanup failed: {str(e)}")
-            return False
+            self._logger.error(f"Cleanup failed: {e!s}")
+            return False

claude_mpm/services/unified/deployment_strategies/cloud_strategies.py

@@ -10,7 +10,7 @@ import json
 import subprocess
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List
 
 from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.services.unified.strategies import StrategyMetadata, StrategyPriority
@@ -29,14 +29,16 @@ class RailwayDeploymentStrategy(DeploymentStrategy):
 
     def __init__(self):
         """Initialize Railway strategy."""
-        super().__init__(StrategyMetadata(
-            name="RailwayDeploymentStrategy",
-            description="Deploy to Railway cloud platform",
-            supported_types=["application", "service", "*"],
-            supported_operations=["deploy", "rollback", "verify"],
-            priority=StrategyPriority.NORMAL,
-            tags={"railway", "cloud", "paas"},
-        ))
+        super().__init__(
+            StrategyMetadata(
+                name="RailwayDeploymentStrategy",
+                description="Deploy to Railway cloud platform",
+                supported_types=["application", "service", "*"],
+                supported_operations=["deploy", "rollback", "verify"],
+                priority=StrategyPriority.NORMAL,
+                tags={"railway", "cloud", "paas"},
+            )
+        )
         self._logger = get_logger(f"{__name__}.RailwayDeploymentStrategy")
 
     def validate(self, context: DeploymentContext) -> List[str]:
@@ -47,7 +49,9 @@ class RailwayDeploymentStrategy(DeploymentStrategy):
         try:
             subprocess.run(["railway", "--version"], capture_output=True, check=True)
         except:
-            errors.append("Railway CLI not installed. Install with: npm i -g @railway/cli")
+            errors.append(
+                "Railway CLI not installed. Install with: npm i -g @railway/cli"
+            )
 
         # Check authentication
         try:
@@ -64,7 +68,9 @@ class RailwayDeploymentStrategy(DeploymentStrategy):
         )
         return [artifact_path]
 
-    def execute(self, context: DeploymentContext, artifacts: List[Path]) -> Dict[str, Any]:
+    def execute(
+        self, context: DeploymentContext, artifacts: List[Path]
+    ) -> Dict[str, Any]:
         """Execute Railway deployment."""
         deploy_dir = artifacts[0] if artifacts else Path(context.source)
 
@@ -75,13 +81,16 @@ class RailwayDeploymentStrategy(DeploymentStrategy):
             cmd.extend(["--environment", context.config["environment"]])
 
         try:
-            result = subprocess.run(cmd, cwd=deploy_dir, capture_output=True, text=True, check=True)
+            result = subprocess.run(
+                cmd, cwd=deploy_dir, capture_output=True, text=True, check=True
+            )
 
             # Parse deployment URL from output
             deployment_url = None
             for line in result.stdout.split("\n"):
                 if "https://" in line:
                     import re
+
                     match = re.search(r"https://[^\s]+", line)
                     if match:
                         deployment_url = match.group(0)
@@ -96,11 +105,16 @@ class RailwayDeploymentStrategy(DeploymentStrategy):
         except subprocess.CalledProcessError as e:
             raise Exception(f"Railway deployment failed: {e.stderr}")
 
-    def verify(self, context: DeploymentContext, deployment_info: Dict[str, Any]) -> bool:
+    def verify(
+        self, context: DeploymentContext, deployment_info: Dict[str, Any]
+    ) -> bool:
         """Verify Railway deployment."""
-        return verify_deployment_health(
-            "railway", deployment_info, ["accessibility"]
-        )["status"] == "healthy"
+        return (
+            verify_deployment_health("railway", deployment_info, ["accessibility"])[
+                "status"
+            ]
+            == "healthy"
+        )
 
     def rollback(self, context: DeploymentContext, result: DeploymentResult) -> bool:
         """Railway doesn't support CLI rollback."""
@@ -117,14 +131,16 @@ class AWSDeploymentStrategy(DeploymentStrategy):
 
     def __init__(self):
         """Initialize AWS strategy."""
-        super().__init__(StrategyMetadata(
-            name="AWSDeploymentStrategy",
-            description="Deploy to AWS services",
-            supported_types=["lambda", "ec2", "ecs", "application", "*"],
-            supported_operations=["deploy", "rollback", "verify"],
-            priority=StrategyPriority.NORMAL,
-            tags={"aws", "cloud", "serverless"},
-        ))
+        super().__init__(
+            StrategyMetadata(
+                name="AWSDeploymentStrategy",
+                description="Deploy to AWS services",
+                supported_types=["lambda", "ec2", "ecs", "application", "*"],
+                supported_operations=["deploy", "rollback", "verify"],
+                priority=StrategyPriority.NORMAL,
+                tags={"aws", "cloud", "serverless"},
+            )
+        )
         self._logger = get_logger(f"{__name__}.AWSDeploymentStrategy")
 
     def validate(self, context: DeploymentContext) -> List[str]:
@@ -139,7 +155,9 @@ class AWSDeploymentStrategy(DeploymentStrategy):
 
         # Check credentials
         try:
-            subprocess.run(["aws", "sts", "get-caller-identity"], capture_output=True, check=True)
+            subprocess.run(
+                ["aws", "sts", "get-caller-identity"], capture_output=True, check=True
+            )
         except:
             errors.append("AWS credentials not configured")
 
@@ -160,24 +178,26 @@ class AWSDeploymentStrategy(DeploymentStrategy):
                 context.source, "zip", context.config
             )
             return [artifact_path]
-        else:
-            artifact_path, _ = prepare_deployment_artifact(
-                context.source, "directory", context.config
-            )
-            return [artifact_path]
+        artifact_path, _ = prepare_deployment_artifact(
+            context.source, "directory", context.config
+        )
+        return [artifact_path]
 
-    def execute(self, context: DeploymentContext, artifacts: List[Path]) -> Dict[str, Any]:
+    def execute(
+        self, context: DeploymentContext, artifacts: List[Path]
+    ) -> Dict[str, Any]:
         """Execute AWS deployment."""
         service = context.config.get("service", "lambda")
 
         if service == "lambda":
             return self._deploy_lambda(context, artifacts[0])
-        elif service == "s3":
+        if service == "s3":
             return self._deploy_s3(context, artifacts[0])
-        else:
-            raise NotImplementedError(f"AWS {service} deployment not implemented")
+        raise NotImplementedError(f"AWS {service} deployment not implemented")
 
-    def _deploy_lambda(self, context: DeploymentContext, artifact: Path) -> Dict[str, Any]:
+    def _deploy_lambda(
+        self, context: DeploymentContext, artifact: Path
+    ) -> Dict[str, Any]:
         """Deploy AWS Lambda function."""
         function_name = context.config.get("function_name", artifact.stem)
 
@@ -185,23 +205,35 @@ class AWSDeploymentStrategy(DeploymentStrategy):
         try:
             subprocess.run(
                 ["aws", "lambda", "get-function", "--function-name", function_name],
-                capture_output=True, check=True
+                capture_output=True,
+                check=True,
             )
             # Update existing function
             cmd = [
-                "aws", "lambda", "update-function-code",
-                "--function-name", function_name,
-                "--zip-file", f"fileb://{artifact}"
+                "aws",
+                "lambda",
+                "update-function-code",
+                "--function-name",
+                function_name,
+                "--zip-file",
+                f"fileb://{artifact}",
             ]
         except:
             # Create new function
             cmd = [
-                "aws", "lambda", "create-function",
-                "--function-name", function_name,
-                "--runtime", context.config.get("runtime", "python3.9"),
-                "--role", context.config.get("role"),
-                "--handler", context.config.get("handler", "index.handler"),
-                "--zip-file", f"fileb://{artifact}"
+                "aws",
+                "lambda",
+                "create-function",
+                "--function-name",
+                function_name,
+                "--runtime",
+                context.config.get("runtime", "python3.9"),
+                "--role",
+                context.config.get("role"),
+                "--handler",
+                context.config.get("handler", "index.handler"),
+                "--zip-file",
+                f"fileb://{artifact}",
             ]
 
         result = subprocess.run(cmd, capture_output=True, text=True, check=True)
@@ -228,14 +260,21 @@ class AWSDeploymentStrategy(DeploymentStrategy):
             "deployed_path": artifact,
         }
 
-    def verify(self, context: DeploymentContext, deployment_info: Dict[str, Any]) -> bool:
+    def verify(
+        self, context: DeploymentContext, deployment_info: Dict[str, Any]
+    ) -> bool:
         """Verify AWS deployment."""
         service = context.config.get("service", "lambda")
 
         if service == "lambda" and "function_arn" in deployment_info:
             try:
-                cmd = ["aws", "lambda", "get-function", "--function-name",
-                      deployment_info["function_arn"]]
+                cmd = [
+                    "aws",
+                    "lambda",
+                    "get-function",
+                    "--function-name",
+                    deployment_info["function_arn"],
+                ]
                 subprocess.run(cmd, capture_output=True, check=True)
                 return True
             except:
@@ -249,10 +288,15 @@ class AWSDeploymentStrategy(DeploymentStrategy):
         if context.config.get("service") == "lambda" and result.previous_version:
             function_name = context.config.get("function_name")
             cmd = [
-                "aws", "lambda", "update-alias",
-                "--function-name", function_name,
-                "--name", "PROD",
-                "--function-version", result.previous_version
+                "aws",
+                "lambda",
+                "update-alias",
+                "--function-name",
+                function_name,
+                "--name",
+                "PROD",
+                "--function-version",
+                result.previous_version,
             ]
             try:
                 subprocess.run(cmd, check=True)
@@ -271,14 +315,16 @@ class DockerDeploymentStrategy(DeploymentStrategy):
 
     def __init__(self):
         """Initialize Docker strategy."""
-        super().__init__(StrategyMetadata(
-            name="DockerDeploymentStrategy",
-            description="Deploy using Docker containers",
-            supported_types=["container", "application", "service", "*"],
-            supported_operations=["deploy", "rollback", "verify", "stop"],
-            priority=StrategyPriority.HIGH,
-            tags={"docker", "container", "microservice"},
-        ))
+        super().__init__(
+            StrategyMetadata(
+                name="DockerDeploymentStrategy",
+                description="Deploy using Docker containers",
+                supported_types=["container", "application", "service", "*"],
+                supported_operations=["deploy", "rollback", "verify", "stop"],
+                priority=StrategyPriority.HIGH,
+                tags={"docker", "container", "microservice"},
+            )
+        )
         self._logger = get_logger(f"{__name__}.DockerDeploymentStrategy")
 
     def validate(self, context: DeploymentContext) -> List[str]:
@@ -304,10 +350,14 @@ class DockerDeploymentStrategy(DeploymentStrategy):
         """Prepare Docker artifacts."""
         return [Path(context.source)]
 
-    def execute(self, context: DeploymentContext, artifacts: List[Path]) -> Dict[str, Any]:
+    def execute(
+        self, context: DeploymentContext, artifacts: List[Path]
+    ) -> Dict[str, Any]:
         """Execute Docker deployment."""
         source_dir = artifacts[0] if artifacts[0].is_dir() else artifacts[0].parent
-        image_name = context.config.get("image_name", f"app_{datetime.now().timestamp()}")
+        image_name = context.config.get(
+            "image_name", f"app_{datetime.now().timestamp()}"
+        )
         container_name = context.config.get("container_name", image_name)
 
         # Build image
@@ -315,8 +365,12 @@ class DockerDeploymentStrategy(DeploymentStrategy):
         subprocess.run(build_cmd, check=True)
 
         # Stop existing container if exists
-        subprocess.run(["docker", "stop", container_name], capture_output=True, check=False)
-        subprocess.run(["docker", "rm", container_name], capture_output=True, check=False)
+        subprocess.run(
+            ["docker", "stop", container_name], capture_output=True, check=False
+        )
+        subprocess.run(
+            ["docker", "rm", container_name], capture_output=True, check=False
+        )
 
         # Run container
         run_cmd = ["docker", "run", "-d", "--name", container_name]
@@ -344,7 +398,9 @@ class DockerDeploymentStrategy(DeploymentStrategy):
             "deployed_path": source_dir,
         }
 
-    def verify(self, context: DeploymentContext, deployment_info: Dict[str, Any]) -> bool:
+    def verify(
+        self, context: DeploymentContext, deployment_info: Dict[str, Any]
+    ) -> bool:
         """Verify Docker deployment."""
         return check_docker_container(deployment_info.get("container_id"))
 
@@ -369,14 +425,16 @@ class GitDeploymentStrategy(DeploymentStrategy):
 
     def __init__(self):
         """Initialize Git strategy."""
-        super().__init__(StrategyMetadata(
-            name="GitDeploymentStrategy",
-            description="Deploy using Git repositories",
-            supported_types=["repository", "code", "*"],
-            supported_operations=["deploy", "rollback", "verify"],
-            priority=StrategyPriority.NORMAL,
-            tags={"git", "github", "gitlab", "version-control"},
-        ))
+        super().__init__(
+            StrategyMetadata(
+                name="GitDeploymentStrategy",
+                description="Deploy using Git repositories",
+                supported_types=["repository", "code", "*"],
+                supported_operations=["deploy", "rollback", "verify"],
+                priority=StrategyPriority.NORMAL,
+                tags={"git", "github", "gitlab", "version-control"},
+            )
+        )
         self._logger = get_logger(f"{__name__}.GitDeploymentStrategy")
 
     def validate(self, context: DeploymentContext) -> List[str]:
@@ -399,7 +457,9 @@ class GitDeploymentStrategy(DeploymentStrategy):
         """Prepare Git artifacts."""
         return [Path(context.source)]
 
-    def execute(self, context: DeploymentContext, artifacts: List[Path]) -> Dict[str, Any]:
+    def execute(
+        self, context: DeploymentContext, artifacts: List[Path]
+    ) -> Dict[str, Any]:
         """Execute Git deployment."""
         source_dir = artifacts[0] if artifacts[0].is_dir() else artifacts[0].parent
         remote_url = context.config.get("remote_url")
@@ -412,7 +472,9 @@ class GitDeploymentStrategy(DeploymentStrategy):
         # Add remote
         subprocess.run(
             ["git", "remote", "add", "deploy", remote_url],
-            cwd=source_dir, capture_output=True, check=False
+            cwd=source_dir,
+            capture_output=True,
+            check=False,
         )
 
         # Add all files
@@ -422,19 +484,23 @@ class GitDeploymentStrategy(DeploymentStrategy):
         commit_msg = context.config.get("commit_message", "Deploy via Claude MPM")
         subprocess.run(
             ["git", "commit", "-m", commit_msg],
-            cwd=source_dir, capture_output=True, check=False
+            cwd=source_dir,
+            capture_output=True,
+            check=False,
         )
 
         # Push
         subprocess.run(
-            ["git", "push", "-u", "deploy", branch],
-            cwd=source_dir, check=True
+            ["git", "push", "-u", "deploy", branch], cwd=source_dir, check=True
         )
 
         # Get commit hash
         result = subprocess.run(
             ["git", "rev-parse", "HEAD"],
-            cwd=source_dir, capture_output=True, text=True, check=True
+            cwd=source_dir,
+            capture_output=True,
+            text=True,
+            check=True,
         )
         commit_hash = result.stdout.strip()
 
@@ -446,14 +512,21 @@ class GitDeploymentStrategy(DeploymentStrategy):
             "deployed_path": source_dir,
         }
 
-    def verify(self, context: DeploymentContext, deployment_info: Dict[str, Any]) -> bool:
+    def verify(
+        self, context: DeploymentContext, deployment_info: Dict[str, Any]
+    ) -> bool:
         """Verify Git deployment."""
         # Check if commit exists on remote
         try:
             subprocess.run(
-                ["git", "ls-remote", deployment_info.get("remote_url"),
-                 deployment_info.get("commit_hash")],
-                capture_output=True, check=True
+                [
+                    "git",
+                    "ls-remote",
+                    deployment_info.get("remote_url"),
+                    deployment_info.get("commit_hash"),
+                ],
+                capture_output=True,
+                check=True,
             )
             return True
         except:
@@ -465,12 +538,19 @@ class GitDeploymentStrategy(DeploymentStrategy):
             try:
                 subprocess.run(
                     ["git", "checkout", result.previous_version],
-                    cwd=result.deployed_path, check=True
+                    cwd=result.deployed_path,
+                    check=True,
                 )
                 subprocess.run(
-                    ["git", "push", "--force", "deploy",
-                     f"{result.previous_version}:{context.config.get('branch', 'main')}"],
-                    cwd=result.deployed_path, check=True
+                    [
+                        "git",
+                        "push",
+                        "--force",
+                        "deploy",
+                        f"{result.previous_version}:{context.config.get('branch', 'main')}",
+                    ],
+                    cwd=result.deployed_path,
+                    check=True,
                 )
                 return True
             except:
@@ -483,4 +563,4 @@ class GitDeploymentStrategy(DeploymentStrategy):
             "status": "healthy" if deployment_info.get("commit_hash") else "unhealthy",
             "commit": deployment_info.get("commit_hash", "unknown"),
             "branch": deployment_info.get("branch", "unknown"),
-        }
+        }