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

claude_mpm/core/pm_hook_interceptor.py

@@ -12,147 +12,160 @@ WHY this is needed:
 """
 
 import functools
-import json
 import os
 import threading
 import time
-from typing import Dict, Any, List, Optional
 from datetime import datetime
+from typing import Any, Dict, List, Optional
 
-from ..core.logger import get_logger
 from ..core.hook_manager import get_hook_manager
+from ..core.logger import get_logger
 
 
 class PMHookInterceptor:
     """Interceptor for PM operations that ensures hook events are triggered.
-    
+
     WHY this design:
     - Acts as a transparent proxy for tool operations
     - Automatically triggers pre/post hook events
     - Maintains session consistency with regular Claude Code operations
     - Provides real-time event streaming for PM operations
     """
-    
+
     def __init__(self):
         self.logger = get_logger("pm_hook_interceptor")
         self.hook_manager = get_hook_manager()
         self._in_intercept = threading.local()  # Prevent recursion
-        
+
     def intercept_todowrite(self, original_function):
         """Decorator to intercept TodoWrite calls and trigger hooks.
-        
+
         Args:
             original_function: The original TodoWrite function
-            
+
         Returns:
             Wrapped function that triggers hooks
         """
+
         @functools.wraps(original_function)
         def wrapper(*args, **kwargs):
             # Prevent recursive interception
-            if getattr(self._in_intercept, 'active', False):
+            if getattr(self._in_intercept, "active", False):
                 return original_function(*args, **kwargs)
-            
+
             self._in_intercept.active = True
-            
+
             try:
                 # Extract todos from arguments
                 todos = self._extract_todos_from_args(args, kwargs)
-                
+
                 # Trigger pre-tool hook
-                self.hook_manager.trigger_pre_tool_hook("TodoWrite", {
-                    "todos": todos,
-                    "source": "PM",
-                    "intercepted": True
-                })
-                
+                self.hook_manager.trigger_pre_tool_hook(
+                    "TodoWrite", {"todos": todos, "source": "PM", "intercepted": True}
+                )
+
                 # Call the original function
                 result = original_function(*args, **kwargs)
-                
+
                 # Trigger post-tool hook
-                self.hook_manager.trigger_post_tool_hook("TodoWrite", 0, {
-                    "todos_count": len(todos) if todos else 0,
-                    "source": "PM",
-                    "success": True
-                })
-                
-                self.logger.debug(f"Successfully intercepted TodoWrite with {len(todos) if todos else 0} todos")
-                
+                self.hook_manager.trigger_post_tool_hook(
+                    "TodoWrite",
+                    0,
+                    {
+                        "todos_count": len(todos) if todos else 0,
+                        "source": "PM",
+                        "success": True,
+                    },
+                )
+
+                self.logger.debug(
+                    f"Successfully intercepted TodoWrite with {len(todos) if todos else 0} todos"
+                )
+
                 return result
-                
+
             except Exception as e:
                 # Trigger post-tool hook with error
-                self.hook_manager.trigger_post_tool_hook("TodoWrite", 1, {
-                    "error": str(e),
-                    "source": "PM",
-                    "success": False
-                })
-                
+                self.hook_manager.trigger_post_tool_hook(
+                    "TodoWrite", 1, {"error": str(e), "source": "PM", "success": False}
+                )
+
                 self.logger.error(f"Error in TodoWrite interception: {e}")
                 raise
             finally:
                 self._in_intercept.active = False
-        
+
         return wrapper
-    
+
     def _extract_todos_from_args(self, args, kwargs) -> List[Dict[str, Any]]:
         """Extract todos from function arguments.
-        
+
         Args:
             args: Positional arguments
             kwargs: Keyword arguments
-            
+
         Returns:
             List of todo dictionaries
         """
         # Look for todos in kwargs first
-        if 'todos' in kwargs:
-            return kwargs['todos']
-        
+        if "todos" in kwargs:
+            return kwargs["todos"]
+
         # Look for todos in positional args
         for arg in args:
             if isinstance(arg, list) and arg and isinstance(arg[0], dict):
                 # Check if this looks like a todos list
-                if 'content' in arg[0] or 'id' in arg[0]:
+                if "content" in arg[0] or "id" in arg[0]:
                     return arg
-        
+
         return []
-    
+
     def trigger_manual_todowrite_hooks(self, todos: List[Dict[str, Any]]):
         """Manually trigger TodoWrite hooks for given todos.
-        
+
         This method can be called directly when TodoWrite operations
         are detected outside of function interception.
-        
+
         Args:
             todos: List of todo dictionaries
         """
         try:
             # Trigger pre-tool hook
-            success1 = self.hook_manager.trigger_pre_tool_hook("TodoWrite", {
-                "todos": todos,
-                "source": "PM_Manual",
-                "timestamp": datetime.utcnow().isoformat()
-            })
-            
+            success1 = self.hook_manager.trigger_pre_tool_hook(
+                "TodoWrite",
+                {
+                    "todos": todos,
+                    "source": "PM_Manual",
+                    "timestamp": datetime.utcnow().isoformat(),
+                },
+            )
+
             # Small delay to ensure proper event ordering
             time.sleep(0.1)
-            
+
             # Trigger post-tool hook
-            success2 = self.hook_manager.trigger_post_tool_hook("TodoWrite", 0, {
-                "todos_count": len(todos),
-                "source": "PM_Manual",
-                "success": True,
-                "timestamp": datetime.utcnow().isoformat()
-            })
-            
+            success2 = self.hook_manager.trigger_post_tool_hook(
+                "TodoWrite",
+                0,
+                {
+                    "todos_count": len(todos),
+                    "source": "PM_Manual",
+                    "success": True,
+                    "timestamp": datetime.utcnow().isoformat(),
+                },
+            )
+
             if success1 and success2:
-                self.logger.info(f"Manually triggered TodoWrite hooks for {len(todos)} todos")
+                self.logger.info(
+                    f"Manually triggered TodoWrite hooks for {len(todos)} todos"
+                )
             else:
-                self.logger.warning(f"Hook triggering partially failed: pre={success1}, post={success2}")
-            
+                self.logger.warning(
+                    f"Hook triggering partially failed: pre={success1}, post={success2}"
+                )
+
             return success1 and success2
-            
+
         except Exception as e:
             self.logger.error(f"Error manually triggering TodoWrite hooks: {e}")
             return False
@@ -172,10 +185,10 @@ def get_pm_hook_interceptor() -> PMHookInterceptor:
 
 def trigger_pm_todowrite_hooks(todos: List[Dict[str, Any]]) -> bool:
     """Convenience function to trigger PM TodoWrite hooks.
-    
+
     Args:
         todos: List of todo dictionaries
-        
+
     Returns:
         bool: True if hooks were triggered successfully
     """
@@ -185,21 +198,21 @@ def trigger_pm_todowrite_hooks(todos: List[Dict[str, Any]]) -> bool:
 
 def simulate_pm_todowrite_operation(todos: List[Dict[str, Any]]):
     """Simulate a PM TodoWrite operation with proper hook triggering.
-    
+
     This function is useful for testing and for cases where we want to
     simulate a TodoWrite operation from the PM agent.
-    
+
     Args:
         todos: List of todo dictionaries
     """
     interceptor = get_pm_hook_interceptor()
-    
+
     # Log the operation
     logger = get_logger("pm_todowrite_simulation")
     logger.info(f"Simulating PM TodoWrite operation with {len(todos)} todos")
-    
+
     # Trigger hooks
     interceptor.trigger_manual_todowrite_hooks(todos)
-    
+
     # Log completion
-    logger.info("PM TodoWrite simulation completed")
+    logger.info("PM TodoWrite simulation completed")

claude_mpm/core/service_registry.py

@@ -5,14 +5,12 @@ Provides centralized service registration and discovery, working with
 the DI container to manage application services.
 """
 
-import logging
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Type, Union, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union
 
-from .container import DIContainer, ServiceLifetime, get_container
 from .base_service import BaseService
-from .logger import get_logger
 from .config import Config
+from .container import DIContainer, ServiceLifetime, get_container
+from .logger import get_logger
 
 if TYPE_CHECKING:
     from claude_mpm.services.agents.deployment import AgentDeploymentService
@@ -23,91 +21,87 @@ logger = get_logger(__name__)
 class ServiceRegistry:
     """
     Central registry for all application services.
-    
+
     Manages service registration, configuration, and lifecycle.
     """
-    
+
     def __init__(self, container: Optional[DIContainer] = None):
         """
         Initialize service registry.
-        
+
         Args:
             container: DI container to use (uses global if not provided)
         """
         self.container = container or get_container()
         self._services: Dict[str, Type[BaseService]] = {}
         self._initialized = False
-        
+
     def register_core_services(self) -> None:
         """Register all core framework services."""
-        from claude_mpm.services.memory.cache.shared_prompt_cache import SharedPromptCache
-        from ..services.ticket_manager import TicketManager
+        from claude_mpm.services.memory.cache.shared_prompt_cache import (
+            SharedPromptCache,
+        )
+
         from ..services import AgentDeploymentService
-        from .session_manager import SessionManager
         from .agent_session_manager import AgentSessionManager
