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

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

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