claude-mpm 0.3.0__py3-none-any.whl

claude_mpm/hooks/builtin/pre_delegation_hook_example.py

@@ -0,0 +1,125 @@
+"""Example pre-delegation hook implementation."""
+
+import json
+from typing import Dict, Any, List
+
+from claude_mpm.hooks.base_hook import PreDelegationHook, HookContext, HookResult
+from claude_mpm.core.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class ContextFilterHook(PreDelegationHook):
+    """Hook that filters sensitive information from context before delegation."""
+    
+    def __init__(self):
+        super().__init__(name="context_filter", priority=10)
+        self.sensitive_keys = {
+            'api_key', 'secret', 'password', 'token',
+            'private_key', 'credentials', 'auth'
+        }
+        
+    def execute(self, context: HookContext) -> HookResult:
+        """Filter sensitive information from delegation context."""
+        try:
+            agent_context = context.data.get('context', {})
+            filtered_context = self._filter_sensitive(agent_context)
+            
+            if filtered_context != agent_context:
+                logger.info("Filtered sensitive information from context")
+                return HookResult(
+                    success=True,
+                    data={
+                        'agent': context.data.get('agent'),
+                        'context': filtered_context
+                    },
+                    modified=True,
+                    metadata={'filtered_keys': True}
+                )
+            else:
+                return HookResult(
+                    success=True,
+                    data=context.data,
+                    modified=False
+                )
+                
+        except Exception as e:
+            logger.error(f"Context filtering failed: {e}")
+            return HookResult(
+                success=False,
+                error=str(e)
+            )
+            
+    def _filter_sensitive(self, data: Any) -> Any:
+        """Recursively filter sensitive keys from data."""
+        if isinstance(data, dict):
+            filtered = {}
+            for key, value in data.items():
+                if any(sensitive in key.lower() for sensitive in self.sensitive_keys):
+                    filtered[key] = "[REDACTED]"
+                else:
+                    filtered[key] = self._filter_sensitive(value)
+            return filtered
+        elif isinstance(data, list):
+            return [self._filter_sensitive(item) for item in data]
+        else:
+            return data
+
+
+class AgentCapabilityEnhancerHook(PreDelegationHook):
+    """Hook that enhances agent context with additional capabilities."""
+    
+    def __init__(self):
+        super().__init__(name="capability_enhancer", priority=30)
+        self.agent_enhancements = {
+            'engineer': {
+                'tools': ['code_analysis', 'refactoring', 'testing'],
+                'context': 'You have access to advanced code analysis tools.'
+            },
+            'researcher': {
+                'tools': ['web_search', 'document_analysis'],
+                'context': 'You can search the web and analyze documents.'
+            },
+            'qa': {
+                'tools': ['test_runner', 'coverage_analyzer'],
+                'context': 'You have access to comprehensive testing tools.'
+            }
+        }
+        
+    def execute(self, context: HookContext) -> HookResult:
+        """Enhance agent capabilities based on agent type."""
+        try:
+            agent_type = context.data.get('agent', '').lower()
+            
+            if agent_type in self.agent_enhancements:
+                enhancement = self.agent_enhancements[agent_type]
+                
+                # Add enhancements to context
+                enhanced_context = context.data.get('context', {}).copy()
+                enhanced_context['additional_tools'] = enhancement['tools']
+                enhanced_context['enhanced_context'] = enhancement['context']
+                
+                logger.info(f"Enhanced {agent_type} agent with additional capabilities")
+                
+                return HookResult(
+                    success=True,
+                    data={
+                        'agent': context.data.get('agent'),
+                        'context': enhanced_context
+                    },
+                    modified=True,
+                    metadata={'enhancements_applied': True}
+                )
+            else:
+                return HookResult(
+                    success=True,
+                    data=context.data,
+                    modified=False
+                )
+                
+        except Exception as e:
+            logger.error(f"Capability enhancement failed: {e}")
+            return HookResult(
+                success=False,
+                error=str(e)
+            )

claude_mpm/hooks/builtin/submit_hook_example.py

