claude-mpm 4.14.7__py3-none-any.whl → 4.14.8__py3-none-any.whl

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 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", []):

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

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 OperationResult
 from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.services.unified.strategies import StrategyMetadata, StrategyPriority
 
@@ -307,7 +308,7 @@ class VercelDeploymentStrategy(DeploymentStrategy):
         deployment_url = deployment_info.get("deployment_url")
 
         health = {
-            "status": "unknown",
+            "status": OperationResult.UNKNOWN,
             "deployment_url": deployment_url,
             "checks": {},
         }

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 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", []),
             )
 
@@ -405,7 +406,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 +415,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),
@@ -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/tools/code_tree_analyzer.py

@@ -1528,10 +1528,31 @@ class CodeTreeAnalyzer:
         if not path.exists() or not path.is_file():
             return {"error": f"Invalid file: {file_path}"}
 
-        # Get language first (needed for return statement)
         language = self._get_language(path)
+        self._emit_analysis_start(path, language)
 
-        # Emit analysis start event
+        # Check cache
+        file_hash = self._get_file_hash(path)
+        cache_key = f"{file_path}:{file_hash}"
+
+        if cache_key in self.cache:
+            nodes = self.cache[cache_key]
+            self._emit_cache_hit(path)
+            filtered_nodes = self._filter_nodes(nodes)
+        else:
+            nodes, filtered_nodes, duration = self._analyze_and_cache_file(
+                path, language, cache_key
+            )
+            self._emit_analysis_complete(path, filtered_nodes, duration)
+
+        # Prepare final data structures
+        final_nodes = self._prepare_final_nodes(nodes, filtered_nodes)
+        elements = self._convert_nodes_to_elements(final_nodes)
+
+        return self._build_result(file_path, language, final_nodes, elements)
+
+    def _emit_analysis_start(self, path: Path, language: str) -> None:
+        """Emit analysis start event."""
         if self.emitter:
             from datetime import datetime
 
@@ -1546,179 +1567,194 @@ class CodeTreeAnalyzer:
                 },
             )
 
-        # Check cache
-        file_hash = self._get_file_hash(path)
-        cache_key = f"{file_path}:{file_hash}"
+    def _emit_cache_hit(self, path: Path) -> None:
+        """Emit cache hit event."""
+        if self.emitter:
+            from datetime import datetime
 
-        if cache_key in self.cache:
-            nodes = self.cache[cache_key]
-            if self.emitter:
-                from datetime import datetime
+            self.emitter.emit(
+                "info",
+                {
+                    "type": "cache.hit",
+                    "file": str(path),
+                    "message": f"Using cached analysis for {path.name}",
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                },
+            )
 
-                self.emitter.emit(
-                    "info",
-                    {
-                        "type": "cache.hit",
-                        "file": str(path),
-                        "message": f"Using cached analysis for {path.name}",
-                        "timestamp": datetime.now(timezone.utc).isoformat(),
-                    },
-                )
-        else:
-            # Analyze file
-            if self.emitter:
-                from datetime import datetime
+    def _emit_cache_miss(self, path: Path) -> None:
+        """Emit cache miss event."""
+        if self.emitter:
+            from datetime import datetime
 
-                self.emitter.emit(
-                    "info",
-                    {
-                        "type": "cache.miss",
-                        "file": str(path),
-                        "message": f"Cache miss, analyzing fresh: {path.name}",
-                        "timestamp": datetime.now(timezone.utc).isoformat(),
-                    },
-                )
+            self.emitter.emit(
+                "info",
+                {
+                    "type": "cache.miss",
+                    "file": str(path),
+                    "message": f"Cache miss, analyzing fresh: {path.name}",
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                },
+            )
 
-            if language == "python":
-                analyzer = self.python_analyzer
-            elif language in {"javascript", "typescript"}:
-                analyzer = self.javascript_analyzer
-            else:
-                analyzer = self.generic_analyzer
+    def _emit_parsing_start(self, path: Path) -> None:
+        """Emit parsing start event."""
+        if self.emitter:
+            from datetime import datetime
+
+            self.emitter.emit(
+                "info",
+                {
+                    "type": "analysis.parse",
+                    "file": str(path),
+                    "message": f"Parsing file content: {path.name}",
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                },
+            )
 
-            start_time = time.time()
+    def _emit_node_found(self, node: CodeNode, path: Path) -> None:
+        """Emit node found event."""
+        if self.emitter:
+            from datetime import datetime
 
