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

claude_mpm/dashboard/open_dashboard.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-"""Open the dashboard statically in the browser."""
-
-import os
-import webbrowser
-from pathlib import Path
-
-def open_dashboard(port=8765, autoconnect=True):
-    """Open the dashboard HTML file directly in the browser.
-    
-    Args:
-        port: Socket.IO server port to connect to
-        autoconnect: Whether to auto-connect on load
-    """
-    # Get the static index.html path (main entry point)
-    dashboard_path = Path(__file__).parent / "templates" / "index.html"
-    
-    if not dashboard_path.exists():
-        raise FileNotFoundError(f"Dashboard not found at {dashboard_path}")
-    
-    # Build URL with query parameters for Socket.IO connection
-    dashboard_url = f"file://{dashboard_path.absolute()}?port={port}"
-    if autoconnect:
-        dashboard_url += "&autoconnect=true"
-    
-    print(f"🌐 Opening static dashboard: {dashboard_url}")
-    print(f"📡 Dashboard will connect to Socket.IO server at localhost:{port}")
-    webbrowser.open(dashboard_url)
-    
-    return dashboard_url
-
-if __name__ == "__main__":
-    # Test opening the dashboard
-    open_dashboard()

claude_mpm/deployment_paths.py

@@ -1,261 +0,0 @@
-"""
-Deployment path management for Claude MPM.
-
-WHY: Using relative parent traversal (e.g., Path(__file__).parent.parent.parent) is fragile
-and breaks when files are moved or during different deployment scenarios (pip install,
-development, packaged distribution). This module provides centralized path resolution
-that works across all deployment scenarios.
-
-DESIGN DECISION: We detect the deployment context and provide consistent paths regardless
-of how the package is installed or run. This includes:
-- Development mode (running from source)
-- Pip installed packages
-- Packaged distributions
-- Test environments
-"""
-
-import os
-import sys
-from pathlib import Path
-from typing import Optional, Dict
-from functools import lru_cache
-
-
-class DeploymentPaths:
-    """Manages paths for different deployment scenarios."""
-    
-    def __init__(self):
-        self._package_root: Optional[Path] = None
-        self._project_root: Optional[Path] = None
-        self._scripts_dir: Optional[Path] = None
-        self._templates_dir: Optional[Path] = None
-        self._static_dir: Optional[Path] = None
-        
-    @property
-    @lru_cache(maxsize=1)
-    def package_root(self) -> Path:
-        """
-        Get the claude_mpm package root directory.
-        
-        WHY: We need to reliably find the package root regardless of which
-        module is calling this function.
-        
-        Returns:
-            Path to the claude_mpm package directory (src/claude_mpm)
-        """
-        if self._package_root:
-            return self._package_root
-            
-        # Try to find the package root by looking for __init__.py
-        current_file = Path(__file__).resolve()
-        
-        # Walk up until we find the claude_mpm package root
-        current = current_file.parent
-        while current != current.parent:
-            if (current.name == "claude_mpm" and 
-                (current / "__init__.py").exists()):
-                self._package_root = current
-                return current
-            current = current.parent
-            
-        # Fallback: assume we're in claude_mpm already
-        self._package_root = current_file.parent
-        return self._package_root
-        
-    @property
-    @lru_cache(maxsize=1)
-    def project_root(self) -> Path:
-        """
-        Get the project root directory.
-        
-        WHY: The project root contains configuration files, scripts directory,
-        and other project-level resources that aren't part of the package.
-        
-        Returns:
-            Path to the project root directory
-        """
-        if self._project_root:
-            return self._project_root
-            
-        # Check if we're in a development environment
-        # In development, project root is typically 2 levels up from package root
-        package = self.package_root
-        
-        # Look for indicators of project root
-        candidates = [
-            package.parent.parent,  # src/claude_mpm -> src -> project_root
-            package.parent,         # claude_mpm -> project_root (if no src/)
-        ]
-        
-        for candidate in candidates:
-            # Check for project indicators
-            if any((candidate / marker).exists() for marker in [
-                "pyproject.toml", "setup.py", "setup.cfg", 
-                ".git", "README.md", "scripts/claude-mpm"
-            ]):
-                self._project_root = candidate
-                return candidate
-                
-        # Fallback to package parent
-        self._project_root = package.parent
-        return self._project_root
-        
-    @property
-    def scripts_dir(self) -> Path:
-        """
-        Get the scripts directory path.
-        
-        WHY: Scripts can be in different locations depending on deployment:
-        - Development: project_root/scripts
-        - Package: claude_mpm/scripts
-        
-        Returns:
-            Path to the scripts directory
-        """
-        if self._scripts_dir:
-            return self._scripts_dir
-            
-        # First try package scripts (for deployed packages)
-        package_scripts = self.package_root / "scripts"
-        if package_scripts.exists():
-            self._scripts_dir = package_scripts
-            return package_scripts
-            
-        # Then try project scripts (for development)
-        project_scripts = self.project_root / "scripts"
-        if project_scripts.exists():
-            self._scripts_dir = project_scripts
-            return project_scripts
-            
-        # Default to package scripts even if it doesn't exist yet
-        self._scripts_dir = package_scripts
-        return package_scripts
-        
-    @property
-    def templates_dir(self) -> Path:
-        """Get the agent templates directory."""
-        if not self._templates_dir:
-            self._templates_dir = self.package_root / "agents" / "templates"
-        return self._templates_dir
-        
-    @property
-    def static_dir(self) -> Path:
-        """Get the static files directory (HTML, CSS, etc)."""
-        if not self._static_dir:
-            # Static files are in package scripts directory
-            self._static_dir = self.package_root / "scripts"
-        return self._static_dir
-        
-    def get_monitor_html_path(self) -> Path:
-        """
-        Get the path to the monitor HTML file.
-        
-        WHY: The monitor HTML can be in different locations depending on
-        deployment context. We now prioritize the new modular web structure.
-        
-        Returns:
-            Path to the monitor HTML file
-        """
-        # Try multiple locations in order of preference
-        candidates = [
-            # New modular structure (preferred)
-            self.package_root / "web" / "templates" / "index.html",
-            self.package_root / "web" / "templates" / "dashboard.html",  # fallback
-            self.package_root / "web" / "index.html",  # root web index
-            # Legacy locations (for backward compatibility)
-            self.static_dir / "claude_mpm_monitor.html",
-            self.scripts_dir / "claude_mpm_monitor.html",
-            self.project_root / "scripts" / "claude_mpm_monitor.html",
-        ]
-        
-        for candidate in candidates:
-            if candidate.exists():
-                return candidate
-                
-        # Return the preferred new location even if it doesn't exist
-        # This allows better error messages and encourages proper structure
-        return self.package_root / "web" / "templates" / "index.html"
-        
-    def get_resource_path(self, resource_type: str, filename: str) -> Path:
-        """
-        Get path to a resource file.
-        
-        Args:
-            resource_type: Type of resource (scripts, templates, static, etc)
-            filename: Name of the file
-            
-        Returns:
-            Path to the resource
-        """
-        resource_dirs = {
-            "scripts": self.scripts_dir,
-            "templates": self.templates_dir,
-            "static": self.static_dir,
-            "agents": self.package_root / "agents",
-        }
-        
-        base_dir = resource_dirs.get(resource_type, self.package_root)
-        return base_dir / filename
-        
-    def resolve_import_path(self, module_path: str) -> Path:
-        """
-        Resolve a module import path to a file path.
-        
-        Args:
-            module_path: Dot-separated module path (e.g., "claude_mpm.cli.commands.run")
-            
-        Returns:
-            Path to the module file
-        """
-        parts = module_path.split(".")
-        if parts[0] == "claude_mpm":
-            parts = parts[1:]  # Remove package name
-            
-        return self.package_root.joinpath(*parts).with_suffix(".py")
-        
-    def ensure_directory(self, path: Path) -> Path:
-        """Ensure a directory exists, creating it if necessary."""
-        path.mkdir(parents=True, exist_ok=True)
-        return path
-        
-    @classmethod
-    @lru_cache(maxsize=1)
-    def get_instance(cls) -> "DeploymentPaths":
-        """Get singleton instance of DeploymentPaths."""
-        return cls()
-
-
-# Convenience functions
-def get_deployment_paths() -> DeploymentPaths:
-    """Get the deployment paths instance."""
-    return DeploymentPaths.get_instance()
-
-
-def get_package_root() -> Path:
-    """Get the claude_mpm package root directory."""
-    return get_deployment_paths().package_root
-
-
-def get_project_root() -> Path:
-    """Get the project root directory."""
-    return get_deployment_paths().project_root
-
-
-def get_scripts_dir() -> Path:
-    """Get the scripts directory."""
-    return get_deployment_paths().scripts_dir
-
-
-def get_monitor_html_path() -> Path:
-    """Get the monitor HTML file path."""
-    return get_deployment_paths().get_monitor_html_path()
-
-
-def get_templates_dir() -> Path:
-    """Get the agent templates directory."""
-    return get_deployment_paths().templates_dir
-
-
-def get_resource_path(resource_type: str, filename: str) -> Path:
-    """Get path to a resource file."""
-    return get_deployment_paths().get_resource_path(resource_type, filename)

claude_mpm/hooks/builtin/__init__.py

@@ -1 +0,0 @@
-"""Built-in hooks for claude-mpm."""

claude_mpm/hooks/builtin/logging_hook_example.py

@@ -1,165 +0,0 @@
-#!/usr/bin/env python3
-"""
-Example logging hook for Claude MPM.
-
-This hook demonstrates how to capture and log all prompts and responses
-through the hook system, providing an alternative to built-in logging.
-"""
-
-import json
-import os
-from datetime import datetime
-from pathlib import Path
-from typing import Dict, Any, Optional
-
-# Configure your logging directory
-LOG_DIR = Path.home() / ".claude-mpm-hook-logs"
-LOG_DIR.mkdir(exist_ok=True)
-
-
-def execute_pre_delegation_hook(agent: str, context: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Log task details before delegation.
-    
-    Args:
-        agent: The agent being invoked
-        context: Contains 'task' and other context data
-    
-    Returns:
-        Empty dict (no modifications)
-    """
-    timestamp = datetime.now().isoformat()
-    log_entry = {
-        "timestamp": timestamp,
-        "event": "pre_delegation",
-        "agent": agent,
-        "task": context.get("task", ""),
-        "context": context
-    }
-    
-    # Write to daily log file
-    log_file = LOG_DIR / f"delegations_{datetime.now().strftime('%Y%m%d')}.jsonl"
-    with open(log_file, 'a') as f:
-        f.write(json.dumps(log_entry) + '\n')
-    
-    return {}
-
-
-def execute_post_delegation_hook(agent: str, result: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Log complete prompt and response after delegation.
-    
-    Args:
-        agent: The agent that was invoked
-        result: Contains task, response, execution_time, tokens
-    
-    Returns:
-        Empty dict (no modifications)
-    """
-    timestamp = datetime.now().isoformat()
-    
-    # Extract data
-    task = result.get("task", "")
-    response = result.get("response", "")
-    execution_time = result.get("execution_time", 0)
-    tokens = result.get("tokens", 0)
-    
-    # Create detailed log entry
-    log_entry = {
-        "timestamp": timestamp,
-        "event": "post_delegation",
-        "agent": agent,
-        "task": task,
-        "response_length": len(response),
-        "execution_time": execution_time,
-        "tokens": tokens,
-        "success": not response.startswith("Error:"),
-        "response_preview": response[:500] + "..." if len(response) > 500 else response
-    }
-    
-    # Write to agent-specific log
-    agent_log_dir = LOG_DIR / "agents" / agent.lower()
-    agent_log_dir.mkdir(parents=True, exist_ok=True)
-    
-    log_file = agent_log_dir / f"{datetime.now().strftime('%Y%m%d')}.jsonl"
-    with open(log_file, 'a') as f:
-        f.write(json.dumps(log_entry) + '\n')
-    
-    # Save full prompt/response if needed
-    if os.environ.get("CLAUDE_MPM_HOOK_LOG_FULL", "").lower() == "true":
-        # Create unique filename
-        task_hash = str(hash(task))[-8:]
-        prompt_file = agent_log_dir / f"prompt_{timestamp}_{task_hash}.txt"
-        response_file = agent_log_dir / f"response_{timestamp}_{task_hash}.txt"
-        
-        # Note: We don't have access to the original prompt in post-delegation
-        # To capture prompts, you'd need to store them in pre-delegation
-        # and match them up using task hash or similar
-        
-        response_file.write_text(response)
-        
-        log_entry["response_file"] = str(response_file)
-    
-    return {}
-
-
-def execute_submit_hook(prompt: str, session_type: str) -> Dict[str, Any]:
-    """
-    Log user prompts at session start.
-    
-    Args:
-        prompt: The user's input prompt
-        session_type: Type of session (e.g., "subprocess")
-    
-    Returns:
-        Empty dict (no modifications)
-    """
-    timestamp = datetime.now().isoformat()
-    log_entry = {
-        "timestamp": timestamp,
-        "event": "user_submit",
-        "session_type": session_type,
-        "prompt": prompt,
-        "prompt_length": len(prompt)
-    }
-    
-    # Write to session log
-    log_file = LOG_DIR / f"sessions_{datetime.now().strftime('%Y%m%d')}.jsonl"
-    with open(log_file, 'a') as f:
-        f.write(json.dumps(log_entry) + '\n')
-    
-    print(f"[Logging Hook] Logged user prompt to {log_file}")
-    
-    return {}
-
-
-# Optional: Hook metadata for registration
-HOOK_METADATA = {
-    "name": "logging_hook",
-    "description": "Comprehensive logging of all prompts and responses",
-    "version": "1.0.0",
-    "author": "claude-mpm",
-    "events": ["pre_delegation", "post_delegation", "submit"],
-    "config": {
-        "log_dir": str(LOG_DIR),
-        "full_logging": os.environ.get("CLAUDE_MPM_HOOK_LOG_FULL", "false")
-    }
-}
-
-
-if __name__ == "__main__":
-    # Test the hook
-    print(f"Logging hook configured to write to: {LOG_DIR}")
-    print("Set CLAUDE_MPM_HOOK_LOG_FULL=true to save complete responses")
-    
-    # Example usage
-    execute_submit_hook("Test prompt", "test")
-    execute_pre_delegation_hook("Engineer", {"task": "Test task"})
-    execute_post_delegation_hook("Engineer", {
-        "task": "Test task",
-        "response": "Test response",
-        "execution_time": 1.5,
-        "tokens": 100
-    })
-    
-    print(f"\nCheck logs in: {LOG_DIR}")

claude_mpm/hooks/builtin/memory_hooks_example.py

@@ -1,67 +0,0 @@
-"""Example of how to register memory integration hooks.
-
-WHY: This demonstrates how to register the memory hooks with the HookService
-for automatic memory injection and learning extraction.
-"""
-
-from claude_mpm.hooks.memory_integration_hook import (
-    MemoryPreDelegationHook,
-    MemoryPostDelegationHook
-)
-from claude_mpm.services.hook_service import HookService
-from claude_mpm.core.config import Config
-
-
-def register_memory_hooks(hook_service: HookService, config: Config = None):
-    """Register memory integration hooks with the hook service.
-    
-    WHY: To enable automatic memory management, both hooks need to be
-    registered with appropriate priorities:
-    - Pre-hook runs early (priority 20) to inject memory into context
-    - Post-hook runs late (priority 80) to extract learnings after processing
-    
-    Args:
-        hook_service: The HookService instance to register with
-        config: Optional configuration (will create default if not provided)
-    """
-    config = config or Config()
-    
-    # Only register if memory system is enabled
-    if not config.get('memory.enabled', True):
-        return
-    
-    # Register pre-delegation hook for memory injection
-    pre_hook = MemoryPreDelegationHook(config)
-    hook_service.register_hook(pre_hook)
-    
-    # Register post-delegation hook for learning extraction
-    # Only if auto-learning is enabled
-    if config.get('memory.auto_learning', False):
-        post_hook = MemoryPostDelegationHook(config)
-        hook_service.register_hook(post_hook)
-
-
-# Example usage:
-if __name__ == "__main__":
-    # This would typically be done during application initialization
-    config = Config(config={
-        'memory': {
-            'enabled': True,
-            'auto_learning': True,
-            'limits': {
-                'default_size_kb': 8,
-                'max_items_per_section': 20
-            }
-        }
-    })
-    
-    # Create hook service (normally this would be passed from main app)
-    from claude_mpm.services.hook_service import HookService
-    hook_service = HookService(config)
-    
-    # Register memory hooks
-    register_memory_hooks(hook_service, config)
-    
-    print("Memory hooks registered successfully!")
-    print(f"Pre-delegation hook: {hook_service.get_hooks('pre_delegation')}")
-    print(f"Post-delegation hook: {hook_service.get_hooks('post_delegation')}")

claude_mpm/hooks/builtin/mpm_command_hook.py

@@ -1,125 +0,0 @@
-"""Hook to intercept and handle /mpm: commands."""
-
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-from claude_mpm.hooks.base_hook import SubmitHook, HookContext, HookResult
-from claude_mpm.core.logger import get_logger
-
-logger = get_logger(__name__)
-
-
-class MpmCommandHook(SubmitHook):
-    """Hook that intercepts /mpm commands and routes them to the command router."""
-    
-    def __init__(self):
-        super().__init__(name="mpm_command", priority=1)  # High priority to intercept early
-        self.command_prefix = "/mpm "
-        self.command_router_path = self._find_command_router()
-    
-    def _find_command_router(self) -> Path:
-        """Find the command router script."""
-        # Look for command router relative to project root
-        possible_paths = [
-            Path(".claude/scripts/command_router.py"),
-            Path(__file__).parent.parent.parent.parent.parent / ".claude/scripts/command_router.py"
-        ]
-        
-        for path in possible_paths:
-            if path.exists():
-                return path.resolve()
-        
-        # Default path
-        return Path(".claude/scripts/command_router.py").resolve()
-    
-    def execute(self, context: HookContext) -> HookResult:
-        """Check for /mpm commands and execute them directly."""
-        try:
-            prompt = context.data.get('prompt', '').strip()
-            
-            # Check if this is an /mpm command
-            if not prompt.startswith(self.command_prefix):
-                # Not our command, pass through
-                return HookResult(
-                    success=True,
-                    data=context.data,
-                    modified=False
-                )
-            
-            # Extract command and arguments
-            command_line = prompt[len(self.command_prefix):].strip()
-            parts = command_line.split()
-            
-            if not parts:
-                return HookResult(
-                    success=True,
-                    data={
-                        'prompt': '',
-                        'response': "No command specified. Available commands: test",
-                        'skip_llm': True
-                    },
-                    modified=True,
-                    metadata={'command_handled': True}
-                )
-            
-            command = parts[0]
-            args = parts[1:]
-            
-            logger.info(f"Executing /mpm {command} with args: {args}")
-            
-            # Execute command using command router
-            try:
-                # Run the command router script
-                cmd = [sys.executable, str(self.command_router_path), command] + args
-                result = subprocess.run(
-                    cmd,
-                    capture_output=True,
-                    text=True,
-                    check=False
-                )
-                
-                if result.returncode == 0:
-                    response = result.stdout.strip()
-                else:
-                    response = f"Command failed: {result.stderr.strip() or 'Unknown error'}"
-                
-                logger.info(f"Command result: {response}")
-                
-                # Return result without going to LLM
-                return HookResult(
-                    success=True,
-                    data={
-                        'prompt': '',  # Clear prompt to prevent LLM processing
-                        'response': response,
-                        'skip_llm': True  # Flag to skip LLM
-                    },
-                    modified=True,
-                    metadata={
-                        'command_handled': True,
-                        'command': command,
-                        'args': args
-                    }
-                )
-                
-            except Exception as e:
-                logger.error(f"Failed to execute command: {e}")
-                return HookResult(
-                    success=True,
-                    data={
-                        'prompt': '',
-                        'response': f"Error executing command: {str(e)}",
-                        'skip_llm': True
-                    },
-                    modified=True,
-                    metadata={'command_error': str(e)}
-                )
-                
-        except Exception as e:
-            logger.error(f"MPM command hook failed: {e}")
-            # On error, pass through to normal processing
-            return HookResult(
-                success=False,
-                error=str(e)
-            )