@@ -0,0 +1,100 @@
+"""Example submit hook implementation."""
+
+import re
+from typing import Dict, Any
+
+from claude_mpm.hooks.base_hook import SubmitHook, HookContext, HookResult
+from claude_mpm.core.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class TicketDetectionSubmitHook(SubmitHook):
+    """Hook that detects ticket references in user prompts."""
+    
+    def __init__(self):
+        super().__init__(name="ticket_detection", priority=10)
+        self.ticket_pattern = re.compile(r'\b(?:TSK|BUG|FEAT)-\d+\b', re.IGNORECASE)
+        
+    def execute(self, context: HookContext) -> HookResult:
+        """Detect and extract ticket references from prompt."""
+        try:
+            prompt = context.data.get('prompt', '')
+            
+            # Find all ticket references
+            tickets = self.ticket_pattern.findall(prompt)
+            
+            if tickets:
+                logger.info(f"Found {len(tickets)} ticket references: {tickets}")
+                
+                # Add ticket references to metadata
+                return HookResult(
+                    success=True,
+                    data={
+                        'tickets': list(set(tickets)),  # Unique tickets
+                        'prompt': prompt
+                    },
+                    modified=True,
+                    metadata={'ticket_count': len(set(tickets))}
+                )
+            else:
+                return HookResult(
+                    success=True,
+                    data={'prompt': prompt},
+                    modified=False
+                )
+                
+        except Exception as e:
+            logger.error(f"Ticket detection failed: {e}")
+            return HookResult(
+                success=False,
+                error=str(e)
+            )
+
+
+class PriorityDetectionSubmitHook(SubmitHook):
+    """Hook that detects priority indicators in prompts."""
+    
+    def __init__(self):
+        super().__init__(name="priority_detection", priority=20)
+        self.priority_keywords = {
+            'urgent': 'high',
+            'asap': 'high',
+            'critical': 'high',
+            'important': 'high',
+            'when you can': 'low',
+            'whenever': 'low',
+            'low priority': 'low'
+        }
+        
+    def execute(self, context: HookContext) -> HookResult:
+        """Detect priority level from prompt."""
+        try:
+            prompt = context.data.get('prompt', '').lower()
+            
+            # Check for priority keywords
+            detected_priority = 'normal'
+            for keyword, priority in self.priority_keywords.items():
+                if keyword in prompt:
+                    detected_priority = priority
+                    break
+                    
+            if detected_priority != 'normal':
+                logger.info(f"Detected priority: {detected_priority}")
+                
+            return HookResult(
+                success=True,
+                data={
+                    'prompt': context.data.get('prompt', ''),
+                    'priority': detected_priority
+                },
+                modified=detected_priority != 'normal',
+                metadata={'priority_detected': detected_priority != 'normal'}
+            )
+            
+        except Exception as e:
+            logger.error(f"Priority detection failed: {e}")
+            return HookResult(
+                success=False,
+                error=str(e)
+            )

claude_mpm/hooks/builtin/ticket_extraction_hook_example.py