-            # Emit parsing event
-            if self.emitter:
-                from datetime import datetime
+            self.emitter.emit(
+                "info",
+                {
+                    "type": f"analysis.{node.node_type}",
+                    "name": node.name,
+                    "file": str(path),
+                    "line_start": node.line_start,
+                    "complexity": node.complexity,
+                    "message": f"Found {node.node_type}: {node.name}",
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                },
+            )
 
-                self.emitter.emit(
-                    "info",
-                    {
-                        "type": "analysis.parse",
-                        "file": str(path),
-                        "message": f"Parsing file content: {path.name}",
-                        "timestamp": datetime.now(timezone.utc).isoformat(),
-                    },
-                )
+    def _emit_analysis_complete(
+        self, path: Path, filtered_nodes: list, duration: float
+    ) -> None:
+        """Emit analysis complete event."""
+        if not self.emitter:
+            return
 
-            nodes = analyzer.analyze_file(path) if analyzer else []
-            duration = time.time() - start_time
+        from datetime import datetime
+
+        stats = self._calculate_node_stats(filtered_nodes)
+        self.emitter.emit(
+            "info",
+            {
+                "type": "analysis.complete",
+                "file": str(path),
+                "stats": stats,
+                "duration": duration,
+                "message": f"Analysis complete: {stats['classes']} classes, {stats['functions']} functions, {stats['methods']} methods",
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            },
+        )
+        self.emitter.emit_file_analyzed(str(path), filtered_nodes, duration)
 
-            # Cache results
-            self.cache[cache_key] = nodes
+    def _analyze_and_cache_file(
+        self, path: Path, language: str, cache_key: str
+    ) -> tuple:
+        """Analyze file content and cache results."""
+        self._emit_cache_miss(path)
+        self._emit_parsing_start(path)
 
-            # Filter internal functions before emitting
-            filtered_nodes = []
-            classes_count = 0
-            functions_count = 0
-            methods_count = 0
+        # Select analyzer based on language
+        analyzer = self._select_analyzer(language)
 
-            for node in nodes:
-                # Only include main structural elements
-                if not self._is_internal_node(node):
-                    # Emit found element event
-                    if self.emitter:
-                        from datetime import datetime
+        # Perform analysis
+        start_time = time.time()
+        nodes = analyzer.analyze_file(path) if analyzer else []
+        duration = time.time() - start_time
 
-                        self.emitter.emit(
-                            "info",
-                            {
-                                "type": f"analysis.{node.node_type}",
-                                "name": node.name,
-                                "file": str(path),
-                                "line_start": node.line_start,
-                                "complexity": node.complexity,
-                                "message": f"Found {node.node_type}: {node.name}",
-                                "timestamp": datetime.now(timezone.utc).isoformat(),
-                            },
-                        )
+        # Cache results
+        self.cache[cache_key] = nodes
 
-                        # Count node types
-                        if node.node_type == "class":
-                            classes_count += 1
-                        elif node.node_type == "function":
-                            functions_count += 1
-                        elif node.node_type == "method":
-                            methods_count += 1
-
-                    filtered_nodes.append(
-                        {
-                            "name": node.name,
-                            "type": node.node_type,
-                            "line_start": node.line_start,
-                            "line_end": node.line_end,
-                            "complexity": node.complexity,
-                            "has_docstring": node.has_docstring,
-                            "signature": node.signature,
-                        }
-                    )
+        # Filter and process nodes
+        filtered_nodes = self._filter_and_emit_nodes(nodes, path)
 
-            # Emit analysis complete event with stats
-            if self.emitter:
-                from datetime import datetime
+        return nodes, filtered_nodes, duration
 
-                self.emitter.emit(
-                    "info",
-                    {
-                        "type": "analysis.complete",
-                        "file": str(path),
-                        "stats": {
-                            "classes": classes_count,
-                            "functions": functions_count,
-                            "methods": methods_count,
-                            "total_nodes": len(filtered_nodes),
-                        },
-                        "duration": duration,
-                        "message": f"Analysis complete: {classes_count} classes, {functions_count} functions, {methods_count} methods",
-                        "timestamp": datetime.now(timezone.utc).isoformat(),
-                    },
-                )
+    def _select_analyzer(self, language: str):
+        """Select appropriate analyzer for language."""
+        if language == "python":
+            return self.python_analyzer
+        if language in {"javascript", "typescript"}:
+            return self.javascript_analyzer
+        return self.generic_analyzer
 
