claude-mpm 4.15.3__py3-none-any.whl → 4.15.6__py3-none-any.whl

claude_mpm/services/socketio/handlers/hook.py

@@ -61,6 +61,10 @@ class HookEventHandler(BaseEventHandler):
 
         hook_data = data.get("data", {})
 
+        # Log hook event processing
+        tool_name = hook_data.get("tool_name", "N/A")
+        self.logger.info(f"Processing hook event: {hook_event} - tool: {tool_name}")
+
         # Create properly formatted event for history
         # Note: add_to_history expects the event data directly, not wrapped
         history_event = {
@@ -77,6 +81,12 @@ class HookEventHandler(BaseEventHandler):
 
         # Broadcast the original event to all connected clients
         # (preserves all original fields)
+        connected_clients = (
+            len(self.server.clients) if hasattr(self.server, "clients") else 0
+        )
+        self.logger.info(
+            f"Broadcasting claude_event to {connected_clients} clients: {hook_event}"
+        )
         await self.broadcast_event("claude_event", data)
 
         # Track sessions based on hook events

claude_mpm/services/socketio/handlers/registry.py

@@ -15,7 +15,8 @@ if TYPE_CHECKING:
 
     from ..server import SocketIOServer
 
-from .code_analysis import CodeAnalysisEventHandler
+# DISABLED: File Tree interface removed from dashboard
+# from .code_analysis import CodeAnalysisEventHandler
 from .connection import ConnectionEventHandler
 from .file import FileEventHandler
 from .git import GitEventHandler
@@ -38,7 +39,8 @@ class EventHandlerRegistry:
         HookEventHandler,  # Hook events for session tracking
         GitEventHandler,  # Git operations
         FileEventHandler,  # File operations
-        CodeAnalysisEventHandler,  # Code analysis for dashboard
+        # DISABLED: File Tree interface removed from dashboard
+        # CodeAnalysisEventHandler,  # Code analysis for dashboard
         ProjectEventHandler,  # Project management (future)
         MemoryEventHandler,  # Memory management (future)
     ]

claude_mpm/services/socketio/server/main.py

@@ -267,15 +267,15 @@ class SocketIOServer(SocketIOServiceInterface):
             except Exception as e:
                 self.logger.error(f"Error during EventBus teardown: {e}")
 
-        # Stop code analysis handler
+        # Stop event handlers
         if self.event_registry:
-            from ..handlers import CodeAnalysisEventHandler, ConnectionEventHandler
-
-            # Stop analysis runner
-            analysis_handler = self.event_registry.get_handler(CodeAnalysisEventHandler)
-            if analysis_handler and hasattr(analysis_handler, "cleanup"):
-                analysis_handler.cleanup()
+            from ..handlers import ConnectionEventHandler
 
+            # DISABLED: File Tree interface removed from dashboard
+            # Stop analysis runner (code analysis handler is disabled)
+            # analysis_handler = self.event_registry.get_handler(CodeAnalysisEventHandler)
+            # if analysis_handler and hasattr(analysis_handler, "cleanup"):
+            #     analysis_handler.cleanup()
             # Stop health monitoring in connection handler
             conn_handler = self.event_registry.get_handler(ConnectionEventHandler)
             if conn_handler and hasattr(conn_handler, "stop_health_monitoring"):

claude_mpm/skills/__init__.py

@@ -0,0 +1,21 @@
+"""
+Claude MPM Skills Package
+
+Skills system for sharing common capabilities across agents.
+This reduces redundancy by extracting shared patterns into reusable skills.
+
+Skills can be:
+- Bundled with MPM (in skills/bundled/)
+- User-installed (in ~/.claude/skills/)
+- Project-specific (in .claude/skills/)
+"""
+
+from .registry import Skill, SkillsRegistry, get_registry
+from .skill_manager import SkillManager
+
+__all__ = [
+    "Skill",
+    "SkillManager",
+    "SkillsRegistry",
+    "get_registry",
+]

claude_mpm/skills/bundled/__init__.py

