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

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"],

claude_mpm/services/version_service.py

@@ -9,7 +9,7 @@ Extracted from ClaudeRunner to follow Single Responsibility Principle.
 """
 
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 from claude_mpm.config.paths import paths
 from claude_mpm.core.base_service import BaseService
@@ -274,3 +274,106 @@ class VersionService(BaseService, VersionServiceInterface):
             "message": "Update checking not implemented",
             "checked_at": None,
         }
+
+    def get_agents_versions(self) -> Dict[str, List[Dict[str, str]]]:
+        """Get all agents grouped by tier with versions.
+
+        Returns:
+            Dict with keys: system, user, project
+            Each value is list of agent dicts with: name, version, id
+        """
+        from claude_mpm.core.unified_agent_registry import get_agent_registry
+
+        agents_by_tier = {"system": [], "user": [], "project": []}
+
+        try:
+            registry = get_agent_registry()
+            all_agents = registry.list_agents()
+
+            for agent in all_agents:
+                agent_info = {
+                    "name": agent.name,
+                    "version": agent.version,
+                    "id": agent.name,  # Use name as ID since agent_id doesn't exist
+                }
+                tier = (
+                    agent.tier.value
+                    if hasattr(agent.tier, "value")
+                    else str(agent.tier)
+                )
+                if tier in agents_by_tier:
+                    agents_by_tier[tier].append(agent_info)
+                else:
+                    agents_by_tier["system"].append(agent_info)
+
+            # Sort each tier alphabetically by name
+            for tier, agents in agents_by_tier.items():
+                agents.sort(key=lambda x: x["name"])
+
+        except Exception as e:
+            self.logger.error(f"Failed to get agent versions: {e}")
+
+        return agents_by_tier
+
+    def get_skills_versions(self) -> Dict[str, List[Dict[str, str]]]:
+        """Get all skills grouped by source with versions.
+
+        Returns:
+            Dict with keys: bundled, user, project
+            Each value is list of skill dicts with: name, version, description
+        """
+        from claude_mpm.skills.registry import get_registry
+
+        skills_by_source = {"bundled": [], "user": [], "project": []}
+
+        try:
+            registry = get_registry()
+
+            for skill in registry.list_skills():
+                skill_info = {
+                    "name": skill.name,
+                    "version": skill.version,
+                    "description": (
+                        skill.description[:60] + "..."
+                        if len(skill.description) > 60
+                        else skill.description
+                    ),
+                }
+                source = skill.source if skill.source in skills_by_source else "bundled"
+                skills_by_source[source].append(skill_info)
+
+            # Sort each source alphabetically by name
+            for source, skills in skills_by_source.items():
+                skills.sort(key=lambda x: x["name"])
+
+        except Exception as e:
+            self.logger.error(f"Failed to get skill versions: {e}")
+
+        return skills_by_source
+
+    def get_version_summary(self) -> Dict:
+        """Get complete version summary.
+
+        Returns:
+            Dict with project_version, build, agents, skills, and counts
+        """
+        agents = self.get_agents_versions()
+        skills = self.get_skills_versions()
+        build = self.get_build_number()
+
+        return {
+            "project_version": self.get_base_version(),
+            "build": build,
+            "agents": agents,
+            "skills": skills,
+            "counts": {
+                "agents_total": sum(len(v) for v in agents.values()),
+                "agents_system": len(agents.get("system", [])),
+                "agents_user": len(agents.get("user", [])),
+                "agents_project": len(agents.get("project", [])),
+                "skills_total": sum(len(v) for v in skills.values()),
+                "skills_bundled": len(skills.get("bundled", [])),
+                "skills_user": len(skills.get("user", [])),
+                "skills_project": len(skills.get("project", [])),
+            },
+        }

claude_mpm/skills/__init__.py

@@ -0,0 +1,21 @@
+"""
+Claude MPM Skills Package
+
+Skills system for sharing common capabilities across agents.
+This reduces redundancy by extracting shared patterns into reusable skills.
+
+Skills can be:
+- Bundled with MPM (in skills/bundled/)
+- User-installed (in ~/.claude/skills/)
+- Project-specific (in .claude/skills/)
+"""
+
+from .registry import Skill, SkillsRegistry, get_registry
+from .skill_manager import SkillManager
+
+__all__ = [
+    "Skill",
+    "SkillManager",
+    "SkillsRegistry",
+    "get_registry",
+]

claude_mpm/skills/bundled/__init__.py

@@ -0,0 +1,6 @@
+"""
+Bundled skills shipped with Claude MPM.
+
+These skills provide reusable patterns and practices that eliminate
+redundancy across agent templates.
+"""