claude-mpm 3.9.9__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/services/framework_claude_md_generator/version_manager.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 """
 Version management for framework CLAUDE.md templates.
 
@@ -5,28 +7,27 @@ Handles version parsing, incrementing, and comparison operations.
 """
 
 import re
-from typing import Tuple, Optional
-from pathlib import Path
+from typing import Optional, Tuple
 
 
 class VersionManager:
     """Manages version numbering for framework CLAUDE.md templates."""
-    
+
     def __init__(self):
         """Initialize version manager."""
         self.framework_version = self._get_framework_version()
-    
+
     def _get_framework_version(self) -> str:
         """
         Get the current framework version from framework/VERSION file.
-        
+
         Returns:
             str: Framework version (e.g., "015")
         """
         # Check if we're in a wheel installation
         package_path = Path(__file__).parent.parent.parent
         path_str = str(package_path.resolve())
-        if 'site-packages' in path_str or 'dist-packages' in path_str:
+        if "site-packages" in path_str or "dist-packages" in path_str:
             # For wheel installations, check data directory
             version_path = package_path / "data" / "framework" / "VERSION"
             if not version_path.exists():
@@ -35,87 +36,88 @@ class VersionManager:
         else:
             # Source installation
             version_path = package_path.parent / "framework" / "VERSION"
-        
+
         if version_path.exists():
-            with open(version_path, 'r') as f:
+            with open(version_path, "r") as f:
                 version_content = f.read().strip()
                 # Framework VERSION file contains just the framework version number
                 try:
                     return f"{int(version_content):03d}"
                 except ValueError:
                     # If not a plain number, try to extract from version string
-                    match = re.match(r'(\d+)', version_content)
+                    match = re.match(r"(\d+)", version_content)
                     if match:
                         return f"{int(match.group(1)):03d}"
         return "014"  # Default fallback
-    
+
     def parse_current_version(self, content: str) -> str:
         """
         Parse the current CLAUDE_MD_VERSION from existing content.
-        
+
         Args:
             content: Existing CLAUDE.md content
-            
+
         Returns:
             str: Version number (e.g., "016")
         """
         # First try simple serial format
-        match = re.search(r'CLAUDE_MD_VERSION:\s*(\d+)(?!-)', content)
+        match = re.search(r"CLAUDE_MD_VERSION:\s*(\d+)(?!-)", content)
         if match:
             return match.group(1)
-        
+
         # Handle old format for backward compatibility
-        match = re.search(r'CLAUDE_MD_VERSION:\s*(\d+)-(\d+)', content)
+        match = re.search(r"CLAUDE_MD_VERSION:\s*(\d+)-(\d+)", content)
         if match:
             return match.group(1)  # Return just the framework part
-        
+
         return self.framework_version
-    
+
     def auto_increment_version(self, current_content: Optional[str] = None) -> str:
         """
         Get the current framework version (no auto-increment for simple serial numbers).
-        
+
         Args:
             current_content: Current CLAUDE.md content (unused with simple serials)
-            
+
         Returns:
             str: Current framework version (e.g., "016")
         """
         # With simple serial numbers, we just use the framework version
         # Incrementing is done by updating the framework/VERSION file
         return self.framework_version
-    
+
     def compare_versions(self, version1: str, version2: str) -> int:
         """
         Compare two version strings.
-        
+
         Args:
             version1: First version string (e.g., "016")
             version2: Second version string (e.g., "017")
-            
+
         Returns:
             int: -1 if version1 < version2, 0 if equal, 1 if version1 > version2
         """
+
         def parse_version(v: str) -> int:
             # Handle simple serial format
-            if '-' not in v:
+            if "-" not in v:
                 try:
                     return int(v)
                 except ValueError:
                     return 0
-            
+
             # Handle old format for backward compatibility
-            match = re.match(r'(\d+)-(\d+)', v)
+            match = re.match(r"(\d+)-(\d+)", v)
             if match:
                 return int(match.group(1))  # Just compare framework part
             return 0
