claude-mpm 4.1.26__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/utils/robust_installer.py

@@ -9,6 +9,7 @@ DESIGN DECISION: We implement exponential backoff for retries and provide
 multiple installation strategies (pip, conda, source) to maximize success rate.
 """
 
+import os
 import re
 import subprocess
 import sys
@@ -80,6 +81,7 @@ class RobustPackageInstaller:
         self.use_cache = use_cache
         self.attempts: List[InstallAttempt] = []
         self.success_cache: Dict[str, bool] = {}
+        self.in_virtualenv = self._check_virtualenv()
         self.is_pep668_managed = self._check_pep668_managed()
         self.pep668_warning_shown = False
 
@@ -100,10 +102,9 @@ class RobustPackageInstaller:
             Tuple of (success, error_message)
         """
         # Check success cache first
-        if package_spec in self.success_cache:
-            if self.success_cache[package_spec]:
-                logger.debug(f"Package {package_spec} already successfully installed")
-                return True, None
+        if self.success_cache.get(package_spec):
+            logger.debug(f"Package {package_spec} already successfully installed")
+            return True, None
 
         # Default strategy order
         if strategies is None:
@@ -202,6 +203,35 @@ class RobustPackageInstaller:
         except Exception as e:
             return False, f"Unexpected error: {e!s}"
 
+    def _check_virtualenv(self) -> bool:
+        """
+        Check if running inside a virtual environment.
+
+        WHY: Virtual environments are already isolated and don't need
+        --user or --break-system-packages flags. In fact, using --user
+        in a virtualenv causes errors.
+
+        Returns:
+            True if in a virtualenv, False otherwise
+        """
+        # Multiple ways to detect virtualenv
+        return (
+            (
+                # venv creates sys.base_prefix
+                hasattr(sys, "base_prefix")
+                and sys.base_prefix != sys.prefix
+            )
+            or (
+                # virtualenv creates sys.real_prefix
+                hasattr(sys, "real_prefix")
+            )
+            or (
+                # VIRTUAL_ENV environment variable
+                os.environ.get("VIRTUAL_ENV")
+                is not None
+            )
+        )
+
     def _check_pep668_managed(self) -> bool:
         """
         Check if Python environment is PEP 668 externally managed.
@@ -212,6 +242,11 @@ class RobustPackageInstaller:
         Returns:
             True if PEP 668 managed, False otherwise
         """
+        # If in virtualenv, PEP 668 doesn't apply
+        if self.in_virtualenv:
+            logger.debug("Running in virtualenv, PEP 668 restrictions don't apply")
+            return False
+
         # Check for EXTERNALLY-MANAGED marker file
         stdlib_path = sysconfig.get_path("stdlib")
         marker_file = Path(stdlib_path) / "EXTERNALLY-MANAGED"
@@ -241,7 +276,7 @@ class RobustPackageInstaller:
                 "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"
+                "Installing packages with --break-system-packages flag...\n"
                 "\n"
                 "RECOMMENDED: Use a virtual environment instead:\n"
                 "  python -m venv .venv\n"
@@ -256,8 +291,10 @@ 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.
+        WHY: Proper environment detection ensures we use the right pip flags:
+        - Virtualenv: No special flags needed (already isolated)
+        - PEP 668 system: Use --break-system-packages only
+        - Normal system: Use --user for user-local install
 
         Args:
             package_spec: Package specification
