claude-mpm 5.4.22__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/skills/git_skill_source_manager.py

@@ -1049,12 +1049,33 @@ class GitSkillSourceManager:
             original_count = len(all_skills)
             # Normalize filter to lowercase for case-insensitive matching
             normalized_filter = {s.lower() for s in skill_filter}
-            # Match against deployment_name (not display name) since skill_filter contains
-            # deployment-style names like "toolchains-python-frameworks-django"
+
+            def matches_filter(deployment_name: str) -> bool:
+                """Match using same fuzzy logic as ProfileManager.is_skill_enabled()"""
+                deployment_lower = deployment_name.lower()
+
+                # Exact match
+                if deployment_lower in normalized_filter:
+                    return True
+
+                # Fuzzy match: check if deployment name ends with or contains short name
+                # Example: "toolchains-python-frameworks-flask" matches "flask"
+                for short_name in normalized_filter:
+                    if deployment_lower.endswith(f"-{short_name}"):
+                        return True
+                    # Check if short name is contained as a segment
+                    if f"-{short_name}-" in deployment_lower:
+                        return True
+                    if deployment_lower.startswith(f"{short_name}-"):
+                        return True
+
+                return False
+
+            # Match against deployment_name using fuzzy matching
             all_skills = [
                 s
                 for s in all_skills
-                if s.get("deployment_name", "").lower() in normalized_filter
+                if matches_filter(s.get("deployment_name", ""))
             ]
             filtered_count = original_count - len(all_skills)
             self.logger.info(
@@ -1062,6 +1083,16 @@ class GitSkillSourceManager:
                 f"match agent requirements ({filtered_count} filtered out)"
             )
 
+            # Cleanup: Remove skills from target directory that aren't in the filtered set
+            # This ensures only the skills in the profile are deployed
+            removed_skills = self._cleanup_unfiltered_skills(
+                target_dir, all_skills
+            )
+            if removed_skills:
+                self.logger.info(
+                    f"Removed {len(removed_skills)} skills not in profile filter: {removed_skills}"
+                )
+
         self.logger.info(
             f"Deploying {len(all_skills)} skills to {target_dir} (force={force})"
         )
@@ -1115,6 +1146,73 @@ class GitSkillSourceManager:
             "filtered_count": filtered_count,
         }
 
+    def _cleanup_unfiltered_skills(
+        self, target_dir: Path, filtered_skills: List[Dict[str, Any]]
+    ) -> List[str]:
+        """Remove skills from target directory that aren't in the filtered skill list.
+
+        Args:
+            target_dir: Target deployment directory
+            filtered_skills: List of skills that should remain deployed
+
+        Returns:
+            List of skill names that were removed
+        """
+        import shutil
+
+        removed_skills = []
+
+        # Build set of deployment names that should exist
+        expected_deployments = {
+            skill.get("deployment_name") for skill in filtered_skills
+            if skill.get("deployment_name")
+        }
+
+        # Check each directory in target_dir
+        if not target_dir.exists():
+            return removed_skills
+
+        try:
+            for item in target_dir.iterdir():
+                # Skip files, only process directories
+                if not item.is_dir():
+                    continue
+
+                # Skip hidden directories
+                if item.name.startswith("."):
+                    continue
+
+                # Check if this skill directory should be kept
+                if item.name not in expected_deployments:
+                    try:
+                        # Security: Validate path is within target_dir
+                        if not self._validate_safe_path(target_dir, item):
+                            self.logger.error(
+                                f"Refusing to remove path outside target directory: {item}"
+                            )
+                            continue
+
+                        # Remove the skill directory
+                        if item.is_symlink():
+                            item.unlink()
+                        else:
+                            shutil.rmtree(item)
+
+                        removed_skills.append(item.name)
+                        self.logger.debug(
+                            f"Removed unfiltered skill: {item.name}"
+                        )
+
+                    except Exception as e:
+                        self.logger.warning(
+                            f"Failed to remove skill directory {item.name}: {e}"
+                        )
+
+        except Exception as e:
+            self.logger.error(f"Error during skill cleanup: {e}")
+
+        return removed_skills
+
     def _deploy_single_skill(
         self, skill: Dict[str, Any], target_dir: Path, deployment_name: str, force: bool
     ) -> Dict[str, Any]:

claude_mpm/services/skills_deployer.py

@@ -257,9 +257,9 @@ class SkillsDeployerService(LoggerMixin):
                 self.logger.error(f"Failed to deploy {skill_name}: {e}")
                 errors.append(f"{skill_name}: {e}")
 
-        # Step 5: Cleanup orphaned skills (if selective mode enabled)
+        # Step 5: Cleanup orphaned skills (always run in selective mode)
         cleanup_result = {"removed_count": 0, "removed_skills": []}
-        if selective and len(deployed) > 0:
+        if selective:
             # Get the set of skills that should remain deployed
             # This is the union of what we just deployed and what was already there
             try:
@@ -267,7 +267,8 @@ class SkillsDeployerService(LoggerMixin):
                     cleanup_orphan_skills,
                 )
 