-        
+
         v1 = parse_version(version1)
         v2 = parse_version(version2)
-        
+
         if v1 < v2:
             return -1
         elif v1 > v2:
             return 1
         else:
-            return 0
+            return 0

claude_mpm/services/hook_service.py

@@ -11,65 +11,65 @@ rather than a single list with type checking because:
 - It prevents accidentally mixing hook types
 """
 
-from typing import List, Optional, Dict, Any
 import time
 from datetime import datetime
+from typing import Any, Dict, List, Optional
 
 from claude_mpm.core.config import Config
+from claude_mpm.core.interfaces import HookServiceInterface
 from claude_mpm.core.logging_config import get_logger, log_operation
 from claude_mpm.hooks.base_hook import (
     BaseHook,
-    PreDelegationHook,
-    PostDelegationHook,
     HookContext,
     HookResult,
-    HookType
+    HookType,
+    PostDelegationHook,
+    PreDelegationHook,
 )
-from claude_mpm.core.interfaces import HookServiceInterface
 
 
 class HookService(HookServiceInterface):
     """Service for managing and executing hooks in the delegation workflow.
-    
+
     WHY: Provides a centralized place to register and execute hooks, ensuring
     they run in the correct order and that failures in individual hooks don't
     break the entire delegation flow.
-    
+
     DESIGN DECISION: We execute hooks even if previous ones fail because:
     - Hooks should be independent and not rely on each other
     - A logging hook failure shouldn't prevent memory hooks from running
     - We log all failures for debugging but keep the system resilient
     """
-    
+
     def __init__(self, config: Optional[Config] = None):
         """Initialize the hook service.
-        
+
         Args:
             config: Optional configuration object for controlling hook behavior
         """
         self.config = config or Config()
         self.logger = get_logger(__name__)
-        
+
         # Separate lists for different hook types for performance
         self.pre_delegation_hooks: List[PreDelegationHook] = []
         self.post_delegation_hooks: List[PostDelegationHook] = []
-        
+
         # Track execution statistics for monitoring
         self.stats = {
             "pre_delegation_executed": 0,
             "post_delegation_executed": 0,
-            "errors": 0
+            "errors": 0,
         }
-    
+
     def register_hook(self, hook: BaseHook) -> bool:
         """Register a hook with the service.
-        
+
         WHY: We need a way to add hooks dynamically, and we validate the hook
         type to ensure it goes into the correct execution list.
-        
+
         Args:
             hook: The hook to register
-            
+
         Returns:
             True if successfully registered, False otherwise
         """
@@ -78,64 +78,66 @@ class HookService(HookServiceInterface):
                 self.pre_delegation_hooks.append(hook)
                 # Sort by priority (lower number = higher priority = executes first)
                 self.pre_delegation_hooks.sort(key=lambda h: h.priority)
-                self.logger.info(f"Registered pre-delegation hook: {hook.name} (priority: {hook.priority})")
+                self.logger.info(
+                    f"Registered pre-delegation hook: {hook.name} (priority: {hook.priority})"
+                )
                 return True
-                
+
             elif isinstance(hook, PostDelegationHook):
                 self.post_delegation_hooks.append(hook)
                 # Sort by priority
                 self.post_delegation_hooks.sort(key=lambda h: h.priority)
-                self.logger.info(f"Registered post-delegation hook: {hook.name} (priority: {hook.priority})")
+                self.logger.info(
+                    f"Registered post-delegation hook: {hook.name} (priority: {hook.priority})"
+                )
                 return True
-                
+
             else:
-                self.logger.warning(f"Attempted to register unsupported hook type: {type(hook).__name__}")
+                self.logger.warning(
+                    f"Attempted to register unsupported hook type: {type(hook).__name__}"
+                )
                 return False
-                
+
         except Exception as e:
             self.logger.error(f"Failed to register hook {hook.name}: {e}")
             return False
-    
+
     def execute_pre_delegation_hooks(self, context: HookContext) -> HookResult:
         """Execute all pre-delegation hooks in priority order.
