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

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

@@ -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,389 @@
+"""
+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
+        self.sio = socketio.AsyncServer(
+            cors_allowed_origins="*", logger=True, engineio_logger=True
+        )
+        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("/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 _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."""
+        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:
+            web.run_app(self.app, host=self.host, port=self.port, access_log=None)
+        except KeyboardInterrupt:
+            print("\n🛑 Server stopped by user")
+        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

claude_mpm/services/socketio/client_proxy.py

@@ -45,6 +45,22 @@ class SocketIOClientProxy:
         self._client_thread = None
         self._client_loop = None
 
+    def start(self):
+        """Start the Socket.IO client connection (compatibility wrapper).
+
+        This method exists for backward compatibility with code that expects
+        a start() method. It simply calls start_sync().
+        """
+        return self.start_sync()
+
+    def stop(self):
+        """Stop the Socket.IO client connection (compatibility wrapper).
+
+        This method exists for backward compatibility with code that expects
+        a stop() method. It simply calls stop_sync().
+        """
+        return self.stop_sync()
+
     def start_sync(self):
         """Start the Socket.IO client connection to the persistent server."""
         self.logger.debug(

claude_mpm/services/socketio/handlers/code_analysis.py

@@ -591,8 +591,11 @@ class CodeAnalysisEventHandler(BaseEventHandler):
             return
 
         try:
+            self.logger.info(f"Starting file analysis for: {path}")
+
             # Ensure analyzer exists
             if not self.code_analyzer:
+                self.logger.info("Creating new CodeTreeAnalyzer instance")
                 emitter = CodeTreeEventEmitter(use_stdout=False)
                 # Override emit method to send to Socket.IO
                 original_emit = emitter.emit
@@ -630,23 +633,42 @@ class CodeAnalysisEventHandler(BaseEventHandler):
                 self.code_analyzer = CodeTreeAnalyzer(
                     emit_events=False, emitter=emitter
                 )
+                self.logger.info("CodeTreeAnalyzer created successfully")
 
             # Analyze file
+            self.logger.info(f"Calling analyze_file for: {path}")
             result = self.code_analyzer.analyze_file(path)
+            self.logger.info(
+                f"Analysis complete. Result keys: {list(result.keys()) if result else 'None'}"
+            )
+
+            if result:
+                self.logger.info(
+                    f"Analysis result: elements={len(result.get('elements', []))}, nodes={len(result.get('nodes', []))}"
+                )
+            else:
+                self.logger.warning("Analysis returned None or empty result")
 
             # Send result with correct event name (using colons, not dots!)
+            response_data = {
+                "request_id": request_id,
+                "path": path,
+                **result,
+            }
+
+            self.logger.info(f"Emitting code:file:analyzed event to {sid}")
             await self.server.core.sio.emit(
                 "code:file:analyzed",
-                {
-                    "request_id": request_id,
-                    "path": path,
-                    **result,
-                },
+                response_data,
                 room=sid,
             )
+            self.logger.info("Event emitted successfully")
 
         except Exception as e:
             self.logger.error(f"Error analyzing file {path}: {e}")
+            import traceback
+
+            self.logger.error(f"Full traceback: {traceback.format_exc()}")
             await self.server.core.sio.emit(
                 "code:analysis:error",
                 {

claude_mpm/services/socketio/monitor_server.py

@@ -2,7 +2,7 @@
 Lightweight MonitorServer for claude-mpm.
 
 WHY: This module provides a minimal, independent monitoring service that:
-- Runs as a stable background service on port 8766
+- Runs as a stable background service on port 8765
 - Only handles event collection and relay (no UI components)
 - Has minimal dependencies and resource usage
 - Can run as always-on background service
@@ -60,7 +60,7 @@ class MonitorServer(SocketIOServiceInterface):
         monitor_config = config.get("monitor_server", {})
 
         self.host = host or monitor_config.get("host", "localhost")
-        self.port = port or monitor_config.get("port", 8766)
+        self.port = port or monitor_config.get("port", 8765)
         self.logger = get_logger(__name__ + ".MonitorServer")
 
         # Configuration-based settings