claude-mpm 0.3.0__py3-none-any.whl

claude_mpm/init.py

@@ -0,0 +1,246 @@
+"""Initialization module for claude-mpm.
+
+Handles creation of necessary directories and configuration files.
+"""
+
+import os
+import shutil
+from pathlib import Path
+from typing import Optional, Dict, Any
+import json
+
+from claude_mpm.core.logger import get_logger
+
+
+class ProjectInitializer:
+    """Handles initialization of claude-mpm directories and configuration."""
+    
+    def __init__(self):
+        self.logger = get_logger("initializer")
+        self.user_dir = Path.home() / ".claude-mpm"
+        self.project_dir = None
+        
+    def initialize_user_directory(self) -> bool:
+        """Initialize user-level .claude-mpm directory structure.
+        
+        Creates:
+        - ~/.claude-mpm/
+          - agents/
+            - user-defined/
+          - config/
+          - logs/
+          - templates/
+        """
+        try:
+            # Create main user directory
+            self.user_dir.mkdir(exist_ok=True)
+            
+            # Create subdirectories
+            directories = [
+                self.user_dir / "agents" / "user-defined",
+                self.user_dir / "config",
+                self.user_dir / "logs",
+                self.user_dir / "templates",
+            ]
+            
+            for directory in directories:
+                directory.mkdir(parents=True, exist_ok=True)
+            
+            # Create default configuration if it doesn't exist
+            config_file = self.user_dir / "config" / "settings.json"
+            if not config_file.exists():
+                self._create_default_config(config_file)
+            
+            # Copy agent templates if they don't exist
+            self._copy_agent_templates()
+            
+            self.logger.info(f"Initialized user directory at {self.user_dir}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to initialize user directory: {e}")
+            return False
+    
+    def initialize_project_directory(self, project_path: Optional[Path] = None) -> bool:
+        """Initialize project-level .claude-mpm directory structure.
+        
+        Creates:
+        - .claude-mpm/
+          - agents/
+            - project-specific/
+          - config/
+          - logs/
+        """
+        try:
+            # Find project root
+            if project_path:
+                self.project_dir = project_path / ".claude-mpm"
+            else:
+                project_root = self._find_project_root()
+                if not project_root:
+                    project_root = Path.cwd()
+                self.project_dir = project_root / ".claude-mpm"
+            
+            # Create project directory
+            self.project_dir.mkdir(exist_ok=True)
+            
+            # Create subdirectories
+            directories = [
+                self.project_dir / "agents" / "project-specific",
+                self.project_dir / "config",
+                self.project_dir / "logs",
+            ]
+            
+            for directory in directories:
+                directory.mkdir(parents=True, exist_ok=True)
+            
+            # Create project configuration
+            config_file = self.project_dir / "config" / "project.json"
+            if not config_file.exists():
+                self._create_project_config(config_file)
+            
+            # Create .gitignore for project directory
+            gitignore = self.project_dir / ".gitignore"
+            if not gitignore.exists():
+                gitignore.write_text("logs/\n*.log\n*.pyc\n__pycache__/\n")
+            
+            self.logger.info(f"Initialized project directory at {self.project_dir}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to initialize project directory: {e}")
+            return False
+    
+    def _find_project_root(self) -> Optional[Path]:
+        """Find project root by looking for .git or other project markers."""
+        current = Path.cwd()
+        while current != current.parent:
+            if (current / ".git").exists():
+                return current
+            if (current / "pyproject.toml").exists():
+                return current
+            if (current / "setup.py").exists():
+                return current
+            current = current.parent
+        return None
+    
+    def _create_default_config(self, config_file: Path):
+        """Create default user configuration."""
+        default_config = {
+            "version": "1.0",
+            "hooks": {
+                "enabled": True,
+                "port_range": [8080, 8099]
+            },
+            "logging": {
+                "level": "INFO",
+                "max_size_mb": 100,
+                "retention_days": 30
+            },
+            "agents": {
+                "auto_discover": True,
+                "precedence": ["project", "user", "system"]
+            },
+            "orchestration": {
+                "default_mode": "subprocess",
+                "enable_todo_hijacking": False
+            }
+        }
+        
+        with open(config_file, 'w') as f:
+            json.dump(default_config, f, indent=2)
+    
+    def _create_project_config(self, config_file: Path):
+        """Create default project configuration."""
+        project_config = {
+            "version": "1.0",
+            "project_name": Path.cwd().name,
+            "agents": {
+                "enabled": True
+            },
+            "tickets": {
+                "auto_create": True,
+                "prefix": "TSK"
+            }
+        }
+        
+        with open(config_file, 'w') as f:
+            json.dump(project_config, f, indent=2)
+    
+    def _copy_agent_templates(self):
+        """Copy agent templates to user directory."""
+        # Get the package directory
+        package_dir = Path(__file__).parent
+        templates_src = package_dir / "agents" / "templates"
+        templates_dst = self.user_dir / "templates"
+        
+        if templates_src.exists():
+            for template_file in templates_src.glob("*.md"):
+                dst_file = templates_dst / template_file.name
+                if not dst_file.exists():
+                    shutil.copy2(template_file, dst_file)
+    
+    def validate_dependencies(self) -> Dict[str, bool]:
+        """Validate that all required dependencies are available."""
+        dependencies = {}
+        
+        # Check Python version
+        import sys
+        dependencies['python'] = sys.version_info >= (3, 8)
+        
+        # Check Claude CLI
+        dependencies['claude_cli'] = shutil.which("claude") is not None
+        
+        # Check required Python packages
+        required_packages = [
+            'ai_trackdown_pytools',
+            'yaml',
+            'dotenv',
+            'rich',
+            'click',
+            'pexpect',
+            'psutil',
+            'requests',
+            'flask',
+            'watchdog',
+            'tree_sitter'
+        ]
+        
+        for package in required_packages:
+            try:
+                __import__(package)
+                dependencies[package] = True
+            except ImportError:
+                dependencies[package] = False
+        
+        return dependencies
+    
+    def ensure_initialized(self) -> bool:
+        """Ensure both user and project directories are initialized."""
+        user_ok = self.initialize_user_directory()
+        project_ok = self.initialize_project_directory()
+        return user_ok and project_ok
+
+
+def ensure_directories():
+    """Convenience function to ensure directories are initialized."""
+    initializer = ProjectInitializer()
+    return initializer.ensure_initialized()
+
+
+def validate_installation():
+    """Validate that claude-mpm is properly installed."""
+    initializer = ProjectInitializer()
+    deps = initializer.validate_dependencies()
+    
+    all_ok = all(deps.values())
+    
+    if not all_ok:
+        print("❌ Missing dependencies:")
+        for dep, status in deps.items():
+            if not status:
+                print(f"  - {dep}")
+    else:
+        print("✅ All dependencies are installed")
+    
+    return all_ok