@@ -268,14 +305,19 @@ class RobustPackageInstaller:
         """
         base_cmd = [sys.executable, "-m", "pip", "install"]
 
-        # Add PEP 668 bypass flags if needed
-        if self.is_pep668_managed:
+        # Determine appropriate flags based on environment
+        if self.in_virtualenv:
+            # In virtualenv - no special flags needed
+            logger.debug("Installing in virtualenv (no special flags)")
+        elif self.is_pep668_managed:
+            # System Python with PEP 668 - use --break-system-packages only
             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"
-            )
+            base_cmd.append("--break-system-packages")
+            logger.debug("Added --break-system-packages flag for PEP 668 environment")
+        else:
+            # Normal system Python - use --user for user-local install
+            base_cmd.append("--user")
+            logger.debug("Added --user flag for user-local installation")
 
         # Add cache control
         if not self.use_cache:
@@ -340,6 +382,12 @@ class RobustPackageInstaller:
             "tree-sitter-java",
             "tree-sitter-cpp",
             "tree-sitter-c",
+            # Database packages that require compilation
+            "mysqlclient",  # Requires MySQL development headers
+            "psycopg2",  # Requires PostgreSQL development headers
+            "cx_oracle",  # Requires Oracle client libraries
+            "pycairo",  # Requires Cairo development headers
+            "lxml",  # Requires libxml2 development headers
         }
 
         return package_name.lower() in special_packages
@@ -363,6 +411,35 @@ class RobustPackageInstaller:
                 InstallStrategy.PIP_NO_DEPS,
             ]
 
+        # Database packages that require compilation
+        compilation_packages = {
+            "mysqlclient": ["pymysql"],  # Pure Python alternative
+            "psycopg2": ["psycopg2-binary"],  # Binary wheel alternative
+            "cx_oracle": [],  # No good alternative
+            "pycairo": [],  # No good alternative
+            "lxml": [],  # Usually works with binary wheels
+        }
+
+        package_lower = package_name.lower()
+        if package_lower in compilation_packages:
+            # Try normal install first, but with limited retries
+            strategies = [InstallStrategy.PIP]
+
+            # If there are alternatives, log suggestion
+            alternatives = compilation_packages[package_lower]
+            if alternatives:
+                logger.info(
+                    f"Package {package_name} requires compilation. "
+                    f"Consider using alternative: {', '.join(alternatives)}"
+                )
+            else:
+                logger.warning(
+                    f"Package {package_name} requires compilation and may fail on systems "
+                    f"without development headers installed."
+                )
+
+            return strategies
+
         return [InstallStrategy.PIP, InstallStrategy.PIP_UPGRADE]
 
     def _verify_installation(self, package_spec: str) -> bool:
@@ -459,6 +536,27 @@ class RobustPackageInstaller:
         if not stderr:
             return "Unknown error"
 
+        # Check for specific compilation errors
+        stderr_lower = stderr.lower()
+
+        if "mysql_config" in stderr_lower or "mysql.h" in stderr_lower:
+            return (
+                "mysqlclient compilation failed (missing MySQL development headers). "
+                "Use 'pip install pymysql' for a pure Python alternative that doesn't require compilation."
+            )
+
+        if "pg_config" in stderr_lower or "libpq-fe.h" in stderr_lower:
+            return (
+                "psycopg2 compilation failed (missing PostgreSQL development headers). "
+                "Use 'pip install psycopg2-binary' for a pre-compiled version."
+            )
+
+        if "oracle" in stderr_lower and "client" in stderr_lower:
+            return (
+                "cx_Oracle compilation failed (missing Oracle client libraries). "
+                "Use 'pip install oracledb' for a pure Python alternative."
+            )
+
         # Look for ERROR: lines
         error_lines = []
         for line in stderr.splitlines():
@@ -557,11 +655,16 @@ class RobustPackageInstaller:
         try:
             cmd = [sys.executable, "-m", "pip", "install"]
 
-            # Add PEP 668 bypass flags if needed
-            if self.is_pep668_managed:
+            # Add appropriate flags based on environment
+            if self.in_virtualenv:
+                logger.debug("Batch install in virtualenv (no special flags)")
+            elif self.is_pep668_managed:
                 self._show_pep668_warning()
-                cmd.extend(["--break-system-packages", "--user"])
-                logger.debug("Added PEP 668 flags for batch installation")
+                cmd.append("--break-system-packages")
+                logger.debug("Added --break-system-packages for batch installation")
+            else:
+                cmd.append("--user")
+                logger.debug("Added --user flag for batch installation")
 
             cmd.extend(packages)
 
@@ -599,12 +702,18 @@ class RobustPackageInstaller:
         lines.append("INSTALLATION REPORT")
         lines.append("=" * 60)
 
-        # Add PEP 668 status
-        if self.is_pep668_managed:
-            lines.append("")
+        # Add environment status
+        lines.append("")
+        if self.in_virtualenv:
+            lines.append("✓ Environment: Virtual Environment (isolated)")
+            lines.append("  No special pip flags needed")
+        elif self.is_pep668_managed:
             lines.append("⚠️  PEP 668 Managed Environment: YES")
-            lines.append("   Installations used --break-system-packages --user flags")
+            lines.append("   Installations used --break-system-packages flag")
             lines.append("   Consider using a virtual environment for better isolation")
+        else:
+            lines.append("Environment: System Python")
+            lines.append("   Installations used --user flag for user-local install")
 
         # Summary
         total_attempts = len(self.attempts)
@@ -617,7 +726,7 @@ class RobustPackageInstaller:
         lines.append("")
 
         # Details by package
-        packages = {}
+        packages: Dict[str, List[InstallAttempt]] = {}
         for attempt in self.attempts:
             if attempt.package not in packages:
                 packages[attempt.package] = []
@@ -659,7 +768,7 @@ def install_with_retry(
         logging.getLogger().setLevel(logging.DEBUG)
 
     installer = RobustPackageInstaller(max_retries=max_retries)
-    successful, failed, errors = installer.install_packages(packages)
+    _successful, failed, errors = installer.install_packages(packages)
 
     if verbose:
         print(installer.get_report())

claude_mpm/utils/session_logging.py

@@ -6,13 +6,13 @@ Session Logging Utilities
 Convenience functions for session-based response logging.
 """
 
-import logging
 import os
 from typing import Any, Dict, Optional
 
