claude-mpm 4.2.2__py3-none-any.whl → 4.2.4__py3-none-any.whl

claude_mpm/dashboard/static/js/socket-client.js

@@ -248,7 +248,7 @@ class SocketClient {
          * @private
          * @const
          */
-        this.pingTimeout = 90000; // 90 seconds for health check (more lenient than Socket.IO timeout)
+        this.pingTimeout = 120000; // 120 seconds for health check (more lenient for stability)
         
         /**
          * Health check interval timer.
@@ -346,13 +346,13 @@ class SocketClient {
             autoConnect: true,
             reconnection: true,
             reconnectionDelay: 1000,
-            reconnectionDelayMax: 5000,
-            reconnectionAttempts: 5,  // Try 5 times then stop (was Infinity which can cause issues)
-            timeout: 20000,  // Connection timeout
+            reconnectionDelayMax: 10000,  // Increased max delay for stability
+            reconnectionAttempts: 10,  // Increased attempts for better resilience  
+            timeout: 30000,  // Increased connection timeout to 30 seconds
             forceNew: true,
             transports: ['websocket', 'polling'],
-            pingInterval: 25000,  // CRITICAL: Must match server's 25 seconds
-            pingTimeout: 20000    // CRITICAL: Must match server's 20 seconds
+            pingInterval: 30000,  // Increased ping interval for stability
+            pingTimeout: 60000    // Much longer timeout for better stability
         });
 
         this.setupSocketHandlers();
@@ -1218,8 +1218,11 @@ class SocketClient {
                         transformedEvent[key] = eventData.data[key];
                     }
                 } else {
-                    // Log warning if data field would overwrite a protected field
-                    console.warn(`Protected field '${key}' in data object was not copied to top level to preserve event structure`);
+                    // Log debug info if data field would overwrite a protected field
+                    // Only log for non-timestamp fields to reduce noise
+                    if (key !== 'timestamp') {
+                        console.debug(`Protected field '${key}' in data object was not copied to top level to preserve event structure`);
+                    }
                 }
             });
             

claude_mpm/dashboard/templates/index.html

@@ -247,7 +247,6 @@
                         <button class="tab-button" data-tab="files">📁 Files</button>
                         <button class="tab-button" data-tab="activity">🌳 Activity</button>
                         <button class="tab-button" data-tab="code">🧬 Code</button>
-                        <a href="/code-simple" class="tab-button" style="background: #f7fafc; color: #4a5568; text-decoration: none; border-left: 2px solid #e2e8f0;">📁 Simple View</a>
                     </div>
 
                     <!-- Events Tab -->
@@ -389,45 +388,52 @@
                     <!-- Code Tab -->
                     <div class="tab-content" id="code-tab">
                         <div class="code-container">
-                            <!-- Simplified header with controls -->
-                            <div class="code-header-compact">
-                                <div class="header-left">
-                                    <button id="code-expand-all" class="btn-compact" title="Expand All">⊕</button>
-                                    <button id="code-collapse-all" class="btn-compact" title="Collapse All">⊖</button>
-                                    <button id="code-reset-zoom" class="btn-compact" title="Reset Zoom">⟲</button>
-                                    <button id="code-toggle-legend" class="btn-compact" title="Toggle Legend">ℹ️</button>
-                                </div>
-                                <div class="header-center">
-                                    <span class="stat-compact">📁 <span id="file-count">0</span></span>
-                                    <span class="stat-compact">🏛️ <span id="class-count">0</span></span>
-                                    <span class="stat-compact">⚡ <span id="function-count">0</span></span>
-                                    <span class="stat-compact">📝 <span id="line-count">0</span></span>
+                            <div id="code-tree-container" class="code-tree-container">
+                                <!-- Top-left corner: Language selector -->
+                                <div class="tree-corner-controls top-left">
+                                    <div class="control-group">
+                                        <label class="control-label">Languages:</label>
+                                        <div class="checkbox-group">
+                                            <label class="checkbox-label"><input type="checkbox" class="language-checkbox" value="python" checked> Python</label>
+                                            <label class="checkbox-label"><input type="checkbox" class="language-checkbox" value="javascript" checked> JS</label>
+                                            <label class="checkbox-label"><input type="checkbox" class="language-checkbox" value="typescript" checked> TS</label>
+                                        </div>
+                                    </div>
                                 </div>
-                                <div class="header-right">
-                                    <select id="language-filter" class="select-compact">
-                                        <option value="all">All</option>
-                                        <option value="python">Python</option>
-                                        <option value="javascript">JS</option>
-                                        <option value="typescript">TS</option>
-                                    </select>
-                                    <input type="text" id="code-search" placeholder="Search..." class="search-compact">
+
+                                <!-- Top-right corner: Layout and search -->
+                                <div class="tree-corner-controls top-right">
+                                    <div class="control-group">
+                                        <select id="code-layout" class="select-compact">
+                                            <option value="tree">Tree</option>
+                                            <option value="radial">Radial</option>
+                                        </select>
+                                        <input type="text" id="code-search" placeholder="Search..." class="search-compact">
+                                    </div>
                                 </div>
-                            </div>
-                            <!-- Advanced options - visible by default -->
-                            <div class="code-advanced-options-visible">
-                                <div class="advanced-content">
-                                    <div class="option-group">
-                                        <label>Languages:</label>
-                                        <label><input type="checkbox" class="language-checkbox" value="python" checked> Python</label>
-                                        <label><input type="checkbox" class="language-checkbox" value="javascript" checked> JS</label>
-                                        <label><input type="checkbox" class="language-checkbox" value="typescript" checked> TS</label>
+
+                                <!-- Bottom-left corner: Stats and Status -->
+                                <div class="tree-corner-controls bottom-left">
+                                    <div class="stats-display" id="code-stats">
+                                        <span id="stats-files">0 files</span> •
+                                        <span id="stats-classes">0 classes</span> •
+                                        <span id="stats-functions">0 functions</span> •
+                                        <span id="stats-methods">0 methods</span>
                                     </div>
-                                    <div class="option-group">
-                                        <label>Ignore: <input type="text" id="ignore-patterns" placeholder="test*, *.spec.js, node_modules" class="input-compact" style="width: 200px;"></label>
+                                    <div class="status-display" id="code-breadcrumb">
+                                        <div class="breadcrumb-ticker" id="breadcrumb-ticker">
+                                            <span id="breadcrumb-content">Ready to analyze...</span>
+                                        </div>
+                                    </div>
+                                </div>
+
+                                <!-- Bottom-right corner: Ignore patterns -->
+                                <div class="tree-corner-controls bottom-right">
+                                    <div class="control-group">
+                                        <label class="control-label">Ignore:</label>
+                                        <input type="text" id="ignore-patterns" placeholder="test*, *.spec.js, node_modules" class="input-compact">
                                     </div>
                                 </div>
-                            </div>
-                            <div id="code-tree-container" class="code-tree-container">
                                 <div id="code-tree"></div>
                                 <!-- Collapsible legend -->
                                 <div class="tree-legend collapsed" id="tree-legend" style="display: none;">
@@ -447,11 +453,6 @@
                                     </div>
                                 </div>
                             </div>
-                            <div class="code-breadcrumb" id="code-breadcrumb">
-                                <div class="breadcrumb-ticker" id="breadcrumb-ticker">
-                                    <span id="breadcrumb-content">Ready to analyze...</span>
-                                </div>
-                            </div>
                         </div>
                     </div>
 

claude_mpm/services/agents/deployment/agent_template_builder.py

@@ -704,16 +704,29 @@ tools:
         if triggers and not examples:
             # Convert first trigger to example with commentary
             trigger = triggers[0]
+
+            # Handle both string and dict trigger formats
+            if isinstance(trigger, dict):
+                # New format with pattern and confidence
+                trigger_text = trigger.get("pattern", "")
+            else:
+                # Old format with simple string
+                trigger_text = str(trigger)
+
+            # Skip if we don't have valid trigger text
+            if not trigger_text:
+                return examples
+
             agent_type = template_data.get("agent_type", "general")
 
             examples.extend(
                 [
                     "<example>",
-                    f"Context: When user needs {trigger}",
-                    f'user: "{trigger}"',
-                    f'assistant: "I\'ll use the {agent_name} agent for {trigger}."',
+                    f"Context: When user needs {trigger_text}",
+                    f'user: "{trigger_text}"',
+                    f'assistant: "I\'ll use the {agent_name} agent for {trigger_text}."',
                     "<commentary>",
-                    f"This {agent_type} agent is appropriate because it has specialized capabilities for {trigger.lower()} tasks.",
+                    f"This {agent_type} agent is appropriate because it has specialized capabilities for {trigger_text.lower()} tasks.",
                     "</commentary>",
                     "</example>",
                 ]

claude_mpm/services/dashboard/stable_server.py

@@ -0,0 +1,482 @@
+"""
+Stable Dashboard Server for claude-mpm.
+
+WHY: This module provides a simple, stable HTTP + SocketIO server that works
+across all installation methods (direct, pip, pipx, homebrew, npm).
+
+DESIGN DECISIONS:
+- Uses proven python-socketio + aiohttp combination
+- Automatically finds dashboard files across installation methods
+- Provides both HTTP endpoints and SocketIO real-time features
+- Simple mock AST analysis to avoid complex backend dependencies
+- Graceful fallbacks for missing dependencies
+"""
+
+import glob
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+try:
+    import aiohttp
+    import socketio
+    from aiohttp import web
+
+    DEPENDENCIES_AVAILABLE = True
+except ImportError:
+    DEPENDENCIES_AVAILABLE = False
+    socketio = None
+    aiohttp = None
+    web = None
+
+
+def find_dashboard_files() -> Optional[Path]:
+    """Find dashboard files across different installation methods."""
+    # Try different possible locations
+    possible_locations = [
+        # Development/direct install
+        Path(__file__).parent.parent.parent / "dashboard",
+        # Current working directory (for development)
+        Path.cwd() / "src" / "claude_mpm" / "dashboard",
+        # Pip install in current Python environment
+        Path(sys.prefix)
+        / "lib"
+        / f"python{sys.version_info.major}.{sys.version_info.minor}"
+        / "site-packages"
+        / "claude_mpm"
+        / "dashboard",
+        # User site-packages
+        Path.home()
+        / ".local"
+        / "lib"
+        / f"python{sys.version_info.major}.{sys.version_info.minor}"
+        / "site-packages"
+        / "claude_mpm"
+        / "dashboard",
+    ]
+
+    # Add glob patterns for different Python versions
+    python_patterns = [
+        f"/opt/homebrew/lib/python{sys.version_info.major}.{sys.version_info.minor}/site-packages/claude_mpm/dashboard",
+        f"/usr/local/lib/python{sys.version_info.major}.{sys.version_info.minor}/site-packages/claude_mpm/dashboard",
+    ]
+
+    # Check direct paths first
+    for location in possible_locations:
+        if location.exists() and (location / "templates" / "index.html").exists():
+            return location
+
+    # Check pattern-based paths
+    for pattern in python_patterns:
+        matches = glob.glob(pattern)
+        for match in matches:
+            path = Path(match)
+            if path.exists() and (path / "templates" / "index.html").exists():
+                return path
+
+    # Fallback: try to find via module import
+    try:
+        import claude_mpm.dashboard
+
+        module_path = Path(claude_mpm.dashboard.__file__).parent
+        if (module_path / "templates" / "index.html").exists():
+            return module_path
+    except ImportError:
+        pass
+
+    return None
+
+
+def create_mock_ast_data(file_path: str, file_name: str) -> Dict[str, Any]:
+    """Create mock AST analysis data."""
+    ext = file_name.split(".")[-1].lower() if "." in file_name else ""
+
+    elements = []
+    if ext == "py":
+        elements = [
+            {
+                "name": "MockClass",
+                "type": "class",
+                "line": 10,
+                "complexity": 2,
+                "docstring": "Mock class for demonstration",
+                "methods": [
+                    {"name": "__init__", "type": "method", "line": 11, "complexity": 1},
+                    {
+                        "name": "mock_method",
+                        "type": "method",
+                        "line": 15,
+                        "complexity": 1,
+                    },
+                ],
+            },
+            {
+                "name": "mock_function",
+                "type": "function",
+                "line": 20,
+                "complexity": 1,
+                "docstring": "Mock function for demonstration",
+            },
+        ]
+    elif ext in ["js", "ts", "jsx", "tsx"]:
+        elements = [
+            {
+                "name": "MockClass",
+                "type": "class",
+                "line": 5,
+                "complexity": 2,
+                "methods": [
+                    {
+                        "name": "constructor",
+                        "type": "method",
+                        "line": 6,
+                        "complexity": 1,
+                    },
+                    {
+                        "name": "mockMethod",
+                        "type": "method",
+                        "line": 10,
+                        "complexity": 1,
+                    },
+                ],
+            },
+            {"name": "mockFunction", "type": "function", "line": 15, "complexity": 1},
+        ]
+
+    return {
+        "path": file_path,
+        "elements": elements,
+        "complexity": sum(e.get("complexity", 1) for e in elements),
+        "lines": 50,
+        "stats": {
+            "classes": len([e for e in elements if e["type"] == "class"]),
+            "functions": len([e for e in elements if e["type"] == "function"]),
+            "methods": sum(len(e.get("methods", [])) for e in elements),
+            "lines": 50,
+        },
+    }
+
+
+class StableDashboardServer:
+    """Stable dashboard server that works across all installation methods."""
+
+    def __init__(self, host: str = "localhost", port: int = 8765, debug: bool = False):
+        self.host = host
+        self.port = port
+        self.debug = debug
+        self.dashboard_path = None
+        self.app = None
+        self.sio = None
+
+    def setup(self) -> bool:
+        """Set up the server components."""
+        if not DEPENDENCIES_AVAILABLE:
+            print(
+                "❌ Error: Missing dependencies. Install with: pip install aiohttp python-socketio"
+            )
+            return False
+
+        # Find dashboard files
+        self.dashboard_path = find_dashboard_files()
+        if not self.dashboard_path:
+            print("❌ Error: Could not find dashboard files")
+            print("Please ensure Claude MPM is properly installed")
+            return False
+
+        print(f"📁 Using dashboard files from: {self.dashboard_path}")
+
+        # Create SocketIO server with improved timeout settings
+        self.sio = socketio.AsyncServer(
+            cors_allowed_origins="*",
+            logger=True,
+            engineio_logger=True,
+            ping_interval=30,  # Match client's 30 second ping interval
+            ping_timeout=60,  # Match client's 60 second timeout
+            max_http_buffer_size=1e8,  # Allow larger messages
+        )
+        self.app = web.Application()
+        self.sio.attach(self.app)
+        print("✅ SocketIO server created and attached")
+
+        # Set up routes
+        self._setup_routes()
+        self._setup_socketio_events()
+
+        print("✅ Server setup complete!")
+
+        return True
+
+    def _setup_routes(self):
+        """Set up HTTP routes."""
+        self.app.router.add_get("/", self._serve_dashboard)
+        self.app.router.add_get("/static/{path:.*}", self._serve_static)
+        self.app.router.add_get("/api/directory/list", self._list_directory)
+        self.app.router.add_get("/api/file/read", self._read_file)
+        self.app.router.add_get("/version.json", self._serve_version)
+
+    def _setup_socketio_events(self):
+        """Set up SocketIO event handlers."""
+
+        @self.sio.event
+        async def connect(sid, environ):
+            print(f"✅ SocketIO client connected: {sid}")
+            print(f"   Client info: {environ.get('HTTP_USER_AGENT', 'Unknown')}")
+            # Send a test message to confirm connection
+            await self.sio.emit(
+                "connection_test", {"status": "connected", "server": "stable"}, room=sid
+            )
+
+        @self.sio.event
+        async def disconnect(sid):
+            print(f"❌ SocketIO client disconnected: {sid}")
+
+        @self.sio.event
+        async def code_analyze_file(sid, data):
+            print(
+                f"📡 Received file analysis request from {sid}: {data.get('path', 'unknown')}"
+            )
+
+            file_path = data.get("path", "")
+            file_name = file_path.split("/")[-1] if file_path else "unknown"
+
+            # Create mock response
+            response = create_mock_ast_data(file_path, file_name)
+
+            print(f"📤 Sending analysis response: {len(response['elements'])} elements")
+            await self.sio.emit("code:file:analyzed", response, room=sid)
+
+        # CRITICAL: Handle the actual event name with colons that the client sends
+        @self.sio.on("code:analyze:file")
+        async def handle_code_analyze_file(sid, data):
+            print(
+                f"📡 Received code:analyze:file from {sid}: {data.get('path', 'unknown')}"
+            )
+
+            file_path = data.get("path", "")
+            file_name = file_path.split("/")[-1] if file_path else "unknown"
+
+            # Create mock response
+            response = create_mock_ast_data(file_path, file_name)
+
+            print(f"📤 Sending analysis response: {len(response['elements'])} elements")
+            await self.sio.emit("code:file:analyzed", response, room=sid)
+
+        # Handle other events the dashboard sends
+        @self.sio.event
+        async def get_git_branch(sid, data):
+            print(f"📡 Received git branch request from {sid}: {data}")
+            await self.sio.emit(
+                "git_branch_response", {"branch": "main", "path": data}, room=sid
+            )
+
+        @self.sio.event
+        async def request_status(sid, data):
+            print(f"📡 Received status request from {sid}")
+            await self.sio.emit(
+                "status_response", {"status": "running", "server": "stable"}, room=sid
+            )
+
+        # Handle the event with dots (SocketIO converts colons to dots sometimes)
+        @self.sio.event
+        async def request_dot_status(sid, data):
+            print(f"📡 Received request.status from {sid}")
+            await self.sio.emit(
+                "status_response", {"status": "running", "server": "stable"}, room=sid
+            )
+
+        @self.sio.event
+        async def code_discover_top_level(sid, data):
+            print(f"📡 Received top-level discovery request from {sid}")
+            await self.sio.emit("code:top_level:discovered", {"status": "ok"}, room=sid)
+
+    async def _serve_dashboard(self, request):
+        """Serve the main dashboard HTML."""
+        dashboard_file = self.dashboard_path / "templates" / "index.html"
+        if dashboard_file.exists():
+            with open(dashboard_file) as f:
+                content = f.read()
+            return web.Response(text=content, content_type="text/html")
+        return web.Response(text="Dashboard not found", status=404)
+
+    async def _serve_static(self, request):
+        """Serve static files."""
+        file_path = request.match_info["path"]
+        static_file = self.dashboard_path / "static" / file_path
+
+        if static_file.exists() and static_file.is_file():
+            content_type = (
+                "text/javascript"
+                if file_path.endswith(".js")
+                else "text/css" if file_path.endswith(".css") else "text/plain"
+            )
+            with open(static_file) as f:
+                content = f.read()
+            return web.Response(text=content, content_type=content_type)
+        return web.Response(text="File not found", status=404)
+
+    async def _list_directory(self, request):
+        """List directory contents."""
+        path = request.query.get("path", ".")
+        abs_path = os.path.abspath(os.path.expanduser(path))
+
+        result = {"path": abs_path, "exists": os.path.exists(abs_path), "contents": []}
+
+        if os.path.exists(abs_path) and os.path.isdir(abs_path):
+            try:
+                for item in sorted(os.listdir(abs_path)):
+                    item_path = os.path.join(abs_path, item)
+                    result["contents"].append(
+                        {
+                            "name": item,
+                            "path": item_path,
+                            "is_directory": os.path.isdir(item_path),
+                            "is_file": os.path.isfile(item_path),
+                            "is_code_file": item.endswith(
+                                (".py", ".js", ".ts", ".jsx", ".tsx")
+                            ),
+                        }
+                    )
+            except PermissionError:
+                result["error"] = "Permission denied"
+
+        return web.json_response(result)
+
+    async def _read_file(self, request):
+        """Read file content for source viewer."""
+        file_path = request.query.get("path", "")
+
+        if not file_path:
+            return web.json_response({"error": "No path provided"}, status=400)
+
+        abs_path = os.path.abspath(os.path.expanduser(file_path))
+
+        # Security check - ensure file is within the project
+        try:
+            # Get the project root (current working directory)
+            project_root = os.getcwd()
+            # Ensure the path is within the project
+            if not abs_path.startswith(project_root):
+                return web.json_response({"error": "Access denied"}, status=403)
+        except Exception:
+            pass  # Allow read if we can't determine project root
+
+        if not os.path.exists(abs_path):
+            return web.json_response({"error": "File not found"}, status=404)
+
+        if not os.path.isfile(abs_path):
+            return web.json_response({"error": "Not a file"}, status=400)
+
+        try:
+            # Read file with appropriate encoding
+            encodings = ["utf-8", "latin-1", "cp1252"]
+            content = None
+
+            for encoding in encodings:
+                try:
+                    with open(abs_path, encoding=encoding) as f:
+                        content = f.read()
+                    break
+                except UnicodeDecodeError:
+                    continue
+
+            if content is None:
+                return web.json_response({"error": "Could not decode file"}, status=400)
+
+            return web.json_response(
+                {
+                    "path": abs_path,
+                    "name": os.path.basename(abs_path),
+                    "content": content,
+                    "lines": len(content.splitlines()),
+                    "size": os.path.getsize(abs_path),
+                }
+            )
+
+        except PermissionError:
+            return web.json_response({"error": "Permission denied"}, status=403)
+        except Exception as e:
+            return web.json_response({"error": str(e)}, status=500)
+
+    async def _serve_version(self, request):
+        """Serve version information."""
+        version_info = {
+            "version": "4.2.2",
+            "server": "stable",
+            "features": ["http", "socketio", "mock_ast"],
+            "status": "running",
+        }
+        return web.json_response(version_info)
+
+    def run(self):
+        """Run the server with automatic port conflict resolution."""
+        print("🔧 Setting up server...")
+        if not self.setup():
+            print("❌ Server setup failed")
+            return False
+
+        print(f"🚀 Starting stable dashboard server at http://{self.host}:{self.port}")
+        print("✅ Server ready: HTTP + SocketIO on same port")
+        print("📡 SocketIO events registered:")
+        print("   - connect/disconnect")
+        print("   - code_analyze_file (from 'code:analyze:file')")
+        print("🌐 HTTP endpoints available:")
+        print("   - GET / (dashboard)")
+        print("   - GET /static/* (static files)")
+        print("   - GET /api/directory/list (directory API)")
+        print(f"🔗 Open in browser: http://{self.host}:{self.port}")
+
+        # Try to start server with port conflict handling
+        max_port_attempts = 10
+        original_port = self.port
+
+        for attempt in range(max_port_attempts):
+            try:
+                web.run_app(self.app, host=self.host, port=self.port, access_log=None)
+                break  # Server started successfully
+            except KeyboardInterrupt:
+                print("\n🛑 Server stopped by user")
+                break
+            except OSError as e:
+                if "[Errno 48]" in str(e) or "Address already in use" in str(e):
+                    # Port is already in use, try next port
+                    if attempt < max_port_attempts - 1:
+                        self.port += 1
+                        print(
+                            f"⚠️ Port {self.port - 1} in use, trying port {self.port}..."
+                        )
+                        # Recreate the app with new port
+                        self.setup()
+                    else:
+                        print(
+                            f"❌ Could not find available port after {max_port_attempts} attempts"
+                        )
+                        print(f"   Ports {original_port} to {self.port} are all in use")
+                        return False
+                else:
+                    # Other OS error
+                    print(f"❌ Server error: {e}")
+                    if self.debug:
+                        import traceback
+
+                        traceback.print_exc()
+                    return False
+            except Exception as e:
+                print(f"❌ Server error: {e}")
+                if self.debug:
+                    import traceback
+
+                    traceback.print_exc()
+                return False
+
+        return True
+
+
+def create_stable_server(
+    dashboard_path: Optional[Path] = None, **kwargs
+) -> StableDashboardServer:
+    """Create a stable dashboard server instance."""
+    server = StableDashboardServer(**kwargs)
+    if dashboard_path:
+        server.dashboard_path = dashboard_path
+    return server