-        
+
         WHY: Pre-delegation hooks need to modify the context before it's sent
         to the agent. Each hook can add or modify context data.
-        
+
         DESIGN DECISION: We pass the context through all hooks sequentially,
         allowing each to modify it. This enables powerful composition patterns.
-        
+
         Args:
             context: The HookContext to be processed by hooks
-            
+
         Returns:
             HookResult containing the final processed data
         """
         # Check if hooks are enabled via config
         if not self._are_hooks_enabled("pre_delegation"):
-            return HookResult(
-                success=True,
-                data=context.data,
-                modified=False
-            )
-            
+            return HookResult(success=True, data=context.data, modified=False)
+
         # Create a working copy of the data to preserve original
         working_data = context.data.copy()
-        
+
         executed_count = 0
         has_modifications = False
-        
+
         for hook in self.pre_delegation_hooks:
             if not hook.enabled:
                 self.logger.debug(f"Skipping disabled hook: {hook.name}")
                 continue
-                
+
             try:
                 # Validate if hook should run
                 if not hook.validate(context):
                     self.logger.debug(f"Hook {hook.name} validation failed, skipping")
                     continue
-                
+
                 # Create a hook context with the current working data
                 hook_context = HookContext(
                     hook_type=context.hook_type,
@@ -143,21 +145,21 @@ class HookService(HookServiceInterface):
                     metadata=context.metadata,
                     timestamp=context.timestamp,
                     session_id=context.session_id,
-                    user_id=context.user_id
+                    user_id=context.user_id,
                 )
-                
+
                 # Execute with timing
                 start_time = time.time()
                 result = hook.execute(hook_context)
                 execution_time = (time.time() - start_time) * 1000  # ms
-                
+
                 if result.success:
                     if result.modified and result.data:
                         # Update working data with modified data
                         working_data.update(result.data)
                         has_modifications = True
                         self.logger.debug(f"Hook {hook.name} modified context")
-                    
+
                     self.logger.info(
                         f"Executed pre-delegation hook {hook.name} "
                         f"(took {execution_time:.2f}ms)"
@@ -165,60 +167,52 @@ class HookService(HookServiceInterface):
                 else:
                     self.logger.warning(f"Hook {hook.name} failed: {result.error}")
                     self.stats["errors"] += 1
-                    
+
                 executed_count += 1
-                
+
             except Exception as e:
                 # Log error but continue with other hooks
                 self.logger.error(f"Exception in hook {hook.name}: {e}", exc_info=True)
                 self.stats["errors"] += 1
-        
+
         self.stats["pre_delegation_executed"] += executed_count
         self.logger.info(f"Executed {executed_count} pre-delegation hooks")
-        
-        return HookResult(
-            success=True,
-            data=working_data,
-            modified=has_modifications
-        )
-    
+
+        return HookResult(success=True, data=working_data, modified=has_modifications)
+
     def execute_post_delegation_hooks(self, context: HookContext) -> HookResult:
         """Execute all post-delegation hooks in priority order.
-        
+
         WHY: Post-delegation hooks need to process agent results, extract learnings,
         log outcomes, or perform other post-processing tasks.
-        
+
         Args:
             context: The HookContext containing delegation results
