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

claude_mpm/services/monitor/server.py

@@ -15,7 +15,6 @@ DESIGN DECISIONS:
 """
 
 import asyncio
-import contextlib
 import os
 import threading
 import time
@@ -25,6 +24,8 @@ from typing import Dict, Optional
 
 import socketio
 from aiohttp import web
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
 
 from ...core.enums import ServiceState
 from ...core.logging_config import get_logger
@@ -45,6 +46,91 @@ except ImportError:
     EVENTBUS_AVAILABLE = False
 
 
+class SvelteBuildWatcher(FileSystemEventHandler):
+    """File watcher for Svelte build directory changes.
+
+    Watches for file changes in svelte-build directory and triggers
+    hot reload via Socket.IO event emission.
+
+    STABILITY FIX: Added thread lock and stop() method to prevent timer leaks.
+    """
+
+    def __init__(
+        self, sio: socketio.AsyncServer, loop: asyncio.AbstractEventLoop, logger
+    ):
+        """Initialize the file watcher.
+
+        Args:
+            sio: Socket.IO server instance for emitting events
+            loop: Event loop for async operations
+            logger: Logger instance
+        """
+        super().__init__()
+        self.sio = sio
+        self.loop = loop
+        self.logger = logger
+        self.debounce_timer = None
+        self.debounce_delay = 0.5  # Wait 500ms after last change
+        self._timer_lock = threading.Lock()  # STABILITY FIX: Prevent race condition
+
+    def stop(self):
+        """Stop the watcher and cancel any pending timers.
+
+        STABILITY FIX: Ensures timer is cancelled on shutdown.
+        """
+        with self._timer_lock:
+            if self.debounce_timer:
+                self.debounce_timer.cancel()
+                self.debounce_timer = None
+
+    def on_any_event(self, event):
+        """Handle any file system event.
+
+        Args:
+            event: File system event from watchdog
+        """
+        # Ignore directory events and temporary files
+        if event.is_directory or event.src_path.endswith((".tmp", ".swp", "~")):
+            return
+
+        self.logger.debug(
+            f"File change detected: {event.event_type} - {event.src_path}"
+        )
+
+        # STABILITY FIX: Use lock to prevent timer race condition
+        with self._timer_lock:
+            # Cancel existing timer
+            if self.debounce_timer:
+                self.debounce_timer.cancel()
+
+            # Schedule reload after debounce delay
+            self.debounce_timer = threading.Timer(
+                self.debounce_delay, self._trigger_reload
+            )
+            self.debounce_timer.start()
+
+    def _trigger_reload(self):
+        """Trigger hot reload by emitting Socket.IO event."""
+        try:
+            # Schedule the async emit in the event loop
+            asyncio.run_coroutine_threadsafe(self._emit_reload_event(), self.loop)
+            self.logger.info("Hot reload triggered - Svelte build changed")
+        except Exception as e:
+            self.logger.error(f"Error triggering reload: {e}")
+
+    async def _emit_reload_event(self):
+        """Emit the reload event to all connected clients."""
+        if self.sio:
+            await self.sio.emit(
+                "reload",
+                {
+                    "type": "reload",
+                    "timestamp": datetime.now(timezone.utc).isoformat() + "Z",
+                    "reason": "svelte-build-updated",
+                },
+            )
+
+
 class UnifiedMonitorServer:
     """Unified server that combines HTTP dashboard and Socket.IO functionality.
 
@@ -52,15 +138,19 @@ class UnifiedMonitorServer:
     Replaces multiple competing server implementations with one stable solution.
     """
 
-    def __init__(self, host: str = "localhost", port: int = 8765):
+    def __init__(
+        self, host: str = "localhost", port: int = 8765, enable_hot_reload: bool = False
+    ):
         """Initialize the unified monitor server.
 
         Args:
             host: Host to bind to
             port: Port to bind to
