claude-mpm 5.0.9__py3-none-any.whl → 5.6.23__py3-none-any.whl

claude_mpm/utils/agent_dependency_loader.py

@@ -65,6 +65,7 @@ class AgentDependencyLoader:
         self.deployment_state_file = (
             Path.cwd() / ".claude" / "agents" / ".mpm_deployment_state"
         )
+        self.is_uv_tool = self._check_uv_tool_installation()
 
     def discover_deployed_agents(self) -> Dict[str, Path]:
         """
@@ -191,9 +192,42 @@ class AgentDependencyLoader:
         logger.debug(f"Loaded dependencies for {len(agent_dependencies)} agents")
         return agent_dependencies
 
+    def _check_uv_tool_installation(self) -> bool:
+        """
+        Check if running in UV tool environment (no pip available).
+
+        WHY: UV tool environments don't have pip installed. The executable
+        path typically contains ".local/share/uv/tools/" and the UV_TOOL_DIR
+        environment variable is set. In such environments, we need to use
+        'uv pip' instead of 'python -m pip'.
+
+        Returns:
+            True if UV tool environment, False otherwise
+        """
+        import os
+
+        # Check UV_TOOL_DIR environment variable
+        uv_tool_dir = os.environ.get("UV_TOOL_DIR", "")
+        if uv_tool_dir and "claude-mpm" in uv_tool_dir:
+            logger.debug(f"UV tool environment detected via UV_TOOL_DIR: {uv_tool_dir}")
+            return True
+
+        # Check executable path for UV tool patterns
+        executable = sys.executable
+        if ".local/share/uv/tools/" in executable or "/uv/tools/" in executable:
+            logger.debug(
+                f"UV tool environment detected via executable path: {executable}"
+            )
+            return True
+
+        return False
+
     def check_python_dependency(self, package_spec: str) -> Tuple[bool, Optional[str]]:
         """
-        Check if a Python package dependency is satisfied.
+        Check if a Python package dependency is satisfied in the TARGET environment.
+
+        WHY: UV tool environments use a separate Python installation. We must check
+        packages in the same environment where they would be installed/used.
 
         Args:
             package_spec: Package specification (e.g., "pandas>=2.0.0")
@@ -221,7 +255,70 @@ class AgentDependencyLoader:
                 )
                 return True, "optional-skipped"
 
-            # Try to import and check version
+            # For UV tool environments, check via UV's Python
+            if self.is_uv_tool:
+                try:
+                    verify_cmd = [
+                        "uv",
+                        "run",
+                        "--no-project",
+                        "python",
+                        "-c",
+                        f"import importlib.metadata; print(importlib.metadata.version('{package_name}'))",
+                    ]
+                    result = subprocess.run(
+                        verify_cmd, capture_output=True, timeout=30, check=False
+                    )
+                    if result.returncode == 0:
+                        version = result.stdout.decode().strip()
+                        self.checked_packages.add(package_name)
+                        if req.specifier.contains(version):
+                            logger.debug(
+                                f"Package {package_name} {version} satisfied in UV environment"
+                            )
+                            return True, version
+                        logger.debug(
+                            f"{package_name} {version} does not satisfy {req.specifier}"
+                        )
+                        return False, version
+                    # Check alternatives for optional packages
+                    if package_name in self.OPTIONAL_DB_PACKAGES:
+                        for alternative in self.OPTIONAL_DB_PACKAGES[package_name]:
+                            alt_cmd = [
+                                "uv",
+                                "run",
+                                "--no-project",
+                                "python",
+                                "-c",
+                                f"import importlib.metadata; print(importlib.metadata.version('{alternative}'))",
+                            ]
+                            alt_result = subprocess.run(
+                                alt_cmd, capture_output=True, timeout=30, check=False
+                            )
+                            if alt_result.returncode == 0:
+                                alt_version = alt_result.stdout.decode().strip()
+                                logger.info(
+                                    f"Using {alternative} as alternative to {package_name}"
+                                )
+                                self.checked_packages.add(package_name)
+                                return True, f"{alternative}:{alt_version}"
+                        # If no alternatives work, mark as optional failure
+                        self.optional_failed[package_name] = "No alternatives available"
+                        logger.warning(
+                            f"Optional package {package_name} not found, marking as optional"
+                        )
+                        return True, "optional-not-found"
+                    return False, None
+                except subprocess.TimeoutExpired:
+                    logger.warning(f"Timeout checking {package_name} in UV environment")
+                    return False, None
+                except Exception as e:
+                    logger.debug(
+                        f"Error checking {package_name} in UV environment: {e}"
+                    )
+                    return False, None
+
+            # For normal Python, try to import and check version
             try:
                 import importlib.metadata
 
@@ -658,12 +755,26 @@ class AgentDependencyLoader:
                 "Robust installer not available, falling back to simple installation"
             )
             try:
