claude-mpm 4.13.2__py3-none-any.whl → 4.18.2__py3-none-any.whl

claude_mpm/services/unified/analyzer_strategies/dependency_analyzer.py

@@ -14,6 +14,7 @@ import re
 from pathlib import Path
 from typing import Any, ClassVar, Dict, List, Optional
 
+from claude_mpm.core.enums import OperationResult
 from claude_mpm.core.logging_utils import get_logger
 
 from ..strategies import (
@@ -166,7 +167,7 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
                 return self._analyze_manifest(target_path, options)
 
         return {
-            "status": "error",
+            "status": OperationResult.ERROR,
             "message": f"Unsupported target type: {type(target).__name__}",
         }
 
@@ -175,7 +176,7 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
     ) -> Dict[str, Any]:
         """Analyze dependencies in a project directory."""
         results = {
-            "status": "success",
+            "status": OperationResult.SUCCESS,
             "type": "project",
             "path": str(project_path),
             "package_managers": [],
@@ -221,7 +222,7 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
     ) -> Dict[str, Any]:
         """Analyze a specific package manifest file."""
         results = {
-            "status": "success",
+            "status": OperationResult.SUCCESS,
             "type": "manifest",
             "path": str(manifest_path),
             "dependencies": {},
@@ -238,7 +239,7 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
 
         if not manager:
             return {
-                "status": "error",
+                "status": OperationResult.ERROR,
                 "message": f"Unknown manifest file: {manifest_path.name}",
             }
 
@@ -598,7 +599,7 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
         """Extract key metrics from analysis results."""
         metrics = {}
 
-        if analysis_result.get("status") != "success":
+        if analysis_result.get("status") != OperationResult.SUCCESS:
             return metrics
 
         # Extract dependency counts

claude_mpm/services/unified/analyzer_strategies/performance_analyzer.py

@@ -14,6 +14,7 @@ import re
 from pathlib import Path
 from typing import Any, ClassVar, Dict, List, Optional
 
+from claude_mpm.core.enums import OperationResult
 from claude_mpm.core.logging_utils import get_logger
 
 from ..strategies import (
@@ -188,14 +189,14 @@ class PerformanceAnalyzerStrategy(AnalyzerStrategy):
             return self._analyze_ast_performance(target, options)
 
         return {
-            "status": "error",
+            "status": OperationResult.ERROR,
             "message": f"Unsupported target type: {type(target).__name__}",
         }
 
     def _analyze_file(self, file_path: Path, options: Dict[str, Any]) -> Dict[str, Any]:
         """Analyze a single file for performance issues."""
         results = {
-            "status": "success",
+            "status": OperationResult.SUCCESS,
             "type": "file",
             "path": str(file_path),
             "issues": [],
@@ -240,7 +241,7 @@ class PerformanceAnalyzerStrategy(AnalyzerStrategy):
 
         except Exception as e:
             logger.error(f"Error analyzing file {file_path}: {e}")
-            results["status"] = "error"
+            results["status"] = OperationResult.ERROR
             results["error"] = str(e)
 
         return results
@@ -250,7 +251,7 @@ class PerformanceAnalyzerStrategy(AnalyzerStrategy):
     ) -> Dict[str, Any]:
         """Analyze all files in a directory for performance issues."""
         results = {
-            "status": "success",
+            "status": OperationResult.SUCCESS,
             "type": "directory",
             "path": str(dir_path),
             "files_analyzed": 0,
@@ -291,7 +292,7 @@ class PerformanceAnalyzerStrategy(AnalyzerStrategy):
                     continue
 
                 file_result = self._analyze_file(file_path, options)
-                if file_result["status"] == "success":
+                if file_result["status"] == OperationResult.SUCCESS:
                     results["files_analyzed"] += 1
                     total_score += file_result["performance_score"]
 
@@ -654,7 +655,7 @@ class PerformanceAnalyzerStrategy(AnalyzerStrategy):
     ) -> Dict[str, Any]:
         """Analyze performance of an AST node."""
         results = {
-            "status": "success",
+            "status": OperationResult.SUCCESS,
             "type": "ast",
             "complexity": {},
             "issues": [],
@@ -802,7 +803,7 @@ class PerformanceAnalyzerStrategy(AnalyzerStrategy):
         """Extract key metrics from analysis results."""
         metrics = {}
 
-        if analysis_result.get("status") != "success":
+        if analysis_result.get("status") != OperationResult.SUCCESS:
             return metrics
 
         if analysis_result.get("type") == "file":

claude_mpm/services/unified/analyzer_strategies/security_analyzer.py

@@ -14,6 +14,7 @@ import re
 from pathlib import Path
 from typing import Any, ClassVar, Dict, List, Optional
 
+from claude_mpm.core.enums import OperationResult
 from claude_mpm.core.logging_utils import get_logger
 
 from ..strategies import (
@@ -198,14 +199,14 @@ class SecurityAnalyzerStrategy(AnalyzerStrategy):
                 return self._analyze_directory(target_path, options)
 
         return {
-            "status": "error",
+            "status": OperationResult.ERROR,
             "message": f"Unsupported target type: {type(target).__name__}",
         }
 
     def _analyze_file(self, file_path: Path, options: Dict[str, Any]) -> Dict[str, Any]:
         """Analyze a single file for security issues."""
         results = {
-            "status": "success",
+            "status": OperationResult.SUCCESS,
             "type": "file",
             "path": str(file_path),
             "vulnerabilities": [],
@@ -241,7 +242,7 @@ class SecurityAnalyzerStrategy(AnalyzerStrategy):
 
         except Exception as e:
             logger.error(f"Error analyzing file {file_path}: {e}")
-            results["status"] = "error"
+            results["status"] = OperationResult.ERROR
             results["error"] = str(e)
 
         return results
@@ -251,7 +252,7 @@ class SecurityAnalyzerStrategy(AnalyzerStrategy):
     ) -> Dict[str, Any]:
         """Analyze all files in a directory for security issues."""
         results = {
-            "status": "success",
+            "status": OperationResult.SUCCESS,
             "type": "directory",
             "path": str(dir_path),
             "files_analyzed": 0,
@@ -301,7 +302,7 @@ class SecurityAnalyzerStrategy(AnalyzerStrategy):
 
                 file_result = self._analyze_file(file_path, options)
                 if (
-                    file_result["status"] == "success"
+                    file_result["status"] == OperationResult.SUCCESS
                     and file_result["vulnerabilities"]
                 ):
                     results["files"].append(file_result)
@@ -645,7 +646,7 @@ class SecurityAnalyzerStrategy(AnalyzerStrategy):
         """Extract key metrics from analysis results."""
         metrics = {}
 
-        if analysis_result.get("status") != "success":
+        if analysis_result.get("status") != OperationResult.SUCCESS:
             return metrics
 
         if analysis_result.get("type") == "file":

claude_mpm/services/unified/analyzer_strategies/structure_analyzer.py

@@ -13,6 +13,7 @@ import fnmatch
 from pathlib import Path
 from typing import Any, ClassVar, Dict, List, Optional, Tuple
 
+from claude_mpm.core.enums import OperationResult
 from claude_mpm.core.logging_utils import get_logger
 
 from ..strategies import (
@@ -174,14 +175,14 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
 
             if not target_path.is_dir():
                 return {
-                    "status": "error",
+                    "status": OperationResult.ERROR,
                     "message": "Target must be a directory",
                 }
 
             return self._analyze_structure(target_path, options)
 
         return {
-            "status": "error",
+            "status": OperationResult.ERROR,
             "message": f"Unsupported target type: {type(target).__name__}",
         }
 
@@ -190,7 +191,7 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
     ) -> Dict[str, Any]:
         """Analyze the structure of a project directory."""
         results = {
-            "status": "success",
+            "status": OperationResult.SUCCESS,
             "type": "structure",
             "path": str(root_path),
             "tree": {},
@@ -640,7 +641,7 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
         """Extract key metrics from analysis results."""
         metrics = {}
 
-        if analysis_result.get("status") != "success":
+        if analysis_result.get("status") != OperationResult.SUCCESS:
             return metrics
 
         # Extract structure statistics

claude_mpm/services/unified/config_strategies/validation_strategy.py

@@ -13,6 +13,7 @@ from enum import Enum
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Pattern, Union
 
+from claude_mpm.core.enums import ValidationSeverity
 from claude_mpm.core.logging_utils import get_logger
 
 from .unified_config_service import IConfigStrategy
@@ -45,7 +46,7 @@ class ValidationRule:
     type: ValidationType
     params: Dict[str, Any] = field(default_factory=dict)
     message: Optional[str] = None
-    severity: str = "error"  # error, warning, info
+    severity: str = ValidationSeverity.ERROR
     condition: Optional[Callable] = None
 
 
@@ -73,15 +74,18 @@ class BaseValidator(ABC):
         """Perform validation"""
 
     def _create_result(
-        self, valid: bool, message: Optional[str] = None, severity: str = "error"
+        self,
+        valid: bool,
+        message: Optional[str] = None,
+        severity: str = ValidationSeverity.ERROR,
     ) -> ValidationResult:
         """Create validation result"""
         result = ValidationResult(valid=valid)
 
         if not valid and message:
-            if severity == "error":
+            if severity == ValidationSeverity.ERROR:
                 result.errors.append(message)
-            elif severity == "warning":
+            elif severity == ValidationSeverity.WARNING:
                 result.warnings.append(message)
             else:
                 result.info.append(message)
@@ -556,9 +560,9 @@ class DependencyValidator(BaseValidator):
         if errors:
             result = ValidationResult(valid=False)
             for error in errors:
-                if rule.severity == "error":
+                if rule.severity == ValidationSeverity.ERROR:
                     result.errors.append(error)
-                elif rule.severity == "warning":
+                elif rule.severity == ValidationSeverity.WARNING:
                     result.warnings.append(error)
                 else:
                     result.info.append(error)
@@ -721,7 +725,7 @@ class ConditionalValidator(BaseValidator):
             type=ValidationType[rule_def.get("type", "CUSTOM").upper()],
             params=rule_def.get("params", {}),
             message=rule_def.get("message"),
-            severity=rule_def.get("severity", "error"),
+            severity=rule_def.get("severity", ValidationSeverity.ERROR),
         )
 
         # Find appropriate validator
@@ -843,9 +847,9 @@ class CrossFieldValidator(BaseValidator):
         for constraint in constraints:
             if not self._evaluate_constraint(config, constraint):
                 message = constraint.get("message", "Cross-field constraint failed")
-                if rule.severity == "error":
+                if rule.severity == ValidationSeverity.ERROR:
                     result.errors.append(message)
-                elif rule.severity == "warning":
+                elif rule.severity == ValidationSeverity.WARNING:
                     result.warnings.append(message)
                 else:
                     result.info.append(message)

claude_mpm/services/unified/deployment_strategies/cloud_strategies.py

@@ -12,6 +12,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List
 
+from claude_mpm.core.enums import OperationResult, ServiceState
 from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.services.unified.strategies import StrategyMetadata, StrategyPriority
 
@@ -411,11 +412,13 @@ class DockerDeploymentStrategy(DeploymentStrategy):
     def get_health_status(self, deployment_info: Dict[str, Any]) -> Dict[str, Any]:
         """Get Docker container health."""
         container_id = deployment_info.get("container_id")
-        health = {"status": "unknown", "container_id": container_id}
+        health = {"status": OperationResult.UNKNOWN, "container_id": container_id}
 
         if container_id:
             health["running"] = check_docker_container(container_id)
-            health["status"] = "healthy" if health["running"] else "unhealthy"
+            health["status"] = (
+                ServiceState.RUNNING if health["running"] else ServiceState.ERROR
+            )
 
         return health
 
@@ -560,7 +563,11 @@ class GitDeploymentStrategy(DeploymentStrategy):
     def get_health_status(self, deployment_info: Dict[str, Any]) -> Dict[str, Any]:
         """Get Git deployment health."""
         return {
-            "status": "healthy" if deployment_info.get("commit_hash") else "unhealthy",
+            "status": (
+                ServiceState.RUNNING
+                if deployment_info.get("commit_hash")
+                else ServiceState.ERROR
+            ),
             "commit": deployment_info.get("commit_hash", "unknown"),
             "branch": deployment_info.get("branch", "unknown"),
         }

claude_mpm/services/unified/deployment_strategies/local.py

@@ -19,6 +19,7 @@ from typing import Any, Dict, List, Optional
 
 import yaml
 
+from claude_mpm.core.enums import HealthStatus, OperationResult
 from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.services.unified.strategies import StrategyMetadata, StrategyPriority
 
@@ -272,14 +273,14 @@ class LocalDeploymentStrategy(DeploymentStrategy):
         deployed_path = Path(deployment_info.get("deployed_path", ""))
 
         health = {
-            "status": "unknown",
+            "status": OperationResult.UNKNOWN,
             "deployed_path": str(deployed_path),
             "exists": deployed_path.exists() if deployed_path else False,
             "checks": {},
         }
 
         if deployed_path and deployed_path.exists():
-            health["status"] = "healthy"
+            health["status"] = OperationResult.SUCCESS
 
             # Check file integrity
             for file_path in deployment_info.get("deployed_files", []):
@@ -288,10 +289,10 @@ class LocalDeploymentStrategy(DeploymentStrategy):
 
             # Check if any file is missing
             if any(not check for check in health["checks"].values()):
-                health["status"] = "degraded"
+                health["status"] = HealthStatus.DEGRADED
 
         else:
-            health["status"] = "unhealthy"
+            health["status"] = HealthStatus.UNHEALTHY
 
         return health
 
@@ -394,7 +395,7 @@ class LocalDeploymentStrategy(DeploymentStrategy):
                 shutil.copy2(artifact, dest)
                 deployed.append(dest)
 
-                self._logger.info(f"Deployed agent: {dest}")
+                self._logger.debug(f"Deployed agent: {dest}")
 
         return deployed
 

claude_mpm/services/unified/deployment_strategies/utils.py

@@ -23,6 +23,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
 
+from claude_mpm.core.enums import HealthStatus, OperationResult
 from claude_mpm.core.logging_utils import get_logger
 
 logger = get_logger(__name__)
@@ -256,7 +257,7 @@ def verify_deployment_health(
         Health status dictionary
     """
     health = {
-        "status": "unknown",
+        "status": OperationResult.UNKNOWN,
         "timestamp": datetime.now(timezone.utc).isoformat(),
         "checks": {},
         "errors": [],
@@ -292,14 +293,14 @@ def verify_deployment_health(
 
         # Determine overall status
         if all(health["checks"].values()):
-            health["status"] = "healthy"
+            health["status"] = HealthStatus.HEALTHY
         elif any(health["checks"].values()):
-            health["status"] = "degraded"
+            health["status"] = HealthStatus.DEGRADED
         else:
-            health["status"] = "unhealthy"
+            health["status"] = HealthStatus.UNHEALTHY
 
     except Exception as e:
-        health["status"] = "error"
+        health["status"] = HealthStatus.UNKNOWN
         health["errors"].append(str(e))
 
     return health

claude_mpm/services/unified/deployment_strategies/vercel.py

@@ -13,6 +13,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
+from claude_mpm.core.enums import HealthStatus, OperationResult
 from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.services.unified.strategies import StrategyMetadata, StrategyPriority
 
@@ -307,13 +308,13 @@ class VercelDeploymentStrategy(DeploymentStrategy):
         deployment_url = deployment_info.get("deployment_url")
 
         health = {
-            "status": "unknown",
+            "status": OperationResult.UNKNOWN,
             "deployment_url": deployment_url,
             "checks": {},
         }
 
         if not deployment_url:
-            health["status"] = "unhealthy"
+            health["status"] = HealthStatus.UNHEALTHY
             health["error"] = "No deployment URL"
             return health
 
@@ -341,14 +342,14 @@ class VercelDeploymentStrategy(DeploymentStrategy):
 
             # Determine overall status
             if all(health["checks"].values()):
-                health["status"] = "healthy"
+                health["status"] = HealthStatus.HEALTHY
             elif any(health["checks"].values()):
-                health["status"] = "degraded"
+                health["status"] = HealthStatus.DEGRADED
             else:
-                health["status"] = "unhealthy"
+                health["status"] = HealthStatus.UNHEALTHY
 
         except Exception as e:
-            health["status"] = "unhealthy"
+            health["status"] = HealthStatus.UNHEALTHY
             health["error"] = str(e)
 
         return health

claude_mpm/services/unified/interfaces.py

@@ -25,6 +25,8 @@ from enum import Enum
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Set, TypeVar, Union
 
+from claude_mpm.core.enums import ValidationSeverity
+
 # Type variables for generic interfaces
 T = TypeVar("T")
 ConfigType = TypeVar("ConfigType", bound=Dict[str, Any])
@@ -88,7 +90,7 @@ class AnalysisResult:
     findings: List[Dict[str, Any]] = field(default_factory=list)
     metrics: Dict[str, Any] = field(default_factory=dict)
     summary: str = ""
-    severity: str = "info"  # info, warning, error, critical
+    severity: str = ValidationSeverity.INFO
     recommendations: List[str] = field(default_factory=list)
 
 

claude_mpm/services/unified/unified_analyzer.py

@@ -25,6 +25,7 @@ Features:
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
+from claude_mpm.core.enums import OperationResult, ServiceState, ValidationSeverity
 from claude_mpm.core.logging_utils import get_logger
 
 from .interfaces import (
@@ -134,7 +135,7 @@ class UnifiedAnalyzer(IAnalyzerService, IUnifiedService):
 
         return {
             "service": "UnifiedAnalyzer",
-            "status": "healthy" if self._initialized else "unhealthy",
+            "status": ServiceState.RUNNING if self._initialized else ServiceState.ERROR,
             "initialized": self._initialized,
             "registered_strategies": len(strategies),
             "cache_size": len(self._analysis_cache),
@@ -223,7 +224,7 @@ class UnifiedAnalyzer(IAnalyzerService, IUnifiedService):
                 return AnalysisResult(
                     success=False,
                     summary=f"No strategy available for analysis type: {analysis_type}",
-                    severity="error",
+                    severity=ValidationSeverity.ERROR,
                 )
 
             # Execute analysis using strategy
@@ -236,7 +237,7 @@ class UnifiedAnalyzer(IAnalyzerService, IUnifiedService):
                 return AnalysisResult(
                     success=False,
                     summary=f"Validation failed: {'; '.join(validation_errors)}",
-                    severity="error",
+                    severity=ValidationSeverity.ERROR,
                 )
 
             # Perform analysis
@@ -251,7 +252,7 @@ class UnifiedAnalyzer(IAnalyzerService, IUnifiedService):
                 findings=result_data.get("findings", []),
                 metrics=metrics,
                 summary=result_data.get("summary", "Analysis completed"),
-                severity=result_data.get("severity", "info"),
+                severity=result_data.get("severity", ValidationSeverity.INFO),
                 recommendations=result_data.get("recommendations", []),
             )
 
@@ -343,8 +344,8 @@ class UnifiedAnalyzer(IAnalyzerService, IUnifiedService):
 
             if not result1.success or not result2.success:
                 return {
-                    "success": False,
-                    "error": "Failed to analyze one or both targets",
+                    OperationResult.SUCCESS.value: False,
+                    OperationResult.ERROR.value: "Failed to analyze one or both targets",
                 }
 
             # Compare metrics
@@ -354,7 +355,7 @@ class UnifiedAnalyzer(IAnalyzerService, IUnifiedService):
             finding_diff = self._compare_findings(result1.findings, result2.findings)
 
             return {
-                "success": True,
+                OperationResult.SUCCESS.value: True,
                 "target1": str(target1),
                 "target2": str(target2),
                 "metric_differences": metric_diff,
@@ -378,7 +379,10 @@ class UnifiedAnalyzer(IAnalyzerService, IUnifiedService):
 
         except Exception as e:
             self._logger.error(f"Comparison error: {e!s}")
-            return {"success": False, "error": str(e)}
+            return {
+                OperationResult.SUCCESS.value: False,
+                OperationResult.ERROR.value: str(e),
+            }
 
     def get_recommendations(
         self, analysis_result: AnalysisResult
@@ -405,7 +409,7 @@ class UnifiedAnalyzer(IAnalyzerService, IUnifiedService):
             )
 
         # Add severity-based recommendations
-        if analysis_result.severity == "critical":
+        if analysis_result.severity == ValidationSeverity.CRITICAL:
             recommendations.insert(
                 0,
                 {
@@ -414,7 +418,7 @@ class UnifiedAnalyzer(IAnalyzerService, IUnifiedService):
                     "priority": "high",
                 },
             )
-        elif analysis_result.severity == "error":
+        elif analysis_result.severity == ValidationSeverity.ERROR:
             recommendations.insert(
                 0,
                 {

claude_mpm/services/unified/unified_config.py

@@ -26,6 +26,7 @@ import json
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
+from claude_mpm.core.enums import ServiceState
 from claude_mpm.core.logging_utils import get_logger
 
 from .interfaces import (
@@ -153,7 +154,7 @@ class UnifiedConfigManager(IConfigurationService, IUnifiedService):
 
         return {
             "service": "UnifiedConfigManager",
-            "status": "healthy" if self._initialized else "unhealthy",
+            "status": ServiceState.RUNNING if self._initialized else ServiceState.ERROR,
             "initialized": self._initialized,
             "registered_strategies": len(strategies),
             "loaded_configs": len(self._configs),

claude_mpm/services/unified/unified_deployment.py

@@ -24,6 +24,7 @@ Features:
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
+from claude_mpm.core.enums import OperationResult, ServiceState
 from claude_mpm.core.logging_utils import get_logger
 
 from .interfaces import (
@@ -140,7 +141,7 @@ class UnifiedDeploymentService(IDeploymentService, IUnifiedService):
 
         return {
             "service": "UnifiedDeploymentService",
-            "status": "healthy" if self._initialized else "unhealthy",
+            "status": ServiceState.RUNNING if self._initialized else ServiceState.ERROR,
             "initialized": self._initialized,
             "registered_strategies": len(strategies),
             "active_deployments": len(self._deployments),
@@ -304,7 +305,7 @@ class UnifiedDeploymentService(IDeploymentService, IUnifiedService):
             }
 
             # Update metrics
-            if result.get("success", False):
+            if result.get(OperationResult.SUCCESS.value, False):
                 self._metrics["successful_deployments"] += 1
                 deployed_path = Path(target) / Path(source).name
 
@@ -318,7 +319,7 @@ class UnifiedDeploymentService(IDeploymentService, IUnifiedService):
             self._metrics["failed_deployments"] += 1
             return DeploymentResult(
                 success=False,
-                message=result.get("error", "Deployment failed"),
+                message=result.get(OperationResult.ERROR.value, "Deployment failed"),
                 metadata=result,
             )
 
@@ -426,7 +427,11 @@ class UnifiedDeploymentService(IDeploymentService, IUnifiedService):
 
         return {
             "id": deployment_id,
-            "status": "rolled_back" if deployment.get("rolled_back") else "active",
+            "status": (
+                OperationResult.CANCELLED
+                if deployment.get("rolled_back")
+                else OperationResult.SUCCESS
+            ),
             "type": deployment["type"],
             "strategy": deployment["strategy"],
             "source": deployment["source"],