+            enable_hot_reload: Enable file watching and hot reload for development
         """
         self.host = host
         self.port = port
+        self.enable_hot_reload = enable_hot_reload
         self.logger = get_logger(__name__)
 
         # Core components
@@ -78,6 +168,10 @@ class UnifiedMonitorServer:
         # High-performance event emitter
         self.event_emitter = None
 
+        # File watching (optional for dev mode)
+        self.file_observer: Optional[Observer] = None
+        self.file_watcher: Optional[SvelteBuildWatcher] = None
+
         # State
         self.running = False
         self.loop = None
@@ -184,6 +278,9 @@ class UnifiedMonitorServer:
 
                         time.sleep(0.1)
 
+                        # STABILITY FIX: Give tasks more time to clean up before closing
+                        time.sleep(0.5)
+
                         # Clear the event loop from the thread BEFORE closing
                         # This prevents other code from accidentally using it
                         asyncio.set_event_loop(None)
@@ -229,6 +326,10 @@ class UnifiedMonitorServer:
             self.heartbeat_task = asyncio.create_task(self._heartbeat_loop())
             self.logger.info("Heartbeat task started (3-minute interval)")
 
+            # Setup file watching for hot reload (if enabled)
+            if self.enable_hot_reload:
+                self._setup_file_watcher()
+
             # Setup HTTP routes
             self._setup_http_routes()
 
@@ -304,20 +405,64 @@ class UnifiedMonitorServer:
             self.logger.error(f"Error setting up event emitter: {e}")
             raise
 
+    def _setup_file_watcher(self):
+        """Setup file watcher for Svelte build directory.
+
+        Watches for changes in svelte-build and triggers hot reload.
+        Only enabled when enable_hot_reload is True.
+        """
+        try:
+            dashboard_dir = Path(__file__).resolve().parent.parent.parent / "dashboard"
+            svelte_build_dir = dashboard_dir / "static" / "svelte-build"
+
+            if not svelte_build_dir.exists():
+                self.logger.warning(
+                    f"Svelte build directory not found: {svelte_build_dir}. "
+                    "Hot reload disabled."
+                )
+                return
+
+            # Create file watcher with Socket.IO reference
+            self.file_watcher = SvelteBuildWatcher(
+                sio=self.sio, loop=self.loop, logger=self.logger
+            )
+
+            # Create observer and schedule watching
+            self.file_observer = Observer()
+            self.file_observer.schedule(
+                self.file_watcher, str(svelte_build_dir), recursive=True
+            )
+            self.file_observer.start()
+
+            self.logger.info(f"🔥 Hot reload enabled - watching {svelte_build_dir}")
+
+        except Exception as e:
+            self.logger.error(f"Error setting up file watcher: {e}")
+            # Don't raise - hot reload is optional
+
     def _setup_http_routes(self):
         """Setup HTTP routes for the dashboard."""
         try:
-            # Dashboard static files
-            dashboard_dir = Path(__file__).parent.parent.parent / "dashboard"
+            # Dashboard static files - use .resolve() for absolute path
+            dashboard_dir = Path(__file__).resolve().parent.parent.parent / "dashboard"
+            static_dir = dashboard_dir / "static"
 
-            # Main dashboard route
+            # Main dashboard route - serve Svelte dashboard
             async def dashboard_index(request):
-                template_path = dashboard_dir / "templates" / "index.html"
-                if template_path.exists():
-                    with template_path.open() as f:
+                svelte_index = static_dir / "svelte-build" / "index.html"
+                if svelte_index.exists():
+                    with svelte_index.open(encoding="utf-8") as f:
                         content = f.read()
                     return web.Response(text=content, content_type="text/html")
-                return web.Response(text="Dashboard not found", status=404)
+
+                # Log error with path details for debugging
+                self.logger.error(
+                    f"Dashboard index.html not found at: {svelte_index.resolve()}"
+                )
+                return web.Response(
+                    text=f"Dashboard not found. Expected location: {svelte_index.resolve()}",
+                    status=404,
+                )
 
             # Health check
             async def health_check(request):
@@ -325,7 +470,8 @@ class UnifiedMonitorServer:
                 version = "1.0.0"
                 try:
                     version_file = (
-                        Path(__file__).parent.parent.parent.parent.parent / "VERSION"
+                        Path(__file__).resolve().parent.parent.parent.parent.parent
+                        / "VERSION"
                     )
                     if version_file.exists():
                         version = version_file.read_text().strip()
@@ -546,12 +692,43 @@ class UnifiedMonitorServer:
                 "/monitor/events", lambda r: monitor_page_handler(r)
             )
 
-            # Static files with cache busting headers for development
-            static_dir = dashboard_dir / "static"
+            # Serve Svelte _app assets (compiled JS/CSS)
+            svelte_build_dir = static_dir / "svelte-build"
+            if svelte_build_dir.exists():
+                svelte_app_dir = svelte_build_dir / "_app"
+                if svelte_app_dir.exists():
+                    # Serve _app assets with proper caching
+                    async def app_assets_handler(request):
+                        """Serve Svelte _app assets."""
+                        from aiohttp.web_fileresponse import FileResponse
+
+                        rel_path = request.match_info["filepath"]
+                        file_path = svelte_app_dir / rel_path
+
+                        if not file_path.exists() or not file_path.is_file():
+                            raise web.HTTPNotFound()
+
+                        response = FileResponse(file_path)
+
+                        # Add cache headers for immutable assets
+                        if "/immutable/" in str(rel_path):
+                            response.headers["Cache-Control"] = (
+                                "public, max-age=31536000, immutable"
+                            )
+                        else:
+                            response.headers["Cache-Control"] = (
+                                "no-cache, no-store, must-revalidate"
+                            )
+
+                        return response
+
+                    self.app.router.add_get("/_app/{filepath:.*}", app_assets_handler)
+
+            # Legacy static files (for backward compatibility)
             if static_dir.exists():
 
                 async def static_handler(request):
-                    """Serve static files with cache-control headers for development."""
+                    """Serve legacy static files with cache-control headers for development."""
 
                     from aiohttp.web_fileresponse import FileResponse
 
@@ -576,10 +753,13 @@ class UnifiedMonitorServer:
 
                 self.app.router.add_get("/static/{filepath:.*}", static_handler)
 
-            # Templates
-            templates_dir = dashboard_dir / "templates"
-            if templates_dir.exists():
-                self.app.router.add_static("/templates/", templates_dir)
+            # Log dashboard availability
+            if svelte_build_dir.exists():
+                self.logger.info(
+                    f"✅ Svelte dashboard available at / (root) (build: {svelte_build_dir})"
+                )
+            else:
+                self.logger.warning(f"Svelte build not found at: {svelte_build_dir}")
 
             self.logger.info("HTTP routes registered successfully")
 
@@ -691,11 +871,37 @@ class UnifiedMonitorServer:
     async def _cleanup_async(self):
         """Cleanup async resources."""
         try:
+            # Stop file observer if running
+            # STABILITY FIX: Ensure watcher is stopped and verify observer termination
+            if self.file_observer:
+                try:
+                    # Stop the watcher first to cancel pending timers
+                    if self.file_watcher:
+                        self.file_watcher.stop()
+
+                    # Stop the observer
+                    self.file_observer.stop()
+                    self.file_observer.join(timeout=2)
+
+                    # Verify observer actually stopped
+                    if self.file_observer.is_alive():
+                        self.logger.warning("File observer did not stop cleanly")
+
+                    self.logger.debug("File observer stopped")
+                except Exception as e:
+                    self.logger.debug(f"Error stopping file observer: {e}")
+                finally:
+                    self.file_observer = None
+                    self.file_watcher = None
+
             # Cancel heartbeat task if running
+            # STABILITY FIX: Add timeout to prevent infinite wait on cancellation
             if self.heartbeat_task and not self.heartbeat_task.done():
                 self.heartbeat_task.cancel()
-                with contextlib.suppress(asyncio.CancelledError):
-                    await self.heartbeat_task
+                try:
+                    await asyncio.wait_for(self.heartbeat_task, timeout=2.0)
+                except (asyncio.CancelledError, asyncio.TimeoutError):
+                    pass
                 self.logger.debug("Heartbeat task cancelled")
 
             # Close the Socket.IO server first to stop accepting new connections

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",
 ]

claude_mpm/services/skills/git_skill_source_manager.py

@@ -20,7 +20,7 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime, timezone
 from pathlib import Path
 from threading import Lock
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Set, Tuple
 
 from claude_mpm.config.skill_sources import SkillSource, SkillSourceConfiguration
 from claude_mpm.core.logging_config import get_logger
@@ -989,6 +989,7 @@ class GitSkillSourceManager:
         target_dir: Optional[Path] = None,
         force: bool = False,
         progress_callback=None,
+        skill_filter: Optional[Set[str]] = None,
     ) -> Dict[str, Any]:
         """Deploy skills from cache to target directory with flat structure.
 
