claude-mpm 4.0.32__py3-none-any.whl → 4.0.34__py3-none-any.whl

claude_mpm/dashboard/static/js/components/agent-inference.js

@@ -27,7 +27,11 @@ class AgentInference {
             // PM delegation tracking for unique instance views
             pmDelegations: new Map(), // delegation_id -> delegation context
             // Map of agent events to their PM delegation
-            agentToDelegation: new Map() // agent_name -> delegation_id
+            agentToDelegation: new Map(), // agent_name -> delegation_id
+            // Track orphan subagent events (SubagentStart without PM Task)
+            orphanSubagents: new Map(), // event_index -> orphan context
+            // Track SubagentStart events for orphan detection
+            subagentStartEvents: new Map() // agent_name -> array of start events
         };
 
         console.log('Agent inference system initialized');
@@ -43,7 +47,9 @@ class AgentInference {
             sessionAgents: new Map(),
             eventAgentMap: new Map(),
             pmDelegations: new Map(),
-            agentToDelegation: new Map()
+            agentToDelegation: new Map(),
+            orphanSubagents: new Map(),
+            subagentStartEvents: new Map()
         };
     }
 
@@ -364,6 +370,8 @@ class AgentInference {
         this.state.eventAgentMap.clear();
         this.state.pmDelegations.clear();
         this.state.agentToDelegation.clear();
+        this.state.orphanSubagents.clear();
+        this.state.subagentStartEvents.clear();
 
         console.log('Processing agent inference for', events.length, 'events');
 
@@ -397,6 +405,25 @@ class AgentInference {
                     };
                 }
 
+                // Track SubagentStart events for orphan detection
+                const hookEventName = event.hook_event_name || event.data?.hook_event_name || '';
+                const isSubagentStart = hookEventName === 'SubagentStart' || 
+                                       event.type === 'hook.subagent_start' ||
+                                       event.subtype === 'subagent_start';
+                
+                if (isSubagentStart && inference.type === 'subagent') {
+                    // Track this SubagentStart event
+                    if (!this.state.subagentStartEvents.has(inference.agentName)) {
+                        this.state.subagentStartEvents.set(inference.agentName, []);
+                    }
+                    this.state.subagentStartEvents.get(inference.agentName).push({
+                        eventIndex: index,
+                        event: event,
+                        timestamp: event.timestamp,
+                        sessionId: sessionId
+                    });
+                }
+
                 // Track delegation boundaries and PM delegations
                 if (event.tool_name === 'Task' && inference.type === 'subagent') {
                     // Start of subagent delegation - create PM delegation entry
@@ -486,12 +513,16 @@ class AgentInference {
             }
         });
 
+        // Identify orphan subagents after all events are processed
+        this.identifyOrphanSubagents(events);
+
         console.log('Agent inference processing complete. Results:', {
             total_events: events.length,
             inferred_agents: this.state.eventAgentMap.size,
             unique_sessions: this.state.sessionAgents.size,
             pm_delegations: this.state.pmDelegations.size,
-            agent_to_delegation_mappings: this.state.agentToDelegation.size
+            agent_to_delegation_mappings: this.state.agentToDelegation.size,
+            orphan_subagents: this.state.orphanSubagents.size
         });
     }
 
@@ -580,6 +611,229 @@ class AgentInference {
         return this.state.agentToDelegation;
     }
 
