claude-mpm 0.3.0__py3-none-any.whl

claude_mpm/orchestration/archive/factory.py

@@ -0,0 +1,215 @@
+"""Orchestrator factory for creating orchestrators based on mode and configuration."""
+
+import logging
+from pathlib import Path
+from typing import Optional, Dict, Type, Any
+from enum import Enum
+
+from ..core.logger import get_logger
+from .orchestrator import MPMOrchestrator
+from .system_prompt_orchestrator import SystemPromptOrchestrator
+from .subprocess_orchestrator import SubprocessOrchestrator
+from .interactive_subprocess_orchestrator import InteractiveSubprocessOrchestrator
+
+
+class OrchestratorMode(Enum):
+    """Available orchestrator modes."""
+    SYSTEM_PROMPT = "system_prompt"
+    SUBPROCESS = "subprocess"
+    INTERACTIVE_SUBPROCESS = "interactive_subprocess"
+    DIRECT = "direct"
+    PTY = "pty"
+    WRAPPER = "wrapper"
+    SIMPLE = "simple"
+
+
+class OrchestratorFactory:
+    """Factory for creating orchestrators based on mode and configuration.
+    
+    This factory simplifies orchestrator selection and reduces complexity
+    in the run_session function by centralizing the logic for choosing
+    and instantiating the appropriate orchestrator.
+    """
+    
+    # Registry of available orchestrators
+    _registry: Dict[OrchestratorMode, Type[MPMOrchestrator]] = {
+        OrchestratorMode.SYSTEM_PROMPT: SystemPromptOrchestrator,
+        OrchestratorMode.SUBPROCESS: SubprocessOrchestrator,
+        OrchestratorMode.INTERACTIVE_SUBPROCESS: InteractiveSubprocessOrchestrator,
+    }
+    
+    def __init__(self):
+        """Initialize the orchestrator factory."""
+        self.logger = get_logger(self.__class__.__name__)
+        self._discover_orchestrators()
+    
+    def _discover_orchestrators(self):
+        """Discover and register additional orchestrators.
+        
+        This method enables automatic discovery of new orchestrator types
+        without modifying the factory code.
+        """
+        # Try to import optional orchestrators
+        try:
+            from .direct_orchestrator import DirectOrchestrator
+            self._registry[OrchestratorMode.DIRECT] = DirectOrchestrator
+            self.logger.debug("Registered DirectOrchestrator")
+        except ImportError:
+            self.logger.debug("DirectOrchestrator not available")
+        
+        try:
+            from .pty_orchestrator import PTYOrchestrator
+            self._registry[OrchestratorMode.PTY] = PTYOrchestrator
+            self.logger.debug("Registered PTYOrchestrator")
+        except ImportError:
+            self.logger.debug("PTYOrchestrator not available")
+        
+        try:
+            from .wrapper_orchestrator import WrapperOrchestrator
+            self._registry[OrchestratorMode.WRAPPER] = WrapperOrchestrator
+            self.logger.debug("Registered WrapperOrchestrator")
+        except ImportError:
+            self.logger.debug("WrapperOrchestrator not available")
+        
+        try:
+            from .simple_orchestrator import SimpleOrchestrator
+            self._registry[OrchestratorMode.SIMPLE] = SimpleOrchestrator
+            self.logger.debug("Registered SimpleOrchestrator")
+        except ImportError:
+            self.logger.debug("SimpleOrchestrator not available")
+    
+    def create_orchestrator(
+        self,
+        mode: Optional[str] = None,
+        config: Optional[Dict[str, Any]] = None
+    ) -> MPMOrchestrator:
+        """Create an orchestrator based on mode and configuration.
+        
+        Args:
+            mode: Orchestrator mode (string or OrchestratorMode enum)
+            config: Configuration dictionary containing:
+                - framework_path: Path to framework directory
+                - agents_dir: Custom agents directory
+                - log_level: Logging level (OFF, INFO, DEBUG)
+                - log_dir: Custom log directory
+                - hook_manager: Hook service manager instance
+                - enable_todo_hijacking: Enable TODO hijacking (subprocess mode)
+                - subprocess: Use subprocess orchestration
+                - interactive_subprocess: Use interactive subprocess
+                - Any other orchestrator-specific parameters
+        
+        Returns:
+            Configured orchestrator instance
+            
+        Raises:
+            ValueError: If mode is invalid or orchestrator creation fails
+        """
+        if config is None:
+            config = {}
+        
+        # Determine orchestrator mode
+        orchestrator_mode = self._determine_mode(mode, config)
+        
+        # Validate mode
+        if orchestrator_mode not in self._registry:
+            available = ", ".join(m.value for m in self._registry.keys())
+            raise ValueError(
+                f"Invalid orchestrator mode: {orchestrator_mode.value}. "
+                f"Available modes: {available}"
+            )
+        
+        # Get orchestrator class
+        orchestrator_class = self._registry[orchestrator_mode]
+        
+        # Extract common parameters
+        common_params = {
+            "framework_path": config.get("framework_path"),
+            "agents_dir": config.get("agents_dir"),
+            "log_level": config.get("log_level", "OFF"),
+            "log_dir": config.get("log_dir"),
+        }
+        
+        # Add hook manager if available
+        if "hook_manager" in config:
+            common_params["hook_manager"] = config["hook_manager"]
+        
+        # Add mode-specific parameters
+        if orchestrator_mode == OrchestratorMode.SUBPROCESS:
+            common_params["enable_todo_hijacking"] = config.get("enable_todo_hijacking", False)
+        
+        try:
+            # Create orchestrator instance
+            orchestrator = orchestrator_class(**common_params)
+            
+            # Configure additional settings
+            if "no_tickets" in config and config["no_tickets"]:
+                orchestrator.ticket_creation_enabled = False
+                self.logger.info("Ticket creation disabled for orchestrator")
+            
+            self.logger.info(
+                f"Created {orchestrator_class.__name__} "
+                f"(mode: {orchestrator_mode.value})"
+            )
+            
+            return orchestrator
+            
+        except Exception as e:
+            self.logger.error(f"Failed to create orchestrator: {e}")
+            raise ValueError(f"Failed to create orchestrator: {e}") from e
+    
+    def _determine_mode(
+        self,
+        mode: Optional[str],
+        config: Dict[str, Any]
+    ) -> OrchestratorMode:
+        """Determine orchestrator mode from explicit mode or config flags.
+        
+        Args:
+            mode: Explicit mode string
+            config: Configuration dictionary
+            
+        Returns:
+            OrchestratorMode enum value
+        """
+        # Always use subprocess orchestrator for simplicity
+        # This provides consistent behavior in both interactive and non-interactive modes
+        return OrchestratorMode.SUBPROCESS
+    
+    def list_available_modes(self) -> Dict[str, Dict[str, Any]]:
+        """List all available orchestrator modes with metadata.
+        
+        Returns:
+            Dictionary mapping mode names to metadata
+        """
+        modes = {}
+        for mode, orchestrator_class in self._registry.items():
+            modes[mode.value] = {
+                "class": orchestrator_class.__name__,
+                "module": orchestrator_class.__module__,
+                "description": orchestrator_class.__doc__.strip() if orchestrator_class.__doc__ else "No description",
+            }
+        return modes
+    
+    def register_orchestrator(
+        self,
+        mode: OrchestratorMode,
+        orchestrator_class: Type[MPMOrchestrator]
+    ):
+        """Register a custom orchestrator.
+        
+        Args:
+            mode: Orchestrator mode
+            orchestrator_class: Orchestrator class (must inherit from MPMOrchestrator)
+            
+        Raises:
+            ValueError: If orchestrator class is invalid
+        """
+        if not issubclass(orchestrator_class, MPMOrchestrator):
+            raise ValueError(
+                f"{orchestrator_class.__name__} must inherit from MPMOrchestrator"
+            )
+        
+        self._registry[mode] = orchestrator_class
+        self.logger.info(
+            f"Registered {orchestrator_class.__name__} for mode {mode.value}"
+        )

