claude-mpm 3.4.27__py3-none-any.whl → 3.5.1__py3-none-any.whl

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']}")