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

claude_mpm/services/shared/async_service_base.py

@@ -4,23 +4,12 @@ Base class for asynchronous services to reduce duplication.
 
 import asyncio
 from abc import ABC, abstractmethod
-from enum import Enum
 from typing import Any, Dict, Optional
 
+from ...core.enums import ServiceState
 from ...core.mixins import LoggerMixin
 
 
-class AsyncServiceState(Enum):
-    """Standard states for async services."""
-
-    UNINITIALIZED = "uninitialized"
-    INITIALIZING = "initializing"
-    RUNNING = "running"
-    STOPPING = "stopping"
-    STOPPED = "stopped"
-    ERROR = "error"
-
-
 class AsyncServiceBase(LoggerMixin, ABC):
     """
     Base class for asynchronous services.
@@ -45,7 +34,7 @@ class AsyncServiceBase(LoggerMixin, ABC):
         self.config = config or {}
 
         # State management
-        self._state = AsyncServiceState.UNINITIALIZED
+        self._state = ServiceState.UNINITIALIZED
         self._state_lock = asyncio.Lock()
 
         # Background tasks
@@ -57,19 +46,19 @@ class AsyncServiceBase(LoggerMixin, ABC):
         self._error_count = 0
 
     @property
-    def state(self) -> AsyncServiceState:
+    def state(self) -> ServiceState:
         """Get current service state."""
         return self._state
 
     @property
     def is_running(self) -> bool:
         """Check if service is running."""
-        return self._state == AsyncServiceState.RUNNING
+        return self._state == ServiceState.RUNNING
 
     @property
     def is_healthy(self) -> bool:
         """Check if service is healthy."""
-        return self._state == AsyncServiceState.RUNNING and self._last_error is None
+        return self._state == ServiceState.RUNNING and self._last_error is None
 
     async def initialize(self) -> bool:
         """
@@ -79,22 +68,22 @@ class AsyncServiceBase(LoggerMixin, ABC):
             True if initialization successful
         """
         async with self._state_lock:
-            if self._state != AsyncServiceState.UNINITIALIZED:
+            if self._state != ServiceState.UNINITIALIZED:
                 self.logger.warning(f"Service {self.service_name} already initialized")
-                return self._state == AsyncServiceState.RUNNING
+                return self._state == ServiceState.RUNNING
 
-            self._state = AsyncServiceState.INITIALIZING
+            self._state = ServiceState.INITIALIZING
             self.logger.info(f"Initializing service: {self.service_name}")
 
             try:
                 success = await self._do_initialize()
                 if success:
-                    self._state = AsyncServiceState.RUNNING
+                    self._state = ServiceState.RUNNING
                     self.logger.info(
                         f"Service {self.service_name} initialized successfully"
                     )
                 else:
-                    self._state = AsyncServiceState.ERROR
+                    self._state = ServiceState.ERROR
                     self.logger.error(
                         f"Service {self.service_name} initialization failed"
                     )
@@ -102,7 +91,7 @@ class AsyncServiceBase(LoggerMixin, ABC):
                 return success
 
             except Exception as e:
-                self._state = AsyncServiceState.ERROR
+                self._state = ServiceState.ERROR
                 self._last_error = e
                 self._error_count += 1
                 self.logger.error(
@@ -114,10 +103,10 @@ class AsyncServiceBase(LoggerMixin, ABC):
     async def shutdown(self) -> None:
         """Shutdown the service gracefully."""
         async with self._state_lock:
-            if self._state in (AsyncServiceState.STOPPED, AsyncServiceState.STOPPING):
+            if self._state in (ServiceState.STOPPED, ServiceState.STOPPING):
                 return
 
-            self._state = AsyncServiceState.STOPPING
+            self._state = ServiceState.STOPPING
             self.logger.info(f"Shutting down service: {self.service_name}")
 
             try:
@@ -130,11 +119,11 @@ class AsyncServiceBase(LoggerMixin, ABC):
                 # Service-specific shutdown
                 await self._do_shutdown()
 
-                self._state = AsyncServiceState.STOPPED
+                self._state = ServiceState.STOPPED
                 self.logger.info(f"Service {self.service_name} shut down successfully")
 
             except Exception as e:
-                self._state = AsyncServiceState.ERROR
+                self._state = ServiceState.ERROR
                 self._last_error = e
                 self.logger.error(
                     f"Service {self.service_name} shutdown error: {e}", exc_info=True
@@ -146,7 +135,7 @@ class AsyncServiceBase(LoggerMixin, ABC):
         await self.shutdown()
 
         # Reset state for restart
-        self._state = AsyncServiceState.UNINITIALIZED
+        self._state = ServiceState.UNINITIALIZED
         self._shutdown_event.clear()
         self._last_error = None
 

claude_mpm/services/shared/lifecycle_service_base.py

@@ -4,25 +4,12 @@ Base class for services with complex lifecycle management.
 
 import time
 from abc import ABC, abstractmethod
-from enum import Enum
 from typing import Any, Dict, List, Optional
 
+from ...core.enums import ServiceState
 from ...core.mixins import LoggerMixin
 
 
-class ServiceState(Enum):
-    """Standard service states."""
-
-    UNINITIALIZED = "uninitialized"
-    INITIALIZING = "initializing"
-    INITIALIZED = "initialized"
-    STARTING = "starting"
-    RUNNING = "running"
-    STOPPING = "stopping"
-    STOPPED = "stopped"
-    ERROR = "error"
-
-
 class LifecycleServiceBase(LoggerMixin, ABC):
     """
     Base class for services with complex lifecycle management.

claude_mpm/services/socketio/handlers/__init__.py

@@ -7,7 +7,9 @@ and maintainability.
 """
 
 from .base import BaseEventHandler
-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
@@ -17,7 +19,8 @@ from .registry import EventHandlerRegistry
 
 __all__ = [
     "BaseEventHandler",
-    "CodeAnalysisEventHandler",
+    # DISABLED: File Tree interface removed from dashboard
+    # "CodeAnalysisEventHandler",
     "ConnectionEventHandler",
     "EventHandlerRegistry",
     "FileEventHandler",

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