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

claude_mpm/orchestration/archive/pexpect_orchestrator.py

@@ -1,252 +0,0 @@
-"""Orchestrator using pexpect for proper terminal interaction."""
-
-import pexpect
-import sys
-import os
-from pathlib import Path
-from typing import Optional
-from datetime import datetime
-import logging
-
-try:
-    from ..core.logger import get_logger, setup_logging
-    # 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
-    # TicketExtractor removed from project
-    from core.framework_loader import FrameworkLoader
-    from orchestration.agent_delegator import AgentDelegator
-
-
-class PexpectOrchestrator:
-    """Orchestrator using pexpect for proper terminal control."""
-    
-    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 Pexpect Orchestrator (log_level={log_level})")
-        else:
-            # Minimal logger
-            self.logger = get_logger("pexpect_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.first_interaction = True
-        self.session_start = datetime.now()
-        self.session_log = []
-        # Ticket creation removed from project
-        self.child = None
-        
-    def run_interactive(self):
-        """Run an interactive session using pexpect."""
-        print("Claude MPM Interactive Session (Terminal Mode)")
-        print("Type '/exit' to end session")
-        print("-" * 50)
-        
-        try:
-            # Start Claude with pexpect
-            self.logger.info("Starting Claude with pexpect")
-            self.child = pexpect.spawn(
-                'claude',
-                ['--model', 'opus', '--dangerously-skip-permissions'],
-                encoding='utf-8',
-                timeout=None,
-                dimensions=(24, 80)  # Standard terminal size
-            )
-            
-            # Set up logging if needed
-            if self.log_level == "DEBUG":
-                log_file = open(self.log_dir / f"pexpect_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log", 'w')
-                self.child.logfile = log_file
-            
-            # Wait for Claude to be ready
-            self.logger.info("Waiting for Claude prompt")
-            self.child.expect('>', timeout=10)
-            
-            # First interaction - inject framework
-            if self.first_interaction:
-                self.logger.info("Injecting framework instructions")
-                framework = self.framework_loader.get_framework_instructions()
-                
-                # Save prompt if debugging
-                if self.log_level == "DEBUG":
-                    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.debug(f"Framework saved to: {prompt_file}")
-                
-                # Send framework
-                self.child.sendline(framework)
-                self.child.expect('>', timeout=60)  # Give more time for framework processing
-                self.first_interaction = False
-                
-                # Clear the screen after framework injection
-                print("\033[2J\033[H")  # Clear screen and move cursor to top
-                print("Claude MPM Interactive Session")
-                print("Type '/exit' to end session")
-                print("-" * 50)
-            
-            # Interactive loop
-            while True:
-                try:
-                    # Get user input
-                    user_input = input("\nYou: ")
-                    
-                    # Check for exit
-                    if user_input.strip().lower() in ['/exit', 'exit', 'quit']:
-                        break
-                    
-                    # Send to Claude
-                    self.child.sendline(user_input)
-                    
-                    # Capture response
-                    print("\nClaude: ", end='', flush=True)
-                    self.child.expect('>', timeout=120)  # 2 minute timeout for responses
-                    
-                    # Get the response (everything before the prompt)
-                    response = self.child.before
-                    
-                    # Process response for tickets
-                    for line in response.split('\n'):
-                        # Ticket extraction removed from project
-                        
-                        # Extract agent delegations
-                        delegations = self.agent_delegator.extract_delegations(line)
-                        for delegation in delegations:
-                            if self.log_level != "OFF":
-                                self.logger.info(f"Detected delegation to {delegation['agent']}: {delegation['task']}")
-                    
-                    # Display response
-                    print(response)
-                    
-                    # Log interaction
-                    self._log_interaction("input", user_input)
-                    self._log_interaction("output", response)
-                    
-                except pexpect.TIMEOUT:
-                    print("\n[Timeout waiting for response]")
-                    self.logger.warning("Response timeout")
-                except KeyboardInterrupt:
-                    print("\n[Interrupted]")
-                    break
-                except Exception as e:
-                    print(f"\n[Error: {e}]")
-                    self.logger.error(f"Interaction error: {e}")
-                    
-        except Exception as e:
-            print(f"\nFailed to start Claude: {e}")
-            self.logger.error(f"Failed to start Claude: {e}")
-        finally:
-            self.stop()
-    
-    def _log_interaction(self, interaction_type: str, content: str):
-        """Log interaction for session history."""
-        self.session_log.append({
-            "type": interaction_type,
-            "content": content,
-            "timestamp": datetime.now().isoformat()
-        })
-    
-    def stop(self):
-        """Stop the orchestrated session."""
-        self.logger.info("Stopping pexpect orchestrator")
-        
-        # Close pexpect child
-        if self.child:
-            try:
-                self.child.sendline('/exit')
-                self.child.expect(pexpect.EOF, timeout=5)
-            except:
-                pass
-            finally:
-                self.child.close()
-                
-        # Save session log
-        self._save_session_log()
-        
-        # Create tickets
-        # Ticket creation removed from project
-        
-        print("\nSession ended")
-    
-    def _save_session_log(self):
-        """Save session log to file."""
-        try:
-            log_dir = Path.home() / ".claude-mpm" / "sessions"
-            log_dir.mkdir(parents=True, exist_ok=True)
-            
-            timestamp = self.session_start.strftime("%Y%m%d_%H%M%S")
-            log_file = log_dir / f"session_{timestamp}.json"
-            
-            import json
-            session_data = {
-                "session_start": self.session_start.isoformat(),
-                "session_end": datetime.now().isoformat(),
-                "interactions": self.session_log,
-                # Ticket extraction removed from project
-            }
-            
-            with open(log_file, 'w') as f:
-                json.dump(session_data, f, indent=2)
-            
-            if self.log_level != "OFF":
-                self.logger.info(f"Session log saved to: {log_file}")
-                
-        except Exception as e:
-            self.logger.error(f"Failed to save session log: {e}")
-    
-    # _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."""
-        # For non-interactive, fall back to simple 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
-            import subprocess
-            result = subprocess.run(cmd, capture_output=True, text=True)
-            
-            if result.returncode == 0:
-                print(result.stdout)
-                
-                # Ticket extraction removed from project
-            else:
-                print(f"Error: {result.stderr}")
-                
-            # Create tickets
-            # 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/pty_orchestrator.py

@@ -1,270 +0,0 @@
-"""Orchestrator using built-in pty module for terminal interaction."""
-
-import os
-import pty
-import select
-import subprocess
-import sys
-import termios
-import tty
-from pathlib import Path
-from typing import Optional
-from datetime import datetime
-import logging
-import threading
-import fcntl
-
-try:
-    from ..core.logger import get_logger, setup_logging
-    from ..utils.subprocess_runner import SubprocessRunner, OutputMode
-    # 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, OutputMode
-    # TicketExtractor removed from project
-    from core.framework_loader import FrameworkLoader
-    from orchestration.agent_delegator import AgentDelegator
-
-
-class PTYOrchestrator:
-    """Orchestrator using built-in pty module for proper terminal control."""
-    
-    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 PTY Orchestrator (log_level={log_level})")
-        else:
-            # Minimal logger
-            self.logger = get_logger("pty_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.first_interaction = True
-        self.session_start = datetime.now()
-        self.session_log = []
-        # Ticket creation removed from project
-        self.process = None
-        self.master_fd = None
-        
-        # Initialize subprocess runner
-        self.subprocess_runner = SubprocessRunner(logger=self.logger)
-        
-    def run_interactive(self):
-        """Run an interactive session using pty."""
-        print("Claude MPM Interactive Session")
-        print("Type 'exit' or 'quit' to end session")
-        print("-" * 50)
-        
-        # Save terminal settings
-        old_tty = termios.tcgetattr(sys.stdin)
-        
-        try:
-            # Create a pseudo-terminal
-            master, slave = pty.openpty()
-            self.master_fd = master
-            
-            # Start Claude process
-            self.logger.info("Starting Claude with pty")
-            self.process = subprocess.Popen(
-                ['claude', '--model', 'opus', '--dangerously-skip-permissions'],
-                stdin=slave,
-                stdout=slave,
-                stderr=slave,
-                preexec_fn=os.setsid
-            )
-            
-            # Close slave fd in parent
-            os.close(slave)
-            
-            # Set non-blocking
-            fcntl.fcntl(master, fcntl.F_SETFL, os.O_NONBLOCK)
-            
-            # Put terminal in raw mode
-            tty.setraw(sys.stdin.fileno())
-            
-            # Framework injection flag
-            framework_injected = False
-            framework_buffer = []
-            
-            # I/O loop
-            while True:
-                try:
-                    # Check if process is still alive
-                    if self.process.poll() is not None:
-                        break
-                    
-                    # Use select to check for available data
-                    r, w, e = select.select([sys.stdin, master], [], [], 0.1)
-                    
-                    # Handle input from user
-                    if sys.stdin in r:
-                        data = os.read(sys.stdin.fileno(), 1024)
-                        
-                        # Check for exit
-                        if data == b'\x03' or data == b'\x04':  # Ctrl+C or Ctrl+D
-                            break
-                        
-                        # Inject framework on first real input (after initial Claude startup)
-                        if not framework_injected and data.strip() and not data.startswith(b'\x1b'):
-                            self.logger.info("Injecting framework instructions")
-                            framework = self.framework_loader.get_framework_instructions()
-                            
-                            # Save prompt if debugging
-                            if self.log_level == "DEBUG":
-                                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.debug(f"Framework saved to: {prompt_file}")
-                            
-                            # Send framework first
-                            os.write(master, framework.encode('utf-8') + b'\n')
-                            framework_injected = True
-                            
-                            # Then send user input
-                            os.write(master, data)
-                        else:
-                            # Normal input
-                            os.write(master, data)
-                    
-                    # Handle output from Claude
-                    if master in r:
-                        try:
-                            data = os.read(master, 1024)
-                            if data:
-                                # Write to stdout
-                                sys.stdout.write(data.decode('utf-8', errors='replace'))
-                                sys.stdout.flush()
-                                
-                                # Process for tickets
-                                text = data.decode('utf-8', errors='replace')
-                                for line in text.split('\n'):
-                                    # Ticket extraction removed from project
-                                    
-                                    # Extract agent delegations
-                                    delegations = self.agent_delegator.extract_delegations(line)
-                                    for delegation in delegations:
-                                        if self.log_level != "OFF":
-                                            self.logger.info(f"Detected delegation to {delegation['agent']}: {delegation['task']}")
-                        except OSError:
-                            # No data available
-                            pass
-                            
-                except KeyboardInterrupt:
-                    break
-                except Exception as e:
-                    self.logger.error(f"Error in I/O loop: {e}")
-                    break
-                    
-        finally:
-            # Restore terminal settings
-            termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old_tty)
-            
-            # Clean up
-            self.stop()
-    
-    def stop(self):
-        """Stop the orchestrated session."""
-        self.logger.info("Stopping PTY orchestrator")
-        
-        # Terminate process
-        if self.process:
-            try:
-                self.process.terminate()
-                self.process.wait(timeout=5)
-            except:
-                self.process.kill()
-                self.process.wait()
-        
-        # Close master fd
-        if self.master_fd:
-            try:
-                os.close(self.master_fd)
-            except:
-                pass
-        
-        # Save session log
-        self._save_session_log()
-        
-        # Ticket creation removed from project
-        
-        print("\n\nSession ended")
-    
-    def _save_session_log(self):
-        """Save session log to file."""
-        try:
-            log_dir = Path.home() / ".claude-mpm" / "sessions"
-            log_dir.mkdir(parents=True, exist_ok=True)
-            
-            timestamp = self.session_start.strftime("%Y%m%d_%H%M%S")
-            log_file = log_dir / f"session_{timestamp}.json"
-            
-            import json
-            session_data = {
-                "session_start": self.session_start.isoformat(),
-                "session_end": datetime.now().isoformat(),
-                "interactions": self.session_log,
-                # Ticket extraction removed from project
-            }
-            
-            with open(log_file, 'w') as f:
-                json.dump(session_data, f, indent=2)
-            
-            if self.log_level != "OFF":
-                self.logger.info(f"Session log saved to: {log_file}")
-                
-        except Exception as e:
-            self.logger.error(f"Failed to save session log: {e}")
-    
-    # _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."""
-        # For non-interactive, fall back to simple 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/simple_orchestrator.py

@@ -1,82 +0,0 @@
-"""Simple orchestrator using Claude's print mode."""
-
-import json
-from pathlib import Path
-from typing import Optional
-from datetime import datetime
-
-try:
-    from ..utils.subprocess_runner import SubprocessRunner
-except ImportError:
-    from utils.subprocess_runner import SubprocessRunner
-
-class SimpleOrchestrator:
-    """Orchestrator that uses Claude's print mode for each interaction."""
-    
-    def __init__(self, framework_loader, log_level="OFF"):
-        self.framework_loader = framework_loader
-        self.log_level = log_level
-        self.conversation_id = None
-        self.framework_injected = False
-        self.subprocess_runner = SubprocessRunner()
-        
-    def send_message(self, message: str) -> str:
-        """Send a message to Claude and get response."""
-        
-        # Prepare the full message
-        if not self.framework_injected:
-            # First message includes framework
-            framework = self.framework_loader.get_framework_instructions()
-            full_message = framework + "\n\nUser: " + message
-            self.framework_injected = True
-        else:
-            full_message = message
-        
-        # Build command
-        cmd = [
-            "claude",
-            "--model", "opus",
-            "--dangerously-skip-permissions",
-            "--print",  # Print mode
-            full_message
-        ]
-        
-        # If we have a conversation ID, continue it
-        if self.conversation_id:
-            cmd.extend(["--conversation", self.conversation_id])
-        
-        # Run Claude
-        result = self.subprocess_runner.run(cmd)
-        
-        if not result.success:
-            raise Exception(f"Claude failed: {result.stderr}")
-        
-        # Extract conversation ID from output if needed
-        # (Claude might output this in stderr or in a specific format)
-        
-        return result.stdout
-    
-    def run_interactive(self):
-        """Run interactive session using multiple print calls."""
-        print("Claude MPM Session (Print Mode)")
-        print("Type 'exit' to quit")
-        print("-" * 50)
-        
-        while True:
-            try:
-                user_input = input("\nYou: ").strip()
-                if user_input.lower() in ['exit', 'quit']:
-                    break
-                    
-                if user_input:
-                    print("\nClaude: ", end='', flush=True)
-                    response = self.send_message(user_input)
-                    print(response)
-                    
-            except KeyboardInterrupt:
-                break
-            except Exception as e:
-                print(f"\nError: {e}")
-                break
-        
-        print("\nSession ended")