claude-mpm 5.1.9__py3-none-any.whl → 5.4.48__py3-none-any.whl

claude_mpm/services/profile_manager.py

@@ -0,0 +1,331 @@
+"""
+Profile Manager Service
+======================
+
+Manages agent and skill filtering based on deployment profiles.
+
+A profile defines which agents and skills should be deployed, reducing
+context usage by limiting available agents to only what's needed for
+a specific project or workflow.
+
+Profile Structure:
+    profile:
+      name: framework-development
+      description: Python backend + TypeScript/Svelte dashboard
+
+    agents:
+      enabled:
+        - python-engineer
+        - typescript-engineer
+      disabled:
+        - java-engineer
+        - dart-engineer
+
+    skills:
+      enabled:
+        - flask
+        - pytest
+      disabled_categories:
+        - wordpress-*
+        - react-*
+
+Usage:
+    # Auto-detect project directory (searches for .claude-mpm in cwd and parents)
+    profile_manager = ProfileManager()
+
+    # Or explicitly specify project directory
+    profile_manager = ProfileManager(project_dir=Path("/path/to/project"))
+
+    profile_manager.load_profile("framework-development")
+
+    if profile_manager.is_agent_enabled("python-engineer"):
+        # Deploy agent
+        pass
+
+    if profile_manager.is_skill_enabled("flask"):
+        # Deploy skill
+        pass
+"""
+
+import fnmatch
+from pathlib import Path
+from typing import Optional, Set, Dict, Any
+
+import yaml
+
+from ..core.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class ProfileManager:
+    """
+    Manages deployment profiles for agent and skill filtering.
+
+    Provides methods to:
+    - Load profiles from YAML files
+    - Check if agents are enabled/disabled
+    - Check if skills are enabled/disabled (with glob pattern support)
+    - Get lists of enabled/disabled entities
+    """
+
+    def __init__(self, project_dir: Optional[Path] = None, profiles_dir: Optional[Path] = None):
+        """
+        Initialize ProfileManager.
+
+        Args:
+            project_dir: Project root directory. If not provided, tries to find
+                         .claude-mpm directory in current or parent directories.
+            profiles_dir: Directory containing profile YAML files. If provided,
+                         takes precedence over project_dir.
+        """
+        if profiles_dir:
+            self.profiles_dir = profiles_dir
+        elif project_dir:
+            self.profiles_dir = Path(project_dir) / ".claude-mpm" / "profiles"
+        else:
+            # Try to find .claude-mpm directory automatically
+            self.profiles_dir = self._find_profiles_dir()
+
+        self.active_profile: Optional[str] = None
+        self._profile_data: Dict[str, Any] = {}
+
+        # Cached sets for performance
+        self._enabled_agents: Set[str] = set()
+        self._disabled_agents: Set[str] = set()
+        self._enabled_skills: Set[str] = set()
+        self._disabled_skill_patterns: list[str] = []
+
+    def _find_profiles_dir(self) -> Path:
+        """Find profiles directory by searching for .claude-mpm in cwd and parents.
+
+        Returns:
+            Path to profiles directory (may not exist yet)
+        """
+        current = Path.cwd()
+
+        # Search current directory and up to 5 parent directories
+        for _ in range(6):
+            profiles_dir = current / ".claude-mpm" / "profiles"
+            if profiles_dir.exists():
+                logger.debug(f"Found profiles directory at: {profiles_dir}")
+                return profiles_dir
+            if current.parent == current:  # Reached filesystem root
+                break
+            current = current.parent
+
+        # Fallback to cwd (directory may not exist yet, which is fine)
+        fallback = Path.cwd() / ".claude-mpm" / "profiles"
+        logger.debug(f"Profiles directory not found, using fallback: {fallback}")
+        return fallback
+
+    def load_profile(self, profile_name: str) -> bool:
+        """
+        Load profile from YAML file.
+
+        Args:
+            profile_name: Name of profile (without .yaml extension)
+
+        Returns:
+            bool: True if profile loaded successfully, False otherwise
+        """
+        profile_path = self.profiles_dir / f"{profile_name}.yaml"
+
+        logger.debug(f"Looking for profile at: {profile_path}")
+
+        if not profile_path.exists():
+            logger.warning(f"Profile not found: {profile_path}")
+            return False
+
+        try:
+            with profile_path.open("r") as f:
+                self._profile_data = yaml.safe_load(f) or {}
+
+            # Extract profile metadata
+            profile_info = self._profile_data.get("profile", {})
+            self.active_profile = profile_info.get("name", profile_name)
+
+            # Parse agents
+            agents_config = self._profile_data.get("agents", {})
+            self._enabled_agents = set(agents_config.get("enabled", []))
+            self._disabled_agents = set(agents_config.get("disabled", []))
+
+            # Parse skills
+            skills_config = self._profile_data.get("skills", {})
+            self._enabled_skills = set(skills_config.get("enabled", []))
+            self._disabled_skill_patterns = skills_config.get("disabled_categories", [])
+
+            logger.info(
+                f"Loaded profile '{self.active_profile}': "
+                f"{len(self._enabled_agents)} agents, "
+                f"{len(self._enabled_skills)} skills enabled"
+            )
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to load profile {profile_name}: {e}")
+            return False
+
+    def is_agent_enabled(self, agent_name: str) -> bool:
+        """
+        Check if agent is enabled in active profile.
+
+        If no profile is loaded, all agents are enabled by default.
+
+        Args:
+            agent_name: Name of agent to check
+
+        Returns:
+            bool: True if agent should be deployed
+        """
+        if not self.active_profile:
+            # No profile active - all agents enabled
+            return True
+
+        # If enabled list exists, agent must be in it
+        if self._enabled_agents:
+            return agent_name in self._enabled_agents
+
+        # Otherwise, agent must NOT be in disabled list
+        return agent_name not in self._disabled_agents
+
+    def is_skill_enabled(self, skill_name: str) -> bool:
+        """
+        Check if skill is enabled in active profile.
+
+        Supports both short names (flask) and full names (toolchains-python-frameworks-flask).
+        Supports glob pattern matching for disabled_categories.
+
+        If no profile is loaded, all skills are enabled by default.
+
+        Args:
+            skill_name: Name of skill to check (e.g., "flask", "toolchains-python-frameworks-flask")
+
+        Returns:
+            bool: True if skill should be deployed
+        """
+        if not self.active_profile:
+            # No profile active - all skills enabled
+            return True
+
+        # Check if skill is explicitly disabled by pattern
+        for pattern in self._disabled_skill_patterns:
+            if fnmatch.fnmatch(skill_name, pattern):
+                logger.debug(f"Skill '{skill_name}' matched disabled pattern '{pattern}'")
+                return False
+
+        # If enabled list exists, check for match
+        if self._enabled_skills:
+            # Exact match
+            if skill_name in self._enabled_skills:
+                return True
+
+            # Check if full skill name ends with short name from enabled list
+            # Example: "toolchains-python-frameworks-flask" matches "flask"
+            for short_name in self._enabled_skills:
+                if skill_name.endswith(f"-{short_name}"):
+                    return True
+                # Also check if short name is contained as a segment
+                if f"-{short_name}-" in skill_name or skill_name.startswith(f"{short_name}-"):
+                    return True
+
+            return False
+
+        # No enabled list and didn't match disabled pattern - allow it
+        return True
+
+    def get_enabled_agents(self) -> Set[str]:
+        """
+        Get set of enabled agent names.
+
+        Returns:
+            Set[str]: Agent names that should be deployed
+        """
+        return self._enabled_agents.copy()
+
+    def get_disabled_agents(self) -> Set[str]:
+        """
+        Get set of disabled agent names.
+
+        Returns:
+            Set[str]: Agent names that should NOT be deployed
+        """
+        return self._disabled_agents.copy()
+
+    def get_enabled_skills(self) -> Set[str]:
+        """
+        Get set of explicitly enabled skill names.
+
+        Returns:
+            Set[str]: Skill names that should be deployed
+        """
+        return self._enabled_skills.copy()
+
+    def get_disabled_skill_patterns(self) -> list[str]:
+        """
+        Get list of disabled skill glob patterns.
+
+        Returns:
+            list[str]: Glob patterns for skills that should NOT be deployed
+        """
+        return self._disabled_skill_patterns.copy()
+
+    def get_filtering_summary(self) -> Dict[str, Any]:
+        """
+        Get summary of current profile filtering.
+
+        Returns:
+            Dict containing:
+            - active_profile: Name of active profile (or None)
+            - enabled_agents_count: Number of explicitly enabled agents
+            - disabled_agents_count: Number of explicitly disabled agents
+            - enabled_skills_count: Number of explicitly enabled skills
+            - disabled_patterns_count: Number of disabled skill patterns
+        """
+        return {
+            "active_profile": self.active_profile,
+            "enabled_agents_count": len(self._enabled_agents),
+            "disabled_agents_count": len(self._disabled_agents),
+            "enabled_skills_count": len(self._enabled_skills),
+            "disabled_patterns_count": len(self._disabled_skill_patterns),
+        }
+
+    def list_available_profiles(self) -> list[str]:
+        """
+        List all available profile names in profiles directory.
+
+        Returns:
+            list[str]: Profile names (without .yaml extension)
+        """
+        if not self.profiles_dir.exists():
+            return []
+
+        profiles = []
+        for profile_path in self.profiles_dir.glob("*.yaml"):
+            profiles.append(profile_path.stem)
+
+        return sorted(profiles)
+
+    def get_profile_description(self, profile_name: str) -> Optional[str]:
+        """
+        Get description of a profile without loading it fully.
+
+        Args:
+            profile_name: Name of profile
+
+        Returns:
+            Optional[str]: Profile description or None if not found
+        """
+        profile_path = self.profiles_dir / f"{profile_name}.yaml"
+
+        if not profile_path.exists():
+            return None
+
+        try:
+            with profile_path.open("r") as f:
+                data = yaml.safe_load(f) or {}
+                profile_info = data.get("profile", {})
+                return profile_info.get("description")
+        except Exception:
+            return None

