claude-mpm 4.4.0__py3-none-any.whl → 4.4.4__py3-none-any.whl

claude_mpm/services/response_tracker.py

@@ -22,9 +22,9 @@ from datetime import datetime, timezone
 from typing import Any, Dict, Optional
 
 from claude_mpm.core.config import Config
+from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.core.shared.config_loader import ConfigLoader
 
-from claude_mpm.core.logging_utils import get_logger
 logger = get_logger(__name__)
 
 

claude_mpm/services/shared/__init__.py

@@ -9,7 +9,7 @@ from .async_service_base import AsyncServiceBase
 from .config_service_base import ConfigServiceBase
 from .lifecycle_service_base import LifecycleServiceBase
 from .manager_base import ManagerBase
-from .service_factory import ServiceFactory
+from .service_factory import ServiceFactory, get_service_factory
 
 __all__ = [
     "AsyncServiceBase",
@@ -17,4 +17,5 @@ __all__ = [
     "LifecycleServiceBase",
     "ManagerBase",
     "ServiceFactory",
+    "get_service_factory",
 ]

claude_mpm/services/shared/service_factory.py

@@ -287,20 +287,23 @@ class ServiceFactory:
         self.logger.debug("Cleared all service registrations")
 
 
-# Global factory instance
-_global_factory = ServiceFactory()
+# Global factory instance (lazy initialization)
+_global_factory: Optional[ServiceFactory] = None
 
 
 def get_service_factory() -> ServiceFactory:
-    """Get global service factory instance."""
+    """Get global service factory instance (created on first use)."""
+    global _global_factory
+    if _global_factory is None:
+        _global_factory = ServiceFactory()
     return _global_factory
 
 
 def create_service(service_class: Type[T], **kwargs) -> T:
     """Convenience function to create service using global factory."""
-    return _global_factory.create_service(service_class, **kwargs)
+    return get_service_factory().create_service(service_class, **kwargs)
 
 
 def register_service(service_name: str, service_class: Type) -> None:
     """Convenience function to register service with global factory."""
-    _global_factory.register_service(service_name, service_class)
+    get_service_factory().register_service(service_name, service_class)

claude_mpm/services/socketio/server/eventbus_integration.py

@@ -10,11 +10,11 @@ WHY this integration module:
 from datetime import datetime, timezone
 from typing import Optional
 
+from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.services.event_bus import EventBus
 from claude_mpm.services.event_bus.config import get_config
 from claude_mpm.services.event_bus.direct_relay import DirectSocketIORelay
 
-from claude_mpm.core.logging_utils import get_logger
 logger = get_logger(__name__)
 
 

claude_mpm/services/unified/__init__.py

@@ -62,4 +62,4 @@ __all__ = [
     "UnifiedDeploymentService",
     "UnifiedAnalyzer",
     "UnifiedConfigManager",
-]
+]

claude_mpm/services/unified/analyzer_strategies/__init__.py

@@ -29,9 +29,9 @@ from .structure_analyzer import StructureAnalyzerStrategy
 __all__ = [
     "CodeAnalyzerStrategy",
     "DependencyAnalyzerStrategy",
-    "StructureAnalyzerStrategy",
-    "SecurityAnalyzerStrategy",
     "PerformanceAnalyzerStrategy",
+    "SecurityAnalyzerStrategy",
+    "StructureAnalyzerStrategy",
 ]
 
 # Strategy registry for automatic discovery
@@ -41,4 +41,4 @@ ANALYZER_STRATEGIES = {
     "structure": StructureAnalyzerStrategy,
     "security": SecurityAnalyzerStrategy,
     "performance": PerformanceAnalyzerStrategy,
-}
+}

claude_mpm/services/unified/analyzer_strategies/code_analyzer.py

@@ -12,11 +12,16 @@ Created: 2025-01-26
 import ast
 import re
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Tuple
+from typing import Any, Dict, List, Optional
 
 from claude_mpm.core.logging_utils import get_logger
 
-from ..strategies import AnalyzerStrategy, StrategyContext, StrategyMetadata, StrategyPriority
+from ..strategies import (
+    AnalyzerStrategy,
+    StrategyContext,
+    StrategyMetadata,
+    StrategyPriority,
+)
 
 logger = get_logger(__name__)
 
@@ -109,7 +114,7 @@ class CodeAnalyzerStrategy(AnalyzerStrategy):
             target_path = Path(target)
             if target_path.is_file():
                 return self._analyze_file(target_path, options)
-            elif target_path.is_dir():
+            if target_path.is_dir():
                 return self._analyze_directory(target_path, options)
         elif isinstance(target, ast.AST):
             return self._analyze_ast(target, options)
@@ -143,7 +148,9 @@ class CodeAnalyzerStrategy(AnalyzerStrategy):
                 metrics.update(self._analyze_python_code(content, file_path))
 
             # Calculate complexity metrics
-            metrics["complexity"] = self._calculate_complexity_metrics(content, language)
+            metrics["complexity"] = self._calculate_complexity_metrics(
+                content, language
+            )
 
             # Detect code smells
             metrics["code_smells"] = self._detect_code_smells(content, metrics)
@@ -166,7 +173,9 @@ class CodeAnalyzerStrategy(AnalyzerStrategy):
                 "error": str(e),
             }
 
-    def _analyze_directory(self, dir_path: Path, options: Dict[str, Any]) -> Dict[str, Any]:
+    def _analyze_directory(
+        self, dir_path: Path, options: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """Analyze all code files in a directory."""
         results = {
             "status": "success",
@@ -198,7 +207,10 @@ class CodeAnalyzerStrategy(AnalyzerStrategy):
         results["summary"] = {
             "total_files": len(results["files"]),
             "total_lines": total_metrics.get("lines_of_code", 0),
-            "average_complexity": total_metrics.get("complexity", {}).get("cyclomatic", 0) / max(len(results["files"]), 1),
+            "average_complexity": total_metrics.get("complexity", {}).get(
+                "cyclomatic", 0
+            )
+            / max(len(results["files"]), 1),
             "code_smells_count": sum(
                 len(f.get("metrics", {}).get("code_smells", []))
                 for f in results["files"]
@@ -219,7 +231,9 @@ class CodeAnalyzerStrategy(AnalyzerStrategy):
 
             for node in ast.walk(tree):
                 if isinstance(node, ast.FunctionDef):
-                    if any(isinstance(parent, ast.ClassDef) for parent in ast.walk(tree)):
+                    if any(
+                        isinstance(parent, ast.ClassDef) for parent in ast.walk(tree)
+                    ):
                         methods.append(node.name)
                     else:
                         functions.append(node.name)
@@ -248,17 +262,27 @@ class CodeAnalyzerStrategy(AnalyzerStrategy):
 
         # Analyze specific node types
         if isinstance(node, ast.FunctionDef):
-            metrics.update({
-                "name": node.name,
-                "parameters": len(node.args.args),
-                "lines": node.end_lineno - node.lineno + 1 if hasattr(node, "end_lineno") else 0,
-            })
+            metrics.update(
+                {
+                    "name": node.name,
+                    "parameters": len(node.args.args),
+                    "lines": (
+                        node.end_lineno - node.lineno + 1
+                        if hasattr(node, "end_lineno")
+                        else 0
+                    ),
+                }
+            )
         elif isinstance(node, ast.ClassDef):
-            metrics.update({
-                "name": node.name,
-                "methods": sum(1 for n in node.body if isinstance(n, ast.FunctionDef)),
-                "bases": len(node.bases),
-            })
+            metrics.update(
+                {
+                    "name": node.name,
+                    "methods": sum(
+                        1 for n in node.body if isinstance(n, ast.FunctionDef)
+                    ),
+                    "bases": len(node.bases),
+                }
+            )
 
         return {
             "status": "success",
@@ -266,7 +290,9 @@ class CodeAnalyzerStrategy(AnalyzerStrategy):
             "metrics": metrics,
         }
 
-    def _calculate_complexity_metrics(self, content: str, language: str) -> Dict[str, Any]:
+    def _calculate_complexity_metrics(
+        self, content: str, language: str
+    ) -> Dict[str, Any]:
         """Calculate various complexity metrics."""
         complexity = {
             "cyclomatic": 1,  # Base complexity
@@ -315,26 +341,35 @@ class CodeAnalyzerStrategy(AnalyzerStrategy):
         """Calculate complexity for a single AST node."""
         return self._calculate_cyclomatic_complexity(node)
 
-    def _detect_code_smells(self, content: str, metrics: Dict[str, Any]) -> List[Dict[str, Any]]:
+    def _detect_code_smells(
+        self, content: str, metrics: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
         """Detect common code smells."""
         smells = []
 
         # Long method/function
-        if metrics.get("lines_of_code", 0) > self.code_smell_patterns["long_method"]["threshold"]:
-            smells.append({
-                "type": "long_method",
-                "severity": "medium",
-                "message": f"Method/function has {metrics['lines_of_code']} lines (threshold: {self.code_smell_patterns['long_method']['threshold']})",
-            })
+        if (
+            metrics.get("lines_of_code", 0)
+            > self.code_smell_patterns["long_method"]["threshold"]
+        ):
+            smells.append(
+                {
+                    "type": "long_method",
+                    "severity": "medium",
+                    "message": f"Method/function has {metrics['lines_of_code']} lines (threshold: {self.code_smell_patterns['long_method']['threshold']})",
+                }
+            )
 
         # High complexity
         complexity = metrics.get("complexity", {}).get("cyclomatic", 0)
         if complexity > 10:
-            smells.append({
-                "type": "high_complexity",
-                "severity": "high",
-                "message": f"High cyclomatic complexity: {complexity}",
-            })
+            smells.append(
+                {
+                    "type": "high_complexity",
+                    "severity": "high",
+                    "message": f"High cyclomatic complexity: {complexity}",
+                }
+            )
 
         return smells
 
@@ -398,25 +433,35 @@ class CodeAnalyzerStrategy(AnalyzerStrategy):
         if "metrics" in analysis_result:
             raw_metrics = analysis_result["metrics"]
 
-            metrics.update({
-                "lines_of_code": raw_metrics.get("lines_of_code", 0),
-                "cyclomatic_complexity": raw_metrics.get("complexity", {}).get("cyclomatic", 0),
-                "cognitive_complexity": raw_metrics.get("complexity", {}).get("cognitive", 0),
-                "maintainability_index": raw_metrics.get("maintainability_index", 0),
-                "code_smells": len(raw_metrics.get("code_smells", [])),
-                "function_count": raw_metrics.get("function_count", 0),
-                "class_count": raw_metrics.get("class_count", 0),
-            })
+            metrics.update(
+                {
+                    "lines_of_code": raw_metrics.get("lines_of_code", 0),
+                    "cyclomatic_complexity": raw_metrics.get("complexity", {}).get(
+                        "cyclomatic", 0
+                    ),
+                    "cognitive_complexity": raw_metrics.get("complexity", {}).get(
+                        "cognitive", 0
+                    ),
+                    "maintainability_index": raw_metrics.get(
+                        "maintainability_index", 0
+                    ),
+                    "code_smells": len(raw_metrics.get("code_smells", [])),
+                    "function_count": raw_metrics.get("function_count", 0),
+                    "class_count": raw_metrics.get("class_count", 0),
+                }
+            )
 
         # Extract summary metrics for directory analysis
         if "summary" in analysis_result:
             summary = analysis_result["summary"]
-            metrics.update({
-                "total_files": summary.get("total_files", 0),
-                "total_lines": summary.get("total_lines", 0),
-                "average_complexity": summary.get("average_complexity", 0),
-                "total_code_smells": summary.get("code_smells_count", 0),
-            })
+            metrics.update(
+                {
+                    "total_files": summary.get("total_files", 0),
+                    "total_lines": summary.get("total_lines", 0),
+                    "average_complexity": summary.get("average_complexity", 0),
+                    "total_code_smells": summary.get("code_smells_count", 0),
+                }
+            )
 
         return metrics
 
@@ -461,13 +506,12 @@ class CodeAnalyzerStrategy(AnalyzerStrategy):
                         comparison["degraded"].append(result)
                     else:
                         comparison["unchanged"].append(result)
+                # Lower is better (complexity, code smells, etc.)
+                elif diff < 0:
+                    comparison["improved"].append(result)
+                elif diff > 0:
+                    comparison["degraded"].append(result)
                 else:
-                    # Lower is better (complexity, code smells, etc.)
-                    if diff < 0:
-                        comparison["improved"].append(result)
-                    elif diff > 0:
-                        comparison["degraded"].append(result)
-                    else:
-                        comparison["unchanged"].append(result)
+                    comparison["unchanged"].append(result)
 
-        return comparison
+        return comparison

claude_mpm/services/unified/analyzer_strategies/dependency_analyzer.py

@@ -11,13 +11,17 @@ Created: 2025-01-26
 
 import json
 import re
-import subprocess
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Tuple
+from typing import Any, Dict, List, Optional
 
 from claude_mpm.core.logging_utils import get_logger
 
-from ..strategies import AnalyzerStrategy, StrategyContext, StrategyMetadata, StrategyPriority
+from ..strategies import (
+    AnalyzerStrategy,
+    StrategyContext,
+    StrategyMetadata,
+    StrategyPriority,
+)
 
 logger = get_logger(__name__)
 
@@ -69,7 +73,15 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
     # Testing framework packages
     TESTING_PACKAGES = {
         "python": ["pytest", "unittest", "nose", "nose2", "tox", "coverage"],
-        "javascript": ["jest", "mocha", "chai", "jasmine", "cypress", "playwright", "vitest"],
+        "javascript": [
+            "jest",
+            "mocha",
+            "chai",
+            "jasmine",
+            "cypress",
+            "playwright",
+            "vitest",
+        ],
         "java": ["junit", "testng", "mockito", "assertj"],
         "ruby": ["rspec", "minitest", "cucumber"],
         "go": ["testify", "ginkgo", "gomega"],
@@ -79,7 +91,16 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
     # Web framework packages
     FRAMEWORK_PACKAGES = {
         "python": ["django", "flask", "fastapi", "pyramid", "tornado", "aiohttp"],
-        "javascript": ["express", "koa", "fastify", "hapi", "nestjs", "next", "nuxt", "gatsby"],
+        "javascript": [
+            "express",
+            "koa",
+            "fastify",
+            "hapi",
+            "nestjs",
+            "next",
+            "nuxt",
+            "gatsby",
+        ],
         "ruby": ["rails", "sinatra", "hanami"],
         "java": ["spring", "spring-boot", "struts", "play"],
         "php": ["laravel", "symfony", "slim", "lumen"],
@@ -141,7 +162,7 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
 
             if target_path.is_dir():
                 return self._analyze_project(target_path, options)
-            elif target_path.is_file():
+            if target_path.is_file():
                 return self._analyze_manifest(target_path, options)
 
         return {
@@ -149,7 +170,9 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
             "message": f"Unsupported target type: {type(target).__name__}",
         }
 
-    def _analyze_project(self, project_path: Path, options: Dict[str, Any]) -> Dict[str, Any]:
+    def _analyze_project(
+        self, project_path: Path, options: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """Analyze dependencies in a project directory."""
         results = {
             "status": "success",
@@ -172,7 +195,9 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
             manager_deps = self._analyze_package_manager(project_path, manager, options)
             if manager_deps:
                 results["dependencies"][manager] = manager_deps.get("dependencies", {})
-                results["dev_dependencies"][manager] = manager_deps.get("dev_dependencies", {})
+                results["dev_dependencies"][manager] = manager_deps.get(
+                    "dev_dependencies", {}
+                )
 
         # Detect frameworks, databases, and testing tools
         all_deps = self._flatten_dependencies(results["dependencies"])
@@ -191,7 +216,9 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
 
         return results
 
-    def _analyze_manifest(self, manifest_path: Path, options: Dict[str, Any]) -> Dict[str, Any]:
+    def _analyze_manifest(
+        self, manifest_path: Path, options: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """Analyze a specific package manifest file."""
         results = {
             "status": "success",
@@ -277,20 +304,21 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
         try:
             if manager in ["npm", "yarn", "pnpm"]:
                 return self._analyze_node_dependencies(project_path, manager)
-            elif manager in ["pip", "pipenv", "poetry"]:
+            if manager in ["pip", "pipenv", "poetry"]:
                 return self._analyze_python_dependencies(project_path, manager)
-            elif manager == "cargo":
+            if manager == "cargo":
                 return self._analyze_cargo_dependencies(project_path)
-            elif manager == "go":
+            if manager == "go":
                 return self._analyze_go_dependencies(project_path)
-            else:
-                logger.debug(f"Unsupported package manager for analysis: {manager}")
-                return None
+            logger.debug(f"Unsupported package manager for analysis: {manager}")
+            return None
         except Exception as e:
             logger.error(f"Error analyzing {manager} dependencies: {e}")
             return None
 
-    def _analyze_node_dependencies(self, project_path: Path, manager: str) -> Dict[str, Any]:
+    def _analyze_node_dependencies(
+        self, project_path: Path, manager: str
+    ) -> Dict[str, Any]:
         """Analyze Node.js dependencies."""
         package_json_path = project_path / "package.json"
         if not package_json_path.exists():
@@ -298,7 +326,9 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
 
         return self._parse_package_json(package_json_path)
 
-    def _analyze_python_dependencies(self, project_path: Path, manager: str) -> Dict[str, Any]:
+    def _analyze_python_dependencies(
+        self, project_path: Path, manager: str
+    ) -> Dict[str, Any]:
         """Analyze Python dependencies."""
         results = {"dependencies": {}, "dev_dependencies": {}}
 
@@ -345,7 +375,7 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
     def _parse_package_json(self, path: Path) -> Dict[str, Any]:
         """Parse package.json file."""
         try:
-            with open(path, "r") as f:
+            with open(path) as f:
                 data = json.load(f)
 
             return {
@@ -479,7 +509,7 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
                 if line.startswith("require ("):
                     in_require = True
                     continue
-                elif line == ")":
+                if line == ")":
                     in_require = False
                     continue
 
@@ -494,7 +524,9 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
 
         return {"dependencies": dependencies}
 
-    def _flatten_dependencies(self, deps_dict: Dict[str, Dict[str, str]]) -> Dict[str, str]:
+    def _flatten_dependencies(
+        self, deps_dict: Dict[str, Dict[str, str]]
+    ) -> Dict[str, str]:
         """Flatten nested dependency dictionaries."""
         flattened = {}
         for manager_deps in deps_dict.values():
@@ -581,11 +613,13 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
         # Extract vulnerability metrics
         if "vulnerabilities" in analysis_result:
             vuln = analysis_result["vulnerabilities"]
-            metrics.update({
-                "vulnerability_total": vuln.get("total", 0),
-                "vulnerability_critical": vuln.get("critical", 0),
-                "vulnerability_high": vuln.get("high", 0),
-            })
+            metrics.update(
+                {
+                    "vulnerability_total": vuln.get("total", 0),
+                    "vulnerability_critical": vuln.get("critical", 0),
+                    "vulnerability_high": vuln.get("high", 0),
+                }
+            )
 
         return metrics
 
@@ -607,27 +641,33 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
         # Find added dependencies
         for dep, version in current_deps.items():
             if dep not in baseline_deps:
-                comparison["added_dependencies"].append({
-                    "name": dep,
-                    "version": version,
-                })
+                comparison["added_dependencies"].append(
+                    {
+                        "name": dep,
+                        "version": version,
+                    }
+                )
 
         # Find removed dependencies
         for dep, version in baseline_deps.items():
             if dep not in current_deps:
-                comparison["removed_dependencies"].append({
-                    "name": dep,
-                    "version": version,
-                })
+                comparison["removed_dependencies"].append(
+                    {
+                        "name": dep,
+                        "version": version,
+                    }
+                )
 
         # Find updated dependencies
         for dep in baseline_deps:
             if dep in current_deps and baseline_deps[dep] != current_deps[dep]:
-                comparison["updated_dependencies"].append({
-                    "name": dep,
-                    "old_version": baseline_deps[dep],
-                    "new_version": current_deps[dep],
-                })
+                comparison["updated_dependencies"].append(
+                    {
+                        "name": dep,
+                        "old_version": baseline_deps[dep],
+                        "new_version": current_deps[dep],
+                    }
+                )
 
         # Compare vulnerability counts
         if "vulnerabilities" in baseline and "vulnerabilities" in current:
@@ -636,8 +676,9 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
 
             comparison["vulnerability_changes"] = {
                 "total": current_vuln.get("total", 0) - baseline_vuln.get("total", 0),
-                "critical": current_vuln.get("critical", 0) - baseline_vuln.get("critical", 0),
+                "critical": current_vuln.get("critical", 0)
+                - baseline_vuln.get("critical", 0),
                 "high": current_vuln.get("high", 0) - baseline_vuln.get("high", 0),
             }
 
-        return comparison
+        return comparison