claude_mpm/orchestration/SUBPROCESS_DESIGN.md

@@ -0,0 +1,66 @@
+# Subprocess Orchestration Design
+
+## Problem
+Claude's `--print` mode times out when generating code or using tools, making subprocess orchestration in non-interactive mode impractical.
+
+## Findings
+
+### Interactive Mode (Working)
+- Claude uses built-in Task tool
+- Creates real subprocesses with ~11.4k tokens each
+- Runs in parallel with independent timing
+- Each subprocess gets framework context
+
+### Non-Interactive Mode Issues
+- `claude --print` works for simple queries (e.g., "What is 2+2?" in ~4s)
+- Times out for any code generation or complex tasks
+- Debug shows Claude is working but tool usage adds overhead
+- Requires `--dangerously-skip-permissions` flag to run
+
+## Alternative Approaches
+
+### 1. Use Claude's Conversation API
+Instead of `--print`, use conversation management:
+```bash
+# Start conversation
+claude --model opus -c "conversation_id" < prompt.txt
+
+# Continue conversation
+claude --continue conversation_id < next_prompt.txt
+```
+
+### 2. Use Interactive Mode with Expect
+Use expect/pexpect to control interactive Claude sessions programmatically.
+
+### 3. Mock Subprocess Mode
+For testing/development:
+- Detect delegations in PM response
+- Show subprocess-like output
+- But don't actually create subprocesses
+
+### 4. Direct API Integration
+Skip CLI entirely and use Claude's API directly (if available).
+
+## Implementation Status
+
+### Completed
+1. ✅ SubprocessOrchestrator class with full functionality
+2. ✅ Delegation detection for multiple formats
+3. ✅ Parallel subprocess execution framework
+4. ✅ Agent-specific prompt generation
+5. ✅ CLI integration via `--subprocess` flag
+6. ✅ Fixed command flags for permissions
+
+### Current Status
+- Implementation is complete but blocked by Claude CLI limitations
+- Use interactive mode for real subprocess orchestration
+- Keep implementation for future when Claude print mode improves
+
+## Delegation Detection Patterns
+
+The PM uses these formats:
+- `**Engineer Agent**: Create a function...`
+- `**QA**: Write tests for...`
+- `I'll delegate this to the Engineer agent...`
+
+We can parse these and show subprocess-style output even without real subprocesses.

claude_mpm/orchestration/__init__.py

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

claude_mpm/orchestration/archive/direct_orchestrator.py

@@ -0,0 +1,195 @@
+"""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}")