@@ -1004,6 +1005,9 @@ class GitSkillSourceManager:
             target_dir: Target deployment directory (default: ~/.claude/skills/)
             force: Overwrite existing skills
             progress_callback: Optional callback(increment: int) called for each skill deployed
+            skill_filter: Optional set of skill names to deploy (selective deployment).
+                         If None, deploys all skills. If provided, only deploys skills
+                         whose name matches an entry in the filter set.
 
         Returns:
             Dict with deployment results:
@@ -1013,13 +1017,19 @@ class GitSkillSourceManager:
                 "failed_count": int,
                 "deployed_skills": List[str],
                 "skipped_skills": List[str],
-                "errors": List[str]
+                "errors": List[str],
+                "filtered_count": int  # Number of skills filtered out
             }
 
         Example:
             >>> manager = GitSkillSourceManager(config)
             >>> result = manager.deploy_skills()
             >>> print(f"Deployed {result['deployed_count']} skills")
+
+            # Selective deployment based on agent requirements:
+            >>> required = {"typescript-core", "react-patterns"}
+            >>> result = manager.deploy_skills(skill_filter=required)
+            >>> print(f"Deployed {result['deployed_count']} of {len(required)} required skills")
         """
         if target_dir is None:
             target_dir = Path.home() / ".claude" / "skills"
@@ -1029,10 +1039,29 @@ class GitSkillSourceManager:
         deployed = []
         skipped = []
         errors = []
+        filtered_count = 0
 
         # Get all skills from all sources
         all_skills = self.get_all_skills()
 
+        # Apply skill filter if provided (selective deployment)
+        if skill_filter is not None:
+            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"
+            all_skills = [
+                s
+                for s in all_skills
+                if s.get("deployment_name", "").lower() in normalized_filter
+            ]
+            filtered_count = original_count - len(all_skills)
+            self.logger.info(
+                f"Selective deployment: {len(all_skills)} of {original_count} skills "
+                f"match agent requirements ({filtered_count} filtered out)"
+            )
+
         self.logger.info(
             f"Deploying {len(all_skills)} skills to {target_dir} (force={force})"
         )
@@ -1083,6 +1112,7 @@ class GitSkillSourceManager:
             "deployed_skills": deployed,
             "skipped_skills": skipped,
             "errors": errors,
+            "filtered_count": filtered_count,
         }
 
     def _deploy_single_skill(