@@ -0,0 +1,6 @@
+"""
+Bundled skills shipped with Claude MPM.
+
+These skills provide reusable patterns and practices that eliminate
+redundancy across agent templates.
+"""

claude_mpm/skills/registry.py

@@ -0,0 +1,198 @@
+"""Skills registry - manages bundled and discovered skills."""
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class Skill:
+    """Represents a skill that can be used by agents."""
+
+    name: str
+    path: Path
+    content: str
+    source: str  # 'bundled', 'user', or 'project'
+    description: str = ""
+    agent_types: List[str] = None  # Which agent types can use this skill
+
+    def __post_init__(self):
+        """Initialize agent_types list if not provided."""
+        if self.agent_types is None:
+            self.agent_types = []
+
+
+class SkillsRegistry:
+    """Registry for managing skills across all tiers."""
+
+    def __init__(self):
+        """Initialize the skills registry."""
+        self.skills: Dict[str, Skill] = {}
+        self._load_bundled_skills()
+        self._load_user_skills()
+        self._load_project_skills()
+
+    def _load_bundled_skills(self):
+        """Load skills bundled with MPM."""
+        bundled_dir = Path(__file__).parent / "bundled"
+        if not bundled_dir.exists():
+            logger.warning(f"Bundled skills directory not found: {bundled_dir}")
+            return
+
+        skill_count = 0
+        for skill_file in bundled_dir.glob("*.md"):
+            try:
+                skill_name = skill_file.stem
+                content = skill_file.read_text(encoding="utf-8")
+
+                # Extract description from first paragraph if available
+                description = self._extract_description(content)
+
+                self.skills[skill_name] = Skill(
+                    name=skill_name,
+                    path=skill_file,
+                    content=content,
+                    source="bundled",
+                    description=description,
+                )
+                skill_count += 1
+            except Exception as e:
+                logger.error(f"Error loading bundled skill {skill_file}: {e}")
+
+        logger.info(f"Loaded {skill_count} bundled skills")
+
+    def _load_user_skills(self):
+        """Load user-installed skills from ~/.claude/skills/"""
+        user_skills_dir = Path.home() / ".claude" / "skills"
+        if not user_skills_dir.exists():
+            logger.debug("User skills directory not found, skipping")
+            return
+
+        skill_count = 0
+        for skill_file in user_skills_dir.glob("*.md"):
+            try:
+                skill_name = skill_file.stem
+                # User skills override bundled skills
+                content = skill_file.read_text(encoding="utf-8")
+                description = self._extract_description(content)
+
+                self.skills[skill_name] = Skill(
+                    name=skill_name,
+                    path=skill_file,
+                    content=content,
+                    source="user",
+                    description=description,
+                )
+                skill_count += 1
+                logger.debug(f"User skill '{skill_name}' overrides bundled version")
+            except Exception as e:
+                logger.error(f"Error loading user skill {skill_file}: {e}")
+
+        if skill_count > 0:
+            logger.info(f"Loaded {skill_count} user skills")
+
+    def _load_project_skills(self):
+        """Load project-specific skills from .claude/skills/"""
+        project_skills_dir = Path.cwd() / ".claude" / "skills"
+        if not project_skills_dir.exists():
+            logger.debug("Project skills directory not found, skipping")
+            return
+
+        skill_count = 0
+        for skill_file in project_skills_dir.glob("*.md"):
+            try:
+                skill_name = skill_file.stem
+                # Project skills override both user and bundled skills
+                content = skill_file.read_text(encoding="utf-8")
+                description = self._extract_description(content)
+
+                self.skills[skill_name] = Skill(
+                    name=skill_name,
+                    path=skill_file,
+                    content=content,
+                    source="project",
+                    description=description,
+                )
+                skill_count += 1
+                logger.debug(f"Project skill '{skill_name}' overrides other versions")
+            except Exception as e:
+                logger.error(f"Error loading project skill {skill_file}: {e}")
+
+        if skill_count > 0:
+            logger.info(f"Loaded {skill_count} project skills")
+
+    def _extract_description(self, content: str) -> str:
+        """Extract description from skill content (first paragraph or summary)."""
+        lines = content.strip().split("\n")
+        description_lines = []
+
+        # Skip title (first line starting with #)
+        start_idx = 0
+        if lines and lines[0].startswith("#"):
+            start_idx = 1
+
+        # Find first non-empty paragraph
+        for line in lines[start_idx:]:
+            line = line.strip()
+            if not line:
+                if description_lines:
+                    break
+                continue
+            if line.startswith("#"):
+                break
+            description_lines.append(line)
+
+        return " ".join(description_lines)[:200]  # Limit to 200 chars
+
+    def get_skill(self, name: str) -> Optional[Skill]:
+        """Get a skill by name."""
+        return self.skills.get(name)
+
+    def list_skills(self, source: Optional[str] = None) -> List[Skill]:
+        """List all skills, optionally filtered by source."""
+        if source:
+            return [s for s in self.skills.values() if s.source == source]
+        return list(self.skills.values())
+
+    def get_skills_for_agent(self, agent_type: str) -> List[Skill]:
+        """
+        Get skills mapped to a specific agent type.
+
+        Args:
+            agent_type: Agent type/ID (e.g., 'engineer', 'python_engineer')
+
+        Returns:
+            List of skills applicable to this agent type
+        """
+        # Filter skills that explicitly list this agent type
+        # If a skill has no agent_types specified, it's available to all agents
+        return [
+            skill
+            for skill in self.skills.values()
+            if not skill.agent_types or agent_type in skill.agent_types
+        ]
+
+    def reload(self):
+        """Reload all skills from disk."""
+        logger.info("Reloading skills registry...")
+        self.skills.clear()
+        self._load_bundled_skills()
+        self._load_user_skills()
+        self._load_project_skills()
+        logger.info(f"Skills registry reloaded with {len(self.skills)} skills")
+
+
+# Global registry instance (singleton pattern)
+_registry: Optional[SkillsRegistry] = None
+
+
+def get_registry() -> SkillsRegistry:
+    """Get the global skills registry (singleton)."""
+    global _registry
+    if _registry is None:
+        _registry = SkillsRegistry()
+    return _registry

claude_mpm/skills/skill_manager.py

@@ -0,0 +1,310 @@
+"""Skills manager - integrates skills with agents."""
+
+import json
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from claude_mpm.core.logging_utils import get_logger
+
+from .registry import Skill, get_registry
+
+logger = get_logger(__name__)
+
+
+class SkillManager:
+    """Manages skills and their integration with agents."""
+
+    def __init__(self):
+        """Initialize the skill manager."""
+        self.registry = get_registry()
+        self.agent_skill_mapping: Dict[str, List[str]] = {}
+        self._load_agent_mappings()
+
+    def _load_agent_mappings(self):
+        """Load skill mappings from agent templates."""
+        # Load mappings from agent JSON templates that have 'skills' field
+        agent_templates_dir = Path(__file__).parent.parent / "agents" / "templates"
+
+        if not agent_templates_dir.exists():
+            logger.warning(
+                f"Agent templates directory not found: {agent_templates_dir}"
+            )
+            return
+
+        mapping_count = 0
+        for template_file in agent_templates_dir.glob("*.json"):
+            try:
+                with open(template_file, encoding="utf-8") as f:
+                    agent_data = json.load(f)
+
+                agent_id = agent_data.get("agent_id") or agent_data.get("agent_type")
+                if not agent_id:
+                    continue
+
+                # Extract skills list if present
+                skills = agent_data.get("skills", [])
+                if skills:
+                    self.agent_skill_mapping[agent_id] = skills
+                    mapping_count += 1
+                    logger.debug(
+                        f"Agent '{agent_id}' mapped to {len(skills)} skills: {', '.join(skills)}"
+                    )
+
+            except Exception as e:
+                logger.error(f"Error loading agent mapping from {template_file}: {e}")
+
+        if mapping_count > 0:
+            logger.info(f"Loaded skill mappings for {mapping_count} agents")
+
+    def get_agent_skills(self, agent_type: str) -> List[Skill]:
+        """
+        Get all skills for an agent (bundled + discovered).
+
+        Args:
+            agent_type: Agent type/ID (e.g., 'engineer', 'python_engineer')
+
+        Returns:
+            List of Skill objects for this agent
+        """
+        skill_names = self.agent_skill_mapping.get(agent_type, [])
+
+        # Get skills from registry
+        skills = []
+        for name in skill_names:
+            skill = self.registry.get_skill(name)
+            if skill:
+                skills.append(skill)
+            else:
+                logger.warning(
+                    f"Skill '{name}' referenced by agent '{agent_type}' not found"
+                )
+
+        # Also include skills that have no agent restriction
+        # or explicitly list this agent type
+        additional_skills = self.registry.get_skills_for_agent(agent_type)
+        for skill in additional_skills:
+            if skill not in skills:
+                skills.append(skill)
+
+        return skills
+
+    def enhance_agent_prompt(
+        self, agent_type: str, base_prompt: str, include_all: bool = False
+    ) -> str:
+        """
+        Enhance agent prompt with available skills.
+
+        Args:
+            agent_type: Agent type/ID
+            base_prompt: Original agent prompt
+            include_all: If True, include all available skills regardless of mapping
+
+        Returns:
+            Enhanced prompt with skills section appended
+        """
+        if include_all:
+            skills = self.registry.list_skills()
+        else:
+            skills = self.get_agent_skills(agent_type)
+
+        if not skills:
+            return base_prompt
+
+        # Build skills section
+        skills_section = "\n\n" + "=" * 80 + "\n"
+        skills_section += "## 🎯 Available Skills\n\n"
+        skills_section += f"You have access to {len(skills)} specialized skills:\n\n"
+
+        for skill in skills:
+            skills_section += f"### 📚 {skill.name.replace('-', ' ').title()}\n\n"
+            skills_section += f"**Source:** {skill.source}\n"
+            if skill.description:
+                skills_section += f"**Description:** {skill.description}\n"
+            skills_section += "\n```\n"
+            skills_section += skill.content
+            skills_section += "\n```\n\n"
+
+        skills_section += "=" * 80 + "\n"
+
+        return base_prompt + skills_section
+
+    def list_agent_skill_mappings(self) -> Dict[str, List[str]]:
+        """
+        Get all agent-to-skill mappings.
+
+        Returns:
+            Dictionary mapping agent IDs to lists of skill names
+        """
+        return self.agent_skill_mapping.copy()
+
+    def add_skill_to_agent(self, agent_type: str, skill_name: str) -> bool:
+        """
+        Add a skill to an agent's mapping.
+
+        Args:
+            agent_type: Agent type/ID
+            skill_name: Name of the skill to add
+
+        Returns:
+            True if successful, False if skill not found
+        """
+        skill = self.registry.get_skill(skill_name)
+        if not skill:
+            logger.error(f"Cannot add skill '{skill_name}': skill not found")
+            return False
+
+        if agent_type not in self.agent_skill_mapping:
+            self.agent_skill_mapping[agent_type] = []
+
+        if skill_name not in self.agent_skill_mapping[agent_type]:
+            self.agent_skill_mapping[agent_type].append(skill_name)
+            logger.info(f"Added skill '{skill_name}' to agent '{agent_type}'")
+
+        return True
+
+    def remove_skill_from_agent(self, agent_type: str, skill_name: str) -> bool:
+        """
+        Remove a skill from an agent's mapping.
+
+        Args:
+            agent_type: Agent type/ID
+            skill_name: Name of the skill to remove
+
+        Returns:
+            True if successful, False if not found
+        """
+        if agent_type not in self.agent_skill_mapping:
+            return False
+
+        if skill_name in self.agent_skill_mapping[agent_type]:
+            self.agent_skill_mapping[agent_type].remove(skill_name)
+            logger.info(f"Removed skill '{skill_name}' from agent '{agent_type}'")
+            return True
+
+        return False
+
+    def reload(self):
+        """Reload skills and agent mappings."""
+        logger.info("Reloading skill manager...")
+        self.registry.reload()
+        self.agent_skill_mapping.clear()
+        self._load_agent_mappings()
+        logger.info("Skill manager reloaded")
+
+    def infer_agents_for_skill(self, skill) -> List[str]:
+        """Infer which agents should have this skill based on tags/name.
+
+        Args:
+            skill: Skill object to analyze
+
+        Returns:
+            List of agent IDs that should have this skill
+        """
+        agents = []
+        content_lower = skill.content.lower()
+        name_lower = skill.name.lower()
+
+        # Python-related
+        if any(
+            tag in content_lower or tag in name_lower
+            for tag in ["python", "django", "flask", "fastapi"]
+        ):
+            agents.append("python-engineer")
+
+        # TypeScript/JavaScript-related
+        if any(
+            tag in content_lower or tag in name_lower
+            for tag in ["typescript", "javascript", "react", "next", "vue", "node"]
+        ):
+            agents.extend(["typescript-engineer", "react-engineer", "nextjs-engineer"])
+
+        # Go-related
+        if any(tag in content_lower or tag in name_lower for tag in ["golang", "go "]):
+            agents.append("golang-engineer")
+
+        # Ops-related
+        if any(
+            tag in content_lower or tag in name_lower
+            for tag in ["docker", "kubernetes", "deploy", "devops", "ops"]
+        ):
+            agents.extend(["ops", "devops", "local-ops"])
+
+        # Testing/QA-related
+        if any(
+            tag in content_lower or tag in name_lower
+            for tag in ["test", "qa", "quality", "assert"]
+        ):
+            agents.extend(["qa", "web-qa", "api-qa"])
+
+        # Documentation-related
+        if any(
+            tag in content_lower or tag in name_lower
+            for tag in ["documentation", "docs", "api doc", "openapi"]
+        ):
+            agents.extend(["docs", "documentation", "technical-writer"])
+
+        # Remove duplicates
+        return list(set(agents))
+
+    def save_mappings_to_config(self, config_path: Optional[Path] = None):
+        """Save current agent-skill mappings to configuration file.
+
+        Args:
+            config_path: Path to configuration file. If None, uses default.
+        """
+        import json
+
+        if config_path is None:
+            config_path = Path.cwd() / ".claude-mpm" / "skills_config.json"
+
+        # Ensure directory exists
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Save mappings
+        with open(config_path, "w", encoding="utf-8") as f:
+            json.dump(self.agent_skill_mapping, f, indent=2)
+
+        logger.info(f"Saved skill mappings to {config_path}")
+
+    def load_mappings_from_config(self, config_path: Optional[Path] = None):
+        """Load agent-skill mappings from configuration file.
+
+        Args:
+            config_path: Path to configuration file. If None, uses default.
+        """
+        import json
+
+        if config_path is None:
+            config_path = Path.cwd() / ".claude-mpm" / "skills_config.json"
+
+        if not config_path.exists():
+            logger.debug(f"No skill mappings config found at {config_path}")
+            return
+
+        try:
+            with open(config_path, encoding="utf-8") as f:
+                loaded_mappings = json.load(f)
+
+            # Merge with existing mappings
+            for agent_id, skills in loaded_mappings.items():
+                if agent_id not in self.agent_skill_mapping:
+                    self.agent_skill_mapping[agent_id] = []
+                for skill in skills:
+                    if skill not in self.agent_skill_mapping[agent_id]:
+                        self.agent_skill_mapping[agent_id].append(skill)
+
+            logger.info(f"Loaded skill mappings from {config_path}")
+        except Exception as e:
+            logger.error(f"Error loading skill mappings from {config_path}: {e}")
+
+
+# Global manager instance (singleton pattern)
+_manager: Optional[SkillManager] = None
+
+
+def get_manager() -> SkillManager:
+    """Get the global skill manager (singleton)."""
+    global _manager
+    if _manager is None:
+        _manager = SkillManager()
+    return _manager

{claude_mpm-4.15.3.dist-info → claude_mpm-4.15.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.15.3
+Version: 4.15.6
 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