+    /**
+     * Build hierarchical delegation tree structure
+     * @returns {Object} Tree structure with PM nodes and subagent children
+     */
+    buildDelegationHierarchy() {
+        // Get all PM delegations
+        const pmDelegations = this.getPMDelegations();
+        const events = this.eventViewer.events;
+        
+        // Build hierarchy tree
+        const hierarchy = {
+            mainPM: {
+                type: 'pm',
+                name: 'PM',
+                delegations: [],
+                ownEvents: [],
+                totalEvents: 0
+            },
+            impliedPM: {
+                type: 'pm_implied',
+                name: 'Implied PM',
+                delegations: [],
+                ownEvents: [],
+                totalEvents: 0
+            }
+        };
+        
+        // Process explicit PM delegations
+        for (const [delegationId, delegation] of pmDelegations) {
+            hierarchy.mainPM.delegations.push({
+                id: delegationId,
+                agentName: delegation.agentName,
+                taskContext: this.extractTaskContext(delegation.pmCall),
+                events: delegation.agentEvents,
+                startTime: delegation.timestamp,
+                endTime: delegation.endIndex ? events[delegation.endIndex]?.timestamp : null,
+                status: delegation.endIndex ? 'completed' : 'active'
+            });
+            hierarchy.mainPM.totalEvents += delegation.agentEvents.length;
+        }
+        
+        // Find PM's own events
+        events.forEach((event, index) => {
+            const inference = this.getInferredAgent(index);
+            if (inference && inference.type === 'main_agent') {
+                hierarchy.mainPM.ownEvents.push({
+                    eventIndex: index,
+                    event: event
+                });
+                hierarchy.mainPM.totalEvents++;
+            }
+        });
+        
+        // Find orphan subagent events
+        const orphanEvents = new Map();
+        events.forEach((event, index) => {
+            const inference = this.getInferredAgent(index);
+            if (inference && inference.type === 'subagent') {
+                // Check if this is part of any PM delegation
+                let isOrphan = true;
+                for (const [_, delegation] of pmDelegations) {
+                    if (delegation.agentEvents.some(e => e.eventIndex === index)) {
+                        isOrphan = false;
+                        break;
+                    }
+                }
+                
+                if (isOrphan) {
+                    const agentName = inference.agentName;
+                    if (!orphanEvents.has(agentName)) {
+                        orphanEvents.set(agentName, []);
+                    }
+                    orphanEvents.get(agentName).push({
+                        eventIndex: index,
+                        event: event,
+                        inference: inference
+                    });
+                }
+            }
+        });
+        
+        // Add orphan agents as implied PM delegations
+        for (const [agentName, agentEvents] of orphanEvents) {
+            hierarchy.impliedPM.delegations.push({
+                id: `implied_${agentName}`,
+                agentName: agentName,
+                taskContext: 'No explicit PM delegation',
+                events: agentEvents,
+                startTime: agentEvents[0].event.timestamp,
+                endTime: agentEvents[agentEvents.length - 1].event.timestamp,
+                status: 'completed'
+            });
+            hierarchy.impliedPM.totalEvents += agentEvents.length;
+        }
+        
+        return hierarchy;
+    }
+    
+    /**
+     * Extract task context from PM call
+     * @param {Object} pmCall - PM's Task tool call
+     * @returns {string} Task description
+     */
+    extractTaskContext(pmCall) {
+        if (!pmCall) return 'Unknown task';
+        
+        const params = pmCall.tool_parameters || pmCall.data?.tool_parameters || {};
+        return params.task || params.request || params.description || 'Task delegation';
+    }
+    
+    /**
+     * Identify orphan subagents (SubagentStart without PM Task delegation)
+     * @param {Array} events - All events to analyze
+     */
+    identifyOrphanSubagents(events) {
+        const ORPHAN_TIME_WINDOW = 5000; // 5 seconds to group orphans together
+        
+        // Check each SubagentStart event
+        for (const [agentName, startEvents] of this.state.subagentStartEvents) {
+            for (const startEvent of startEvents) {
+                const eventIndex = startEvent.eventIndex;
+                const timestamp = new Date(startEvent.timestamp).getTime();
+                
+                // Check if this SubagentStart has a corresponding PM Task delegation
+                let hasTaskDelegation = false;
+                
+                // Look for a Task tool call within a reasonable time window before this SubagentStart
+                for (let i = Math.max(0, eventIndex - 20); i < eventIndex; i++) {
+                    const prevEvent = events[i];
+                    if (!prevEvent) continue;
+                    
+                    const prevTimestamp = new Date(prevEvent.timestamp).getTime();
+                    const timeDiff = timestamp - prevTimestamp;
+                    
+                    // Check if this is a Task tool call within 10 seconds
+                    if (prevEvent.tool_name === 'Task' && timeDiff >= 0 && timeDiff < 10000) {
+                        const inference = this.state.eventAgentMap.get(i);
+                        if (inference && inference.agentName === agentName) {
+                            hasTaskDelegation = true;
+                            break;
+                        }
+                    }
+                }
+                
+                // If no Task delegation found, mark as orphan
+                if (!hasTaskDelegation) {
+                    this.state.orphanSubagents.set(eventIndex, {
+                        agentName: agentName,
+                        timestamp: startEvent.timestamp,
+                        sessionId: startEvent.sessionId,
+                        event: startEvent.event,
+                        groupingKey: null // Will be set by grouping logic
+                    });
+                }
+            }
+        }
+        
+        // Group orphan subagents by time proximity or session
+        this.groupOrphanSubagents(ORPHAN_TIME_WINDOW);
+    }
+    
+    /**
+     * Group orphan subagents that occur close together in time or same session
+     * @param {number} timeWindow - Time window in milliseconds for grouping
+     */
+    groupOrphanSubagents(timeWindow) {
+        const orphansList = Array.from(this.state.orphanSubagents.values())
+            .sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
+        
+        let currentGroup = null;
+        let lastTimestamp = null;
+        
+        for (const orphan of orphansList) {
+            const timestamp = new Date(orphan.timestamp).getTime();
+            
+            // Check if this orphan should be in the same group
+            if (!currentGroup || 
+                (lastTimestamp && timestamp - lastTimestamp > timeWindow)) {
+                // Start a new group
+                currentGroup = `implied_pm_${orphan.sessionId}_${timestamp}`;
+            }
+            
+            orphan.groupingKey = currentGroup;
+            lastTimestamp = timestamp;
+        }
+    }
+    
+    /**
+     * Check if a subagent event is an orphan (no PM Task delegation)
+     * @param {number} eventIndex - Index of the event
+     * @returns {boolean} True if the event is from an orphan subagent
+     */
+    isOrphanSubagent(eventIndex) {
+        return this.state.orphanSubagents.has(eventIndex);
+    }
+    
+    /**
+     * Get orphan subagent context for an event
+     * @param {number} eventIndex - Index of the event  
+     * @returns {Object|null} Orphan context or null
+     */
+    getOrphanContext(eventIndex) {
+        return this.state.orphanSubagents.get(eventIndex) || null;
+    }
+    
+    /**
+     * Get all orphan subagent groups
+     * @returns {Map} Map of groupingKey -> array of orphan contexts
+     */
+    getOrphanGroups() {
+        const groups = new Map();
+        
+        for (const orphan of this.state.orphanSubagents.values()) {
+            const key = orphan.groupingKey;
+            if (!groups.has(key)) {
+                groups.set(key, []);
+            }
+            groups.get(key).push(orphan);
+        }
+        
+        return groups;
+    }
+
     /**
      * Get unique agent instances (one per agent type, consolidating multiple delegations)
      * This is used for the unique instance view in the agents tab

claude_mpm/dashboard/static/js/components/build-tracker.js

@@ -0,0 +1,289 @@
+/**
+ * Build Tracker Component
+ * 
+ * WHY: Displays and manages version/build information for both MPM and Monitor UI,
+ * providing users with clear visibility of the current system versions.
+ * 
+ * DESIGN DECISION: Implemented as a standalone component that can be easily
+ * integrated into the dashboard header, with automatic updates from SocketIO.
+ */
+
+export class BuildTracker {
+    constructor() {
+        this.element = null;
+        this.buildInfo = {
+            monitor: {
+                version: "1.0.0",
+                build: 1,
+                formatted_build: "0001",
+                full_version: "v1.0.0-0001"
+            },
+            mpm: {
+                version: "unknown",
+                build: "unknown",
+                full_version: "v0.0.0"
+            }
+        };
+        
+        // Socket client reference (will be set during initialization)
+        this.socketClient = null;
+        
+        // Initialize the component
+        this.init();
+    }
+    
+    /**
+     * Initialize the build tracker component
+     */
+    init() {
+        console.log('Initializing BuildTracker component');
+        this.createElements();
+        this.setupEventListeners();
+    }
+    
+    /**
+     * Create the DOM elements for version display
+     * 
+     * WHY: Creates a clean, unobtrusive version display that fits
+     * seamlessly into the dashboard header.
+     */
+    createElements() {
+        // Create container element
+        this.element = document.createElement('div');
+        this.element.className = 'version-display';
+        this.element.id = 'version-display';
+        
+        // Create MPM version element
+        const mpmVersion = document.createElement('span');
+        mpmVersion.className = 'version-item mpm-version';
+        mpmVersion.id = 'mpm-version';
+        mpmVersion.innerHTML = `
+            <span class="version-label">MPM</span>
+            <span class="version-value">v0.0.0</span>
+        `;
+        
+        // Create separator
+        const separator = document.createElement('span');
+        separator.className = 'version-separator';
+        separator.textContent = '|';
+        
+        // Create Monitor version element
+        const monitorVersion = document.createElement('span');
+        monitorVersion.className = 'version-item monitor-version';
+        monitorVersion.id = 'monitor-version';
+        monitorVersion.innerHTML = `
+            <span class="version-label">Monitor</span>
+            <span class="version-value">v1.0.0-0001</span>
+        `;
+        
+        // Assemble elements
+        this.element.appendChild(mpmVersion);
+        this.element.appendChild(separator);
+        this.element.appendChild(monitorVersion);
+        
+        // Add tooltip for detailed info
+        this.element.title = 'Click for detailed version information';
+    }
+    
+    /**
+     * Set the socket client for receiving updates
+     * 
+     * @param {Object} socketClient - The Socket.IO client instance
+     */
+    setSocketClient(socketClient) {
+        this.socketClient = socketClient;
+        
+        // Listen for build info updates
+        if (this.socketClient && this.socketClient.socket) {
+            // Listen for welcome message with build info
+            this.socketClient.socket.on('welcome', (eventData) => {
+                // Handle both old format (direct) and new schema (nested in data)
+                const buildInfo = eventData.build_info || 
+                                 (eventData.data && eventData.data.build_info);
+                if (buildInfo) {
+                    this.updateBuildInfo(buildInfo);
+                }
+            });
+            
+            // Listen for status updates with build info
+            this.socketClient.socket.on('status', (eventData) => {
+                // Handle both old format (direct) and new schema (nested in data)
+                const buildInfo = eventData.build_info || 
+                                 (eventData.data && eventData.data.build_info);
+                if (buildInfo) {
+                    this.updateBuildInfo(buildInfo);
+                }
+            });
+            
+            // Listen for explicit build info updates
+            this.socketClient.socket.on('build_info', (data) => {
+                this.updateBuildInfo(data);
+            });
+        }
+    }
+    
+    /**
+     * Update the build information
+     * 
+     * @param {Object} buildInfo - Build information from server
+     */
+    updateBuildInfo(buildInfo) {
+        console.log('Updating build info:', buildInfo);
+        
+        // Store the build info
+        this.buildInfo = buildInfo;
+        
+        // Update display
+        this.updateDisplay();
+    }
+    
+    /**
+     * Update the version display elements
+     * 
+     * WHY: Keeps the UI in sync with the latest version information
+     * received from the server.
+     */
+    updateDisplay() {
+        // Update MPM version
+        const mpmElement = this.element.querySelector('.mpm-version .version-value');
+        if (mpmElement && this.buildInfo.mpm) {
+            const mpmVersion = this.buildInfo.mpm.full_version || 
+                              `v${this.buildInfo.mpm.version}`;
+            mpmElement.textContent = mpmVersion;
+            
+            // Add build number to tooltip if available
+            if (this.buildInfo.mpm.build && this.buildInfo.mpm.build !== "unknown") {
+                mpmElement.parentElement.title = `MPM Build: ${this.buildInfo.mpm.build}`;
+            }
+        }
+        
+        // Update Monitor version
+        const monitorElement = this.element.querySelector('.monitor-version .version-value');
+        if (monitorElement && this.buildInfo.monitor) {
+            const monitorVersion = this.buildInfo.monitor.full_version || 
+                                  `v${this.buildInfo.monitor.version}-${this.buildInfo.monitor.formatted_build}`;
+            monitorElement.textContent = monitorVersion;
+            
+            // Add last updated to tooltip if available
+            if (this.buildInfo.monitor.last_updated) {
+                const lastUpdated = new Date(this.buildInfo.monitor.last_updated).toLocaleString();
+                monitorElement.parentElement.title = `Monitor Build: ${this.buildInfo.monitor.formatted_build}\nLast Updated: ${lastUpdated}`;
+            }
+        }
+    }
+    
+    /**
+     * Setup event listeners
+     * 
+     * WHY: Allows users to interact with the version display for
+     * additional information or actions.
+     */
+    setupEventListeners() {
+        // Click handler for showing detailed version info
+        this.element.addEventListener('click', () => {
+            this.showDetailedInfo();
+        });
+    }
+    
+    /**
+     * Show detailed version information in a modal or alert
+     * 
+     * WHY: Provides power users with detailed build and version
+     * information for debugging and support purposes.
+     */
+    showDetailedInfo() {
+        const info = [];
+        
+        // MPM information
+        if (this.buildInfo.mpm) {
+            info.push('=== MPM Framework ===');
+            info.push(`Version: ${this.buildInfo.mpm.version}`);
+            if (this.buildInfo.mpm.build && this.buildInfo.mpm.build !== "unknown") {
+                info.push(`Build: ${this.buildInfo.mpm.build}`);
+            }
+            info.push(`Full: ${this.buildInfo.mpm.full_version}`);
+        }
+        
+        info.push('');
+        
+        // Monitor information
+        if (this.buildInfo.monitor) {
+            info.push('=== Monitor UI ===');
+            info.push(`Version: ${this.buildInfo.monitor.version}`);
+            info.push(`Build: ${this.buildInfo.monitor.formatted_build} (${this.buildInfo.monitor.build})`);
+            info.push(`Full: ${this.buildInfo.monitor.full_version}`);
+            if (this.buildInfo.monitor.last_updated) {
+                const lastUpdated = new Date(this.buildInfo.monitor.last_updated).toLocaleString();
+                info.push(`Updated: ${lastUpdated}`);
+            }
+        }
+        
+        // Show in console and alert
+        console.log('Version Information:\n' + info.join('\n'));
+        
+        // Create a simple modal-like display
+        const modal = document.createElement('div');
+        modal.className = 'version-modal';
+        modal.innerHTML = `
+            <div class="version-modal-content">
+                <h3>Version Information</h3>
+                <pre>${info.join('\n')}</pre>
+                <button onclick="this.parentElement.parentElement.remove()">Close</button>
+            </div>
+        `;
+        
+        // Add to body
+        document.body.appendChild(modal);
+        
+        // Auto-remove after 10 seconds
+        setTimeout(() => {
+            modal.remove();
+        }, 10000);
+    }
+    
+    /**
+     * Mount the component to a parent element
+     * 
+     * @param {HTMLElement|string} parent - Parent element or selector
+     */
+    mount(parent) {
+        const parentElement = typeof parent === 'string' 
+            ? document.querySelector(parent) 
+            : parent;
+        
+        if (parentElement && this.element) {
+            parentElement.appendChild(this.element);
+            console.log('BuildTracker mounted to', parent);
+        } else {
+            console.error('Failed to mount BuildTracker: parent element not found');
+        }
+    }
+    
+    /**
+     * Get the component's DOM element
+     * 
+     * @returns {HTMLElement} The component's root element
+     */
+    getElement() {
+        return this.element;
+    }
+    
+    /**
+     * Destroy the component and clean up
+     */
+    destroy() {
+        if (this.element && this.element.parentNode) {
+            this.element.parentNode.removeChild(this.element);
+        }
+        
+        // Clean up socket listeners
+        if (this.socketClient && this.socketClient.socket) {
+            this.socketClient.socket.off('welcome');
+            this.socketClient.socket.off('status');
+            this.socketClient.socket.off('build_info');
+        }
+        
+        this.element = null;
+        this.socketClient = null;
+    }
+}