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

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')

claude_mpm/hooks/builtin/workflow_start_hook.py

@@ -1,181 +0,0 @@
-"""Hook to log workflow information at the start of execution."""
-
-import json
-from typing import Dict, Any, List, Optional
-from datetime import datetime
-
-from claude_mpm.hooks.base_hook import SubmitHook, HookContext, HookResult, HookType
-from claude_mpm.core.logger import get_logger
-
-logger = get_logger(__name__)
-
-
-class WorkflowStartHook(SubmitHook):
-    """Hook that logs workflow information including steps list at workflow start."""
-    
-    def __init__(self):
-        super().__init__(name="workflow_start_logger", priority=5)
-    
-    def execute(self, context: HookContext) -> HookResult:
-        """Log workflow information when a workflow starts."""
-        try:
-            # Extract prompt and workflow data from context
-            prompt = context.data.get('prompt', '')
-            workflow_data = context.data.get('workflow', {})
-            
-            # Check if this is a workflow start (either by explicit workflow data or detected pattern)
-            if workflow_data or self._is_workflow_prompt(prompt):
-                # Extract workflow information
-                workflow_name = workflow_data.get('name', 'Unnamed Workflow')
-                workflow_steps = workflow_data.get('steps', [])
-                
-                # If no explicit steps provided, try to parse from prompt
-                if not workflow_steps and prompt:
-                    workflow_steps = self._extract_steps_from_prompt(prompt)
-                
-                # Log workflow start information
-                logger.info("="*60)
-                logger.info("WORKFLOW START")
-                logger.info("="*60)
-                logger.info(f"Workflow: {workflow_name}")
-                logger.info(f"Started at: {context.timestamp.isoformat()}")
-                logger.info(f"Session ID: {context.session_id or 'N/A'}")
-                logger.info(f"User ID: {context.user_id or 'N/A'}")
-                
-                if workflow_steps:
-                    logger.info(f"\nWorkflow Steps ({len(workflow_steps)} total):")
-                    for i, step in enumerate(workflow_steps, 1):
-                        if isinstance(step, dict):
-                            step_name = step.get('name', step.get('description', 'Unnamed step'))
-                            step_type = step.get('type', 'task')
-                            logger.info(f"  {i}. [{step_type}] {step_name}")
-                        else:
-                            # Handle simple string steps
-                            logger.info(f"  {i}. {step}")
-                else:
-                    logger.info("\nNo explicit workflow steps defined")
-                
-                # Log additional metadata if present
-                metadata = workflow_data.get('metadata', {})
-                if metadata:
-                    logger.info(f"\nWorkflow Metadata:")
-                    for key, value in metadata.items():
-                        logger.info(f"  {key}: {value}")
-                
-                logger.info("="*60)
-                
-                # Add workflow info to result metadata for downstream hooks
-                return HookResult(
-                    success=True,
-                    modified=False,
-                    metadata={
-                        'workflow_logged': True,
-                        'workflow_name': workflow_name,
-                        'step_count': len(workflow_steps),
-                        'has_explicit_workflow': bool(workflow_data)
-                    }
-                )
-            
-            # Not a workflow start, pass through
-            return HookResult(success=True, modified=False)
-            
-        except Exception as e:
-            logger.error(f"Workflow start logging failed: {e}")
-            # Don't block execution on logging errors
-            return HookResult(
-                success=True,
-                modified=False,
-                error=str(e)
-            )
-    
-    def _is_workflow_prompt(self, prompt: str) -> bool:
-        """Detect if a prompt indicates a workflow start."""
-        if not prompt:
-            return False
-        
-        prompt_lower = prompt.lower()
-        workflow_indicators = [
-            'workflow', 'steps:', 'step 1', 'first,', 'then,', 'finally,',
-            'process:', 'procedure:', 'sequence:', 'plan:'
-        ]
-        
-        return any(indicator in prompt_lower for indicator in workflow_indicators)
-    
-    def _extract_steps_from_prompt(self, prompt: str) -> List[str]:
-        """Try to extract workflow steps from a prompt text."""
-        steps = []
-        
-        # Look for numbered steps (1. 2. 3. or 1) 2) 3))
-        import re
-        numbered_pattern = re.compile(r'^\s*\d+[\)\.]\s*(.+)$', re.MULTILINE)
-        matches = numbered_pattern.findall(prompt)
-        if matches:
-            steps.extend(matches)
-            return steps
-        
-        # Look for bullet points
-        bullet_pattern = re.compile(r'^\s*[-*•]\s*(.+)$', re.MULTILINE)
-        matches = bullet_pattern.findall(prompt)
-        if matches:
-            steps.extend(matches)
-            return steps
-        
-        # Look for sequential keywords
-        sequential_pattern = re.compile(
-            r'(?:first|then|next|after that|finally|lastly),?\s*(.+?)(?=(?:first|then|next|after that|finally|lastly|$))',
-            re.IGNORECASE | re.DOTALL
-        )
-        matches = sequential_pattern.findall(prompt)
-        if matches:
-            steps.extend([m.strip() for m in matches if m.strip()])
-        
-        return steps
-    
-    def validate(self, context: HookContext) -> bool:
-        """Validate if hook should run for given context."""
-        if not super().validate(context):
-            return False
-        
-        # This hook runs for all submit contexts to check for workflows
-        return context.hook_type == HookType.SUBMIT
-
-
-class WorkflowStepLogger(SubmitHook):
-    """Alternative hook that logs individual workflow step execution."""
-    
-    def __init__(self):
-        super().__init__(name="workflow_step_logger", priority=6)
-    
-    def execute(self, context: HookContext) -> HookResult:
-        """Log individual workflow step execution."""
-        try:
-            # Check if this is a workflow step execution
-            step_data = context.data.get('workflow_step', {})
-            if not step_data:
-                return HookResult(success=True, modified=False)
-            
-            # Extract step information
-            step_number = step_data.get('number', 0)
-            step_name = step_data.get('name', 'Unnamed step')
-            step_type = step_data.get('type', 'task')
-            workflow_name = step_data.get('workflow_name', 'Unknown workflow')
-            
-            # Log step execution
-            logger.info(f"\n→ Executing Step {step_number}: {step_name}")
-            logger.info(f"  Type: {step_type}")
-            logger.info(f"  Workflow: {workflow_name}")
-            logger.info(f"  Started: {context.timestamp.isoformat()}")
-            
-            return HookResult(
-                success=True,
-                modified=False,
-                metadata={
-                    'step_logged': True,
-                    'step_number': step_number,
-                    'step_name': step_name
-                }
-            )
-            
-        except Exception as e:
-            logger.error(f"Workflow step logging failed: {e}")
-            return HookResult(success=True, modified=False, error=str(e))

