claude-mpm 3.5.4__py3-none-any.whl → 3.6.0__py3-none-any.whl

claude_mpm/utils/dependency_strategies.py

@@ -0,0 +1,343 @@
+"""
+Dependency management strategies for different contexts.
+
+This module provides smart dependency checking and installation strategies
+based on the execution context and user preferences.
+"""
+
+import os
+import sys
+import time
+import json
+from pathlib import Path
+from typing import Optional, Dict, Any, Tuple
+from enum import Enum
+from datetime import datetime, timedelta
+
+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 (
+            os.path.exists("/.dockerenv") 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 open(self.config_path) 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 open(self.cache_path) as f:
+                cache = json.load(f)
+                last_check = datetime.fromisoformat(cache.get("timestamp", ""))
+                
+                # Check if cache is still valid
+                if datetime.now() - 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().isoformat(),
+                "results": results
+            }
+            
+            with open(self.cache_path, '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 open(self.cache_path) 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:
+            response = input("\nInstall missing dependencies? [y/N/always/never]: ").lower().strip()
+            
+            if response in ['y', 'yes']:
+                return 'yes'
+            elif response in ['n', 'no', '']:
+                return 'no'
+            elif response == 'always':
+                self._save_preference(DependencyMode.AUTO)
+                return 'yes'
+            elif response == 'never':
+                self._save_preference(DependencyMode.OFF)
+                return 'no'
+            else:
+                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 open(self.config_path) as f:
+                    config = yaml.safe_load(f) or {}
+            
+            # Update dependency mode
+            config['dependency_mode'] = mode.value
+            
+            # Save config
+            import yaml
+            with open(self.config_path, '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
+        
+    elif strategy.mode == DependencyMode.INTERACTIVE:
+        choice = strategy.prompt_for_installation(missing)
+        if choice in ['yes']:
+            success, _ = loader.install_missing_dependencies(missing)
+            return success
+        return False
+        
+    else:  # CHECK or OFF
+        logger.warning(f"Agent {agent_id} missing {len(missing)} dependencies")
+        return False  # Proceed anyway

claude_mpm/utils/environment_context.py

@@ -0,0 +1,310 @@
+"""
+Environment context detection for smart dependency checking.
+
+This module determines the execution environment and whether interactive
+prompting is appropriate for dependency installation.
+"""
+
+import os
+import sys
+from typing import Dict, Tuple
+import logging
+
+from ..core.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class EnvironmentContext:
+    """
+    Detects and analyzes the execution environment.
+    
+    WHY: We need to know if we're in an environment where prompting makes sense.
+    Interactive prompting should only happen in TTY environments where a human
+    is present. CI/CD, Docker, and non-interactive contexts should skip prompts.
+    
+    DESIGN DECISION: Use multiple indicators to detect environment type:
+    - TTY presence is the primary indicator for interactivity
+    - Environment variables help identify CI/CD and containerized environments
+    - Command-line flags can override automatic detection
+    """
+    
+    # Known CI environment variables
+    CI_ENV_VARS = [
+        'CI', 'CONTINUOUS_INTEGRATION', 'GITHUB_ACTIONS', 
+        'GITLAB_CI', 'JENKINS', 'TRAVIS', 'CIRCLECI',
+        'BUILDKITE', 'DRONE', 'TEAMCITY_VERSION', 'TF_BUILD',
+        'CODEBUILD_BUILD_ID', 'BITBUCKET_BUILD_NUMBER'
+    ]
+    
+    # Docker/container indicators
+    CONTAINER_INDICATORS = [
+        '/.dockerenv',  # Docker creates this file
+        '/run/.containerenv',  # Podman creates this file
+    ]
+    
+    @classmethod
+    def detect_execution_context(cls) -> Dict[str, bool]:
+        """
+        Detect the current execution context.
+        
+        Returns:
+            Dictionary with context indicators:
+            - is_tty: True if running in a terminal with TTY
+            - is_ci: True if running in CI/CD environment
+            - is_docker: True if running inside Docker container
+            - is_interactive: True if interactive prompting is possible
+            - is_automated: True if running in automated context (CI or scheduled)
+        """
+        context = {
+            'is_tty': cls._detect_tty(),
+            'is_ci': cls._detect_ci(),
+            'is_docker': cls._detect_docker(),
+            'is_interactive': False,
+            'is_automated': False,
+            'is_jupyter': cls._detect_jupyter(),
+            'is_ssh': cls._detect_ssh()
+        }
+        
+        # Determine if we're in an automated context
+        context['is_automated'] = context['is_ci'] or cls._detect_automated()
+        
+        # Interactive if TTY is available and not in automated context
+        context['is_interactive'] = (
+            context['is_tty'] and 
+            not context['is_automated'] and
+            not context['is_docker']  # Docker usually non-interactive
+        )
+        
+        logger.debug(f"Environment context detected: {context}")
+        return context
+    
+    @classmethod
+    def _detect_tty(cls) -> bool:
+        """
+        Detect if we have a TTY (terminal) available.
+        
+        WHY: TTY presence is the most reliable indicator that a human
+        is present and can respond to prompts.
+        """
+        try:
+            # Check if stdin is a terminal
+            has_stdin_tty = sys.stdin.isatty() if hasattr(sys.stdin, 'isatty') else False
+            
+            # Check if stdout is a terminal (for output)
+            has_stdout_tty = sys.stdout.isatty() if hasattr(sys.stdout, 'isatty') else False
+            
+            # Both should be TTY for interactive use
+            return has_stdin_tty and has_stdout_tty
+        except Exception as e:
+            logger.debug(f"TTY detection failed: {e}")
+            return False
+    
+    @classmethod
+    def _detect_ci(cls) -> bool:
+        """
+        Detect if running in a CI/CD environment.
+        
+        WHY: CI environments should never prompt for user input.
+        They need to run fully automated without human intervention.
+        """
+        # Check for common CI environment variables
+        for var in cls.CI_ENV_VARS:
+            if os.environ.get(var):
+                logger.debug(f"CI environment detected via {var}={os.environ.get(var)}")
+                return True
+        
+        # Additional heuristics for CI detection
+        if os.environ.get('BUILD_ID') or os.environ.get('BUILD_NUMBER'):
+            return True
+            
+        return False
+    
+    @classmethod
+    def _detect_docker(cls) -> bool:
+        """
+        Detect if running inside a Docker container.
+        
+        WHY: Docker containers typically run non-interactively,
+        and prompting for input often doesn't make sense.
+        """
+        # Check for Docker-specific files
+        for indicator_file in cls.CONTAINER_INDICATORS:
+            if os.path.exists(indicator_file):
+                logger.debug(f"Container detected via {indicator_file}")
+                return True
+        
+        # Check for container-related environment variables
+        if os.environ.get('KUBERNETES_SERVICE_HOST'):
+            return True
+            
+        # Check cgroup for docker/containerd references
+        try:
+            with open('/proc/1/cgroup', 'r') as f:
+                cgroup_content = f.read()
+                if 'docker' in cgroup_content or 'containerd' in cgroup_content:
+                    return True
+        except (FileNotFoundError, PermissionError):
+            pass
+            
+        return False
+    
+    @classmethod
+    def _detect_automated(cls) -> bool:
+        """
+        Detect if running in an automated context (cron, systemd, etc).
+        
+        WHY: Automated scripts should not prompt for input even if
+        they technically have TTY access.
+        """
+        # Check for cron execution
+        if os.environ.get('CRON') or not os.environ.get('TERM'):
+            return True
+            
+        # Check for systemd service
+        if os.environ.get('INVOCATION_ID'):  # systemd sets this
+            return True
+            
+        return False
+    
+    @classmethod
+    def _detect_jupyter(cls) -> bool:
+        """
+        Detect if running in Jupyter notebook/lab.
+        
+        WHY: Jupyter has its own interaction model and standard
+        terminal prompts don't work well.
+        """
+        try:
+            # Check for IPython/Jupyter
+            get_ipython = globals().get('get_ipython')
+            if get_ipython is not None:
+                return True
+        except:
+            pass
+            
+        # Check for Jupyter-specific environment variables
+        if 'JPY_PARENT_PID' in os.environ:
+            return True
+            
+        return False
+    
+    @classmethod
+    def _detect_ssh(cls) -> bool:
+        """
+        Detect if running over SSH.
+        
+        WHY: SSH sessions might have TTY but prompting behavior
+        should be more conservative.
+        """
+        return 'SSH_CLIENT' in os.environ or 'SSH_TTY' in os.environ
+    
+    @classmethod
+    def should_prompt_for_dependencies(
+        cls,
+        force_prompt: bool = False,
+        force_skip: bool = False
+    ) -> Tuple[bool, str]:
+        """
+        Determine if we should prompt for dependency installation.
+        
+        Args:
+            force_prompt: Force prompting regardless of environment
+            force_skip: Force skipping prompts regardless of environment
+            
+        Returns:
+            Tuple of (should_prompt, reason_message)
+            
+        WHY: This is the main decision point for the smart dependency system.
+        We want to prompt only when it makes sense and is safe to do so.
+        """
+        # Handle forced flags
+        if force_skip:
+            return False, "Prompting disabled by --no-prompt flag"
+        if force_prompt:
+            return True, "Prompting forced by --prompt flag"
+        
+        # Get environment context
+        context = cls.detect_execution_context()
+        
+        # Decision logic with clear reasoning
+        if not context['is_tty']:
+            return False, "No TTY available for interactive prompts"
+            
+        if context['is_ci']:
+            return False, "Running in CI environment - prompts disabled"
+            
+        if context['is_docker']:
+            return False, "Running in Docker container - prompts disabled"
+            
+        if context['is_automated']:
+            return False, "Running in automated context - prompts disabled"
+            
+        if context['is_jupyter']:
+            return False, "Running in Jupyter - standard prompts not supported"
+            
+        if context['is_interactive']:
+            return True, "Interactive TTY environment detected"
+            
+        # Default to not prompting if uncertain
+        return False, "Environment type uncertain - prompts disabled for safety"
+    
+    @classmethod
+    def get_environment_summary(cls) -> str:
+        """
+        Get a human-readable summary of the environment.
+        
+        Returns:
+            String describing the detected environment.
+        """
+        context = cls.detect_execution_context()
+        
+        env_types = []
+        if context['is_ci']:
+            env_types.append("CI/CD")
+        if context['is_docker']:
+            env_types.append("Docker")
+        if context['is_jupyter']:
+            env_types.append("Jupyter")
+        if context['is_ssh']:
+            env_types.append("SSH")
+        if context['is_automated']:
+            env_types.append("Automated")
+            
+        if not env_types:
+            if context['is_interactive']:
+                env_types.append("Interactive Terminal")
+            else:
+                env_types.append("Non-interactive")
+                
+        return f"Environment: {', '.join(env_types)} (TTY: {context['is_tty']})"
+
+
+def detect_execution_context() -> Dict[str, bool]:
+    """
+    Convenience function to detect execution context.
+    
+    Returns:
+        Dictionary with context indicators.
+    """
+    return EnvironmentContext.detect_execution_context()
+
+
+def should_prompt_for_dependencies(
+    force_prompt: bool = False,
+    force_skip: bool = False
+) -> Tuple[bool, str]:
+    """
+    Convenience function to determine if prompting is appropriate.
+    
+    Args:
+        force_prompt: Force prompting regardless of environment
+        force_skip: Force skipping prompts regardless of environment
+        
+    Returns:
+        Tuple of (should_prompt, reason_message)
+    """
+    return EnvironmentContext.should_prompt_for_dependencies(
+        force_prompt=force_prompt,
+        force_skip=force_skip
+    )