-            
+
         Returns:
             HookResult containing the final processed data
         """
         # Check if hooks are enabled via config
         if not self._are_hooks_enabled("post_delegation"):
-            return HookResult(
-                success=True,
-                data=context.data,
-                modified=False
-            )
-            
+            return HookResult(success=True, data=context.data, modified=False)
+
         # Create a working copy of the data to preserve original
         working_data = context.data.copy()
-        
+
         executed_count = 0
         has_modifications = False
-        
+
         for hook in self.post_delegation_hooks:
             if not hook.enabled:
                 self.logger.debug(f"Skipping disabled hook: {hook.name}")
                 continue
-                
+
             try:
                 # Validate if hook should run
                 if not hook.validate(context):
                     self.logger.debug(f"Hook {hook.name} validation failed, skipping")
                     continue
-                
+
                 # Create a hook context with the current working data
                 hook_context = HookContext(
                     hook_type=context.hook_type,
@@ -226,21 +220,21 @@ class HookService(HookServiceInterface):
                     metadata=context.metadata,
                     timestamp=context.timestamp,
                     session_id=context.session_id,
-                    user_id=context.user_id
+                    user_id=context.user_id,
                 )
-                
+
                 # Execute with timing
                 start_time = time.time()
                 result = hook.execute(hook_context)
                 execution_time = (time.time() - start_time) * 1000  # ms
-                
+
                 if result.success:
                     if result.modified and result.data:
                         # Update working data with modified data
                         working_data.update(result.data)
                         has_modifications = True
                         self.logger.debug(f"Hook {hook.name} modified context")
-                    
+
                     self.logger.info(
                         f"Executed post-delegation hook {hook.name} "
                         f"(took {execution_time:.2f}ms)"
@@ -248,32 +242,28 @@ class HookService(HookServiceInterface):
                 else:
                     self.logger.warning(f"Hook {hook.name} failed: {result.error}")
                     self.stats["errors"] += 1
-                    
+
                 executed_count += 1
-                
+
             except Exception as e:
                 # Log error but continue with other hooks
                 self.logger.error(f"Exception in hook {hook.name}: {e}", exc_info=True)
                 self.stats["errors"] += 1
-        
+
         self.stats["post_delegation_executed"] += executed_count
         self.logger.info(f"Executed {executed_count} post-delegation hooks")
-        
-        return HookResult(
-            success=True,
-            data=working_data,
-            modified=has_modifications
-        )
-    
+
+        return HookResult(success=True, data=working_data, modified=has_modifications)
+
     def _are_hooks_enabled(self, hook_type: str) -> bool:
         """Check if hooks are enabled in configuration.
-        
+
         WHY: We need fine-grained control over hook execution. This allows
         disabling hooks for debugging or in specific environments.
-        
+
         Args:
             hook_type: Type of hooks to check (pre_delegation, post_delegation)
-            
+
         Returns:
             True if hooks are enabled
         """
@@ -281,67 +271,69 @@ class HookService(HookServiceInterface):
         if not self.config.get("hooks.enabled", True):
             self.logger.debug("All hooks disabled via configuration")
             return False
-            
+
         # Check specific hook type enable flag
         if not self.config.get(f"hooks.{hook_type}.enabled", True):
             self.logger.debug(f"{hook_type} hooks disabled via configuration")
             return False
-            
+
         # Special check for memory hooks if they depend on memory system
         if hook_type in ["pre_delegation", "post_delegation"]:
             # If any registered hooks are memory-related, check memory.enabled
             for hook in getattr(self, f"{hook_type}_hooks", []):
                 if "memory" in hook.name.lower():
                     if not self.config.get("memory.enabled", True):
-                        self.logger.debug("Memory hooks disabled via memory.enabled config")
+                        self.logger.debug(
+                            "Memory hooks disabled via memory.enabled config"
+                        )
                         return False
-                        
+
         return True
-    
+
     def get_stats(self) -> Dict[str, int]:
         """Get execution statistics.
-        
+
         WHY: Monitoring hook execution helps identify performance issues
         and debug problems in production.
-        
+
         Returns:
             Dictionary of execution statistics
         """
         return self.stats.copy()
-    
+
     def reset_stats(self):
         """Reset execution statistics.
-        
+
         WHY: Allows periodic cleanup of stats for long-running services.
         """
         self.stats = {
             "pre_delegation_executed": 0,
             "post_delegation_executed": 0,
-            "errors": 0
+            "errors": 0,
         }
-    
+
     def list_hooks(self) -> Dict[str, List[str]]:
         """List all registered hooks by type.
-        
+
         WHY: Useful for debugging and understanding what hooks are active.