claude_mpm/services/self_upgrade_service.py

@@ -3,7 +3,7 @@ Self-Upgrade Service
 ====================
 
 Handles version checking and self-upgrade functionality for claude-mpm.
-Supports pip, pipx, and npm installations with automatic detection.
+Supports pip, pipx, npm, uv tool, and Homebrew installations with automatic detection.
 Also checks Claude Code version compatibility.
 
 WHY: Users should be notified of updates and have an easy way to upgrade
@@ -11,7 +11,7 @@ without manually running installation commands. Claude Code version checking
 ensures compatibility with required features.
 
 DESIGN DECISIONS:
-- Detects installation method (pip/pipx/npm/editable)
+- Detects installation method (pip/pipx/npm/uv_tool/homebrew/editable)
 - Non-blocking version checks with caching
 - Interactive upgrade prompts with confirmation
 - Automatic restart after upgrade
@@ -40,6 +40,8 @@ class InstallationMethod:
     PIP = "pip"
     PIPX = "pipx"
     NPM = "npm"
+    UV_TOOL = "uv_tool"
+    HOMEBREW = "homebrew"
     EDITABLE = "editable"
     UNKNOWN = "unknown"
 
@@ -95,6 +97,14 @@ class SelfUpgradeService:
         """
         Detect how claude-mpm was installed.
 
+        Detection priority:
+        1. Editable (skip auto-upgrade)
+        2. UV Tool
+        3. Homebrew
+        4. Pipx
+        5. NPM
+        6. Pip (default)
+
         Returns:
             Installation method constant
         """
@@ -105,6 +115,14 @@ class SelfUpgradeService:
         ]:
             return InstallationMethod.EDITABLE
 
+        # Check for UV tool installation
+        if self._check_uv_tool_installation():
+            return InstallationMethod.UV_TOOL
+
+        # Check for Homebrew installation
+        if self._check_homebrew_installation():
+            return InstallationMethod.HOMEBREW
+
         # Check for pipx by looking at executable path
         executable = sys.executable
         if "pipx" in executable:
@@ -127,6 +145,85 @@ class SelfUpgradeService:
         # Default to pip
         return InstallationMethod.PIP
 
+    def _check_uv_tool_installation(self) -> bool:
+        """
+        Check if claude-mpm is installed via uv tool.
+
+        Detection methods:
+        1. Check UV_TOOL_DIR environment variable
+        2. Check if executable path contains .local/share/uv/tools/
+        3. Fallback: Run `uv tool list` and check for claude-mpm
+
+        Returns:
+            True if UV tool installation detected
+        """
+        # Method 1: 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:
+            return True
+
+        # Method 2: Check executable path
+        executable = sys.executable
+        if ".local/share/uv/tools/" in executable or "uv/tools/" in executable:
+            return True
+
+        # Method 3: Fallback to `uv tool list` command
+        try:
+            result = subprocess.run(
+                ["uv", "tool", "list"],
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0 and "claude-mpm" in result.stdout:
+                return True
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            # uv not installed or command failed
+            pass
+        except Exception as e:
+            self.logger.debug(f"UV tool check failed: {e}")
+
+        return False
+
+    def _check_homebrew_installation(self) -> bool:
+        """
+        Check if claude-mpm is installed via Homebrew.
+
+        Detection methods:
+        1. Check if executable path starts with /opt/homebrew/ or /usr/local/Cellar/
+        2. Fallback: Run `brew list claude-mpm` to verify
+
+        Returns:
+            True if Homebrew installation detected
+        """
+        # Method 1: Check executable path
+        executable = sys.executable
+        if executable.startswith("/opt/homebrew/") or executable.startswith(
+            "/usr/local/Cellar/"
+        ):
+            return True
+
+        # Method 2: Fallback to `brew list` command
+        try:
+            result = subprocess.run(
+                ["brew", "list", "claude-mpm"],
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            # brew list returns 0 if package is installed
+            if result.returncode == 0:
+                return True
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            # brew not installed or command failed
+            pass
+        except Exception as e:
+            self.logger.debug(f"Homebrew check failed: {e}")
+
+        return False
+
     def _get_claude_code_version(self) -> Optional[str]:
         """
         Get the installed Claude Code version.
@@ -257,6 +354,8 @@ class SelfUpgradeService:
         if self.installation_method in [
             InstallationMethod.PIP,
             InstallationMethod.PIPX,
+            InstallationMethod.UV_TOOL,
+            InstallationMethod.HOMEBREW,
         ]:
             result = await self.version_checker.check_for_update(
                 "claude-mpm", self.current_version, cache_ttl
@@ -313,15 +412,18 @@ class SelfUpgradeService:
         Returns:
             Shell command string to upgrade claude-mpm
         """
-        if self.installation_method == InstallationMethod.PIPX:
-            return "pipx upgrade claude-mpm"
-        if self.installation_method == InstallationMethod.NPM:
-            return "npm update -g claude-mpm"
-        if self.installation_method == InstallationMethod.PIP:
-            return f"{sys.executable} -m pip install --upgrade claude-mpm"
-        if self.installation_method == InstallationMethod.EDITABLE:
-            return "git pull && pip install -e ."
-        return "pip install --upgrade claude-mpm"
+        upgrade_commands = {
+            InstallationMethod.UV_TOOL: "uv tool upgrade claude-mpm",
+            InstallationMethod.HOMEBREW: "brew upgrade claude-mpm",
+            InstallationMethod.PIPX: "pipx upgrade claude-mpm",
+            InstallationMethod.NPM: "npm update -g claude-mpm",
+            InstallationMethod.PIP: f"{sys.executable} -m pip install --upgrade claude-mpm",
+            InstallationMethod.EDITABLE: "git pull && pip install -e .",
+        }
+
+        return upgrade_commands.get(
+            self.installation_method, "pip install --upgrade claude-mpm"
+        )
 
     def prompt_for_upgrade(self, update_info: Dict[str, any]) -> bool:
         """
@@ -432,7 +534,13 @@ class SelfUpgradeService:
             args = sys.argv[:]
 
             # Replace current process with new one
-            if self.installation_method == InstallationMethod.PIPX:
+            if self.installation_method == InstallationMethod.UV_TOOL:
+                # Use uv run
+                os.execvp("uv", ["uv", "tool", "run", "claude-mpm", *args[1:]])
+            elif self.installation_method == InstallationMethod.HOMEBREW:
+                # Use direct executable (installed to PATH by Homebrew)
+                os.execvp("claude-mpm", args)
+            elif self.installation_method == InstallationMethod.PIPX:
                 # Use pipx run
                 os.execvp("pipx", ["pipx", "run", "claude-mpm", *args[1:]])
             elif self.installation_method == InstallationMethod.NPM:

claude_mpm/services/skills/__init__.py

@@ -3,6 +3,7 @@
 This package provides services for Git-based skills management:
 - GitSkillSourceManager: Multi-repository orchestration with priority resolution
 - SkillDiscoveryService: Parse skills from Git repositories (Markdown with YAML frontmatter)
+- SkillToAgentMapper: Map skills to agents using YAML configuration
 """
 
 from claude_mpm.services.skills.git_skill_source_manager import GitSkillSourceManager
@@ -10,9 +11,11 @@ from claude_mpm.services.skills.skill_discovery_service import (
     SkillDiscoveryService,
     SkillMetadata,
 )
+from claude_mpm.services.skills.skill_to_agent_mapper import SkillToAgentMapper
 
 __all__ = [
     "GitSkillSourceManager",
     "SkillDiscoveryService",
     "SkillMetadata",
+    "SkillToAgentMapper",
 ]