claude_mpm/orchestration/archive/hook_enabled_orchestrator.py

@@ -0,0 +1,188 @@
+"""Example orchestrator that integrates with the hook service."""
+
+import asyncio
+import logging
+from typing import Any, Dict, List, Optional
+
+from src.hooks.hook_client import get_hook_client, HookServiceClient
+from src.hooks.base_hook import HookType
+from src.orchestration.orchestrator import Orchestrator
+from src.services.ticket_manager import TicketManager
+from src.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class HookEnabledOrchestrator(Orchestrator):
+    """Orchestrator that integrates with the centralized hook service."""
+    
+    def __init__(self, *args, **kwargs):
+        """Initialize hook-enabled orchestrator."""
+        super().__init__(*args, **kwargs)
+        
+        # Initialize hook client
+        self.hook_client = get_hook_client()
+        
+        # Check hook service health
+        health = self.hook_client.health_check()
+        if health.get('status') == 'healthy':
+            logger.info(f"Hook service is healthy with {health.get('hooks_count', 0)} hooks")
+        else:
+            logger.warning(f"Hook service is not available: {health.get('error')}")
+            
+    async def process_prompt(self, prompt: str) -> str:
+        """Process user prompt with hook integration.
+        
+        Args:
+            prompt: User prompt to process
+            
+        Returns:
+            Response from orchestration
+        """
+        try:
+            # Execute submit hooks
+            logger.debug("Executing submit hooks...")
+            submit_results = self.hook_client.execute_submit_hook(
+                prompt=prompt,
+                session_id=getattr(self, 'session_id', None)
+            )
+            
+            # Get modified prompt data
+            modified_data = self.hook_client.get_modified_data(submit_results)
+            if modified_data.get('prompt'):
+                prompt = modified_data['prompt']
+                
+            # Check for priority override
+            if modified_data.get('priority'):
+                logger.info(f"Priority detected: {modified_data['priority']}")
+                
+            # Process prompt through normal orchestration
+            response = await super().process_prompt(prompt)
+            
+            # Execute ticket extraction hooks on the conversation
+            logger.debug("Executing ticket extraction hooks...")
+            extraction_results = self.hook_client.execute_ticket_extraction_hook(
+                content={
+                    'prompt': prompt,
+                    'response': response
+                }
+            )
+            
+            # Extract and create tickets
+            tickets = self.hook_client.get_extracted_tickets(extraction_results)
+            if tickets:
+                logger.info(f"Extracted {len(tickets)} tickets from conversation")
+                await self._create_tickets(tickets)
+                
+            return response
+            
+        except Exception as e:
+            logger.error(f"Error in hook-enabled orchestration: {e}")
+            # Fallback to normal orchestration if hooks fail
+            return await super().process_prompt(prompt)
+            
+    async def delegate_to_agent(self, agent_name: str, context: Dict[str, Any]) -> Any:
+        """Delegate to agent with hook integration.
+        
+        Args:
+            agent_name: Name of agent to delegate to
+            context: Context to pass to agent
+            
+        Returns:
+            Result from agent
+        """
+        try:
+            # Execute pre-delegation hooks
+            logger.debug(f"Executing pre-delegation hooks for {agent_name}...")
+            pre_results = self.hook_client.execute_pre_delegation_hook(
+                agent=agent_name,
+                context=context
+            )
+            
+            # Get modified context
+            modified_data = self.hook_client.get_modified_data(pre_results)
+            if 'context' in modified_data:
+                context = modified_data['context']
+                logger.debug("Context modified by pre-delegation hooks")
+                
+            # Delegate to agent
+            result = await super().delegate_to_agent(agent_name, context)
+            
+            # Execute post-delegation hooks
+            logger.debug(f"Executing post-delegation hooks for {agent_name}...")
+            post_results = self.hook_client.execute_post_delegation_hook(
+                agent=agent_name,
+                result=result,
+                execution_time_ms=context.get('execution_time_ms')
+            )
+            
+            # Get modified result
+            modified_data = self.hook_client.get_modified_data(post_results)
+            if 'result' in modified_data:
+                result = modified_data['result']
+                logger.debug("Result modified by post-delegation hooks")
+                
+            # Check for validation issues
+            for post_result in post_results:
+                if 'validation_issues' in post_result.get('data', {}):
+                    issues = post_result['data']['validation_issues']
+                    logger.warning(f"Validation issues: {issues}")
+                    
+            return result
+            
+        except Exception as e:
+            logger.error(f"Error in hook-enabled delegation: {e}")
+            # Fallback to normal delegation if hooks fail
+            return await super().delegate_to_agent(agent_name, context)
+            
+    async def _create_tickets(self, tickets: List[Dict[str, Any]]):
+        """Create tickets in the ticket system.
+        
+        Args:
+            tickets: List of ticket dictionaries
+        """
+        try:
+            # Initialize ticket manager if needed
+            if not hasattr(self, 'ticket_manager'):
+                self.ticket_manager = TicketManager()
+                
+            for ticket in tickets:
+                try:
+                    # Create ticket
+                    ticket_id = await self.ticket_manager.create_ticket(
+                        title=ticket.get('title', 'Untitled'),
+                        description=ticket.get('description', ''),
+                        priority=ticket.get('priority', 'normal'),
+                        ticket_type=ticket.get('type', 'task'),
+                        metadata=ticket.get('metadata', {})
+                    )
+                    logger.info(f"Created ticket {ticket_id}: {ticket['title']}")
+                except Exception as e:
+                    logger.error(f"Failed to create ticket: {e}")
+                    
+        except Exception as e:
+            logger.error(f"Error creating tickets: {e}")
+
+
+# Example usage
+async def main():
+    """Example usage of hook-enabled orchestrator."""
+    # Create orchestrator
+    orchestrator = HookEnabledOrchestrator()
+    
+    # Process some prompts
+    prompts = [
+        "URGENT: Fix the bug in the login system",
+        "TODO: Add unit tests for the new API endpoints",
+        "Can you create ticket: Implement user dashboard feature",
+        "Research the best practices for React performance optimization"
+    ]
+    
+    for prompt in prompts:
+        print(f"\nProcessing: {prompt}")
+        response = await orchestrator.process_prompt(prompt)
+        print(f"Response: {response[:100]}...")
+        
+        
+if __name__ == "__main__":
+    asyncio.run(main())

