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

claude_mpm/VERSION

@@ -1 +1 @@
-4.3.22
+4.4.0

claude_mpm/cli/commands/doctor.py

@@ -107,8 +107,8 @@ def doctor_command(args):
         Exit code (0 for success, 1 for warnings, 2 for errors)
     """
     # Configure logging
-from claude_mpm.core.logging_utils import get_logger
-logger = get_logger(__name__)
+    from claude_mpm.core.logging_utils import get_logger
+    logger = get_logger(__name__)
 
     # Determine output format
     if args.json:

claude_mpm/hooks/memory_integration_hook.py

@@ -16,7 +16,7 @@ import re
 from typing import Dict, List
 
 from claude_mpm.core.config import Config
-from claude_mpm.core.logger import get_logger
+from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.core.shared.config_loader import ConfigLoader
 from claude_mpm.hooks.base_hook import (
     HookContext,

claude_mpm/services/agents/memory/content_manager.py

@@ -12,12 +12,15 @@ This module provides:
 - Content repair and structure validation
 """
 
-import logging
 import re
 from datetime import datetime, timezone
 from difflib import SequenceMatcher
 from typing import Any, Dict, List, Optional, Tuple
 
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
 
 class MemoryContentManager:
     """Manages memory content manipulation and validation.
@@ -34,7 +37,7 @@ class MemoryContentManager:
             memory_limits: Dictionary containing memory limits configuration
         """
         self.memory_limits = memory_limits
-        self.logger = logging.getLogger(f"{__name__}.{self.__class__.__name__}")
+        self.logger = logger  # Use the module-level logger
 
     def add_item_to_list(self, content: str, new_item: str) -> str:
         """Add item to memory list with deduplication.

claude_mpm/services/agents/memory/memory_file_service.py

@@ -18,6 +18,7 @@ class MemoryFileService:
             memories_dir: Directory where memory files are stored
         """
         self.memories_dir = memories_dir
+        self.logger = logger  # Use the module-level logger
 
     def get_memory_file_with_migration(self, directory: Path, agent_id: str) -> Path:
         """Get memory file path with migration support.

claude_mpm/services/agents/memory/memory_limits_service.py

@@ -26,6 +26,7 @@ class MemoryLimitsService:
             config: Optional Config object for reading configuration
         """
         self.config = config or Config()
+        self.logger = logger  # Use the module-level logger
         self.memory_limits = self._init_memory_limits()
 
     def _init_memory_limits(self) -> Dict[str, Any]:

claude_mpm/services/unified/__init__.py

@@ -0,0 +1,65 @@
+"""
+Unified Services Module for Phase 2 Service Consolidation
+=========================================================
+
+This module implements the strategy pattern framework for consolidating
+Claude MPM's 314 service files into approximately 180 more maintainable services.
+
+Architecture:
+- Base service interfaces for common service patterns
+- Strategy pattern for pluggable behavior
+- Backward compatibility layer for existing services
+- Feature flags for gradual migration
+
+Components:
+- interfaces.py: Core service interfaces (IDeploymentService, IAnalyzerService, etc.)
+- strategies.py: Strategy pattern framework with plugin registry
+- migration.py: Migration utilities and backward compatibility
+- Unified service implementations for major service categories
+"""
+
+from .interfaces import (
+    IAnalyzerService,
+    IConfigurationService,
+    IDeploymentService,
+    ServiceCapability,
+    ServiceMetadata,
+)
+from .migration import (
+    FeatureFlag,
+    MigrationStatus,
+    ServiceMapper,
+    create_compatibility_wrapper,
+)
+from .strategies import (
+    AnalyzerStrategy,
+    ConfigStrategy,
+    DeploymentStrategy,
+    StrategyRegistry,
+)
+from .unified_analyzer import UnifiedAnalyzer
+from .unified_config import UnifiedConfigManager
+from .unified_deployment import UnifiedDeploymentService
+
+__all__ = [
+    # Interfaces
+    "IDeploymentService",
+    "IAnalyzerService",
+    "IConfigurationService",
+    "ServiceMetadata",
+    "ServiceCapability",
+    # Strategies
+    "DeploymentStrategy",
+    "AnalyzerStrategy",
+    "ConfigStrategy",
+    "StrategyRegistry",
+    # Migration
+    "ServiceMapper",
+    "MigrationStatus",
+    "FeatureFlag",
+    "create_compatibility_wrapper",
+    # Unified Services
+    "UnifiedDeploymentService",
+    "UnifiedAnalyzer",
+    "UnifiedConfigManager",
+]

claude_mpm/services/unified/analyzer_strategies/__init__.py