-        
+        from .session_manager import SessionManager
+
         # Register configuration as singleton with name
         config = Config()
         self.container.register_singleton(Config, instance=config, name="main_config")
-        
+
         # Register core services with proper lifetime management
         self.register_service(
-            "session_manager",
-            SessionManager,
-            lifetime=ServiceLifetime.SINGLETON
+            "session_manager", SessionManager, lifetime=ServiceLifetime.SINGLETON
         )
-        
+
         self.register_service(
             "agent_session_manager",
             AgentSessionManager,
             lifetime=ServiceLifetime.SINGLETON,
-            dependencies={
-                'session_dir': lambda c: c.get(Config).get('session_dir')
-            }
+            dependencies={"session_dir": lambda c: c.get(Config).get("session_dir")},
         )
-        
+
         # Register shared cache as singleton with factory
         self.container.register_factory(
             SharedPromptCache,
             lambda c: SharedPromptCache.get_instance(),
             lifetime=ServiceLifetime.SINGLETON,
-            name="prompt_cache"
-        )
-        
-        # Register ticket manager as scoped (per-request)
-        self.container.register_scoped(
-            TicketManager,
-            TicketManager,
-            name="ticket_manager"
+            name="prompt_cache",
         )
-        
+
+        # Ticket manager removed - use claude-mpm tickets CLI commands instead
+
         # Register agent deployment service with factory for better initialization
         self.container.register_factory(
             AgentDeploymentService,
             lambda c: self._create_agent_deployment_service(c),
             lifetime=ServiceLifetime.TRANSIENT,
-            name="agent_deployment"
+            name="agent_deployment",
         )
-        
+
         logger.info("Core services registered with enhanced DI container")
-        
-    def _create_agent_deployment_service(self, container: DIContainer) -> 'AgentDeploymentService':
+
+    def _create_agent_deployment_service(
+        self, container: DIContainer
+    ) -> "AgentDeploymentService":
         """Factory method for creating agent deployment service."""
         import os
         from pathlib import Path
-        
+
         config = container.get(Config)
-        
+
         # Get working directory from environment or config
-        if 'CLAUDE_MPM_USER_PWD' in os.environ:
-            working_dir = Path(os.environ['CLAUDE_MPM_USER_PWD'])
+        if "CLAUDE_MPM_USER_PWD" in os.environ:
+            working_dir = Path(os.environ["CLAUDE_MPM_USER_PWD"])
         else:
-            working_dir = Path(config.get('project.dir', '.'))
-            
+            working_dir = Path(config.get("project.dir", "."))
+
         # Lazy import to avoid circular dependencies
         from claude_mpm.services.agents.deployment import AgentDeploymentService
+
         return AgentDeploymentService(working_directory=working_dir)
-        
+
     def register_service(
         self,
         name: str,
@@ -115,11 +109,11 @@ class ServiceRegistry:
         lifetime: ServiceLifetime = ServiceLifetime.SINGLETON,
         factory: Optional[Any] = None,
         dependencies: Optional[Dict[str, Any]] = None,
-        config: Optional[Dict[str, Any]] = None
+        config: Optional[Dict[str, Any]] = None,
     ) -> None:
         """
         Register a service with the registry.
-        
+
         Args:
             name: Service name for lookup
             service_class: Service class (must inherit from BaseService)
@@ -130,31 +124,28 @@ class ServiceRegistry:
         """
         # Store service metadata
         self._services[name] = service_class
-        
+
         # Create factory wrapper if config provided
         if config and not factory:
             factory = lambda c: service_class(name=name, config=config, container=c)
         elif not factory:
             # Default factory with container injection
             factory = lambda c: service_class(name=name, container=c)
-            
+
         # Register with DI container
         self.container.register(
-            service_class,
-            factory=factory,
-            lifetime=lifetime,
-            dependencies=dependencies
+            service_class, factory=factory, lifetime=lifetime, dependencies=dependencies
         )
-        
+
         logger.debug(f"Registered service: {name} ({service_class.__name__})")
-        
+
     def get_service(self, service_type: Union[str, Type[BaseService]]) -> BaseService:
         """
         Get a service instance.
-        
+
         Args:
             service_type: Service name or class
-            
+
         Returns:
             Service instance
         """
@@ -172,110 +163,121 @@ class ServiceRegistry:
         else:
             # Direct class resolution
             return self.container.get(service_type)
-        
+
     def get_service_optional(
         self,
         service_type: Union[str, Type[BaseService]],
-        default: Optional[BaseService] = None
+        default: Optional[BaseService] = None,
     ) -> Optional[BaseService]:
         """Get a service if available, otherwise return default."""
         try:
             return self.get_service(service_type)
         except (KeyError, Exception):
             return default