claude_mpm/orchestration/archive/hook_integration_example.py

@@ -0,0 +1,178 @@
+"""Example of how to integrate hooks into orchestrator methods."""
+
+from typing import Optional
+from ..hooks.hook_client import HookServiceClient
+
+
+class HookIntegrationExample:
+    """Example methods showing how to integrate hooks into orchestrators."""
+    
+    def __init__(self, hook_client: Optional[HookServiceClient] = None):
+        """Initialize with optional hook client."""
+        self.hook_client = hook_client
+    
+    def process_user_input_with_hooks(self, user_input: str) -> str:
+        """Process user input through submit hooks before sending to Claude.
+        
+        This method shows how to:
+        1. Send user input to hook service
+        2. Get modified input back
+        3. Use the modified input for Claude
+        """
+        if not self.hook_client:
+            # No hooks available, return original input
+            return user_input
+        
+        try:
+            # Execute submit hooks
+            results = self.hook_client.execute_submit_hook(
+                prompt=user_input,
+                session_id="current_session"
+            )
+            
+            # Get modified data from hooks
+            modified_data = self.hook_client.get_modified_data(results)
+            
+            # Use modified prompt if available
+            if modified_data.get('prompt'):
+                return modified_data['prompt']
+            
+            # Check for priority changes
+            if modified_data.get('priority'):
+                # Could adjust Claude model or other settings based on priority
+                print(f"Priority set by hooks: {modified_data['priority']}")
+            
+            return user_input
+            
+        except Exception as e:
+            print(f"Hook processing failed: {e}")
+            # Fallback to original input
+            return user_input
+    
+    def process_agent_delegation_with_hooks(self, agent_name: str, task: str) -> tuple[str, str]:
+        """Process agent delegation through pre-delegation hooks.
+        
+        Returns:
+            Tuple of (agent_name, task) potentially modified by hooks
+        """
+        if not self.hook_client:
+            return agent_name, task
+        
+        try:
+            # Execute pre-delegation hooks
+            context = {
+                'agent': agent_name,
+                'task': task
+            }
+            
+            results = self.hook_client.execute_pre_delegation_hook(
+                agent=agent_name,
+                context=context
+            )
+            
+            # Get modified data
+            modified_data = self.hook_client.get_modified_data(results)
+            
+            # Update agent or task if modified
+            new_agent = modified_data.get('agent', agent_name)
+            new_context = modified_data.get('context', {})
+            new_task = new_context.get('task', task)
+            
+            return new_agent, new_task
+            
+        except Exception as e:
+            print(f"Pre-delegation hook failed: {e}")
+            return agent_name, task
+    
+    def process_agent_response_with_hooks(self, agent_name: str, response: str) -> str:
+        """Process agent response through post-delegation hooks.
+        
+        Returns:
+            Potentially modified response
+        """
+        if not self.hook_client:
+            return response
+        
+        try:
+            # Execute post-delegation hooks
+            result = {
+                'response': response,
+                'success': True
+            }
+            
+            results = self.hook_client.execute_post_delegation_hook(
+                agent=agent_name,
+                result=result
+            )
+            
+            # Get modified data
+            modified_data = self.hook_client.get_modified_data(results)
+            
+            # Use modified response if available
+            if modified_data.get('result', {}).get('response'):
+                return modified_data['result']['response']
+            
+            return response
+            
+        except Exception as e:
+            print(f"Post-delegation hook failed: {e}")
+            return response
+    
+    def extract_tickets_with_hooks(self, conversation: str) -> list:
+        """Extract tickets from conversation using ticket extraction hooks.
+        
+        Returns:
+            List of extracted tickets
+        """
+        if not self.hook_client:
+            return []
+        
+        try:
+            # Execute ticket extraction hooks
+            results = self.hook_client.execute_ticket_extraction_hook(
+                content={'conversation': conversation}
+            )
+            
+            # Get extracted tickets
+            tickets = self.hook_client.get_extracted_tickets(results)
+            
+            return tickets
+            
+        except Exception as e:
+            print(f"Ticket extraction hook failed: {e}")
+            return []
+
+
+# Example of integrating into an existing orchestrator method
+def example_orchestrator_run_method(self, user_input: str):
+    """Example of how to modify an existing orchestrator run method."""
+    
+    # Process input through hooks if available
+    if self.hook_client:
+        user_input = self.process_user_input_with_hooks(user_input)
+    
+    # Continue with normal orchestration
+    # ... existing orchestrator code ...
+    
+    # When delegating to agents
+    if needs_delegation:
+        agent_name = "Engineer"
+        task = "Implement the feature"
+        
+        # Process through pre-delegation hooks
+        if self.hook_client:
+            agent_name, task = self.process_agent_delegation_with_hooks(agent_name, task)
+        
+        # Perform delegation
+        response = self.delegate_to_agent(agent_name, task)
+        
+        # Process response through post-delegation hooks
+        if self.hook_client:
+            response = self.process_agent_response_with_hooks(agent_name, response)
+    
+    # Extract tickets from the conversation
+    if self.hook_client:
+        conversation = f"User: {user_input}\nAssistant: {response}"
+        tickets = self.extract_tickets_with_hooks(conversation)
+        for ticket in tickets:
+            print(f"Extracted ticket: {ticket['title']}")