claude-mpm 4.1.10__py3-none-any.whl → 4.1.11__py3-none-any.whl

claude_mpm/dashboard/static/js/components/event-viewer.js

@@ -39,7 +39,6 @@ class EventViewer {
 
         // Subscribe to socket events
         this.socketClient.onEventUpdate((events, sessions) => {
-            console.log('EventViewer received event update:', events?.length || 0, 'events');
             // Ensure we always have a valid events array
             this.events = Array.isArray(events) ? events : [];
             this.updateDisplay();
@@ -76,7 +75,6 @@ class EventViewer {
     setupKeyboardNavigation() {
         // Keyboard navigation is now handled by Dashboard.setupUnifiedKeyboardNavigation()
         // This method is kept for backward compatibility but does nothing
-        console.log('EventViewer: Keyboard navigation handled by unified Dashboard system');
     }
 
     /**
@@ -110,18 +108,10 @@ class EventViewer {
         }
 
         this.filteredEvents = this.events.filter(event => {
-            // Filter out info level log messages
-            if (event.type === 'log' && event.data && event.data.level === 'info') {
-                return false;
-            }
-            
-            // Filter out code analysis events (they're shown in footer status bar)
-            if (event.type === 'code' || 
-                (event.type === 'unknown' && event.originalEventName && event.originalEventName.startsWith('code:'))) {
-                return false;
-            }
+            // NO AUTOMATIC FILTERING - All events are shown by default for complete visibility
+            // Users can apply their own filters using the search and type filter controls
             
-            // Search filter
+            // User-controlled search filter
             if (this.searchFilter) {
                 const searchableText = [
                     event.type || '',
@@ -134,7 +124,7 @@ class EventViewer {
                 }
             }
 
-            // Type filter - now handles full hook types (like "hook.user_prompt") and main types
+            // User-controlled type filter - handles full hook types (like "hook.user_prompt") and main types
             if (this.typeFilter) {
                 // Use the same logic as formatEventType to get the full event type
                 const eventType = event.type && event.type.trim() !== '' ? event.type : '';
@@ -144,13 +134,14 @@ class EventViewer {
                 }
             }
 
-            // Session filter
+            // User-controlled session filter
             if (this.sessionFilter && this.sessionFilter !== '') {
                 if (!event.data || event.data.session_id !== this.sessionFilter) {
                     return false;
                 }
             }
 
+            // Allow all events through unless filtered by user controls
             return true;
         });
 
@@ -222,7 +213,6 @@ class EventViewer {
      * Update the display with current events
      */
     updateDisplay() {
-        console.log('EventViewer updating display with', this.events?.length || 0, 'events');
         this.updateEventTypeDropdown();
         this.applyFilters();
     }
@@ -234,6 +224,9 @@ class EventViewer {
         const eventsList = document.getElementById('events-list');
         if (!eventsList) return;
 
+        // Check if user is at bottom BEFORE rendering (for autoscroll decision)
+        const wasAtBottom = (eventsList.scrollTop + eventsList.clientHeight >= eventsList.scrollHeight - 10);
+
         if (this.filteredEvents.length === 0) {
             eventsList.innerHTML = `
                 <div class="no-events">
@@ -281,9 +274,12 @@ class EventViewer {
             window.dashboard.tabNavigation.events.items = this.filteredEventElements;
         }
 
-        // Auto-scroll to bottom if enabled
-        if (this.autoScroll && this.filteredEvents.length > 0) {
-            eventsList.scrollTop = eventsList.scrollHeight;
+        // Auto-scroll only if user was already at bottom before rendering
+        if (this.filteredEvents.length > 0 && wasAtBottom && this.autoScroll) {
+            // Use requestAnimationFrame to ensure DOM has updated
+            requestAnimationFrame(() => {
+                eventsList.scrollTop = eventsList.scrollHeight;
+            });
         }
     }
 
@@ -337,6 +333,8 @@ class EventViewer {
                 return this.formatMemoryEvent(event);
             case 'log':
                 return this.formatLogEvent(event);
+            case 'code':
+                return this.formatCodeEvent(event);
             default:
                 return this.formatGenericEvent(event);
         }
@@ -480,6 +478,47 @@ class EventViewer {
         return `<strong>[${level.toUpperCase()}]</strong> ${truncated}`;
     }
 
+    /**
+     * Format code analysis event data
+     */
+    formatCodeEvent(event) {
+        const data = event.data || {};
+        
+        // Handle different code event subtypes
+        if (event.subtype === 'progress') {
+            const message = data.message || 'Processing...';
+            const percentage = data.percentage;
+            if (percentage !== undefined) {
+                return `<strong>Progress:</strong> ${message} (${Math.round(percentage)}%)`;
+            }
+            return `<strong>Progress:</strong> ${message}`;
+        } else if (event.subtype === 'analysis:queued') {
+            return `<strong>Queued:</strong> Analysis for ${data.path || 'Unknown path'}`;
+        } else if (event.subtype === 'analysis:start') {
+            return `<strong>Started:</strong> Analyzing ${data.path || 'Unknown path'}`;
+        } else if (event.subtype === 'analysis:complete') {
+            const duration = data.duration ? ` (${data.duration.toFixed(2)}s)` : '';
+            return `<strong>Complete:</strong> Analysis finished${duration}`;
+        } else if (event.subtype === 'analysis:error') {
+            return `<strong>Error:</strong> ${data.message || 'Analysis failed'}`;
+        } else if (event.subtype === 'analysis:cancelled') {
+            return `<strong>Cancelled:</strong> Analysis stopped for ${data.path || 'Unknown path'}`;
+        } else if (event.subtype === 'file:start') {
+            return `<strong>File:</strong> Processing ${data.file || 'Unknown file'}`;
+        } else if (event.subtype === 'file:complete') {
+            const nodes = data.nodes_count !== undefined ? ` (${data.nodes_count} nodes)` : '';
+            return `<strong>File done:</strong> ${data.file || 'Unknown file'}${nodes}`;
+        } else if (event.subtype === 'node:found') {
+            return `<strong>Node:</strong> Found ${data.node_type || 'element'} "${data.name || 'unnamed'}"`;
+        } else if (event.subtype === 'error') {
+            return `<strong>Error:</strong> ${data.error || 'Unknown error'} in ${data.file || 'file'}`;
+        }
+        
+        // Generic fallback for code events
+        const json = JSON.stringify(data);
+        return `<strong>Code:</strong> ${json.length > 100 ? json.substring(0, 100) + '...' : json}`;
+    }
+
     /**
      * Format generic event data
      */

claude_mpm/dashboard/static/js/dashboard.js

@@ -393,13 +393,25 @@ class Dashboard {
                             console.log('Dashboard triggering activity tree render...');
                             window.activityTreeInstance.renderWhenVisible();
                         }
+                        
+                        // Force show to ensure the tree is visible
+                        if (typeof window.activityTreeInstance.forceShow === 'function') {
+                            console.log('Dashboard forcing activity tree to show...');
+                            window.activityTreeInstance.forceShow();
+                        }
                     }
                 } else if (window.activityTree && typeof window.activityTree === 'function') {
                     // Fallback to legacy approach if available
                     const activityTreeInstance = window.activityTree();
-                    if (activityTreeInstance && typeof activityTreeInstance.renderWhenVisible === 'function') {
-                        console.log('Dashboard triggering activity tree render (legacy)...');
-                        activityTreeInstance.renderWhenVisible();
+                    if (activityTreeInstance) {
+                        if (typeof activityTreeInstance.renderWhenVisible === 'function') {
+                            console.log('Dashboard triggering activity tree render (legacy)...');
+                            activityTreeInstance.renderWhenVisible();
+                        }
+                        if (typeof activityTreeInstance.forceShow === 'function') {
+                            console.log('Dashboard forcing activity tree to show (legacy)...');
+                            activityTreeInstance.forceShow();
+                        }
                     }
                 } else {
                     // Module not loaded yet, retry after a delay

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

@@ -475,11 +475,10 @@ class SocketClient {
                 return;
             }
             
-            // Check if this is a code analysis event - if so, don't add to events list
-            // Code analysis events are handled by the code-tree component and shown in the footer
+            // Code analysis events are now allowed to flow through to the events list for troubleshooting
+            // They will appear in both the Events tab and the Code tab
             if (validatedEvent.type && validatedEvent.type.startsWith('code:')) {
-                console.log('Code analysis event received via claude_event, not adding to events list:', validatedEvent.type);
-                return;
+                console.log('Code analysis event received via claude_event, adding to events list for troubleshooting:', validatedEvent.type);
             }
             
             // Transform event to match expected format (for backward compatibility)
@@ -551,46 +550,55 @@ class SocketClient {
             this.addEvent({ type: 'log', subtype: 'entry', timestamp: new Date().toISOString(), data });
         });
 
-        // Code analysis events - don't add to event list, just pass through
-        // These are handled by the code-tree component and shown in the footer
+        // Code analysis events - now allowed to flow through for troubleshooting
+        // These are ALSO handled by the code-tree component and shown in the footer
+        // They will appear in both places: Events tab (for troubleshooting) and Code tab (for visualization)
         this.socket.on('code:analysis:queued', (data) => {
-            // Don't add to events list - handled by code-tree component
-            console.log('Code analysis queued event received, not adding to events list');
+            // Add to events list for troubleshooting
+            console.log('Code analysis queued event received, adding to events list for troubleshooting');
+            this.addEvent({ type: 'code', subtype: 'analysis:queued', timestamp: new Date().toISOString(), data });
         });
         
         this.socket.on('code:analysis:accepted', (data) => {
-            // Don't add to events list
-            console.log('Code analysis accepted event received, not adding to events list');
+            // Add to events list for troubleshooting
+            console.log('Code analysis accepted event received, adding to events list for troubleshooting');
+            this.addEvent({ type: 'code', subtype: 'analysis:accepted', timestamp: new Date().toISOString(), data });
         });
         
         this.socket.on('code:analysis:start', (data) => {
-            // Don't add to events list
-            console.log('Code analysis start event received, not adding to events list');
+            // Add to events list for troubleshooting
+            console.log('Code analysis start event received, adding to events list for troubleshooting');
+            this.addEvent({ type: 'code', subtype: 'analysis:start', timestamp: new Date().toISOString(), data });
         });
         
         this.socket.on('code:analysis:complete', (data) => {
-            // Don't add to events list
-            console.log('Code analysis complete event received, not adding to events list');
+            // Add to events list for troubleshooting
+            console.log('Code analysis complete event received, adding to events list for troubleshooting');
+            this.addEvent({ type: 'code', subtype: 'analysis:complete', timestamp: new Date().toISOString(), data });
         });
         
         this.socket.on('code:analysis:error', (data) => {
-            // Don't add to events list
-            console.log('Code analysis error event received, not adding to events list');
+            // Add to events list for troubleshooting
+            console.log('Code analysis error event received, adding to events list for troubleshooting');
+            this.addEvent({ type: 'code', subtype: 'analysis:error', timestamp: new Date().toISOString(), data });
         });
         
         this.socket.on('code:file:start', (data) => {
-            // Don't add to events list
-            console.log('Code file start event received, not adding to events list');
+            // Add to events list for troubleshooting
+            console.log('Code file start event received, adding to events list for troubleshooting');
+            this.addEvent({ type: 'code', subtype: 'file:start', timestamp: new Date().toISOString(), data });
         });
         
         this.socket.on('code:node:found', (data) => {
-            // Don't add to events list
-            console.log('Code node found event received, not adding to events list');
+            // Add to events list for troubleshooting
+            console.log('Code node found event received, adding to events list for troubleshooting');
+            this.addEvent({ type: 'code', subtype: 'node:found', timestamp: new Date().toISOString(), data });
         });
         
         this.socket.on('code:analysis:progress', (data) => {
-            // Don't add to events list
-            console.log('Code analysis progress event received, not adding to events list');
+            // Add to events list for troubleshooting
+            console.log('Code analysis progress event received, adding to events list for troubleshooting');
+            this.addEvent({ type: 'code', subtype: 'analysis:progress', timestamp: new Date().toISOString(), data });
         });
 
         this.socket.on('history', (data) => {
@@ -1082,6 +1090,7 @@ class SocketClient {
         // 1. Hook events: { type: 'hook.pre_tool', timestamp: '...', data: {...} }
         // 2. Legacy events: { event: 'TestStart', timestamp: '...', ... }
         // 3. Standard events: { type: 'session', subtype: 'started', ... }
+        // 4. Normalized events: { type: 'code', subtype: 'progress', ... } - already normalized, keep as-is
 
         if (!eventData) {
             return eventData; // Return as-is if null/undefined
@@ -1089,8 +1098,26 @@ class SocketClient {
 
         let transformedEvent = { ...eventData };
 
+        // Check if event is already normalized (has both type and subtype as separate fields)
+        // This prevents double-transformation of events that were normalized on the backend
+        const isAlreadyNormalized = eventData.type && eventData.subtype && 
+                                   !eventData.type.includes('.') && 
+                                   !eventData.type.includes(':');
+
+        if (isAlreadyNormalized) {
+            // Event is already properly normalized from backend, just preserve it
+            // Store a composite originalEventName for display if needed
+            if (!transformedEvent.originalEventName) {
+                if (eventData.subtype === 'generic' || eventData.type === eventData.subtype) {
+                    transformedEvent.originalEventName = eventData.type;
+                } else {
+                    transformedEvent.originalEventName = `${eventData.type}.${eventData.subtype}`;
+                }
+            }
+            // Return early to avoid further transformation
+        }
         // Handle legacy format with 'event' field but no 'type'
-        if (!eventData.type && eventData.event) {
+        else if (!eventData.type && eventData.event) {
             // Map common event names to proper type/subtype
             const eventName = eventData.event;
             
@@ -1121,8 +1148,10 @@ class SocketClient {
             
             // Remove the 'event' field to avoid confusion
             delete transformedEvent.event;
+            // Store original event name for display purposes
+            transformedEvent.originalEventName = eventName;
         }
-        // Handle standard format with 'type' field
+        // Handle standard format with 'type' field that needs transformation
         else if (eventData.type) {
             const type = eventData.type;
             
@@ -1131,30 +1160,43 @@ class SocketClient {
                 const subtype = type.substring(5); // Remove 'hook.' prefix
                 transformedEvent.type = 'hook';
                 transformedEvent.subtype = subtype;
+                transformedEvent.originalEventName = type;
             }
             // Transform 'code:*' events to proper code type
+            // Handle multi-level subtypes like 'code:analysis:queued'
             else if (type.startsWith('code:')) {
                 transformedEvent.type = 'code';
-                transformedEvent.subtype = type.substring(5); // Remove 'code:' prefix
+                // Replace colons with underscores in subtype for consistency
+                const subtypePart = type.substring(5); // Remove 'code:' prefix
+                transformedEvent.subtype = subtypePart.replace(/:/g, '_');
+                transformedEvent.originalEventName = type;
             }
             // Transform other dotted types like 'session.started' -> type: 'session', subtype: 'started'
             else if (type.includes('.')) {
                 const [mainType, ...subtypeParts] = type.split('.');
                 transformedEvent.type = mainType;
                 transformedEvent.subtype = subtypeParts.join('.');
+                transformedEvent.originalEventName = type;
+            }
+            // Transform any remaining colon-separated types generically
+            else if (type.includes(':')) {
+                const parts = type.split(':', 2); // Split into max 2 parts
+                transformedEvent.type = parts[0];
+                // Replace any remaining colons with underscores in subtype
+                transformedEvent.subtype = parts.length > 1 ? parts[1].replace(/:/g, '_') : 'generic';
+                transformedEvent.originalEventName = type;
+            }
+            // If type doesn't need transformation but has no subtype, set a default
+            else if (!eventData.subtype) {
+                transformedEvent.subtype = 'generic';
+                transformedEvent.originalEventName = type;
             }
         }
         // If no type and no event field, mark as unknown
         else {
             transformedEvent.type = 'unknown';
             transformedEvent.subtype = '';
-        }
-
-        // Store original event name for display purposes (before any transformation)
-        if (!eventData.type && eventData.event) {
-            transformedEvent.originalEventName = eventData.event;
-        } else if (eventData.type) {
-            transformedEvent.originalEventName = eventData.type;
+            transformedEvent.originalEventName = 'unknown';
         }
 
         // Extract and flatten data fields to top level for dashboard compatibility

claude_mpm/dashboard/templates/index.html

@@ -389,12 +389,9 @@
                     <!-- Code Tab -->
                     <div class="tab-content" id="code-tab">
                         <div class="code-container">
-                            <!-- Compact header with all controls in one line -->
+                            <!-- Simplified header with controls -->
                             <div class="code-header-compact">
                                 <div class="header-left">
-                                    <input type="text" id="analysis-path" placeholder="Path" value="." class="path-input-compact">
-                                    <button id="analyze-code" class="btn-compact btn-primary">🔍</button>
-                                    <button id="cancel-analysis" class="btn-compact btn-danger" style="display: none;">✕</button>
                                     <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>
@@ -416,22 +413,23 @@
                                     <input type="text" id="code-search" placeholder="Search..." class="search-compact">
                                 </div>
                             </div>
-                            <!-- Collapsible advanced options -->
-                            <details class="code-advanced-options">
-                                <summary>Advanced Options</summary>
+                            <!-- 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"> TS</label>
+                                        <label><input type="checkbox" class="language-checkbox" value="typescript" checked> TS</label>
                                     </div>
                                     <div class="option-group">
-                                        <label>Depth: <input type="number" id="max-depth" min="1" max="10" value="5" class="input-compact"></label>
-                                        <label>Ignore: <input type="text" id="ignore-patterns" placeholder="test*, *.spec.js" class="input-compact"></label>
+                                        <label>Ignore: <input type="text" id="ignore-patterns" placeholder="test*, *.spec.js, node_modules" class="input-compact" style="width: 200px;"></label>
+                                    </div>
+                                    <div class="option-group">
+                                        <label><input type="checkbox" id="show-hidden-files"> Show hidden files (dotfiles)</label>
                                     </div>
                                 </div>
-                            </details>
+                            </div>
                             <div id="code-tree-container" class="code-tree-container">
                                 <div id="code-tree"></div>
                                 <!-- Collapsible legend -->

claude_mpm/services/agents/memory/memory_format_service.py

@@ -62,7 +62,9 @@ class MemoryFormatService:
             line = line.strip()
             # Skip headers, empty lines, and metadata
             if (
-                not line or line.startswith(("#", "Last Updated:", "**")) or line == "---"
+                not line
+                or line.startswith(("#", "Last Updated:", "**"))
+                or line == "---"
             ):
                 continue
 

claude_mpm/services/cli/agent_cleanup_service.py

@@ -233,10 +233,7 @@ class AgentCleanupService(IAgentCleanupService):
             all_agents = multi_source_service.discover_agents_from_all_sources()
 
             # Detect orphaned agents
-            return multi_source_service.detect_orphaned_agents(
-                agents_dir, all_agents
-            )
-
+            return multi_source_service.detect_orphaned_agents(agents_dir, all_agents)
 
         except Exception as e:
             self.logger.error(f"Error finding orphaned agents: {e}", exc_info=True)

claude_mpm/services/cli/startup_checker.py

@@ -177,7 +177,6 @@ class StartupCheckerService(IStartupChecker):
         try:
             # Check Python version
 
-
             # Check for common missing directories
             warnings.extend(self._check_required_directories())
 

claude_mpm/services/core/cache_manager.py

@@ -307,4 +307,3 @@ class CacheManager(ICacheManager):
                 },
                 "fs_cache": self._fs_cache.get_stats() if self._fs_cache else {},
             }
-

claude_mpm/services/socketio/event_normalizer.py

@@ -59,6 +59,7 @@ class EventType(Enum):
     PERFORMANCE = "performance"  # Performance metrics
     CLAUDE = "claude"  # Claude process events
     TEST = "test"  # Test events
+    CODE = "code"  # Code analysis events
     TOOL = "tool"  # Tool events
     SUBAGENT = "subagent"  # Subagent events
 
@@ -351,6 +352,41 @@ class EventNormalizer:
                 event_type.value if isinstance(event_type, EventType) else event_type
             ), subtype
 
+        # Handle colon-separated event names (e.g., "code:analysis:queued", "code:progress")
+        # These are commonly used by the code analysis system
+        if ":" in event_name:
+            parts = event_name.split(":", 2)  # Split into max 3 parts
+            if len(parts) >= 2:
+                type_part = parts[0].lower()
+                # For events like "code:analysis:queued", combine the last parts as subtype
+                # Replace colons with underscores for clean subtypes
+                if len(parts) == 3:
+                    subtype_part = f"{parts[1]}_{parts[2]}"
+                else:
+                    subtype_part = parts[1].replace(":", "_")
+
+                # Map the type part to known types
+                if type_part in [
+                    "code",  # Code analysis events
+                    "hook",
+                    "session",
+                    "file",
+                    "system",
+                    "connection",
+                    "memory",
+                    "git",
+                    "todo",
+                    "ticket",
+                    "agent",
+                    "claude",
+                    "error",
+                    "performance",
+                    "test",
+                    "tool",
+                    "subagent",
+                ]:
+                    return type_part, subtype_part
+
         # Handle dotted event names (e.g., "connection.status", "session.started")
         if "." in event_name:
             parts = event_name.split(".", 1)
@@ -443,6 +479,34 @@ class EventNormalizer:
                 return EventType.MEMORY.value, "injected"
             return EventType.MEMORY.value, "generic"
 
+        # Code analysis events - using underscores for clean subtypes
+        if "code" in event_lower:
+            if "analysis" in event_lower:
+                if "queue" in event_lower:
+                    return EventType.CODE.value, "analysis_queued"
+                if "start" in event_lower:
+                    return EventType.CODE.value, "analysis_start"
+                if "complete" in event_lower:
+                    return EventType.CODE.value, "analysis_complete"
+                if "error" in event_lower:
+                    return EventType.CODE.value, "analysis_error"
+                if "cancel" in event_lower:
+                    return EventType.CODE.value, "analysis_cancelled"
+                return EventType.CODE.value, "analysis_generic"
+            if "progress" in event_lower:
+                return EventType.CODE.value, "progress"
+            if "file" in event_lower:
+                if "discovered" in event_lower:
+                    return EventType.CODE.value, "file_discovered"
+                if "analyzed" in event_lower:
+                    return EventType.CODE.value, "file_analyzed"
+                return EventType.CODE.value, "file_complete"
+            if "directory" in event_lower:
+                return EventType.CODE.value, "directory_discovered"
+            if "node" in event_lower:
+                return EventType.CODE.value, "node_found"
+            return EventType.CODE.value, "generic"
+
         # Default to unknown with lowercase subtype
         return "unknown", event_name.lower() if event_name else ""