+from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.services.claude_session_logger import get_session_logger
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 def is_session_logging_enabled() -> bool:

claude_mpm/utils/subprocess_utils.py

@@ -8,7 +8,6 @@ with proper error handling, timeouts, and process cleanup.
 
 import asyncio
 import contextlib
-import logging
 import shlex
 import subprocess
 import time
@@ -16,7 +15,9 @@ from typing import Any, Dict, List, Optional
 
 import psutil
 
-logger = logging.getLogger(__name__)
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
 
 
 class SubprocessError(Exception):
@@ -83,7 +84,7 @@ def run_command(command_string: str, timeout: float = 60) -> str:
             returncode=getattr(e, "returncode", None),
             stdout=getattr(e, "stdout", ""),
             stderr=stderr,
-        )
+        ) from e
 
 
 def run_subprocess(
@@ -137,16 +138,16 @@ def run_subprocess(
             returncode=None,
             stdout=e.stdout.decode() if e.stdout else "",
             stderr=e.stderr.decode() if e.stderr else "",
-        )
+        ) from e
     except subprocess.CalledProcessError as e:
         raise SubprocessError(
             f"Command failed with return code {e.returncode}: {' '.join(cmd)}",
             returncode=e.returncode,
             stdout=e.stdout if e.stdout else "",
             stderr=e.stderr if e.stderr else "",
-        )
+        ) from e
     except Exception as e:
-        raise SubprocessError(f"Subprocess execution failed: {e}")
+        raise SubprocessError(f"Subprocess execution failed: {e}") from e
 
 
 async def run_subprocess_async(
@@ -195,7 +196,7 @@ async def run_subprocess_async(
             await process.wait()
             raise SubprocessError(
                 f"Command timed out after {timeout}s: {' '.join(cmd)}", returncode=None
-            )
+            ) from None
 
         return SubprocessResult(
             returncode=process.returncode,
@@ -205,7 +206,7 @@ async def run_subprocess_async(
 
     except Exception as e:
         if not isinstance(e, SubprocessError):
-            raise SubprocessError(f"Async subprocess execution failed: {e}")
+            raise SubprocessError(f"Async subprocess execution failed: {e}") from e
         raise
 
 

claude_mpm/validation/agent_validator.py

@@ -20,9 +20,8 @@ Security Considerations:
 """
 
 import json
-import logging
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
@@ -35,8 +34,9 @@ from claude_mpm.core.constants import (
     SystemLimits,
     TimeoutConfig,
 )
+from claude_mpm.core.logging_utils import get_logger
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 @dataclass
@@ -102,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) as f:
+            with self.schema_path.open() as f:
                 return json.load(f)
         except Exception as e:
             logger.error(f"Failed to load schema from {self.schema_path}: {e}")
@@ -182,7 +182,7 @@ class AgentValidator:
 
         # Add metadata
         result.metadata = {
-            "validated_at": datetime.utcnow().isoformat(),
+            "validated_at": datetime.now(timezone.utc).isoformat(),
             "schema_version": self.schema.get("version", "1.1.0"),
             "agent_id": agent_data.get("id", "unknown"),
         }
@@ -392,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) as f:
+            with file_path.open() as f:
                 agent_data = json.load(f)
 
             result = self.validate_agent(agent_data)

claude_mpm/validation/frontmatter_validator.py

@@ -3,12 +3,12 @@ from pathlib import Path
 """
 Claude Code Frontmatter Validator
 
-Validates agent frontmatter against Claude Code Desktop specification.
+Validates agent frontmatter against Claude Code specification.
 Critical for ensuring agents work correctly with Claude Code.
 """
 
 import re
-from typing import Dict, List, Optional, Tuple
+from typing import ClassVar, Dict, List, Optional, Tuple
 
 import yaml
 
@@ -21,7 +21,7 @@ class FrontmatterValidator:
     NAME_PATTERN = re.compile(r"^[a-z0-9]+(-[a-z0-9]+)*$")
 
     # Valid tool names (from Claude Code spec)
-    VALID_TOOLS = {
+    VALID_TOOLS: ClassVar[set] = {
         "Read",
         "Write",
         "Edit",
@@ -41,10 +41,10 @@ class FrontmatterValidator:
     }
 
     # Valid model tiers
-    VALID_MODELS = {"opus", "sonnet", "haiku"}
+    VALID_MODELS: ClassVar[set] = {"opus", "sonnet", "haiku"}
 
     # Required fields in frontmatter
-    REQUIRED_FIELDS = {"name", "description", "tools"}
+    REQUIRED_FIELDS: ClassVar[set] = {"name", "description", "tools"}
 
     @classmethod
     def validate_name(cls, name: str) -> Tuple[bool, Optional[str]]:
@@ -185,7 +185,7 @@ class FrontmatterValidator:
         errors = []
 
         try:
-            with open(file_path) as f:
+            with file_path.open() as f:
                 content = f.read()
 
             # Check for frontmatter markers