claude-mpm 4.1.1__py3-none-any.whl → 4.1.2__py3-none-any.whl

claude_mpm/utils/robust_installer.py

@@ -12,10 +12,12 @@ multiple installation strategies (pip, conda, source) to maximize success rate.
 import re
 import subprocess
 import sys
+import sysconfig
 import time
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Dict, List, Optional, Tuple
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
 
 from ..core.logger import get_logger
 
@@ -51,6 +53,9 @@ class RobustPackageInstaller:
     WHY: This class handles the complexity of package installation in various
     environments, network conditions, and Python versions. It ensures maximum
     success rate while providing clear feedback on failures.
+
+    DECISION: Added PEP 668 detection and handling to work with externally managed
+    Python environments (like Homebrew's Python 3.13).
     """
 
     def __init__(
@@ -75,6 +80,8 @@ class RobustPackageInstaller:
         self.use_cache = use_cache
         self.attempts: List[InstallAttempt] = []
         self.success_cache: Dict[str, bool] = {}
+        self.is_pep668_managed = self._check_pep668_managed()
+        self.pep668_warning_shown = False
 
     def install_package(
         self, package_spec: str, strategies: Optional[List[InstallStrategy]] = None
@@ -178,24 +185,70 @@ class RobustPackageInstaller:
             logger.debug(f"Running: {' '.join(cmd)}")
 
             result = subprocess.run(
-                cmd, capture_output=True, text=True, timeout=self.timeout
+                cmd, capture_output=True, text=True, timeout=self.timeout, check=False
             )
 
             if result.returncode == 0:
                 # Verify installation
                 if self._verify_installation(package_spec):
                     return True, None
-                else:
-                    return False, "Package installed but verification failed"
-            else:
-                error_msg = self._extract_error_message(result.stderr)
-                logger.debug(f"Installation failed: {error_msg}")
-                return False, error_msg
+                return False, "Package installed but verification failed"
+            error_msg = self._extract_error_message(result.stderr)
+            logger.debug(f"Installation failed: {error_msg}")
+            return False, error_msg
 
         except subprocess.TimeoutExpired:
             return False, f"Installation timed out after {self.timeout}s"
         except Exception as e:
-            return False, f"Unexpected error: {str(e)}"
+            return False, f"Unexpected error: {e!s}"
+
+    def _check_pep668_managed(self) -> bool:
+        """
+        Check if Python environment is PEP 668 externally managed.
+
+        WHY: PEP 668 prevents pip from installing packages into system Python
+        to avoid conflicts with system package managers (like Homebrew).
+
+        Returns:
+            True if PEP 668 managed, False otherwise
+        """
+        # Check for EXTERNALLY-MANAGED marker file
+        stdlib_path = sysconfig.get_path("stdlib")
+        marker_file = Path(stdlib_path) / "EXTERNALLY-MANAGED"
+
+        if marker_file.exists():
+            logger.debug(f"PEP 668 EXTERNALLY-MANAGED marker found at {marker_file}")
+            return True
+
+        # Also check parent directory (some Python installations place it there)
+        parent_marker = marker_file.parent.parent / "EXTERNALLY-MANAGED"
+        if parent_marker.exists():
+            logger.debug(f"PEP 668 EXTERNALLY-MANAGED marker found at {parent_marker}")
+            return True
+
+        return False
+
+    def _show_pep668_warning(self) -> None:
+        """
+        Show warning about PEP 668 managed environment.
+
+        WHY: Users should understand why we're bypassing PEP 668 restrictions
+        and be encouraged to use virtual environments as best practice.
+        """
+        if not self.pep668_warning_shown:
+            logger.warning(
+                "⚠️  PEP 668 MANAGED ENVIRONMENT DETECTED\n"
+                "Your Python installation is marked as externally managed (PEP 668).\n"
+                "This typically means you're using a system Python managed by Homebrew, apt, etc.\n"
+                "\n"
+                "Installing packages with --break-system-packages --user flags...\n"
+                "\n"
+                "RECOMMENDED: Use a virtual environment instead:\n"
+                "  python -m venv .venv\n"
+                "  source .venv/bin/activate  # On Windows: .venv\\Scripts\\activate\n"
+                "  pip install claude-mpm\n"
+            )
+            self.pep668_warning_shown = True
 
     def _build_install_command(
         self, package_spec: str, strategy: InstallStrategy
@@ -203,6 +256,9 @@ class RobustPackageInstaller:
         """
         Build the installation command for a given strategy.
 
+        WHY: PEP 668 support added to handle externally managed Python
+        environments by adding appropriate flags when needed.
+
         Args:
             package_spec: Package specification
             strategy: Installation strategy
@@ -212,22 +268,32 @@ class RobustPackageInstaller:
         """
         base_cmd = [sys.executable, "-m", "pip", "install"]
 
+        # Add PEP 668 bypass flags if needed
+        if self.is_pep668_managed:
+            self._show_pep668_warning()
+            # Add flags to bypass PEP 668 restrictions
+            base_cmd.extend(["--break-system-packages", "--user"])
+            logger.debug(
+                "Added --break-system-packages --user flags for PEP 668 environment"
+            )
+
         # Add cache control
         if not self.use_cache:
             base_cmd.append("--no-cache-dir")
 
         if strategy == InstallStrategy.PIP:
-            return base_cmd + [package_spec]
+            return [*base_cmd, package_spec]
 
-        elif strategy == InstallStrategy.PIP_NO_DEPS:
-            return base_cmd + ["--no-deps", package_spec]
+        if strategy == InstallStrategy.PIP_NO_DEPS:
+            return [*base_cmd, "--no-deps", package_spec]
 
-        elif strategy == InstallStrategy.PIP_UPGRADE:
-            return base_cmd + ["--upgrade", package_spec]
+        if strategy == InstallStrategy.PIP_UPGRADE:
+            return [*base_cmd, "--upgrade", package_spec]
 
-        elif strategy == InstallStrategy.PIP_INDEX_URL:
+        if strategy == InstallStrategy.PIP_INDEX_URL:
             # Try alternative index (PyPI mirror)
-            return base_cmd + [
+            return [
+                *base_cmd,
                 "--index-url",
                 "https://pypi.org/simple",
                 "--extra-index-url",
@@ -235,8 +301,7 @@ class RobustPackageInstaller:
                 package_spec,
             ]
 
-        else:
-            return base_cmd + [package_spec]
+        return [*base_cmd, package_spec]
 
     def _extract_package_name(self, package_spec: str) -> str:
         """
@@ -433,9 +498,8 @@ class RobustPackageInstaller:
 
         # Format error message
         if len(errors) == 1:
-            return list(errors)[0]
-        else:
-            return f"Multiple errors: {' | '.join(errors)}"
+            return next(iter(errors))
+        return f"Multiple errors: {' | '.join(errors)}"
 
     def install_packages(
         self, packages: List[str], parallel: bool = False
@@ -463,9 +527,8 @@ class RobustPackageInstaller:
             if success:
                 logger.info("Batch installation successful")
                 return packages, [], {}
-            else:
-                logger.warning(f"Batch installation failed: {error}")
-                logger.info("Falling back to individual installation...")
+            logger.warning(f"Batch installation failed: {error}")
+            logger.info("Falling back to individual installation...")
 
         # Install packages individually
         for i, package in enumerate(packages, 1):
@@ -492,13 +555,22 @@ class RobustPackageInstaller:
             Tuple of (success, error_message)
         """
         try:
-            cmd = [sys.executable, "-m", "pip", "install"] + packages
+            cmd = [sys.executable, "-m", "pip", "install"]
+
+            # Add PEP 668 bypass flags if needed
+            if self.is_pep668_managed:
+                self._show_pep668_warning()
+                cmd.extend(["--break-system-packages", "--user"])
+                logger.debug("Added PEP 668 flags for batch installation")
+
+            cmd.extend(packages)
 
             result = subprocess.run(
                 cmd,
                 capture_output=True,
                 text=True,
-                timeout=self.timeout * 2,  # Longer timeout for batch
+                timeout=self.timeout * 2,
+                check=False,  # Longer timeout for batch
             )
 
             if result.returncode == 0:
@@ -506,16 +578,14 @@ class RobustPackageInstaller:
                 all_verified = all(self._verify_installation(pkg) for pkg in packages)
                 if all_verified:
                     return True, None
-                else:
-                    return False, "Some packages failed verification"
-            else:
-                error_msg = self._extract_error_message(result.stderr)
-                return False, error_msg
+                return False, "Some packages failed verification"
+            error_msg = self._extract_error_message(result.stderr)
+            return False, error_msg
 
         except subprocess.TimeoutExpired:
-            return False, f"Batch installation timed out"
+            return False, "Batch installation timed out"
         except Exception as e:
-            return False, f"Batch installation error: {str(e)}"
+            return False, f"Batch installation error: {e!s}"
 
     def get_report(self) -> str:
         """
@@ -529,6 +599,13 @@ class RobustPackageInstaller:
         lines.append("INSTALLATION REPORT")
         lines.append("=" * 60)
 
+        # Add PEP 668 status
+        if self.is_pep668_managed:
+            lines.append("")
+            lines.append("⚠️  PEP 668 Managed Environment: YES")
+            lines.append("   Installations used --break-system-packages --user flags")
+            lines.append("   Consider using a virtual environment for better isolation")
+
         # Summary
         total_attempts = len(self.attempts)
         successful = sum(1 for a in self.attempts if a.success)

claude_mpm/utils/subprocess_utils.py

@@ -7,12 +7,12 @@ with proper error handling, timeouts, and process cleanup.
 """
 
 import asyncio
+import contextlib
 import logging
 import shlex
-import signal
 import subprocess
 import time
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional
 
 import psutil
 
@@ -122,6 +122,7 @@ def run_subprocess(
             cwd=cwd,
             env=env,
             **kwargs,
+            check=False,
         )
 
         return SubprocessResult(
@@ -229,16 +230,14 @@ def terminate_process_tree(pid: int, timeout: float = 5.0) -> int:
 
     # Get all child processes recursively
     children = parent.children(recursive=True)
-    processes = [parent] + children
+    processes = [parent, *children]
 
     terminated_count = 0
 
     # First, try graceful termination
     for process in processes:
-        try:
+        with contextlib.suppress(psutil.NoSuchProcess):
             process.terminate()
-        except psutil.NoSuchProcess:
-            pass
 
     # Wait for processes to terminate gracefully
     gone, alive = psutil.wait_procs(processes, timeout=timeout)

claude_mpm/validation/agent_validator.py

@@ -26,17 +26,14 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
-import jsonschema
 from jsonschema import Draft7Validator, ValidationError, validate
 
 from claude_mpm.config.paths import paths
 from claude_mpm.core.constants import (
-    ComplexityMetrics,
     ErrorMessages,
     ResourceLimits,
     SystemLimits,
     TimeoutConfig,
-    ValidationRules,
 )
 
 logger = logging.getLogger(__name__)
@@ -105,7 +102,7 @@ class AgentValidator:
             if not self.schema_path.is_file():
                 raise ValueError(f"Schema path is not a file: {self.schema_path}")
 
-            with open(self.schema_path, "r") as f:
+            with open(self.schema_path) as f:
                 return json.load(f)
         except Exception as e:
             logger.error(f"Failed to load schema from {self.schema_path}: {e}")
@@ -130,7 +127,7 @@ class AgentValidator:
 
         # Check if model contains tier name
         model_lower = model.lower()
-        for tier in {"opus", "sonnet", "haiku"}:
+        for tier in ("opus", "sonnet", "haiku"):
             if tier in model_lower:
                 return tier
 
@@ -395,7 +392,7 @@ class AgentValidator:
             max_size = SystemLimits.MAX_AGENT_CONFIG_SIZE
             if file_size > max_size:
                 raise ValueError(ErrorMessages.FILE_TOO_LARGE.format(limit=max_size))
-            with open(file_path, "r") as f:
+            with open(file_path) as f:
                 agent_data = json.load(f)
 
             result = self.validate_agent(agent_data)

claude_mpm/validation/frontmatter_validator.py

@@ -185,7 +185,7 @@ class FrontmatterValidator:
         errors = []
 
         try:
-            with open(file_path, "r") as f:
+            with open(file_path) as f:
                 content = f.read()
 
             # Check for frontmatter markers

{claude_mpm-4.1.1.dist-info → claude_mpm-4.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.1.1
+Version: 4.1.2
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team