claude-mpm 3.4.10__py3-none-any.whl → 5.4.85__py3-none-any.whl

claude_mpm/orchestration/archive/factory.py

@@ -1,215 +0,0 @@
-"""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

@@ -1,188 +0,0 @@
-"""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

@@ -1,178 +0,0 @@
-"""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']}")