-                cmd = [sys.executable, "-m", "pip", "install"]
-
                 # Check environment and add appropriate flags
                 import os
                 import sysconfig
 
+                # Check if in UV tool environment (no pip available)
+                uv_tool_dir = os.environ.get("UV_TOOL_DIR", "")
+                is_uv_tool = (
+                    (uv_tool_dir and "claude-mpm" in uv_tool_dir)
+                    or ".local/share/uv/tools/" in sys.executable
+                    or "/uv/tools/" in sys.executable
+                )
+
+                if is_uv_tool:
+                    cmd = ["uv", "pip", "install", "--python", sys.executable]
+                    logger.debug(
+                        f"Using 'uv pip install --python {sys.executable}' for UV tool environment"
+                    )
+                else:
+                    cmd = [sys.executable, "-m", "pip", "install"]
+
                 # Check if in virtualenv
                 in_virtualenv = (
                     (hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix)

claude_mpm/utils/agent_filters.py

@@ -4,10 +4,14 @@ Agent filtering utilities for claude-mpm.
 WHY: This module provides centralized filtering logic to remove non-deployable
 agents (BASE_AGENT) and already-deployed agents from user-facing displays.
 
+ARCHITECTURE:
+- SOURCE: ~/.claude-mpm/cache/agents/ (git repository cache)
+- DEPLOYMENT: .claude/agents/ (project-level deployment location)
+
 DESIGN DECISIONS:
 - BASE_AGENT is a build tool, not a deployable agent - filter everywhere
-- Deployed agent detection supports both new (.claude-mpm/agents/) and
-  legacy (.claude/agents/)
+- Deployed agent detection checks .claude/agents/ for all deployed agents
+- Supports both virtual (.mpm_deployment_state) and physical (.md files) detection
 - Case-insensitive BASE_AGENT detection for robustness
 - Pure functions for easy testing and reuse
 
@@ -102,10 +106,11 @@ def get_deployed_agent_ids(project_dir: Optional[Path] = None) -> Set[str]:
 
     Design Rationale:
         - Primary detection: Virtual deployment state (.mpm_deployment_state)
-        - Fallback detection: Physical .md files (.claude-mpm/agents/, .claude/agents/)
+        - Fallback detection: Physical .md files in .claude/agents/
         - Returns leaf names for consistent comparison with agent_id formats
         - Combines both detection methods for complete coverage
         - Graceful error handling for malformed or missing state files
+        - Only checks project-level deployment (simplified architecture)
 
     Related:
         - Fixes checkbox interface showing all agents as "○ [Available]" instead of "● [Installed]"
@@ -115,24 +120,17 @@ def get_deployed_agent_ids(project_dir: Optional[Path] = None) -> Set[str]:
     deployed = set()
 
     # Track if project_dir was explicitly provided
-    explicit_project_dir = project_dir is not None
 
     if project_dir is None:
         project_dir = Path.cwd()
 
     # NEW: Check virtual deployment state (primary method)
     # This is the current deployment model used by Claude Code
+    # Only checking project-level deployment in simplified architecture
     deployment_state_paths = [
         project_dir / ".claude" / "agents" / ".mpm_deployment_state",
     ]
 
-    # Only check user-level state if using default project directory
-    # This prevents test isolation issues when explicit project_dir is provided
-    if not explicit_project_dir:
-        deployment_state_paths.append(
-            Path.home() / ".claude" / "agents" / ".mpm_deployment_state"
-        )
-
     for state_path in deployment_state_paths:
         if state_path.exists():
             try:
@@ -162,42 +160,17 @@ def get_deployed_agent_ids(project_dir: Optional[Path] = None) -> Set[str]:
                 continue
 
     # EXISTING: Check physical .md files (fallback for backward compatibility)
-    # Check new architecture
-    new_agents_dir = project_dir / ".claude-mpm" / "agents"
-    if new_agents_dir.exists():
-        for file in new_agents_dir.glob("*.md"):
-            if file.stem not in {"BASE-AGENT", ".DS_Store"}:
-                deployed.add(file.stem)
-
-    # Check legacy architecture
-    legacy_agents_dir = project_dir / ".claude" / "agents"
-    if legacy_agents_dir.exists():
-        for file in legacy_agents_dir.glob("*.md"):
+    # Check project deployment location (.claude/agents/)
+    agents_dir = project_dir / ".claude" / "agents"
+    if agents_dir.exists():
+        for file in agents_dir.glob("*.md"):
             if file.stem not in {"BASE-AGENT", ".DS_Store"}:
                 deployed.add(file.stem)
 
-    # Check .claude/templates/ directory (where agents are actually deployed)
-    templates_dir = project_dir / ".claude" / "templates"
-    if templates_dir.exists():
-        for file in templates_dir.glob("*.md"):
-            if file.stem not in {
-                "BASE-AGENT",
-                ".DS_Store",
-                "README",
-                "circuit-breakers",
-            }:
-                # Skip template/example files
-                if not any(x in file.stem for x in ["example", "template", "pm-"]):
-                    deployed.add(file.stem)
-
-    # Check user-level directory only if using default project directory
-    # This prevents test isolation issues when explicit project_dir is provided
-    if not explicit_project_dir:
-        user_agents_dir = Path.home() / ".claude" / "agents"
-        if user_agents_dir.exists():
-            for file in user_agents_dir.glob("*.md"):
-                if file.stem not in {"BASE-AGENT", ".DS_Store"}:
-                    deployed.add(file.stem)
+    # NOTE: .claude/templates/ contains PM instruction templates, NOT deployed agents
+    # It should NOT be checked here. Agents are deployed to:
+    # - .mpm_deployment_state (virtual deployment)
+    # - .claude/agents/*.md (project deployment)
 
     return deployed
 

claude_mpm/utils/gitignore.py

@@ -212,6 +212,9 @@ def ensure_claude_mpm_gitignore(project_dir: str = ".") -> dict:
         entries_to_add = [
             ".claude-mpm/",
             ".claude/agents/",
+            ".mcp.json",
+            ".claude.json",
+            ".claude/",
         ]
 
         added, existing = manager.ensure_entries(entries_to_add)

claude_mpm/utils/migration.py

@@ -2,7 +2,7 @@
 
 WHY: Phase 3 of 1M-486 requires migrating from old single-tier deployment
      (~/.claude/agents/, ~/.claude/skills/) to new two-phase architecture:
-     - Cache: ~/.claude-mpm/cache/remote-agents/, ~/.claude-mpm/cache/skills/
+     - Cache: ~/.claude-mpm/cache/agents/, ~/.claude-mpm/cache/skills/
      - Deployment: .claude-mpm/agents/, .claude-mpm/skills/
 
 DESIGN DECISIONS:
@@ -41,7 +41,7 @@ class MigrationUtility:
         self.old_agent_dir = Path.home() / ".claude" / "agents"
         self.old_skill_dir = Path.home() / ".claude" / "skills"
 
-        self.new_agent_cache = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+        self.new_agent_cache = Path.home() / ".claude-mpm" / "cache" / "agents"
         self.new_skill_cache = Path.home() / ".claude-mpm" / "cache" / "skills"
 
     def detect_old_locations(self) -> Dict[str, bool]:
@@ -80,7 +80,7 @@ class MigrationUtility:
     def migrate_agents(
         self, dry_run: bool = False, auto_confirm: bool = False
     ) -> Dict[str, any]:
-        """Migrate agents from ~/.claude/agents/ to ~/.claude-mpm/cache/remote-agents/.
+        """Migrate agents from ~/.claude/agents/ to ~/.claude-mpm/cache/agents/.
 
         Args:
             dry_run: Preview migration without making changes
@@ -329,7 +329,7 @@ class MigrationUtility:
 
         warning += "\nThe deployment architecture has changed:\n"
         warning += "  OLD: ~/.claude/agents/ (single-tier, global)\n"
-        warning += "  NEW: ~/.claude-mpm/cache/remote-agents/ → .claude-mpm/agents/ (two-phase, per-project)\n\n"
+        warning += "  NEW: ~/.claude-mpm/cache/agents/ → .claude-mpm/agents/ (two-phase, per-project)\n\n"
 
         warning += "To migrate:\n"
         warning += "  claude-mpm migrate\n\n"

claude_mpm/utils/robust_installer.py

@@ -82,6 +82,7 @@ class RobustPackageInstaller:
         self.attempts: List[InstallAttempt] = []
         self.success_cache: Dict[str, bool] = {}
         self.in_virtualenv = self._check_virtualenv()
+        self.is_uv_tool = self._check_uv_tool_installation()
         self.is_pep668_managed = self._check_pep668_managed()
         self.pep668_warning_shown = False
 
@@ -261,6 +262,36 @@ class RobustPackageInstaller:
 
         return False
 
+    def _check_uv_tool_installation(self) -> bool:
+        """
+        Check if running in UV tool environment (no pip available).
+
+        WHY: UV tool environments don't have pip installed. The executable
+        path typically contains ".local/share/uv/tools/" and the UV_TOOL_DIR
+        environment variable is set. In such environments, we need to use
+        'uv pip' instead of 'python -m pip'.
+
+        Returns:
+            True if UV tool environment, False otherwise
+        """
+        import os
+
+        # Check UV_TOOL_DIR environment variable
+        uv_tool_dir = os.environ.get("UV_TOOL_DIR", "")
+        if uv_tool_dir and "claude-mpm" in uv_tool_dir:
+            logger.debug(f"UV tool environment detected via UV_TOOL_DIR: {uv_tool_dir}")
+            return True
+
+        # Check executable path for UV tool patterns
+        executable = sys.executable
+        if ".local/share/uv/tools/" in executable or "/uv/tools/" in executable:
+            logger.debug(
+                f"UV tool environment detected via executable path: {executable}"
+            )
+            return True
+
+        return False
+
     def _show_pep668_warning(self) -> None:
         """
         Show warning about PEP 668 managed environment.
@@ -301,7 +332,14 @@ class RobustPackageInstaller:
         Returns:
             Command as list of arguments
         """
-        base_cmd = [sys.executable, "-m", "pip", "install"]
+        # UV tool environments don't have pip; use uv pip install --python instead
+        if self.is_uv_tool:
+            base_cmd = ["uv", "pip", "install", "--python", sys.executable]
+            logger.debug(
+                f"Using 'uv pip install --python {sys.executable}' for UV tool environment"
+            )
+        else:
+            base_cmd = [sys.executable, "-m", "pip", "install"]
 
         # Determine appropriate flags based on environment
         if self.in_virtualenv:
@@ -442,42 +480,56 @@ class RobustPackageInstaller:
 
     def _verify_installation(self, package_spec: str) -> bool:
         """
-        Verify that a package was successfully installed.
+        Verify that a package was successfully installed in the TARGET environment.
+
+        WHY: UV installs packages to its own Python environment, not the current process.
+        We must verify in the same environment where packages were installed.
 
         Args:
             package_spec: Package specification
 
         Returns:
-            True if package is installed and importable
+            True if package is installed and importable in the target environment
         """
         package_name = self._extract_package_name(package_spec)
 
-        # Convert package name to import name (e.g., tree-sitter-ruby -> tree_sitter_ruby)
-        import_name = package_name.replace("-", "_")
-
         try:
-            # Check if package is installed
+            if self.is_uv_tool:
+                # For UV tool, verify via UV's Python environment
+                verify_cmd = [
+                    "uv",
+                    "run",
+                    "--no-project",
+                    "python",
+                    "-c",
+                    f"import importlib.metadata; print(importlib.metadata.version('{package_name}'))",
+                ]
+                result = subprocess.run(
+                    verify_cmd, capture_output=True, timeout=30, check=False
+                )
+                if result.returncode == 0:
+                    logger.debug(
+                        f"Package {package_name} verified in UV environment: {result.stdout.decode().strip()}"
+                    )
+                    return True
+                logger.debug(
+                    f"Package {package_name} not found in UV environment: {result.stderr.decode().strip()}"
+                )
+                return False
+            # For normal Python, use importlib.metadata in current process
             import importlib.metadata
 
             try:
                 version = importlib.metadata.version(package_name)
                 logger.debug(f"Package {package_name} version {version} is installed")
-
-                # For tree-sitter packages, don't try to import (they have C extensions)
-                if package_name.startswith("tree-sitter-"):
-                    return True
-
-                # Try to import the package
-                try:
-                    __import__(import_name)
-                    return True
-                except ImportError:
-                    # Some packages have different import names, that's OK
-                    return True
+                return True
 
             except importlib.metadata.PackageNotFoundError:
                 return False
 
+        except subprocess.TimeoutExpired:
+            logger.warning(f"Verification timeout for {package_name}")
+            return False
         except ImportError:
             # Fallback for older Python versions
             try:
@@ -487,6 +539,9 @@ class RobustPackageInstaller:
                 return True
             except pkg_resources.DistributionNotFound:
                 return False
+        except Exception as e:
+            logger.debug(f"Verification error for {package_name}: {e}")
+            return False
 
     def _is_retryable_error(self, error: Optional[str]) -> bool:
         """
@@ -651,7 +706,14 @@ class RobustPackageInstaller:
             Tuple of (success, error_message)
         """
         try:
-            cmd = [sys.executable, "-m", "pip", "install"]
+            # UV tool environments don't have pip; use uv pip install --python instead
+            if self.is_uv_tool:
+                cmd = ["uv", "pip", "install", "--python", sys.executable]
+                logger.debug(
+                    f"Using 'uv pip install --python {sys.executable}' for batch installation"
+                )
+            else:
+                cmd = [sys.executable, "-m", "pip", "install"]
 
             # Add appropriate flags based on environment
             if self.in_virtualenv:
@@ -702,7 +764,10 @@ class RobustPackageInstaller:
 
         # Add environment status
         lines.append("")
-        if self.in_virtualenv:
+        if self.is_uv_tool:
+            lines.append("✓ Environment: UV Tool Environment")
+            lines.append("  Using 'uv pip' command (pip not available)")
+        elif self.in_virtualenv:
             lines.append("✓ Environment: Virtual Environment (isolated)")
             lines.append("  No special pip flags needed")
         elif self.is_pep668_managed: