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

claude_mpm/utils/dependency_manager.py

@@ -11,9 +11,7 @@ that's running claude-mpm, respecting virtual environments and user setups.
 
 import subprocess
 import sys
-import importlib
-from typing import List, Tuple, Optional
-from pathlib import Path
+from typing import List, Optional, Tuple
 
 from ..core.logger import get_logger
 
@@ -21,25 +19,26 @@ from ..core.logger import get_logger
 def check_dependency(package_name: str, import_name: Optional[str] = None) -> bool:
     """
     Check if a Python package is installed and importable.
-    
+
     WHY: We need to verify if optional dependencies are available before
     attempting to use them. This prevents ImportError crashes.
-    
+
     DESIGN DECISION: We use importlib.util.find_spec() which is more reliable
     than try/except import because it doesn't execute module code.
-    
+
     Args:
         package_name: Name of the package (e.g., 'python-socketio')
         import_name: Name to import (e.g., 'socketio'). Defaults to package_name.
-        
+
     Returns:
         bool: True if package is available, False otherwise
     """
     if import_name is None:
-        import_name = package_name.replace('-', '_')
-    
+        import_name = package_name.replace("-", "_")
+
     try:
         import importlib.util
+
         spec = importlib.util.find_spec(import_name)
         return spec is not None
     except (ImportError, ModuleNotFoundError, ValueError):
@@ -49,50 +48,50 @@ def check_dependency(package_name: str, import_name: Optional[str] = None) -> bo
 def install_packages(packages: List[str], logger=None) -> Tuple[bool, str]:
     """
     Install Python packages using pip in the current environment.
-    
+
     WHY: Users should not need to manually install optional dependencies.
     This function handles automatic installation while respecting the current
     Python environment (including virtual environments).
-    
+
     DESIGN DECISION: We use subprocess to call pip instead of importlib
     because pip installation needs to be done in the same environment
     that's running the application.
-    
+
     Args:
         packages: List of package names to install
         logger: Optional logger for output
-        
+
     Returns:
         Tuple[bool, str]: (success, error_message_if_failed)
     """
     if logger is None:
         logger = get_logger("dependency_manager")
-    
+
     try:
         # Use the same Python executable that's running this script
-        cmd = [sys.executable, "-m", "pip", "install"] + packages
-        
+        cmd = [sys.executable, "-m", "pip", "install", *packages]
+
         logger.info(f"Installing packages: {packages}")
         logger.debug(f"Running command: {' '.join(cmd)}")
-        
+
         # Run pip install with proper error handling
         result = subprocess.run(
             cmd,
             capture_output=True,
             text=True,
-            timeout=300  # 5 minute timeout for installation
+            timeout=300,
+            check=False,  # 5 minute timeout for installation
         )
-        
+
         if result.returncode == 0:
             logger.info(f"Successfully installed packages: {packages}")
             return True, ""
-        else:
-            error_msg = f"pip install failed with return code {result.returncode}"
-            if result.stderr:
-                error_msg += f": {result.stderr.strip()}"
-            logger.error(error_msg)
-            return False, error_msg
-            
+        error_msg = f"pip install failed with return code {result.returncode}"
+        if result.stderr:
+            error_msg += f": {result.stderr.strip()}"
+        logger.error(error_msg)
+        return False, error_msg
+
     except subprocess.TimeoutExpired:
         error_msg = "Package installation timed out after 5 minutes"
         logger.error(error_msg)
@@ -106,70 +105,73 @@ def install_packages(packages: List[str], logger=None) -> Tuple[bool, str]:
 def ensure_socketio_dependencies(logger=None) -> Tuple[bool, str]:
     """
     Ensure Socket.IO dependencies are installed for monitoring features.
-    
+
     WHY: Socket.IO dependencies (python-socketio, aiohttp, python-engineio) are now
     core dependencies and should be installed automatically with claude-mpm.
     This function verifies they are available and provides helpful error messages
     if something went wrong during installation.
-    
+
     DESIGN DECISION: We still check each dependency individually to provide
     specific error messages if any are missing, which helps with troubleshooting
     installation issues.
-    
+
     Args:
         logger: Optional logger for output
-        
+
     Returns:
         Tuple[bool, str]: (success, error_message_if_failed)
     """
     if logger is None:
         logger = get_logger("dependency_manager")
-    
+
     # Define required packages for Socket.IO monitoring
     required_packages = [
         ("python-socketio", "socketio"),
         ("aiohttp", "aiohttp"),
-        ("python-engineio", "engineio")
+        ("python-engineio", "engineio"),
     ]
-    
+
     missing_packages = []
-    
+
     # Check which packages are missing
     for package_name, import_name in required_packages:
         if not check_dependency(package_name, import_name):
             missing_packages.append(package_name)
             logger.debug(f"Missing dependency: {package_name}")
-    
+
     if not missing_packages:
         logger.debug("All Socket.IO dependencies are already installed")
         return True, ""
-    
+
     # Install missing packages (should be rare since they're now core dependencies)
-    logger.warning(f"Socket.IO dependencies are missing despite being core dependencies: {missing_packages}")
+    logger.warning(
+        f"Socket.IO dependencies are missing despite being core dependencies: {missing_packages}"
+    )
     logger.info(f"Attempting to install missing dependencies: {missing_packages}")
     success, error_msg = install_packages(missing_packages, logger)
-    
+
     if success:
         # Verify installation worked
         for package_name, import_name in required_packages:
             if not check_dependency(package_name, import_name):
-                error_msg = f"Package {package_name} was installed but is not importable"
+                error_msg = (
+                    f"Package {package_name} was installed but is not importable"
+                )
                 logger.error(error_msg)
                 return False, error_msg
-        
+
         logger.info("Socket.IO dependencies installed and verified successfully")
         return True, ""
-    else:
-        return False, error_msg
+    return False, error_msg
 
 
 def get_pip_freeze_output() -> List[str]:
     """
     Get the output of 'pip freeze' for debugging dependency issues.
-    
+
     WHY: When dependency installation fails, we need to help users
     understand what packages are installed and what might be conflicting.
-    
+
     Returns:
         List[str]: List of installed packages from pip freeze
     """
@@ -178,14 +180,14 @@ def get_pip_freeze_output() -> List[str]:
             [sys.executable, "-m", "pip", "freeze"],
             capture_output=True,
             text=True,
-            timeout=30
+            timeout=30,
+            check=False,
         )
-        
+
         if result.returncode == 0:
-            return result.stdout.strip().split('\n')
-        else:
-            return [f"pip freeze failed: {result.stderr}"]
-            
+            return result.stdout.strip().split("\n")
+        return [f"pip freeze failed: {result.stderr}"]
+
     except Exception as e:
         return [f"Failed to get pip freeze output: {e}"]
 
@@ -193,22 +195,21 @@ def get_pip_freeze_output() -> List[str]:
 def check_virtual_environment() -> Tuple[bool, str]:
     """
     Check if we're running in a virtual environment.
-    
+
     WHY: Installation behavior might differ between virtual environments
     and system Python. This helps with debugging and user guidance.
-    
+
     Returns:
         Tuple[bool, str]: (is_virtual_env, environment_info)
     """
     # Check for virtual environment indicators
     in_venv = (
-        hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix
-        or hasattr(sys, 'real_prefix')
-        or (hasattr(sys, 'prefix') and 'conda' in sys.prefix.lower())
+        (hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix)
+        or hasattr(sys, "real_prefix")
+        or (hasattr(sys, "prefix") and "conda" in sys.prefix.lower())
     )
-    
+
     if in_venv:
-        venv_path = getattr(sys, 'prefix', 'unknown')
+        venv_path = getattr(sys, "prefix", "unknown")
         return True, f"Virtual environment: {venv_path}"
-    else:
-        return False, f"System Python: {sys.prefix}"
+    return False, f"System Python: {sys.prefix}"

claude_mpm/utils/dependency_strategies.py

@@ -0,0 +1,381 @@
+from pathlib import Path
+
+"""
+Dependency management strategies for different contexts.
+
+This module provides smart dependency checking and installation strategies
+based on the execution context and user preferences.
+"""
+
+import json
+import os
+import sys
+from datetime import datetime, timedelta, timezone
+from enum import Enum
+from typing import Any, Dict, Optional, Tuple
+
+from ..core.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class DependencyMode(Enum):
+    """Dependency checking and installation modes."""
+
+    OFF = "off"  # No checking at all
+    CHECK = "check"  # Check and warn only
+    INTERACTIVE = "interactive"  # Prompt user for installation
+    AUTO = "auto"  # Automatically install missing deps
+    LAZY = "lazy"  # Check only when agent is invoked
+
+
+class DependencyStrategy:
+    """
+    Smart dependency management based on context and preferences.
+
+    This class determines the appropriate dependency strategy based on:
+    - Execution environment (CI, Docker, TTY, etc.)
+    - User configuration
+    - Cached check results
+    - Command being executed
+    """
+
+    def __init__(self, config_path: Optional[Path] = None):
+        """
+        Initialize dependency strategy manager.
+
+        Args:
+            config_path: Optional path to configuration file
+        """
+        self.config_path = config_path or Path.home() / ".claude-mpm" / "config.yaml"
+        self.cache_path = Path.home() / ".claude-mpm" / ".dep_cache.json"
+        self.mode = self._determine_mode()
+
+    def _determine_mode(self) -> DependencyMode:
+        """
+        Determine the appropriate dependency mode based on context.
+
+        Returns:
+            The dependency mode to use
+        """
+        # Check environment variable override
+        env_mode = os.environ.get("CLAUDE_MPM_DEP_MODE")
+        if env_mode:
+            try:
+                return DependencyMode(env_mode.lower())
+            except ValueError:
+                logger.warning(f"Invalid CLAUDE_MPM_DEP_MODE: {env_mode}")
+
+        # Check if in CI environment
+        if self._is_ci_environment():
+            logger.debug("CI environment detected - using CHECK mode")
+            return DependencyMode.CHECK
+
+        # Check if in Docker container
+        if self._is_docker():
+            logger.debug("Docker environment detected - using CHECK mode")
+            return DependencyMode.CHECK
+
+        # Check if non-interactive terminal
+        if not self._is_interactive():
+            logger.debug("Non-interactive terminal - using CHECK mode")
+            return DependencyMode.CHECK
+
+        # Load user configuration
+        user_mode = self._load_user_preference()
+        if user_mode:
+            return user_mode
+
+        # Default to interactive for TTY sessions
+        return DependencyMode.INTERACTIVE
+
+    def _is_ci_environment(self) -> bool:
+        """Check if running in CI environment."""
+        ci_indicators = [
+            "CI",
+            "CONTINUOUS_INTEGRATION",
+            "JENKINS",
+            "TRAVIS",
+            "CIRCLECI",
+            "GITHUB_ACTIONS",
+            "GITLAB_CI",
+            "BUILDKITE",
+        ]
+        return any(os.environ.get(var) for var in ci_indicators)
+
+    def _is_docker(self) -> bool:
+        """Check if running inside Docker container."""
+        return (
+            Path("/.dockerenv").exists()
+            or os.environ.get("KUBERNETES_SERVICE_HOST") is not None
+        )
+
+    def _is_interactive(self) -> bool:
+        """Check if running in interactive terminal."""
+        return sys.stdin.isatty() and sys.stdout.isatty()
+
+    def _load_user_preference(self) -> Optional[DependencyMode]:
+        """
+        Load user preference from config file.
+
+        Returns:
+            User's preferred dependency mode or None
+        """
+        if not self.config_path.exists():
+            return None
+
+        try:
+            # Try to load YAML config
+            import yaml
+
+            with self.config_path.open() as f:
+                config = yaml.safe_load(f)
+                mode_str = config.get("dependency_mode")
+                if mode_str:
+                    return DependencyMode(mode_str)
+        except Exception as e:
+            logger.debug(f"Could not load config: {e}")
+
+        return None
+
+    def should_check_now(self, cache_ttl: int = 86400) -> bool:
+        """
+        Determine if dependency check should run now based on cache.
+
+        Args:
+            cache_ttl: Cache time-to-live in seconds (default 24 hours)
+
+        Returns:
+            True if check should run, False if cached results are fresh
+        """
+        if self.mode == DependencyMode.OFF:
+            return False
+
+        if not self.cache_path.exists():
+            return True
+
+        try:
+            with self.cache_path.open() as f:
+                cache = json.load(f)
+                last_check = datetime.fromisoformat(cache.get("timestamp", ""))
+
+                # Check if cache is still valid
+                if datetime.now(timezone.utc) - last_check < timedelta(
+                    seconds=cache_ttl
+                ):
+                    logger.debug(f"Using cached dependency check from {last_check}")
+                    return False
+
+        except Exception as e:
+            logger.debug(f"Cache invalid or corrupted: {e}")
+
+        return True
+
+    def cache_results(self, results: Dict[str, Any]) -> None:
+        """
+        Cache dependency check results.
+
+        Args:
+            results: Dependency check results to cache
+        """
+        try:
+            self.cache_path.parent.mkdir(parents=True, exist_ok=True)
+
+            cache_data = {
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "results": results,
+            }
+
+            with self.cache_path.open("w") as f:
+                json.dump(cache_data, f, indent=2)
+
+            logger.debug(f"Cached dependency results to {self.cache_path}")
+
+        except Exception as e:
+            logger.warning(f"Failed to cache results: {e}")
+
+    def get_cached_results(self) -> Optional[Dict[str, Any]]:
+        """
+        Get cached dependency check results if available.
+
+        Returns:
+            Cached results or None
+        """
+        if not self.cache_path.exists():
+            return None
+
+        try:
+            with self.cache_path.open() as f:
+                cache = json.load(f)
+                return cache.get("results")
+        except Exception:
+            return None
+
+    def prompt_for_installation(self, missing_deps: list) -> str:
+        """
+        Prompt user for dependency installation preference.
+
+        Args:
+            missing_deps: List of missing dependencies
+
+        Returns:
+            User's choice: 'yes', 'no', 'always', 'never'
+        """
+        if not self._is_interactive():
+            return "no"
+
+        print(f"\n⚠️  Missing {len(missing_deps)} dependencies:")
+        for dep in missing_deps[:5]:  # Show first 5
+            print(f"  - {dep}")
+        if len(missing_deps) > 5:
+            print(f"  ... and {len(missing_deps) - 5} more")
+
+        while True:
+            sys.stdout.flush()  # Ensure prompt is displayed before input
+
+            # Check if we're in a TTY environment for proper input handling
+            if not sys.stdin.isatty():
+                # In non-TTY environment (like pipes), use readline
+                print(
+                    "\nInstall missing dependencies? [y/N/always/never]: ",
+                    end="",
+                    flush=True,
+                )
+                try:
+                    response = sys.stdin.readline().strip().lower()
+                    # Handle various line endings and control characters
+                    response = response.replace("\r", "").replace("\n", "").strip()
+                except (EOFError, KeyboardInterrupt):
+                    response = "n"
+            else:
+                # In TTY environment, use normal input()
+                try:
+                    response = (
+                        input("\nInstall missing dependencies? [y/N/always/never]: ")
+                        .lower()
+                        .strip()
+                    )
+                except (EOFError, KeyboardInterrupt):
+                    response = "n"
+
+            if response in ["y", "yes"]:
+                return "yes"
+            if response in ["n", "no", ""]:
+                return "no"
+            if response == "always":
+                self._save_preference(DependencyMode.AUTO)
+                return "yes"
+            if response == "never":
+                self._save_preference(DependencyMode.OFF)
+                return "no"
+            print("Invalid choice. Please enter: y, n, always, or never")
+
+    def _save_preference(self, mode: DependencyMode) -> None:
+        """
+        Save user's dependency mode preference.
+
+        Args:
+            mode: The dependency mode to save
+        """
+        try:
+            self.config_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Load existing config or create new
+            config = {}
+            if self.config_path.exists():
+                import yaml
+
+                with self.config_path.open() as f:
+                    config = yaml.safe_load(f) or {}
+
+            # Update dependency mode
+            config["dependency_mode"] = mode.value
+
+            # Save config
+            import yaml
+
+            with self.config_path.open("w") as f:
+                yaml.dump(config, f, default_flow_style=False)
+
+            print(f"✓ Saved preference: {mode.value}")
+
+        except Exception as e:
+            logger.error(f"Failed to save preference: {e}")
+
+
+def get_smart_dependency_handler(
+    command: Optional[str] = None,
+) -> Tuple[DependencyMode, DependencyStrategy]:
+    """
+    Get the appropriate dependency handler for the current context.
+
+    Args:
+        command: The command being executed (e.g., 'run', 'agents')
+
+    Returns:
+        Tuple of (mode, strategy) to use
+    """
+    strategy = DependencyStrategy()
+
+    # Override for specific commands
+    if command == "agents" and "deps-" in str(sys.argv):
+        # If running agents deps-* commands, don't check automatically
+        return (DependencyMode.OFF, strategy)
+
+    # Quick commands shouldn't check dependencies
+    quick_commands = ["help", "version", "info", "tickets"]
+    if command in quick_commands:
+        return (DependencyMode.OFF, strategy)
+
+    return (strategy.mode, strategy)
+
+
+def lazy_check_agent_dependency(agent_id: str) -> bool:
+    """
+    Lazily check dependencies when a specific agent is invoked.
+
+    Args:
+        agent_id: The agent being invoked
+
+    Returns:
+        True if dependencies are satisfied or installed, False otherwise
+    """
+    from .agent_dependency_loader import AgentDependencyLoader
+
+    logger.debug(f"Lazy checking dependencies for agent: {agent_id}")
+
+    loader = AgentDependencyLoader(auto_install=False)
+    loader.discover_deployed_agents()
+
+    # Only check the specific agent
+    if agent_id not in loader.deployed_agents:
+        return True  # Agent not deployed, no deps to check
+
+    loader.deployed_agents = {agent_id: loader.deployed_agents[agent_id]}
+    loader.load_agent_dependencies()
+    results = loader.analyze_dependencies()
+
+    agent_results = results["agents"].get(agent_id, {})
+    missing = agent_results.get("python", {}).get("missing", [])
+
+    if not missing:
+        return True
+
+    # Get strategy for handling missing deps
+    strategy = DependencyStrategy()
+
+    if strategy.mode == DependencyMode.AUTO:
+        logger.info(f"Auto-installing {len(missing)} dependencies for {agent_id}")
+        success, _ = loader.install_missing_dependencies(missing)
+        return success
+
+    if strategy.mode == DependencyMode.INTERACTIVE:
+        choice = strategy.prompt_for_installation(missing)
+        if choice in ["yes"]:
+            success, _ = loader.install_missing_dependencies(missing)
+            return success
+        return False
+
+    # CHECK or OFF
+    logger.warning(f"Agent {agent_id} missing {len(missing)} dependencies")
+    return False  # Proceed anyway