@@ -0,0 +1,237 @@
+"""Example ticket extraction hook implementation."""
+
+import re
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+from claude_mpm.hooks.base_hook import TicketExtractionHook, HookContext, HookResult
+from claude_mpm.core.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class AutoTicketExtractionHook(TicketExtractionHook):
+    """Hook that automatically extracts tickets from conversations."""
+    
+    def __init__(self):
+        super().__init__(name="auto_ticket_extraction", priority=10)
+        
+        # Patterns for detecting ticket-worthy content
+        self.ticket_patterns = [
+            # Action items: "TODO:", "FIXME:", "ACTION:"
+            (r'(?:TODO|FIXME|ACTION):\s*(.+?)(?:\n|$)', 'action'),
+            # Bug reports: "bug:", "issue:", "problem:"
+            (r'(?:bug|issue|problem):\s*(.+?)(?:\n|$)', 'bug'),
+            # Feature requests: "feature:", "enhancement:", "request:"
+            (r'(?:feature|enhancement|request):\s*(.+?)(?:\n|$)', 'feature'),
+            # Questions that need follow-up
+            (r'(?:question|Q):\s*(.+?)(?:\n|$)', 'question'),
+            # Explicit ticket creation: "create ticket:", "new ticket:"
+            (r'(?:create ticket|new ticket):\s*(.+?)(?:\n|$)', 'ticket')
+        ]
+        
+    def execute(self, context: HookContext) -> HookResult:
+        """Extract potential tickets from conversation."""
+        try:
+            # Get conversation content
+            content = context.data.get('content', '')
+            if isinstance(content, dict):
+                # Handle structured content
+                content = self._extract_text_content(content)
+                
+            # Find all potential tickets
+            tickets = []
+            
+            for pattern, ticket_type in self.ticket_patterns:
+                matches = re.finditer(pattern, content, re.IGNORECASE | re.MULTILINE)
+                for match in matches:
+                    description = match.group(1).strip()
+                    if description:
+                        ticket = self._create_ticket(
+                            description=description,
+                            ticket_type=ticket_type,
+                            context=context
+                        )
+                        tickets.append(ticket)
+                        
+            # Also check for numbered lists that might be tasks
+            numbered_tasks = re.findall(r'^\d+\.\s*(.+?)$', content, re.MULTILINE)
+            for task in numbered_tasks:
+                if self._is_actionable(task):
+                    ticket = self._create_ticket(
+                        description=task.strip(),
+                        ticket_type='task',
+                        context=context
+                    )
+                    tickets.append(ticket)
+                    
+            if tickets:
+                logger.info(f"Extracted {len(tickets)} potential tickets")
+                return HookResult(
+                    success=True,
+                    data={
+                        'tickets': tickets,
+                        'original_content': content
+                    },
+                    modified=True,
+                    metadata={'ticket_count': len(tickets)}
+                )
+            else:
+                return HookResult(
+                    success=True,
+                    data={'original_content': content},
+                    modified=False
+                )
+                
+        except Exception as e:
+            logger.error(f"Ticket extraction failed: {e}")
+            return HookResult(
+                success=False,
+                error=str(e)
+            )
+            
+    def _extract_text_content(self, data: Any) -> str:
+        """Extract text content from structured data."""
+        if isinstance(data, str):
+            return data
+        elif isinstance(data, dict):
+            # Try common keys
+            for key in ['content', 'text', 'message', 'result']:
+                if key in data:
+                    return self._extract_text_content(data[key])
+            # Fallback to string representation
+            return str(data)
+        elif isinstance(data, list):
+            return '\n'.join(self._extract_text_content(item) for item in data)
+        else:
+            return str(data)
+            
+    def _is_actionable(self, text: str) -> bool:
+        """Determine if text represents an actionable item."""
+        actionable_verbs = [
+            'implement', 'create', 'add', 'fix', 'update', 'remove',
+            'test', 'verify', 'check', 'investigate', 'research',
+            'document', 'write', 'review', 'refactor', 'optimize'
+        ]
+        
+        text_lower = text.lower()
+        return any(verb in text_lower for verb in actionable_verbs)
+        
+    def _create_ticket(self, description: str, ticket_type: str, 
+                      context: HookContext) -> Dict[str, Any]:
+        """Create a ticket structure."""
+        return {
+            'id': None,  # To be assigned by ticket system
+            'title': self._generate_title(description),
+            'description': description,
+            'type': ticket_type,
+            'priority': context.data.get('priority', 'normal'),
+            'status': 'pending',
+            'created_at': datetime.now().isoformat(),
+            'source': 'auto_extraction',
+            'metadata': {
+                'session_id': context.session_id,
+                'user_id': context.user_id,
+                'extraction_timestamp': context.timestamp.isoformat()
+            }
+        }
+        
+    def _generate_title(self, description: str) -> str:
+        """Generate a concise title from description."""
+        # Take first 50 chars or up to first period/newline
+        title = description[:50]
+        
+        # Try to cut at sentence boundary
+        for delimiter in ['.', '\n', '!', '?']:
+            if delimiter in title:
+                title = title.split(delimiter)[0]
+                break
+                
+        # Clean up and ensure not too long
+        title = title.strip()
+        if len(title) > 50:
+            title = title[:47] + '...'
+            
+        return title
+
+
+class TicketPriorityAnalyzerHook(TicketExtractionHook):
+    """Hook that analyzes and assigns priority to extracted tickets."""
+    
+    def __init__(self):
+        super().__init__(name="ticket_priority_analyzer", priority=50)
+        
+        self.priority_indicators = {
+            'critical': ['critical', 'urgent', 'blocker', 'emergency', 'asap'],
+            'high': ['important', 'high priority', 'needed', 'required'],
+            'low': ['minor', 'nice to have', 'someday', 'optional']
+        }
+        
+    def execute(self, context: HookContext) -> HookResult:
+        """Analyze and update ticket priorities."""
+        try:
+            tickets = context.data.get('tickets', [])
+            
+            if not tickets:
+                return HookResult(
+                    success=True,
+                    data=context.data,
+                    modified=False
+                )
+                
+            # Analyze each ticket
+            updated_tickets = []
+            priorities_updated = 0
+            
+            for ticket in tickets:
+                original_priority = ticket.get('priority', 'normal')
+                analyzed_priority = self._analyze_priority(ticket)
+                
+                if analyzed_priority != original_priority:
+                    ticket['priority'] = analyzed_priority
+                    ticket['metadata']['priority_analyzed'] = True
+                    priorities_updated += 1
+                    
+                updated_tickets.append(ticket)
+                
+            if priorities_updated > 0:
+                logger.info(f"Updated priority for {priorities_updated} tickets")
+                return HookResult(
+                    success=True,
+                    data={
+                        'tickets': updated_tickets
+                    },
+                    modified=True,
+                    metadata={'priorities_updated': priorities_updated}
+                )
+            else:
+                return HookResult(
+                    success=True,
+                    data=context.data,
+                    modified=False
+                )
+                
+        except Exception as e:
+            logger.error(f"Priority analysis failed: {e}")
+            return HookResult(
+                success=False,
+                error=str(e)
+            )
+            
+    def _analyze_priority(self, ticket: Dict[str, Any]) -> str:
+        """Analyze ticket content to determine priority."""
+        content = f"{ticket.get('title', '')} {ticket.get('description', '')}".lower()
+        
+        # Check for priority indicators
+        for priority, indicators in self.priority_indicators.items():
+            if any(indicator in content for indicator in indicators):
+                return priority
+                
+        # Check ticket type
+        ticket_type = ticket.get('type', '')
+        if ticket_type == 'bug':
+            return 'high'
+        elif ticket_type == 'question':
+            return 'normal'
+            
+        return 'normal'