-            
+
     def start_all_services(self) -> None:
         """Start all registered singleton services."""
         import asyncio
-        
+
         async def _start_all():
             for name, service_class in self._services.items():
                 try:
                     # Only start singleton services
-                    registration = self.container.get_all_registrations().get(service_class)
-                    if registration and registration.lifetime == ServiceLifetime.SINGLETON:
+                    registration = self.container.get_all_registrations().get(
+                        service_class
+                    )
+                    if (
+                        registration
+                        and registration.lifetime == ServiceLifetime.SINGLETON
+                    ):
                         service = self.get_service(service_class)
-                        if hasattr(service, 'start'):
+                        if hasattr(service, "start"):
                             await service.start()
                             logger.info(f"Started service: {name}")
                 except Exception as e:
                     logger.error(f"Failed to start service {name}: {e}")
-                    
+
         asyncio.run(_start_all())
         self._initialized = True
-        
+
     def stop_all_services(self) -> None:
         """Stop all running singleton services."""
         import asyncio
-        
+
         async def _stop_all():
             for name, service_class in reversed(list(self._services.items())):
                 try:
                     # Only stop singleton services
-                    registration = self.container.get_all_registrations().get(service_class)
-                    if registration and registration.lifetime == ServiceLifetime.SINGLETON:
+                    registration = self.container.get_all_registrations().get(
+                        service_class
+                    )
+                    if (
+                        registration
+                        and registration.lifetime == ServiceLifetime.SINGLETON
+                    ):
                         if service_class in self.container._singletons:
                             service = self.container._singletons[service_class]
-                            if hasattr(service, 'stop') and service.running:
+                            if hasattr(service, "stop") and service.running:
                                 await service.stop()
                                 logger.info(f"Stopped service: {name}")
                 except Exception as e:
                     logger.error(f"Failed to stop service {name}: {e}")
-                    
+
         asyncio.run(_stop_all())
-        
+
     def get_service_health(self) -> Dict[str, Dict[str, Any]]:
         """Get health status of all services."""
         import asyncio
-        
+
         async def _get_health():
             health_status = {}
-            
+
             for name, service_class in self._services.items():
                 try:
                     if service_class in self.container._singletons:
                         service = self.container._singletons[service_class]
-                        if hasattr(service, 'health_check'):
+                        if hasattr(service, "health_check"):
                             health = await service.health_check()
                             health_status[name] = {
-                                'status': health.status,
-                                'message': health.message,
-                                'metrics': health.metrics
+                                "status": health.status,
+                                "message": health.message,
+                                "metrics": health.metrics,
                             }
                 except Exception as e:
-                    health_status[name] = {
-                        'status': 'error',
-                        'message': str(e)
-                    }
-                    
+                    health_status[name] = {"status": "error", "message": str(e)}
+
             return health_status
-            
+
         return asyncio.run(_get_health())
-        
+
     def list_services(self) -> List[Dict[str, Any]]:
         """List all registered services with their metadata."""
         services = []
-        
+
         for name, service_class in self._services.items():
             registration = self.container.get_all_registrations().get(service_class)
-            
+
             service_info = {
-                'name': name,
-                'class': service_class.__name__,
-                'module': service_class.__module__,
-                'lifetime': registration.lifetime.value if registration else 'unknown',
-                'is_singleton': registration.lifetime == ServiceLifetime.SINGLETON if registration else False,
-                'is_running': False
+                "name": name,
+                "class": service_class.__name__,
+                "module": service_class.__module__,
+                "lifetime": registration.lifetime.value if registration else "unknown",
+                "is_singleton": (
+                    registration.lifetime == ServiceLifetime.SINGLETON
+                    if registration
+                    else False
+                ),
+                "is_running": False,
             }
-            
+
             # Check if singleton is running
             if service_class in self.container._singletons:
                 service = self.container._singletons[service_class]
-                if hasattr(service, 'running'):
-                    service_info['is_running'] = service.running
-                    
+                if hasattr(service, "running"):
+                    service_info["is_running"] = service.running
+
             services.append(service_info)
-            
+
         return services
 
 
@@ -295,23 +297,23 @@ def get_service_registry() -> ServiceRegistry:
 def initialize_services(config: Optional[Dict[str, Any]] = None) -> ServiceRegistry:
     """
     Initialize all application services.
-    
+
     Args:
         config: Optional configuration overrides
-        
+
     Returns:
         Initialized service registry
     """
     registry = get_service_registry()
-    
+
     if config:
         # Apply configuration overrides
         config_service = registry.container.resolve(Config)
         for key, value in config.items():
             config_service.set(key, value)
-            
+
     # Start all services
     if not registry._initialized:
         registry.start_all_services()
-        
-    return registry
+
+    return registry