-        
+
         Returns:
             Dictionary mapping hook type to list of hook names
         """
         return {
             "pre_delegation": [h.name for h in self.pre_delegation_hooks],
-            "post_delegation": [h.name for h in self.post_delegation_hooks]
+            "post_delegation": [h.name for h in self.post_delegation_hooks],
         }
-    
+
     def remove_hook(self, hook_name: str) -> bool:
         """Remove a hook by name.
-        
+
         WHY: Allows dynamic hook management, useful for testing or
         conditional hook usage.
-        
+
         Args:
             hook_name: Name of the hook to remove
-            
+
         Returns:
             True if hook was found and removed
         """
@@ -351,28 +343,28 @@ class HookService(HookServiceInterface):
                 self.pre_delegation_hooks.pop(i)
                 self.logger.info(f"Removed pre-delegation hook: {hook_name}")
                 return True
-                
+
         # Check post-delegation hooks
         for i, hook in enumerate(self.post_delegation_hooks):
             if hook.name == hook_name:
                 self.post_delegation_hooks.pop(i)
                 self.logger.info(f"Removed post-delegation hook: {hook_name}")
                 return True
-                
+
         self.logger.warning(f"Hook not found: {hook_name}")
         return False
-    
+
     # ================================================================================
     # Interface Adapter Methods
     # ================================================================================
     # These methods are added to comply with HookServiceInterface
-    
+
     def get_registered_hooks(self) -> Dict[str, List[Any]]:
         """Get all registered hooks by type.
-        
+
         WHY: This method provides interface compliance by exposing the
         registered hooks for inspection and debugging purposes.
-        
+
         Returns:
             Dictionary mapping hook types to lists of hooks
         """
@@ -382,7 +374,7 @@ class HookService(HookServiceInterface):
                     "name": hook.name,
                     "priority": hook.priority,
                     "enabled": hook.enabled,
-                    "type": "pre_delegation"
+                    "type": "pre_delegation",
                 }
                 for hook in self.pre_delegation_hooks
             ],
@@ -391,18 +383,18 @@ class HookService(HookServiceInterface):
                     "name": hook.name,
                     "priority": hook.priority,
                     "enabled": hook.enabled,
-                    "type": "post_delegation"
+                    "type": "post_delegation",
                 }
                 for hook in self.post_delegation_hooks
-            ]
+            ],
         }
-    
+
     def clear_hooks(self, hook_type: Optional[str] = None) -> None:
         """Clear registered hooks.
-        
+
         WHY: This method provides interface compliance by allowing bulk
         removal of hooks, useful for testing and cleanup scenarios.
-        
+
         Args:
             hook_type: Optional specific hook type to clear, or None for all
         """
@@ -411,12 +403,12 @@ class HookService(HookServiceInterface):
             self.pre_delegation_hooks.clear()
             if count > 0:
                 self.logger.info(f"Cleared {count} pre-delegation hooks")
-        
+
         if hook_type is None or hook_type == "post_delegation":
             count = len(self.post_delegation_hooks)
             self.post_delegation_hooks.clear()
             if count > 0:
                 self.logger.info(f"Cleared {count} post-delegation hooks")
-        
+
         if hook_type and hook_type not in ["pre_delegation", "post_delegation"]:
-            self.logger.warning(f"Unknown hook type: {hook_type}")
+            self.logger.warning(f"Unknown hook type: {hook_type}")

claude_mpm/services/infrastructure/__init__.py

@@ -13,12 +13,14 @@ Services:
 - MemoryGuardian: Memory monitoring and process restart management
 """
 
+from .health_monitor import HealthMonitor
 from .logging import LoggingService
-from .monitoring import AdvancedHealthMonitor as HealthMonitor
 from .memory_guardian import MemoryGuardian
+from .monitoring import AdvancedHealthMonitor
 
 __all__ = [
-    'LoggingService',
-    'HealthMonitor',
-    'MemoryGuardian',
-]
+    "LoggingService",
+    "AdvancedHealthMonitor",  # For SocketIO server monitoring
+    "HealthMonitor",  # For Memory Guardian system monitoring
+    "MemoryGuardian",
+]