claude_mpm/orchestration/__init__.py

@@ -1,6 +0,0 @@
-"""Orchestration components for Claude MPM (legacy)."""
-
-# Most orchestration components have been simplified and moved to core.claude_runner
-# This module is kept for backwards compatibility
-
-__all__ = []

claude_mpm/orchestration/archive/direct_orchestrator.py

@@ -1,195 +0,0 @@
-"""Direct orchestrator that runs Claude with minimal intervention."""
-
-import os
-from pathlib import Path
-from typing import Optional
-from datetime import datetime
-import logging
-import tempfile
-
-try:
-    from ..core.logger import get_logger, setup_logging
-    from ..utils.subprocess_runner import SubprocessRunner
-    # TicketExtractor removed from project
-    from ..core.framework_loader import FrameworkLoader
-    from .agent_delegator import AgentDelegator
-except ImportError:
-    from core.logger import get_logger, setup_logging
-    from utils.subprocess_runner import SubprocessRunner
-    # TicketExtractor removed from project
-    from core.framework_loader import FrameworkLoader
-    from orchestration.agent_delegator import AgentDelegator
-
-
-class DirectOrchestrator:
-    """Orchestrator that runs Claude directly with framework injection via file."""
-    
-    def __init__(
-        self,
-        framework_path: Optional[Path] = None,
-        agents_dir: Optional[Path] = None,
-        log_level: str = "OFF",
-        log_dir: Optional[Path] = None,
-    ):
-        """Initialize the orchestrator."""
-        self.log_level = log_level
-        self.log_dir = log_dir or (Path.home() / ".claude-mpm" / "logs")
-        
-        # Set up logging
-        if log_level != "OFF":
-            self.logger = setup_logging(level=log_level, log_dir=log_dir)
-            self.logger.info(f"Initializing Direct Orchestrator (log_level={log_level})")
-        else:
-            # Minimal logger
-            self.logger = get_logger("direct_orchestrator")
-            self.logger.setLevel(logging.WARNING)
-        
-        # Components
-        self.framework_loader = FrameworkLoader(framework_path, agents_dir)
-        # TicketExtractor removed from project
-        self.agent_delegator = AgentDelegator(self.framework_loader.agent_registry)
-        
-        # State
-        self.session_start = datetime.now()
-        # Ticket creation removed from project
-        
-        # Initialize subprocess runner
-        self.subprocess_runner = SubprocessRunner(logger=self.logger)
-        
-    def run_interactive(self):
-        """Run an interactive session by launching Claude directly."""
-        print("Claude MPM Interactive Session")
-        print("Framework will be injected on first interaction")
-        print("-" * 50)
-        
-        # Get framework instructions
-        framework = self.framework_loader.get_framework_instructions()
-        
-        # Save framework to a temporary file
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
-            f.write(framework)
-            f.write("\n\nNOTE: This is the claude-mpm framework. Please acknowledge you've received these instructions and then we can begin our session.\n")
-            framework_file = f.name
-        
-        try:
-            # Log framework injection
-            if self.log_level != "OFF":
-                self.logger.info(f"Framework saved to temporary file: {framework_file}")
-                
-                # Also save to prompts directory
-                prompt_path = Path.home() / ".claude-mpm" / "prompts"
-                prompt_path.mkdir(parents=True, exist_ok=True)
-                prompt_file = prompt_path / f"prompt_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
-                prompt_file.write_text(framework)
-                self.logger.info(f"Framework also saved to: {prompt_file}")
-            
-            # Read the framework content
-            with open(framework_file, 'r') as f:
-                framework_content = f.read()
-            
-            # Generate a unique session ID
-            import uuid
-            session_id = str(uuid.uuid4())
-            
-            # Build command to start Claude with print mode and session ID
-            cmd = [
-                "claude",
-                "--model", "opus",
-                "--dangerously-skip-permissions",
-                "--session-id", session_id,
-                "--print",  # Print mode
-                framework_content
-            ]
-            
-            self.logger.info(f"Starting Claude with framework injection (session: {session_id})")
-            
-            # Run Claude with framework
-            print("\nInjecting framework instructions...")
-            result = self.subprocess_runner.run(cmd)
-            
-            if result.success:
-                print("\nFramework injected. Claude's response:")
-                print("-" * 50)
-                print(result.stdout)
-                print("-" * 50)
-                
-                # Debug: show stderr if logging is enabled
-                if self.log_level != "OFF" and result.stderr:
-                    self.logger.debug(f"Claude stderr: {result.stderr}")
-                
-                # Check if we can find the conversation file
-                # Parse stderr for conversation file location
-                conversation_file = None
-                if result.stderr:
-                    import re
-                    # Look for patterns like "Conversation saved to: /path/to/file"
-                    match = re.search(r'(?:conversation saved to|saved to)[:\s]+([^\s]+)', result.stderr, re.I)
-                    if match:
-                        conversation_file = match.group(1).strip()
-                        self.logger.info(f"Found conversation file: {conversation_file}")
-                
-                # Now start interactive Claude session with same session ID
-                print("\nStarting interactive session...")
-                interactive_cmd = [
-                    "claude",
-                    "--model", "opus",
-                    "--dangerously-skip-permissions"
-                ]
-                
-                # Try to continue the conversation
-                if conversation_file and Path(conversation_file).exists():
-                    interactive_cmd.extend(["--continue", conversation_file])
-                    print(f"Continuing conversation from: {conversation_file}")
-                elif session_id:
-                    interactive_cmd.extend(["--session-id", session_id])
-                    print(f"Using session ID: {session_id}")
-                
-                # Run Claude interactively
-                self.subprocess_runner.run(interactive_cmd)
-            else:
-                print(f"Error injecting framework: {result.stderr}")
-            
-            self.logger.info(f"Claude exited with code: {result.returncode}")
-            
-        finally:
-            # Clean up temporary file
-            try:
-                os.unlink(framework_file)
-            except:
-                pass
-            
-            # Ticket creation removed from project
-    
-    # _create_tickets method removed - TicketExtractor functionality removed from project
-    
-    def run_non_interactive(self, user_input: str):
-        """Run a non-interactive session using print mode."""
-        try:
-            # Prepare message with framework
-            framework = self.framework_loader.get_framework_instructions()
-            full_message = framework + "\n\nUser: " + user_input
-            
-            # Build command
-            cmd = [
-                "claude",
-                "--model", "opus",
-                "--dangerously-skip-permissions",
-                "--print",  # Print mode
-                full_message
-            ]
-            
-            # Run Claude
-            result = self.subprocess_runner.run(cmd)
-            
-            if result.success:
-                print(result.stdout)
-                
-                # Ticket extraction removed from project
-            else:
-                print(f"Error: {result.stderr}")
-                
-            # Ticket creation removed from project
-                
-        except Exception as e:
-            print(f"Error: {e}")
-            self.logger.error(f"Non-interactive error: {e}")