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

claude_mpm/hooks/builtin/submit_hook_example.py

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

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

claude_mpm/hooks/builtin/todo_agent_prefix_hook.py

@@ -1,240 +0,0 @@
-"""Hook to enforce [Agent] prefix requirement for TodoWrite tool calls."""
-
-import re
-from typing import Dict, Any, List, Optional
-
-from claude_mpm.hooks.base_hook import BaseHook, HookContext, HookResult, HookType
-from claude_mpm.core.logger import get_logger
-from claude_mpm.core.agent_name_normalizer import agent_name_normalizer
-
-logger = get_logger(__name__)
-
-
-class TodoAgentPrefixHook(BaseHook):
-    """Hook that enforces agent name prefixes in TodoWrite tool calls."""
-    
-    def __init__(self):
-        super().__init__(name="todo_agent_prefix_enforcer", priority=20)
-        
-        # Mapping of task content patterns to appropriate agent prefixes
-        self.agent_patterns = {
-            'engineer': [
-                r'implement', r'code', r'fix', r'refactor', r'debug', r'develop',
-                r'create.*function', r'write.*class', r'add.*feature', r'optimize.*code'
-            ],
-            'research': [
-                r'research', r'investigate', r'analyze', r'explore', r'find.*best',
-                r'compare', r'evaluate', r'study', r'discover', r'understand'
-            ],
-            'documentation': [
-                r'document', r'write.*doc', r'update.*readme', r'changelog',
-                r'create.*guide', r'explain', r'describe', r'write.*tutorial'
-            ],
-            'qa': [
-                r'test', r'validate', r'verify', r'check', r'ensure.*quality',
-                r'run.*tests', r'coverage', r'lint', r'audit'
-            ],
-            'security': [
-                r'security', r'vulnerability', r'protect', r'secure', r'audit.*security',
-                r'penetration', r'encrypt', r'authenticate', r'authorize'
-            ],
-            'ops': [
-                r'deploy', r'configure', r'setup', r'install', r'provision',
-                r'infrastructure', r'ci/cd', r'pipeline', r'monitor'
-            ],
-            'data_engineer': [
-                r'data.*pipeline', r'etl', r'database', r'schema', r'migrate',
-                r'transform.*data', r'api.*integration', r'data.*flow'
-            ],
-            'version_control': [
-                r'version', r'release', r'tag', r'branch', r'merge',
-                r'git', r'commit', r'push', r'pull'
-            ]
-        }
-        
-        # Compile patterns for efficiency
-        self.compiled_patterns = {}
-        for agent, patterns in self.agent_patterns.items():
-            self.compiled_patterns[agent] = [
-                re.compile(pattern, re.IGNORECASE) for pattern in patterns
-            ]
-    
-    def execute(self, context: HookContext) -> HookResult:
-        """Check and enforce agent prefix in TodoWrite calls."""
-        try:
-            # This hook is designed to work with tool interception
-            # Check if this is a TodoWrite tool call
-            if context.hook_type != HookType.CUSTOM:
-                return HookResult(success=True, modified=False)
-            
-            tool_name = context.data.get('tool_name', '')
-            if tool_name != 'TodoWrite':
-                return HookResult(success=True, modified=False)
-            
-            # Extract todos from the tool parameters
-            tool_params = context.data.get('parameters', {})
-            todos = tool_params.get('todos', [])
-            
-            if not todos:
-                return HookResult(success=True, modified=False)
-            
-            # Check and fix each todo item
-            modified = False
-            validation_errors = []
-            updated_todos = []
-            
-            for todo in todos:
-                content = todo.get('content', '')
-                
-                # Check if content already has an agent prefix
-                if self._has_agent_prefix(content):
-                    updated_todos.append(todo)
-                    continue
-                
-                # Try to determine appropriate agent
-                suggested_agent = self._suggest_agent(content)
-                
-                if suggested_agent:
-                    # Automatically add the prefix using normalized format
-                    prefix = agent_name_normalizer.to_todo_prefix(suggested_agent)
-                    todo['content'] = f"{prefix} {content}"
-                    updated_todos.append(todo)
-                    modified = True
-                    logger.info(f"Added '{prefix}' prefix to todo: {content[:50]}...")
-                else:
-                    # If we can't determine the agent, block the call
-                    validation_errors.append(
-                        f"Todo item missing required [Agent] prefix: '{content[:50]}...'. "
-                        f"Please prefix with one of: [Research], [Engineer], [QA], "
-                        f"[Security], [Documentation], [Ops], [Data Engineer], or [Version Control]."
-                    )
-            
-            # If there are validation errors, block the call
-            if validation_errors:
-                return HookResult(
-                    success=False,
-                    error="\n".join(validation_errors),
-                    metadata={'validation_failed': True}
-                )
-            
-            # If we modified any todos, update the parameters
-            if modified:
-                tool_params['todos'] = updated_todos
-                return HookResult(
-                    success=True,
-                    data={
-                        'tool_name': tool_name,
-                        'parameters': tool_params
-                    },
-                    modified=True,
-                    metadata={'prefixes_added': True}
-                )
-            
-            return HookResult(success=True, modified=False)
-            
-        except Exception as e:
-            logger.error(f"Todo agent prefix enforcement failed: {e}")
-            return HookResult(
-                success=False,
-                error=str(e)
-            )
-    
-    def _has_agent_prefix(self, content: str) -> bool:
-        """Check if content already has an agent prefix."""
-        import re
-        content = content.strip()
-        # Only check for [Agent] prefix at the beginning, not agent mentions in content
-        match = re.match(r'^\[([^\]]+)\]', content)
-        return match is not None
-    
-    def _suggest_agent(self, content: str) -> Optional[str]:
-        """Suggest an appropriate agent based on content analysis."""
-        content_lower = content.lower()
-        
-        # Check each agent's patterns
-        for agent, patterns in self.compiled_patterns.items():
-            for pattern in patterns:
-                if pattern.search(content_lower):
-                    return agent_name_normalizer.normalize(agent)
-        
-        # Default suggestions based on common keywords
-        if any(word in content_lower for word in ['code', 'implement', 'fix', 'bug']):
-            return agent_name_normalizer.normalize('engineer')
-        elif any(word in content_lower for word in ['test', 'validate', 'check']):
-            return agent_name_normalizer.normalize('qa')
-        elif any(word in content_lower for word in ['doc', 'readme', 'guide']):
-            return agent_name_normalizer.normalize('documentation')
-        elif any(word in content_lower for word in ['research', 'investigate']):
-            return agent_name_normalizer.normalize('research')
-        
-        return None
-    
-    def validate(self, context: HookContext) -> bool:
-        """Validate if hook should run for given context."""
-        if not super().validate(context):
-            return False
-        
-        # This hook only runs for CUSTOM type with tool_name = TodoWrite
-        return (context.hook_type == HookType.CUSTOM and 
-                context.data.get('tool_name') == 'TodoWrite')
-
-
-class TodoAgentPrefixValidatorHook(BaseHook):
-    """Alternative hook that only validates without auto-fixing."""
-    
-    def __init__(self):
-        super().__init__(name="todo_agent_prefix_validator", priority=15)
-        # Get valid agents from normalizer
-        self.valid_agents = list(agent_name_normalizer.CANONICAL_NAMES.values())
-    
-    def execute(self, context: HookContext) -> HookResult:
-        """Validate agent prefix in TodoWrite calls without auto-fixing."""
-        try:
-            # Check if this is a TodoWrite tool call
-            if context.data.get('tool_name') != 'TodoWrite':
-                return HookResult(success=True, modified=False)
-            
-            # Extract todos
-            tool_params = context.data.get('parameters', {})
-            todos = tool_params.get('todos', [])
-            
-            validation_errors = []
-            
-            for i, todo in enumerate(todos):
-                content = todo.get('content', '')
-                
-                # Check for agent prefix using normalizer
-                if not agent_name_normalizer.extract_from_todo(content):
-                    validation_errors.append(
-                        f"Todo #{i+1} missing required agent prefix. "
-                        f"Content: '{content[:50]}...'\n"
-                        f"Please use format: '[Agent] Task description' where [Agent] is one of: "
-                        f"{', '.join('[' + agent + ']' for agent in self.valid_agents)}"
-                    )
-            
-            if validation_errors:
-                return HookResult(
-                    success=False,
-                    error="\n\n".join(validation_errors),
-                    metadata={
-                        'validation_type': 'agent_prefix',
-                        'valid_agents': self.valid_agents
-                    }
-                )
-            
-            return HookResult(success=True, modified=False)
-            
-        except Exception as e:
-            logger.error(f"Todo validation failed: {e}")
-            return HookResult(
-                success=False,
-                error=str(e)
-            )
-    
-    def validate(self, context: HookContext) -> bool:
-        """Validate if hook should run for given context."""
-        if not super().validate(context):
-            return False
-        
-        return (context.hook_type == HookType.CUSTOM and 
-                context.data.get('tool_name') == 'TodoWrite')