@@ -0,0 +1,44 @@
+"""
+Concrete Analyzer Strategy Implementations
+==========================================
+
+This module provides concrete implementations of the AnalyzerStrategy base class,
+consolidating functionality from multiple analyzer services with 70-80% code duplication.
+
+Consolidates:
+- enhanced_analyzer.py (1,118 LOC)
+- project_analyzer.py (815 LOC)
+- structure_analyzer.py (703 LOC)
+- code_analyzer.py (385 LOC)
+- dependency_analyzer.py (326 LOC)
+- file_analyzer.py (247 LOC)
+- project_report_generator.py (121 LOC)
+
+Total: 3,715 LOC → ~1,200 LOC (68% reduction)
+
+Author: Claude MPM Development Team
+Created: 2025-01-26
+"""
+
+from .code_analyzer import CodeAnalyzerStrategy
+from .dependency_analyzer import DependencyAnalyzerStrategy
+from .performance_analyzer import PerformanceAnalyzerStrategy
+from .security_analyzer import SecurityAnalyzerStrategy
+from .structure_analyzer import StructureAnalyzerStrategy
+
+__all__ = [
+    "CodeAnalyzerStrategy",
+    "DependencyAnalyzerStrategy",
+    "StructureAnalyzerStrategy",
+    "SecurityAnalyzerStrategy",
+    "PerformanceAnalyzerStrategy",
+]
+
+# Strategy registry for automatic discovery
+ANALYZER_STRATEGIES = {
+    "code": CodeAnalyzerStrategy,
+    "dependency": DependencyAnalyzerStrategy,
+    "structure": StructureAnalyzerStrategy,
+    "security": SecurityAnalyzerStrategy,
+    "performance": PerformanceAnalyzerStrategy,
+}

claude_mpm/services/unified/analyzer_strategies/code_analyzer.py

@@ -0,0 +1,473 @@
+"""
+Code Analyzer Strategy Implementation
+=====================================
+
+Analyzes code structure, complexity, quality metrics, and patterns.
+Consolidates functionality from multiple analyzer services.
+
+Author: Claude MPM Development Team
+Created: 2025-01-26
+"""
+
+import ast
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+from claude_mpm.core.logging_utils import get_logger
+
+from ..strategies import AnalyzerStrategy, StrategyContext, StrategyMetadata, StrategyPriority
+
+logger = get_logger(__name__)
+
+
+class CodeAnalyzerStrategy(AnalyzerStrategy):
+    """
+    Strategy for analyzing code structure, complexity, and quality metrics.
+
+    Consolidates:
+    - Code complexity analysis (cyclomatic, cognitive)
+    - Code quality metrics (maintainability index, technical debt)
+    - Pattern detection (anti-patterns, code smells)
+    - Function/class analysis (size, complexity, coupling)
+    """
+
+    def __init__(self):
+        """Initialize code analyzer strategy."""
+        metadata = StrategyMetadata(
+            name="CodeAnalyzer",
+            description="Analyzes code structure, complexity, and quality metrics",
+            supported_types=["file", "directory", "module", "class", "function"],
+            supported_operations=["analyze", "metrics", "complexity", "quality"],
+            priority=StrategyPriority.HIGH,
+            tags={"code", "complexity", "quality", "metrics", "ast"},
+        )
+        super().__init__(metadata)
+
+        # Language-specific file extensions
+        self.language_extensions = {
+            "python": {".py", ".pyi"},
+            "javascript": {".js", ".jsx", ".mjs"},
+            "typescript": {".ts", ".tsx"},
+            "java": {".java"},
+            "go": {".go"},
+            "rust": {".rs"},
+            "c": {".c", ".h"},
+            "cpp": {".cpp", ".cc", ".cxx", ".hpp", ".h"},
+        }
+
+        # Code smell patterns
+        self.code_smell_patterns = {
+            "long_method": {"threshold": 50, "metric": "lines"},
+            "large_class": {"threshold": 500, "metric": "lines"},
+            "long_parameter_list": {"threshold": 5, "metric": "count"},
+            "duplicate_code": {"threshold": 0.7, "metric": "similarity"},
+            "god_class": {"threshold": 10, "metric": "responsibilities"},
+        }
+
+    def can_handle(self, context: StrategyContext) -> bool:
+        """Check if strategy can handle the given context."""
+        return (
+            context.target_type in self.metadata.supported_types
+            and context.operation in self.metadata.supported_operations
+        )
+
+    def validate_input(self, input_data: Any) -> List[str]:
+        """Validate input data for strategy."""
+        errors = []
+
+        if not input_data:
+            errors.append("Input data is required")
+            return errors
+
+        if isinstance(input_data, (str, Path)):
+            path = Path(input_data)
+            if not path.exists():
+                errors.append(f"Path does not exist: {path}")
+        elif not isinstance(input_data, dict):
+            errors.append(f"Invalid input type: {type(input_data).__name__}")
+
+        return errors
+
+    def analyze(
+        self, target: Any, options: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Execute code analysis on target.
+
+        Args:
+            target: Code file, directory, or AST node to analyze
+            options: Analysis options (language, metrics, depth, etc.)
+
+        Returns:
+            Analysis results with metrics and findings
+        """
+        options = options or {}
+
+        # Determine target type and language
+        if isinstance(target, (str, Path)):
+            target_path = Path(target)
+            if target_path.is_file():
+                return self._analyze_file(target_path, options)
+            elif target_path.is_dir():
+                return self._analyze_directory(target_path, options)
+        elif isinstance(target, ast.AST):
+            return self._analyze_ast(target, options)
+
+        return {
+            "status": "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 code file."""
+        try:
+            # Detect language from extension
+            language = self._detect_language(file_path)
+
+            # Read file content
+            content = file_path.read_text(encoding="utf-8")
+            lines = content.splitlines()
+
+            # Base metrics
+            metrics = {
+                "file": str(file_path),
+                "language": language,
+                "lines_of_code": len(lines),
+                "blank_lines": sum(1 for line in lines if not line.strip()),
+                "comment_lines": self._count_comment_lines(content, language),
+            }
+
+            # Language-specific analysis
+            if language == "python":
+                metrics.update(self._analyze_python_code(content, file_path))
+
+            # Calculate complexity metrics
+            metrics["complexity"] = self._calculate_complexity_metrics(content, language)
+
+            # Detect code smells
+            metrics["code_smells"] = self._detect_code_smells(content, metrics)
+
+            # Calculate maintainability index
+            metrics["maintainability_index"] = self._calculate_maintainability(metrics)
+
+            return {
+                "status": "success",
+                "type": "file",
+                "path": str(file_path),
+                "metrics": metrics,
+            }
+
+        except Exception as e:
+            logger.error(f"Error analyzing file {file_path}: {e}")
+            return {
+                "status": "error",
+                "path": str(file_path),
+                "error": str(e),
+            }
+
+    def _analyze_directory(self, dir_path: Path, options: Dict[str, Any]) -> Dict[str, Any]:
+        """Analyze all code files in a directory."""
+        results = {
+            "status": "success",
+            "type": "directory",
+            "path": str(dir_path),
+            "files": [],
+            "summary": {},
+        }
+
+        # Collect all code files
+        code_files = []
+        for ext_set in self.language_extensions.values():
+            for ext in ext_set:
+                code_files.extend(dir_path.rglob(f"*{ext}"))
+
+        # Analyze each file
+        total_metrics = {}
+        for file_path in code_files:
+            file_result = self._analyze_file(file_path, options)
+            if file_result["status"] == "success":
+                results["files"].append(file_result)
+
+                # Aggregate metrics
+                for key, value in file_result.get("metrics", {}).items():
+                    if isinstance(value, (int, float)):
+                        total_metrics[key] = total_metrics.get(key, 0) + value
+
+        # Calculate summary statistics
+        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),
+            "code_smells_count": sum(
+                len(f.get("metrics", {}).get("code_smells", []))
+                for f in results["files"]
+            ),
+        }
+
+        return results
+
+    def _analyze_python_code(self, content: str, file_path: Path) -> Dict[str, Any]:
+        """Perform Python-specific code analysis."""
+        try:
+            tree = ast.parse(content)
+
+            # Count functions, classes, methods
+            functions = []
+            classes = []
+            methods = []
+
+            for node in ast.walk(tree):
+                if isinstance(node, ast.FunctionDef):
+                    if any(isinstance(parent, ast.ClassDef) for parent in ast.walk(tree)):
+                        methods.append(node.name)
+                    else:
+                        functions.append(node.name)
+                elif isinstance(node, ast.ClassDef):
+                    classes.append(node.name)
+
+            return {
+                "functions": functions,
+                "classes": classes,
+                "methods": methods,
+                "function_count": len(functions),
+                "class_count": len(classes),
+                "method_count": len(methods),
+            }
+
+        except SyntaxError as e:
+            logger.warning(f"Syntax error in {file_path}: {e}")
+            return {}
+
+    def _analyze_ast(self, node: ast.AST, options: Dict[str, Any]) -> Dict[str, Any]:
+        """Analyze an AST node directly."""
+        metrics = {
+            "node_type": node.__class__.__name__,
+            "complexity": self._calculate_ast_complexity(node),
+        }
+
+        # 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,
+            })
+        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),
+            })
+
+        return {
+            "status": "success",
+            "type": "ast",
+            "metrics": metrics,
+        }
+
+    def _calculate_complexity_metrics(self, content: str, language: str) -> Dict[str, Any]:
+        """Calculate various complexity metrics."""
+        complexity = {
+            "cyclomatic": 1,  # Base complexity
+            "cognitive": 0,
+            "halstead": {},
+        }
+
+        if language == "python":
+            try:
+                tree = ast.parse(content)
+                complexity["cyclomatic"] = self._calculate_cyclomatic_complexity(tree)
+                complexity["cognitive"] = self._calculate_cognitive_complexity(tree)
+            except:
+                pass
+
+        return complexity
+
+    def _calculate_cyclomatic_complexity(self, tree: ast.AST) -> int:
+        """Calculate cyclomatic complexity for Python AST."""
+        complexity = 1
+
+        for node in ast.walk(tree):
+            # Decision points increase complexity
+            if isinstance(node, (ast.If, ast.While, ast.For, ast.ExceptHandler)):
+                complexity += 1
+            elif isinstance(node, ast.BoolOp):
+                complexity += len(node.values) - 1
+
+        return complexity
+
+    def _calculate_cognitive_complexity(self, tree: ast.AST) -> int:
+        """Calculate cognitive complexity (simplified version)."""
+        complexity = 0
+        nesting_level = 0
+
+        # Simplified cognitive complexity calculation
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.If, ast.While, ast.For)):
+                complexity += 1 + nesting_level
+            elif isinstance(node, ast.BoolOp):
+                complexity += len(node.values) - 1
+
+        return complexity
+
+    def _calculate_ast_complexity(self, node: ast.AST) -> int:
+        """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]]:
+        """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']})",
+            })
+
+        # 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}",
+            })
+
+        return smells
+
+    def _calculate_maintainability(self, metrics: Dict[str, Any]) -> float:
+        """
+        Calculate maintainability index (0-100 scale).
+        Simplified version of the standard formula.
+        """
+        loc = metrics.get("lines_of_code", 0)
+        complexity = metrics.get("complexity", {}).get("cyclomatic", 1)
+
+        # Simplified maintainability index
+        if loc == 0:
+            return 100.0
+
+        # Basic formula (simplified)
+        mi = 171 - 5.2 * (loc / 100) - 0.23 * complexity
+
+        # Normalize to 0-100 scale
+        return max(0, min(100, mi))
+
+    def _detect_language(self, file_path: Path) -> str:
+        """Detect programming language from file extension."""
+        ext = file_path.suffix.lower()
+
+        for language, extensions in self.language_extensions.items():
+            if ext in extensions:
+                return language
+
+        return "unknown"
+
+    def _count_comment_lines(self, content: str, language: str) -> int:
+        """Count comment lines based on language."""
+        comment_patterns = {
+            "python": r"^\s*#",
+            "javascript": r"^\s*(//|/\*|\*)",
+            "java": r"^\s*(//|/\*|\*)",
+            "c": r"^\s*(//|/\*|\*)",
+            "cpp": r"^\s*(//|/\*|\*)",
+        }
+
+        pattern = comment_patterns.get(language)
+        if not pattern:
+            return 0
+
+        count = 0
+        for line in content.splitlines():
+            if re.match(pattern, line):
+                count += 1
+
+        return count
+
+    def extract_metrics(self, analysis_result: Dict[str, Any]) -> Dict[str, Any]:
+        """Extract key metrics from analysis results."""
+        metrics = {}
+
+        if analysis_result.get("status") != "success":
+            return metrics
+
+        # Extract relevant metrics
+        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),
+            })
+
+        # 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),
+            })
+
+        return metrics
+
+    def compare_results(
+        self, baseline: Dict[str, Any], current: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Compare two analysis results."""
+        comparison = {
+            "improved": [],
+            "degraded": [],
+            "unchanged": [],
+        }
+
+        baseline_metrics = self.extract_metrics(baseline)
+        current_metrics = self.extract_metrics(current)
+
+        for key in baseline_metrics:
+            if key not in current_metrics:
+                continue
+
+            baseline_val = baseline_metrics[key]
+            current_val = current_metrics[key]
+
+            if isinstance(baseline_val, (int, float)):
+                diff = current_val - baseline_val
+                pct_change = (diff / baseline_val * 100) if baseline_val else 0
+
+                result = {
+                    "metric": key,
+                    "baseline": baseline_val,
+                    "current": current_val,
+                    "change": diff,
+                    "percent_change": pct_change,
+                }
+
+                # Determine if improvement or degradation
+                if key in ["maintainability_index"]:
+                    # Higher is better
+                    if diff > 0:
+                        comparison["improved"].append(result)
+                    elif diff < 0:
+                        comparison["degraded"].append(result)
+                    else:
+                        comparison["unchanged"].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)
+
+        return comparison