-                self.emitter.emit_file_analyzed(file_path, filtered_nodes, duration)
+    def _filter_nodes(self, nodes: list) -> list:
+        """Filter nodes without emitting events."""
+        return [self._node_to_dict(n) for n in nodes if not self._is_internal_node(n)]
 
-        # Prepare the nodes data
-        final_nodes = (
-            filtered_nodes
-            if "filtered_nodes" in locals()
-            else [
-                {
-                    "name": n.name,
-                    "type": n.node_type,
-                    "line_start": n.line_start,
-                    "line_end": n.line_end,
-                    "complexity": n.complexity,
-                    "has_docstring": n.has_docstring,
-                    "signature": n.signature,
-                }
-                for n in nodes
-                if not self._is_internal_node(n)
-            ]
-        )
+    def _filter_and_emit_nodes(self, nodes: list, path: Path) -> list:
+        """Filter nodes and emit events for each."""
+        filtered_nodes = []
+        for node in nodes:
+            if not self._is_internal_node(node):
+                self._emit_node_found(node, path)
+                filtered_nodes.append(self._node_to_dict(node))
+        return filtered_nodes
+
+    def _node_to_dict(self, node: CodeNode) -> dict:
+        """Convert CodeNode to dictionary."""
+        return {
+            "name": node.name,
+            "type": node.node_type,
+            "line_start": node.line_start,
+            "line_end": node.line_end,
+            "complexity": node.complexity,
+            "has_docstring": node.has_docstring,
+            "signature": node.signature,
+        }
+
+    def _calculate_node_stats(self, filtered_nodes: list) -> dict:
+        """Calculate statistics from filtered nodes."""
+        classes_count = sum(1 for n in filtered_nodes if n["type"] == "class")
+        functions_count = sum(1 for n in filtered_nodes if n["type"] == "function")
+        methods_count = sum(1 for n in filtered_nodes if n["type"] == "method")
+        return {
+            "classes": classes_count,
+            "functions": functions_count,
+            "methods": methods_count,
+            "total_nodes": len(filtered_nodes),
+        }
+
+    def _prepare_final_nodes(self, nodes: list, filtered_nodes: list) -> list:
+        """Prepare final nodes data structure."""
+        if filtered_nodes:
+            return filtered_nodes
+        return [self._node_to_dict(n) for n in nodes if not self._is_internal_node(n)]
 
-        # Convert nodes to elements format for dashboard compatibility
+    def _convert_nodes_to_elements(self, final_nodes: list) -> list:
+        """Convert nodes to elements format for dashboard."""
         elements = []
         for node in final_nodes:
             element = {
                 "name": node["name"],
                 "type": node["type"],
-                "line": node["line_start"],  # Dashboard expects 'line' not 'line_start'
+                "line": node["line_start"],
                 "complexity": node["complexity"],
                 "signature": node.get("signature", ""),
                 "has_docstring": node.get("has_docstring", False),
             }
-            # Add methods if it's a class (for expandable tree)
             if node["type"] == "class":
-                element["methods"] = []  # Could be populated with class methods
+                element["methods"] = []
             elements.append(element)
+        return elements
 
+    def _build_result(
+        self, file_path: str, language: str, final_nodes: list, elements: list
+    ) -> dict:
+        """Build final result dictionary."""
         return {
             "path": file_path,
             "language": language,
-            "nodes": final_nodes,  # Keep for backward compatibility
-            "elements": elements,  # Add for dashboard compatibility
+            "nodes": final_nodes,
+            "elements": elements,
             "complexity": sum(e["complexity"] for e in elements),
-            "lines": len(elements),  # Simple line count approximation
+            "lines": len(elements),
             "stats": {
                 "classes": len([e for e in elements if e["type"] == "class"]),
                 "functions": len([e for e in elements if e["type"] == "function"]),

claude_mpm/tools/code_tree_events.py

@@ -22,6 +22,8 @@ from dataclasses import asdict, dataclass
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
+from ..core.enums import OperationResult
+
 try:
     import socketio
 
@@ -268,7 +270,7 @@ class CodeTreeEventEmitter:
                 "name": Path(file_path).name,
                 "language": language or "unknown",
                 "type": "file",
-                "status": "analyzing",
+                "status": OperationResult.PENDING,
             },
         )
 
@@ -287,7 +289,7 @@ class CodeTreeEventEmitter:
                 "nodes_count": nodes_count,
                 "duration": duration,
                 "type": "file",
-                "status": "complete",
+                "status": OperationResult.COMPLETED,
             },
         )
 

{claude_mpm-4.14.7.dist-info → claude_mpm-4.14.8.dist-info}/METADATA

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