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

claude_mpm/services/unified/analyzer_strategies/structure_analyzer.py

@@ -10,13 +10,17 @@ Created: 2025-01-26
 """
 
 import fnmatch
-import os
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 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__)
 
@@ -87,11 +91,26 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
 
     # Common ignore patterns
     IGNORE_PATTERNS = [
-        "*.pyc", "__pycache__", ".git", ".svn", ".hg",
-        "node_modules", "venv", ".venv", "env",
-        "dist", "build", "target", "bin", "obj",
-        ".idea", ".vscode", "*.egg-info",
-        ".pytest_cache", ".coverage", ".tox",
+        "*.pyc",
+        "__pycache__",
+        ".git",
+        ".svn",
+        ".hg",
+        "node_modules",
+        "venv",
+        ".venv",
+        "env",
+        "dist",
+        "build",
+        "target",
+        "bin",
+        "obj",
+        ".idea",
+        ".vscode",
+        "*.egg-info",
+        ".pytest_cache",
+        ".coverage",
+        ".tox",
     ]
 
     def __init__(self):
@@ -166,7 +185,9 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
             "message": f"Unsupported target type: {type(target).__name__}",
         }
 
-    def _analyze_structure(self, root_path: Path, options: Dict[str, Any]) -> Dict[str, Any]:
+    def _analyze_structure(
+        self, root_path: Path, options: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """Analyze the structure of a project directory."""
         results = {
             "status": "success",
@@ -264,7 +285,9 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
                     # Track file types
                     ext = item.suffix.lower()
                     if ext:
-                        statistics["file_types"][ext] = statistics["file_types"].get(ext, 0) + 1
+                        statistics["file_types"][ext] = (
+                            statistics["file_types"].get(ext, 0) + 1
+                        )
 
                     # Get file info
                     try:
@@ -321,8 +344,9 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
         config_files = {
             child["name"].lower()
             for child in tree.get("children", [])
-            if child["type"] == "file"
-            and child["name"].startswith(".") or child["name"].endswith(".config.js")
+            if (child["type"] == "file"
+            and child["name"].startswith("."))
+            or child["name"].endswith(".config.js")
         }
         patterns["has_config"] = len(config_files) > 0
 
@@ -338,7 +362,11 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
         def collect_names(node: Dict[str, Any]) -> None:
             """Collect all file and directory names."""
             if node["type"] == "file":
-                name = node["name"].rsplit(".", 1)[0] if "." in node["name"] else node["name"]
+                name = (
+                    node["name"].rsplit(".", 1)[0]
+                    if "." in node["name"]
+                    else node["name"]
+                )
                 file_names.append(name)
             elif node["type"] == "directory":
                 file_names.append(node["name"])
@@ -353,8 +381,12 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
         # Count naming patterns
         snake_case = sum(1 for n in file_names if "_" in n and n.islower())
         kebab_case = sum(1 for n in file_names if "-" in n)
-        camel_case = sum(1 for n in file_names if n[0].islower() and any(c.isupper() for c in n))
-        pascal_case = sum(1 for n in file_names if n[0].isupper() and any(c.islower() for c in n))
+        camel_case = sum(
+            1 for n in file_names if n[0].islower() and any(c.isupper() for c in n)
+        )
+        pascal_case = sum(
+            1 for n in file_names if n[0].isupper() and any(c.islower() for c in n)
+        )
 
         # Determine dominant pattern
         patterns = {
@@ -411,9 +443,7 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
             )
 
         # Check file distribution
-        avg_files_per_dir = (
-            stats["total_files"] / max(stats["total_dirs"], 1)
-        )
+        avg_files_per_dir = stats["total_files"] / max(stats["total_dirs"], 1)
         if avg_files_per_dir > 20:
             score -= 10
             organization["recommendations"].append(
@@ -472,17 +502,18 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
             found_dirs = required_dirs & dir_names
 
             if len(found_dirs) >= len(required_dirs) * pattern_info["confidence"]:
-                architecture["detected_patterns"].append({
-                    "name": pattern_name,
-                    "confidence": len(found_dirs) / len(required_dirs),
-                    "matched_dirs": list(found_dirs),
-                })
+                architecture["detected_patterns"].append(
+                    {
+                        "name": pattern_name,
+                        "confidence": len(found_dirs) / len(required_dirs),
+                        "matched_dirs": list(found_dirs),
+                    }
+                )
 
         # Select the pattern with highest confidence
         if architecture["detected_patterns"]:
             best_pattern = max(
-                architecture["detected_patterns"],
-                key=lambda x: x["confidence"]
+                architecture["detected_patterns"], key=lambda x: x["confidence"]
             )
             architecture["pattern"] = best_pattern["name"]
             architecture["confidence"] = best_pattern["confidence"]
@@ -502,14 +533,12 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
 
         # Structural complexity based on file and directory count
         total_nodes = stats["total_files"] + stats["total_dirs"]
-        complexity["structural_complexity"] = (
-            (total_nodes / 100) * (stats["max_depth"] / 3)
+        complexity["structural_complexity"] = (total_nodes / 100) * (
+            stats["max_depth"] / 3
         )
 
         # Nesting complexity
-        complexity["nesting_complexity"] = min(
-            100, (stats["max_depth"] / 7) * 100
-        )
+        complexity["nesting_complexity"] = min(100, (stats["max_depth"] / 7) * 100)
 
         # File dispersion (how spread out files are)
         if stats["total_dirs"] > 0:
@@ -562,10 +591,7 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
 
         file_counts = {}
         for language, extensions in language_extensions.items():
-            count = sum(
-                len(list(root_path.rglob(f"*{ext}")))
-                for ext in extensions
-            )
+            count = sum(len(list(root_path.rglob(f"*{ext}"))) for ext in extensions)
             if count > 0:
                 file_counts[language] = count
 
@@ -621,12 +647,14 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
         # Extract structure statistics
         if "statistics" in analysis_result:
             stats = analysis_result["statistics"]
-            metrics.update({
-                "total_files": stats.get("total_files", 0),
-                "total_directories": stats.get("total_dirs", 0),
-                "max_depth": stats.get("max_depth", 0),
-                "unique_file_types": len(stats.get("file_types", {})),
-            })
+            metrics.update(
+                {
+                    "total_files": stats.get("total_files", 0),
+                    "total_directories": stats.get("total_dirs", 0),
+                    "max_depth": stats.get("max_depth", 0),
+                    "unique_file_types": len(stats.get("file_types", {})),
+                }
+            )
 
         # Extract organization metrics
         if "organization" in analysis_result:
@@ -636,12 +664,14 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
         # Extract complexity metrics
         if "complexity" in analysis_result:
             complexity = analysis_result["complexity"]
-            metrics.update({
-                "structural_complexity": complexity.get("structural_complexity", 0),
-                "nesting_complexity": complexity.get("nesting_complexity", 0),
-                "file_dispersion": complexity.get("file_dispersion", 0),
-                "coupling_indicator": complexity.get("coupling_indicator", 0),
-            })
+            metrics.update(
+                {
+                    "structural_complexity": complexity.get("structural_complexity", 0),
+                    "nesting_complexity": complexity.get("nesting_complexity", 0),
+                    "file_dispersion": complexity.get("file_dispersion", 0),
+                    "coupling_indicator": complexity.get("coupling_indicator", 0),
+                }
+            )
 
         return metrics
 
@@ -668,7 +698,8 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
                     "change": diff,
                     "percent_change": (
                         (diff / baseline_metrics[key] * 100)
-                        if baseline_metrics[key] else 0
+                        if baseline_metrics[key]
+                        else 0
                     ),
                 }
 
@@ -687,10 +718,13 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
 
         # Compare architecture
         if "architecture" in baseline and "architecture" in current:
-            if baseline["architecture"]["pattern"] != current["architecture"]["pattern"]:
+            if (
+                baseline["architecture"]["pattern"]
+                != current["architecture"]["pattern"]
+            ):
                 comparison["architecture_change"] = {
                     "baseline": baseline["architecture"]["pattern"],
                     "current": current["architecture"]["pattern"],
                 }
 
-        return comparison
+        return comparison

claude_mpm/services/unified/config_strategies/__init__.py

@@ -0,0 +1,175 @@
+"""
+Unified Configuration Strategies - Phase 3 Consolidation
+Reduces 15,000+ lines of configuration code by 65-75%
+
+This package consolidates:
+- 15+ configuration services → 1 unified service
+- 215 file loading instances → 5 strategic loaders
+- 236 validation functions → 15 composable validators
+- 99 error handling patterns → Unified error strategy
+
+Target: 10,000-11,000 line reduction with 20-30% performance improvement
+"""
+
+from .config_schema import (
+    ConfigMigration,
+    ConfigSchema,
+    SchemaBuilder,
+    SchemaFormat,
+    SchemaProperty,
+    SchemaRegistry,
+    SchemaType,
+    SchemaValidator,
+    TypedConfig,
+    create_api_schema,
+    create_database_schema,
+    create_logging_schema,
+)
+from .context_strategy import (
+    CachingContextManager,
+    ContextLifecycle,
+    ContextScope,
+    ContextStrategy,
+    HierarchicalContextManager,
+    IsolatedContextManager,
+    ScopedConfigManager,
+    ThreadLocalContextManager,
+)
+from .error_handling_strategy import (
+    CompositeErrorHandler,
+    ErrorCategory,
+    ErrorContext,
+    ErrorHandlingResult,
+    ErrorHandlingStrategy,
+    ErrorSeverity,
+    FileIOErrorHandler,
+    NetworkErrorHandler,
+    ParsingErrorHandler,
+    TypeConversionErrorHandler,
+    ValidationErrorHandler,
+)
+from .file_loader_strategy import (
+    CompositeFileLoader,
+    EnvironmentFileLoader,
+    FileLoadContext,
+    FileLoaderStrategy,
+    LegacyFileLoader,
+    LoaderType,
+    ProgrammaticFileLoader,
+    StructuredFileLoader,
+)
+from .unified_config_service import (
+    ConfigContext,
+    ConfigFormat,
+    ConfigMetadata,
+    IConfigStrategy,
+    UnifiedConfigService,
+)
+from .validation_strategy import (
+    CompositeValidator,
+    ConditionalValidator,
+    CrossFieldValidator,
+    CustomValidator,
+    DependencyValidator,
+    EnumValidator,
+    FormatValidator,
+    LengthValidator,
+    PatternValidator,
+    RangeValidator,
+    RecursiveValidator,
+    RequiredValidator,
+    SchemaValidator,
+    TypeValidator,
+    UniqueValidator,
+    ValidationResult,
+    ValidationRule,
+    ValidationStrategy,
+    ValidationType,
+)
+
+# Create singleton instance for global use
+unified_config = UnifiedConfigService()
+
+# Backward compatibility aliases
+ConfigService = UnifiedConfigService
+ConfigManager = UnifiedConfigService
+ConfigLoader = UnifiedConfigService
+
+# Export all public APIs
+__all__ = [
+    # Main service
+    "UnifiedConfigService",
+    "unified_config",
+    # Strategies
+    "FileLoaderStrategy",
+    "ValidationStrategy",
+    "ErrorHandlingStrategy",
+    "ContextStrategy",
+    # Core types
+    "ConfigFormat",
+    "ConfigContext",
+    "ConfigMetadata",
+    "IConfigStrategy",
+    # File loading
+    "LoaderType",
+    "FileLoadContext",
+    "StructuredFileLoader",
+    "EnvironmentFileLoader",
+    "ProgrammaticFileLoader",
+    "LegacyFileLoader",
+    "CompositeFileLoader",
+    # Validation
+    "ValidationRule",
+    "ValidationResult",
+    "ValidationType",
+    # Error handling
+    "ErrorContext",
+    "ErrorHandlingResult",
+    "ErrorCategory",
+    "ErrorSeverity",
+    # Context management
+    "ContextScope",
+    "ContextLifecycle",
+    "HierarchicalContextManager",
+    "ScopedConfigManager",
+    # Schema
+    "ConfigSchema",
+    "SchemaProperty",
+    "SchemaBuilder",
+    "SchemaValidator",
+    "SchemaRegistry",
+    "ConfigMigration",
+    "TypedConfig",
+    "SchemaType",
+    "SchemaFormat",
+    # Backward compatibility
+    "ConfigService",
+    "ConfigManager",
+    "ConfigLoader",
+]
+
+
+# Module initialization
+def initialize():
+    """Initialize the unified configuration system"""
+    # Register default strategies
+    unified_config.register_strategy("file", FileLoaderStrategy())
+    unified_config.register_strategy("validation", ValidationStrategy())
+    unified_config.register_strategy("error", ErrorHandlingStrategy())
+    unified_config.register_strategy("context", ContextStrategy())
+
+    # Set up default error handlers
+    error_strategy = ErrorHandlingStrategy()
+
+    # Register recovery strategies
+    error_strategy.register_recovery_strategy(
+        "default_fallback", lambda ctx: ctx.metadata.get("default_config", {})
+    )
+
+    error_strategy.register_recovery_strategy("empty_fallback", lambda ctx: {})
+
+    return unified_config
+
+
+# Auto-initialize on import
+_unified_instance = initialize()