claude-mpm 5.4.91__py3-none-any.whl → 5.4.95__py3-none-any.whl

claude_mpm/services/monitor/server.py

@@ -368,6 +368,83 @@ class UnifiedMonitorServer:
         finally:
             await self._cleanup_async()
 
+    def _categorize_event(self, event_name: str) -> str:
+        """Categorize event by name to determine Socket.IO event type.
+
+        Maps specific event names to their category for frontend filtering.
+
+        Args:
+            event_name: The raw event name (e.g., "subagent_start", "todo_updated")
+
+        Returns:
+            Category name (e.g., "hook_event", "system_event")
+        """
+        # Hook events - agent lifecycle and todo updates
+        if event_name in ("subagent_start", "subagent_stop", "todo_updated"):
+            return "hook_event"
+
+        # Tool events - both hook-style and direct tool events
+        if event_name in (
+            "pre_tool",
+            "post_tool",
+            "tool.start",
+            "tool.end",
+            "tool_use",
+            "tool_result",
+        ):
+            return "tool_event"
+
+        # Session events - session lifecycle
+        if event_name in (
+            "session.started",
+            "session.ended",
+            "session_start",
+            "session_end",
+        ):
+            return "session_event"
+
+        # Response events - API response lifecycle
+        if event_name in (
+            "response.start",
+            "response.end",
+            "response_started",
+            "response_ended",
+        ):
+            return "response_event"
+
+        # Agent events - agent delegation and returns
+        if event_name in (
+            "agent.delegated",
+            "agent.returned",
+            "agent_start",
+            "agent_end",
+        ):
+            return "agent_event"
+
+        # File events - file operations
+        if event_name in (
+            "file.read",
+            "file.write",
+            "file.edit",
+            "file_read",
+            "file_write",
+        ):
+            return "file_event"
+
+        # Claude API events
+        if event_name in ("user_prompt", "assistant_message"):
+            return "claude_event"
+
+        # System events
+        if event_name in ("system_ready", "system_shutdown"):
+            return "system_event"
+
+        # Log uncategorized events for debugging
+        self.logger.debug(f"Uncategorized event: {event_name}")
+
+        # Default to claude_event for unknown events
+        return "claude_event"
+
     def _setup_event_handlers(self):
         """Setup Socket.IO event handlers."""
         try:
@@ -474,7 +551,7 @@ class UnifiedMonitorServer:
                     )
                     if version_file.exists():
                         version = version_file.read_text().strip()
-                except Exception:
+                except Exception:  # nosec B110
                     pass
 
                 return web.json_response(
@@ -499,10 +576,23 @@ class UnifiedMonitorServer:
                     event = data.get("event", "claude_event")
                     event_data = data.get("data", {})
 
-                    # Emit to Socket.IO clients via the appropriate event
+                    # Categorize event and wrap in expected format
+                    event_type = self._categorize_event(event)
+                    wrapped_event = {
+                        "type": event_type,
+                        "subtype": event,
+                        "data": event_data,
+                        "timestamp": event_data.get("timestamp")
+                        or datetime.now(timezone.utc).isoformat() + "Z",
+                        "session_id": event_data.get("session_id"),
+                    }
+
+                    # Emit to Socket.IO clients via the categorized event type
                     if self.sio:
-                        await self.sio.emit(event, event_data)
-                        self.logger.debug(f"HTTP event forwarded to Socket.IO: {event}")
+                        await self.sio.emit(event_type, wrapped_event)
+                        self.logger.debug(
+                            f"HTTP event forwarded to Socket.IO: {event} -> {event_type}"
+                        )
 
                     return web.Response(status=204)  # No content response
 
@@ -859,7 +949,7 @@ class UnifiedMonitorServer:
             # Configuration endpoint for dashboard initialization
             async def config_handler(request):
                 """Return configuration for dashboard initialization."""
-                import subprocess
+                import subprocess  # nosec B404
 
                 config = {
                     "workingDirectory": Path.cwd(),
@@ -870,7 +960,7 @@ class UnifiedMonitorServer:
 
                 # Try to get current git branch
                 try:
-                    result = subprocess.run(
+                    result = subprocess.run(  # nosec B603 B607
                         ["git", "branch", "--show-current"],
                         capture_output=True,
                         text=True,
@@ -880,7 +970,7 @@ class UnifiedMonitorServer:
                     )
                     if result.returncode == 0 and result.stdout.strip():
                         config["gitBranch"] = result.stdout.strip()
-                except Exception:
+                except Exception:  # nosec B110
                     pass  # Keep default "Unknown" value
 
                 return web.json_response(config)
@@ -910,7 +1000,7 @@ class UnifiedMonitorServer:
             # Git history handler
             async def git_history_handler(request: web.Request) -> web.Response:
                 """Get git history for a file."""
-                import subprocess
+                import subprocess  # nosec B404
 
                 try:
                     data = await request.json()
@@ -939,7 +1029,7 @@ class UnifiedMonitorServer:
                         )
 
                     # Get git log for file
-                    result = subprocess.run(
+                    result = subprocess.run(  # nosec B603 B607
                         [
                             "git",
                             "log",
@@ -978,7 +1068,7 @@ class UnifiedMonitorServer:
             # Git diff handler
             async def git_diff_handler(request: web.Request) -> web.Response:
                 """Get git diff for a file with optional commit selection."""
-                import subprocess
+                import subprocess  # nosec B404
 
                 try:
                     file_path = request.query.get("path", "")
@@ -1010,7 +1100,7 @@ class UnifiedMonitorServer:
                         )
 
                     # Find git repository root
-                    git_root_result = subprocess.run(
+                    git_root_result = subprocess.run(  # nosec B603 B607
                         ["git", "rev-parse", "--show-toplevel"],
                         check=False,
                         capture_output=True,
@@ -1034,7 +1124,7 @@ class UnifiedMonitorServer:
                     git_root = Path(git_root_result.stdout.strip())
 
                     # Check if file is tracked by git
-                    ls_files_result = subprocess.run(
+                    ls_files_result = subprocess.run(  # nosec B603 B607
                         ["git", "ls-files", "--error-unmatch", str(path)],
                         check=False,
                         capture_output=True,
@@ -1056,7 +1146,7 @@ class UnifiedMonitorServer:
                         )
 
                     # Get commit history for this file (last 5 commits)
-                    history_result = subprocess.run(
+                    history_result = subprocess.run(  # nosec B603 B607
                         [
                             "git",
                             "log",
@@ -1087,7 +1177,7 @@ class UnifiedMonitorServer:
                                     )
 
                     # Check for uncommitted changes
-                    uncommitted_result = subprocess.run(
+                    uncommitted_result = subprocess.run(  # nosec B603 B607
                         ["git", "diff", "HEAD", str(path)],
                         check=False,
                         capture_output=True,
@@ -1100,7 +1190,7 @@ class UnifiedMonitorServer:
                     # Get diff based on commit parameter
                     if commit_hash:
                         # Get diff for specific commit
-                        result = subprocess.run(
+                        result = subprocess.run(  # nosec B603 B607
                             ["git", "show", commit_hash, "--", str(path)],
                             check=False,
                             capture_output=True,
@@ -1469,7 +1559,7 @@ class UnifiedMonitorServer:
                 gather = asyncio.gather(*tasks_to_cancel, return_exceptions=True)
                 try:
                     loop.run_until_complete(gather)
-                except Exception:
+                except Exception:  # nosec B110
                     # Some tasks might fail to cancel, that's ok
                     pass
 

claude_mpm/services/skills/selective_skill_deployer.py

@@ -214,18 +214,90 @@ def get_skills_from_mapping(agent_ids: List[str]) -> Set[str]:
     return set()
 
 
+def extract_skills_from_content(agent_file: Path) -> Set[str]:
+    """Extract skill names from [SKILL: skill-name] markers in agent file content.
+
+    This function complements frontmatter skill extraction by finding inline
+    skill references in the agent's markdown content body.
+
+    Supports multiple formats:
+    - Bold marker: **[SKILL: skill-name]**
+    - Plain marker: [SKILL: skill-name]
+    - Backtick list: - `skill-name` - Description
+    - With spaces: [SKILL:  skill-name  ]
+
+    Args:
+        agent_file: Path to agent markdown file
+
+    Returns:
+        Set of skill names found in content body
+
+    Example:
+        >>> skills = extract_skills_from_content(Path("pm.md"))
+        >>> # Finds skills from markers like **[SKILL: mpm-delegation-patterns]**
+        >>> # Also finds from lists like - `mpm-teaching-mode` - Description
+        >>> print(f"Found {len(skills)} skills in content")
+    """
+    try:
+        content = agent_file.read_text(encoding="utf-8")
+    except Exception as e:
+        logger.warning(f"Failed to read {agent_file}: {e}")
+        return set()
+
+    skills = set()
+
+    # Pattern 1: [SKILL: skill-name] markers (with optional markdown bold)
+    # Handles: **[SKILL: skill-name]** or [SKILL: skill-name]
+    # Pattern breakdown:
+    # - \*{0,2}: Optional bold markdown (0-2 asterisks)
+    # - \[SKILL:\s*: Opening bracket with optional whitespace
+    # - ([a-zA-Z0-9_-]+): Skill name (capture group)
+    # - \s*\]: Closing bracket with optional whitespace
+    # - \*{0,2}: Optional closing bold markdown
+    pattern1 = r"\*{0,2}\[SKILL:\s*([a-zA-Z0-9_-]+)\s*\]\*{0,2}"
+    matches1 = re.findall(pattern1, content, re.IGNORECASE)
+    skills.update(matches1)
+
+    # Pattern 2: Backtick list items with mpm-* or toolchains-* skills
+    # Handles: - `mpm-skill-name` - Description
+    # Pattern breakdown:
+    # - ^-\s+: Start with dash and whitespace (list item)
+    # - `: Opening backtick
+    # - ((?:mpm-|toolchains-|universal-)[a-zA-Z0-9_-]+): Skill name starting with prefix
+    # - `: Closing backtick
+    # - \s+-: Followed by whitespace and dash (description separator)
+    pattern2 = r"^-\s+`((?:mpm-|toolchains-|universal-)[a-zA-Z0-9_-]+)`\s+-"
+    matches2 = re.findall(pattern2, content, re.MULTILINE | re.IGNORECASE)
+    skills.update(matches2)
+
+    if skills:
+        logger.debug(
+            f"Found {len(skills)} skills from content markers in {agent_file.name}"
+        )
+
+    return skills
+
+
 def get_required_skills_from_agents(agents_dir: Path) -> Set[str]:
     """Extract all skills referenced by deployed agents.
 
-    MAJOR CHANGE (Phase 3): Now ONLY uses frontmatter-declared skills.
+    MAJOR CHANGE (Phase 3): Now uses TWO sources for skill discovery:
+    1. Frontmatter-declared skills (skills: field)
+    2. Content body markers ([SKILL: skill-name])
+
     The static skill_to_agent_mapping.yaml is DEPRECATED. Each agent must
-    declare its skills in frontmatter or it gets zero skills deployed.
+    declare its skills via frontmatter OR inline markers.
 
     This change:
     - Eliminates dual-source complexity (frontmatter + mapping)
     - Makes skill requirements explicit per agent
-    - Enables per-agent customization via frontmatter
+    - Enables per-agent customization via frontmatter or inline markers
     - Removes dependency on static YAML mapping
+    - Fixes PM skills being removed as orphaned (they use inline markers)
+
+    Special handling for PM_INSTRUCTIONS.md:
+    - Also scans .claude-mpm/PM_INSTRUCTIONS.md for skill markers
+    - PM instructions are not in agents_dir but contain [SKILL: ...] references
 
     Args:
         agents_dir: Path to deployed agents directory (e.g., .claude/agents/)
@@ -244,37 +316,63 @@ def get_required_skills_from_agents(agents_dir: Path) -> Set[str]:
 
     # Scan all agent markdown files
     agent_files = list(agents_dir.glob("*.md"))
-    logger.debug(f"Scanning {len(agent_files)} agent files in {agents_dir}")
 
-    # ONLY use frontmatter skills - no more mapping inference
+    # Special case: Add PM_INSTRUCTIONS.md if it exists
+    # PM instructions live in .claude-mpm/ not .claude/agents/
+    pm_instructions = agents_dir.parent.parent / ".claude-mpm" / "PM_INSTRUCTIONS.md"
+    if pm_instructions.exists():
+        agent_files.append(pm_instructions)
+        logger.debug("Added PM_INSTRUCTIONS.md for skill scanning")
+
+    logger.debug(f"Scanning {len(agent_files)} agent files (including PM instructions)")
+
+    # Use TWO sources: frontmatter AND content markers
     frontmatter_skills = set()
+    content_skills = set()
 
     for agent_file in agent_files:
         agent_id = agent_file.stem
 
+        # Source 1: Extract from frontmatter
         frontmatter = parse_agent_frontmatter(agent_file)
-        agent_skills = get_skills_from_agent(frontmatter)
+        agent_fm_skills = get_skills_from_agent(frontmatter)
 
-        if agent_skills:
-            frontmatter_skills.update(agent_skills)
+        if agent_fm_skills:
+            frontmatter_skills.update(agent_fm_skills)
             logger.debug(
-                f"Agent {agent_id}: {len(agent_skills)} skills from frontmatter"
+                f"Agent {agent_id}: {len(agent_fm_skills)} skills from frontmatter"
             )
-        else:
-            logger.debug(f"Agent {agent_id}: No skills declared in frontmatter")
+
+        # Source 2: Extract from content body [SKILL: ...] markers
+        agent_content_skills = extract_skills_from_content(agent_file)
+
+        if agent_content_skills:
+            content_skills.update(agent_content_skills)
+            logger.debug(
+                f"Agent {agent_id}: {len(agent_content_skills)} skills from content markers"
+            )
+
+        if not agent_fm_skills and not agent_content_skills:
+            logger.debug(
+                f"Agent {agent_id}: No skills declared (checked frontmatter + content)"
+            )
+
+    # Combine both sources
+    all_skills = frontmatter_skills | content_skills
 
     logger.info(
-        f"Found {len(frontmatter_skills)} unique skills from agent frontmatter "
-        f"(static mapping no longer used)"
+        f"Found {len(all_skills)} unique skills "
+        f"({len(frontmatter_skills)} from frontmatter, "
+        f"{len(content_skills)} from content markers)"
     )
 
     # Normalize skill paths: convert slashes to dashes for compatibility with deployment
     # Some skills may use slash format, normalize to dashes
-    normalized_skills = {skill.replace("/", "-") for skill in frontmatter_skills}
+    normalized_skills = {skill.replace("/", "-") for skill in all_skills}
 
-    if normalized_skills != frontmatter_skills:
+    if normalized_skills != all_skills:
         logger.debug(
-            f"Normalized {len(frontmatter_skills)} skills to {len(normalized_skills)} "
+            f"Normalized {len(all_skills)} skills to {len(normalized_skills)} "
             "(converted slashes to dashes)"
         )
 

{claude_mpm-5.4.91.dist-info → claude_mpm-5.4.95.dist-info}/METADATA

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