-                # Only cleanup if we're in selective mode
+                # Cleanup orphaned skills not referenced by agents
+                # This runs even if nothing new was deployed to remove stale skills
                 cleanup_result = cleanup_orphan_skills(
                     self.CLAUDE_SKILLS_DIR, set(filtered_skills_names)
                 )

claude_mpm/services/socketio/dashboard_server.py

@@ -152,6 +152,7 @@ class DashboardServer(SocketIOServiceInterface):
 
         # Register handlers for all events we want to relay from monitor to dashboard
         relay_events = [
+            "claude_event",  # Tool events from Claude Code hooks
             "session_started",
             "session_ended",
             "claude_status",

claude_mpm/services/socketio/event_normalizer.py

@@ -6,7 +6,7 @@ This normalizer ensures all events follow a consistent schema before broadcastin
 providing backward compatibility while establishing a standard format.
 
 DESIGN DECISION: Transform all events to a consistent schema:
-- event: Socket.IO event name (always "claude_event")
+- event: Socket.IO event name (always "mpm_event")
 - type: Main category (hook, system, session, file, connection)
 - subtype: Specific event type (pre_tool, heartbeat, started, etc.)
 - timestamp: ISO format timestamp
@@ -72,7 +72,7 @@ class NormalizedEvent:
     structure explicit and self-documenting.
     """
 
-    event: str = "claude_event"  # Socket.IO event name
+    event: str = "mpm_event"  # Socket.IO event name
     source: str = ""  # WHERE the event comes from
     type: str = ""  # WHAT category of event
     subtype: str = ""  # Specific event type
@@ -81,6 +81,8 @@ class NormalizedEvent:
     correlation_id: Optional[str] = (
         None  # For correlating related events (e.g., pre_tool/post_tool)
     )
+    session_id: Optional[str] = None  # Session identifier for stream grouping
+    cwd: Optional[str] = None  # Working directory for project identification
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for emission."""
@@ -95,6 +97,12 @@ class NormalizedEvent:
         # Include correlation_id if present
         if self.correlation_id:
             result["correlation_id"] = self.correlation_id
+        # Include session_id if present
+        if self.session_id:
+            result["session_id"] = self.session_id
+        # Include cwd if present
+        if self.cwd:
+            result["cwd"] = self.cwd
         return result
 
 
@@ -113,6 +121,7 @@ class EventNormalizer:
         "pre_response": (EventType.HOOK, "pre_response"),
         "post_response": (EventType.HOOK, "post_response"),
         "hook_event": (EventType.HOOK, "generic"),
+        "hook_execution": (EventType.HOOK, "execution"),  # Hook execution metadata
         "UserPrompt": (EventType.HOOK, "user_prompt"),  # Legacy format
         # Test events (legacy format)
         "TestStart": (EventType.TEST, "start"),
@@ -225,20 +234,32 @@ class EventNormalizer:
             # Get or generate timestamp
             timestamp = self._extract_timestamp(event_data)
 
-            # Extract correlation_id if present
+            # Extract correlation_id, session_id, and cwd if present
             correlation_id = None
+            session_id = None
+            cwd = None
             if isinstance(event_data, dict):
                 correlation_id = event_data.get("correlation_id")
+                # Try both naming conventions for session_id
+                session_id = event_data.get("session_id") or event_data.get("sessionId")
+                # Try multiple field names for working directory
+                cwd = (
+                    event_data.get("cwd")
+                    or event_data.get("working_directory")
+                    or event_data.get("workingDirectory")
+                )
 
             # Create normalized event
             normalized = NormalizedEvent(
-                event="claude_event",
+                event="mpm_event",
                 source=event_source,
                 type=event_type,
                 subtype=subtype,
                 timestamp=timestamp,
                 data=data,
                 correlation_id=correlation_id,
+                session_id=session_id,
+                cwd=cwd,
             )
 
             self.stats["normalized"] += 1
@@ -252,7 +273,7 @@ class EventNormalizer:
 
             # Return a generic event on error
             return NormalizedEvent(
-                event="claude_event",
+                event="mpm_event",
                 source="system",
                 type="unknown",
                 subtype="error",
@@ -285,8 +306,16 @@ class EventNormalizer:
             # If source is not a valid EventSource value, keep it as-is
             pass
 
+        # Extract session_id and cwd, trying multiple naming conventions
+        session_id = event_data.get("session_id") or event_data.get("sessionId")
+        cwd = (
+            event_data.get("cwd")
+            or event_data.get("working_directory")
+            or event_data.get("workingDirectory")
+        )
+
         return NormalizedEvent(
-            event="claude_event",  # Always use standard event name
+            event="mpm_event",  # Always use standard event name
             source=source,
             type=event_data.get("type", "unknown"),
             subtype=event_data.get("subtype", "generic"),
@@ -295,6 +324,8 @@ class EventNormalizer:
             ),
             data=event_data.get("data", {}),
             correlation_id=event_data.get("correlation_id"),
+            session_id=session_id,
+            cwd=cwd,
         )
 
     def _extract_event_info(self, event_data: Any) -> Tuple[str, str, Dict[str, Any]]: