claude-mpm 4.0.9__py3-none-any.whl → 4.0.11__py3-none-any.whl

claude_mpm/BUILD_NUMBER

@@ -0,0 +1 @@
+287

claude_mpm/VERSION

@@ -1 +1 @@
-4.0.9
+4.0.10

claude_mpm/core/framework_loader.py

@@ -721,31 +721,47 @@ Extract tickets from these patterns:
                 Path.home() / ".claude" / "agents",  # User's system agents
             ]
             
-            agents_dir = None
-            for potential_dir in agents_dirs:
+            # Collect agents from all directories with proper precedence
+            # Project agents override user agents with the same name
+            all_agents = {}  # key: agent_id, value: (agent_data, priority)
+            
+            for priority, potential_dir in enumerate(agents_dirs):
                 if potential_dir.exists() and any(potential_dir.glob("*.md")):
-                    agents_dir = potential_dir
-                    self.logger.debug(f"Found agents directory at: {agents_dir}")
-                    break
-
-
-            if not agents_dir:
-                self.logger.warning(f"No .claude/agents directory found in any location: {agents_dirs}")
+                    self.logger.debug(f"Found agents directory at: {potential_dir}")
+                    
+                    # Collect agents from this directory
+                    for agent_file in potential_dir.glob("*.md"):
+                        if agent_file.name.startswith("."):
+                            continue
+                        
+                        # Parse agent metadata
+                        agent_data = self._parse_agent_metadata(agent_file)
+                        if agent_data:
+                            agent_id = agent_data["id"]
+                            # Only add if not already present (project has priority 0, user has priority 1)
+                            # Lower priority number wins (project > user)
+                            if agent_id not in all_agents or priority < all_agents[agent_id][1]:
+                                all_agents[agent_id] = (agent_data, priority)
+                                self.logger.debug(f"Added/Updated agent {agent_id} from {potential_dir} (priority {priority})")
+
+            if not all_agents:
+                self.logger.warning(f"No agents found in any location: {agents_dirs}")
                 return self._get_fallback_capabilities()
-
+            
+            # Log agent collection summary
+            project_agents = [aid for aid, (_, pri) in all_agents.items() if pri == 0]
+            user_agents = [aid for aid, (_, pri) in all_agents.items() if pri == 1]
+            
+            if project_agents:
+                self.logger.info(f"Loaded {len(project_agents)} project agents: {', '.join(sorted(project_agents))}")
+            if user_agents:
+                self.logger.info(f"Loaded {len(user_agents)} user agents: {', '.join(sorted(user_agents))}")
+            
             # Build capabilities section
             section = "\n\n## Available Agent Capabilities\n\n"
 
-            # Collect deployed agents
-            deployed_agents = []
-            for agent_file in agents_dir.glob("*.md"):
-                if agent_file.name.startswith("."):
-                    continue
-
-                # Parse agent metadata
-                agent_data = self._parse_agent_metadata(agent_file)
-                if agent_data:
-                    deployed_agents.append(agent_data)
+            # Extract just the agent data (drop priority info) and sort
+            deployed_agents = [agent_data for agent_data, _ in all_agents.values()]
 
             if not deployed_agents:
                 return self._get_fallback_capabilities()

claude_mpm/core/interactive_session.py

@@ -469,9 +469,9 @@ class InteractiveSession:
     def _show_available_agents(self) -> bool:
         """Show available agents in the system."""
         try:
-            from claude_mpm.cli import _get_agent_versions_display
+            from claude_mpm.cli.utils import get_agent_versions_display
 
-            agent_versions = _get_agent_versions_display()
+            agent_versions = get_agent_versions_display()
 
             if agent_versions:
                 print(agent_versions)

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

@@ -20,14 +20,33 @@ class SocketClient {
         // Connection state
         this.isConnected = false;
         this.isConnecting = false;
+        this.lastConnectTime = null;
+        this.disconnectTime = null;
 
         // Event processing
         this.events = [];
         this.sessions = new Map();
         this.currentSessionId = null;
 
+        // Event queue for disconnection periods
+        this.eventQueue = [];
+        this.maxQueueSize = 100;
+        
+        // Retry configuration
+        this.retryAttempts = 0;
+        this.maxRetryAttempts = 3;
+        this.retryDelays = [1000, 2000, 4000]; // Exponential backoff
+        this.pendingEmissions = new Map(); // Track pending emissions for retry
+        
+        // Health monitoring
+        this.lastPingTime = null;
+        this.lastPongTime = null;
+        this.pingTimeout = 40000; // 40 seconds (server sends every 30s)
+        this.healthCheckInterval = null;
+        
         // Start periodic status check as fallback mechanism
         this.startStatusCheckFallback();
+        this.startHealthMonitoring();
     }
 
     /**
@@ -88,8 +107,21 @@ class SocketClient {
     setupSocketHandlers() {
         this.socket.on('connect', () => {
             console.log('Connected to Socket.IO server');
+            const previouslyConnected = this.isConnected;
             this.isConnected = true;
             this.isConnecting = false;
+            this.lastConnectTime = Date.now();
+            this.retryAttempts = 0; // Reset retry counter on successful connect
+            
+            // Calculate downtime if this is a reconnection
+            if (this.disconnectTime && previouslyConnected === false) {
+                const downtime = (Date.now() - this.disconnectTime) / 1000;
+                console.log(`Reconnected after ${downtime.toFixed(1)}s downtime`);
+                
+                // Flush queued events after reconnection
+                this.flushEventQueue();
+            }
+            
             this.notifyConnectionStatus('Connected', 'connected');
 
             // Emit connect callback
@@ -106,12 +138,25 @@ class SocketClient {
             console.log('Disconnected from server:', reason);
             this.isConnected = false;
             this.isConnecting = false;
+            this.disconnectTime = Date.now();
+            
+            // Calculate uptime
+            if (this.lastConnectTime) {
+                const uptime = (Date.now() - this.lastConnectTime) / 1000;
+                console.log(`Connection uptime was ${uptime.toFixed(1)}s`);
+            }
+            
             this.notifyConnectionStatus(`Disconnected: ${reason}`, 'disconnected');
 
             // Emit disconnect callback
             this.connectionCallbacks.disconnect.forEach(callback =>
                 callback(reason)
             );
+            
+            // Start auto-reconnect if it was an unexpected disconnect
+            if (reason === 'transport close' || reason === 'ping timeout') {
+                this.scheduleReconnect();
+            }
         });
 
         this.socket.on('connect_error', (error) => {
@@ -124,13 +169,20 @@ class SocketClient {
             this.addEvent({
                 type: 'connection.error',
                 timestamp: new Date().toISOString(),
-                data: { error: errorMsg, url: this.socket.io.uri }
+                data: { 
+                    error: errorMsg, 
+                    url: this.socket.io.uri,
+                    retry_attempt: this.retryAttempts
+                }
             });
 
             // Emit error callback
             this.connectionCallbacks.error.forEach(callback =>
                 callback(errorMsg)
             );
+            
+            // Schedule reconnect with backoff
+            this.scheduleReconnect();
         });
 
         // Primary event handler - this is what the server actually emits
@@ -143,6 +195,18 @@ class SocketClient {
             this.addEvent(transformedEvent);
         });
 
+        // Add ping/pong handlers for health monitoring
+        this.socket.on('ping', (data) => {
+            // console.log('Received ping from server');
+            this.lastPingTime = Date.now();
+            
+            // Send pong response immediately
+            this.socket.emit('pong', { 
+                timestamp: data.timestamp,
+                client_time: Date.now()
+            });
+        });
+        
         // Session and event handlers (legacy/fallback)
         this.socket.on('session.started', (data) => {
             this.addEvent({ type: 'session', subtype: 'started', timestamp: new Date().toISOString(), data });
@@ -235,13 +299,144 @@ class SocketClient {
         this.isConnecting = false;
     }
 
+    /**
+     * Emit an event with retry support
+     * @param {string} event - Event name
+     * @param {any} data - Event data
+     * @param {Object} options - Options for retry behavior
+     */
+    emitWithRetry(event, data = null, options = {}) {
+        const { 
+            maxRetries = 3,
+            retryDelays = [1000, 2000, 4000],
+            onSuccess = null,
+            onFailure = null
+        } = options;
+        
+        const emissionId = `${event}_${Date.now()}_${Math.random()}`;
+        
+        const attemptEmission = (attemptNum = 0) => {
+            if (!this.socket || !this.socket.connected) {
+                // Queue for later if disconnected
+                if (attemptNum === 0) {
+                    this.queueEvent(event, data);
+                    console.log(`Queued ${event} for later emission (disconnected)`);
+                    if (onFailure) onFailure('disconnected');
+                }
+                return;
+            }
+            
+            try {
+                // Attempt emission
+                this.socket.emit(event, data);
+                console.log(`Emitted ${event} successfully`);
+                
+                // Remove from pending
+                this.pendingEmissions.delete(emissionId);
+                
+                if (onSuccess) onSuccess();
+                
+            } catch (error) {
+                console.error(`Failed to emit ${event} (attempt ${attemptNum + 1}):`, error);
+                
+                if (attemptNum < maxRetries - 1) {
+                    const delay = retryDelays[attemptNum] || retryDelays[retryDelays.length - 1];
+                    console.log(`Retrying ${event} in ${delay}ms...`);
+                    
+                    // Store pending emission
+                    this.pendingEmissions.set(emissionId, {
+                        event,
+                        data,
+                        attemptNum: attemptNum + 1,
+                        scheduledTime: Date.now() + delay
+                    });
+                    
+                    setTimeout(() => attemptEmission(attemptNum + 1), delay);
+                } else {
+                    console.error(`Failed to emit ${event} after ${maxRetries} attempts`);
+                    this.pendingEmissions.delete(emissionId);
+                    if (onFailure) onFailure('max_retries_exceeded');
+                }
+            }
+        };
+        
+        attemptEmission();
+    }
+    
+    /**
+     * Queue an event for later emission
+     * @param {string} event - Event name
+     * @param {any} data - Event data
+     */
+    queueEvent(event, data) {
+        if (this.eventQueue.length >= this.maxQueueSize) {
+            // Remove oldest event if queue is full
+            const removed = this.eventQueue.shift();
+            console.warn(`Event queue full, dropped oldest event: ${removed.event}`);
+        }
+        
+        this.eventQueue.push({
+            event,
+            data,
+            timestamp: Date.now()
+        });
+    }
+    
+    /**
+     * Flush queued events after reconnection
+     */
+    flushEventQueue() {
+        if (this.eventQueue.length === 0) return;
+        
+        console.log(`Flushing ${this.eventQueue.length} queued events...`);
+        const events = [...this.eventQueue];
+        this.eventQueue = [];
+        
+        // Emit each queued event with a small delay between them
+        events.forEach((item, index) => {
+            setTimeout(() => {
+                if (this.socket && this.socket.connected) {
+                    this.socket.emit(item.event, item.data);
+                    console.log(`Flushed queued event: ${item.event}`);
+                }
+            }, index * 100); // 100ms between each event
+        });
+    }
+    
+    /**
+     * Schedule a reconnection attempt with exponential backoff
+     */
+    scheduleReconnect() {
+        if (this.retryAttempts >= this.maxRetryAttempts) {
+            console.log('Max reconnection attempts reached, stopping auto-reconnect');
+            this.notifyConnectionStatus('Reconnection failed', 'disconnected');
+            return;
+        }
+        
+        const delay = this.retryDelays[this.retryAttempts] || this.retryDelays[this.retryDelays.length - 1];
+        this.retryAttempts++;
+        
+        console.log(`Scheduling reconnect attempt ${this.retryAttempts}/${this.maxRetryAttempts} in ${delay}ms...`);
+        this.notifyConnectionStatus(`Reconnecting in ${delay/1000}s...`, 'connecting');
+        
+        setTimeout(() => {
+            if (!this.isConnected && this.port) {
+                console.log(`Attempting reconnection ${this.retryAttempts}/${this.maxRetryAttempts}...`);
+                this.connect(this.port);
+            }
+        }, delay);
+    }
+    
     /**
      * Request server status
      */
     requestStatus() {
         if (this.socket && this.socket.connected) {
             console.log('Requesting server status...');
-            this.socket.emit('request.status');
+            this.emitWithRetry('request.status', null, {
+                maxRetries: 2,
+                retryDelays: [500, 1000]
+            });
         }
     }
 
@@ -258,7 +453,13 @@ class SocketClient {
                 event_types: options.event_types || []
             };
             console.log('Requesting event history...', params);
-            this.socket.emit('get_history', params);
+            this.emitWithRetry('get_history', params, {
+                maxRetries: 3,
+                retryDelays: [1000, 2000, 3000],
+                onFailure: (reason) => {
+                    console.error(`Failed to request history: ${reason}`);
+                }
+            });
         } else {
             console.warn('Cannot request history: not connected to server');
         }
@@ -554,6 +755,43 @@ class SocketClient {
         };
     }
 
+    /**
+     * Start health monitoring
+     * Detects stale connections and triggers reconnection
+     */
+    startHealthMonitoring() {
+        this.healthCheckInterval = setInterval(() => {
+            if (this.isConnected && this.lastPingTime) {
+                const timeSinceLastPing = Date.now() - this.lastPingTime;
+                
+                if (timeSinceLastPing > this.pingTimeout) {
+                    console.warn(`No ping from server for ${timeSinceLastPing/1000}s, connection may be stale`);
+                    
+                    // Force reconnection
+                    if (this.socket) {
+                        console.log('Forcing reconnection due to stale connection...');
+                        this.socket.disconnect();
+                        setTimeout(() => {
+                            if (this.port) {
+                                this.connect(this.port);
+                            }
+                        }, 1000);
+                    }
+                }
+            }
+        }, 10000); // Check every 10 seconds
+    }
+    
+    /**
+     * Stop health monitoring
+     */
+    stopHealthMonitoring() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = null;
+        }
+    }
+    
     /**
      * Start periodic status check as fallback mechanism
      * This ensures the UI stays in sync with actual socket state
@@ -615,6 +853,35 @@ class SocketClient {
     }
 }
 
+    /**
+     * Clean up resources
+     */
+    destroy() {
+        this.stopHealthMonitoring();
+        if (this.socket) {
+            this.socket.disconnect();
+            this.socket = null;
+        }
+        this.eventQueue = [];
+        this.pendingEmissions.clear();
+    }
+    
+    /**
+     * Get connection metrics
+     * @returns {Object} Connection metrics
+     */
+    getConnectionMetrics() {
+        return {
+            isConnected: this.isConnected,
+            uptime: this.lastConnectTime ? (Date.now() - this.lastConnectTime) / 1000 : 0,
+            lastPing: this.lastPingTime ? (Date.now() - this.lastPingTime) / 1000 : null,
+            queuedEvents: this.eventQueue.length,
+            pendingEmissions: this.pendingEmissions.size,
+            retryAttempts: this.retryAttempts
+        };
+    }
+}
+
 // ES6 Module export
 export { SocketClient };
 export default SocketClient;

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -903,7 +903,9 @@ def main():
             )
         # Always output continue action to not block Claude
         print(json.dumps({"action": "continue"}))
-        sys.exit(0)
+        # Only exit if this is a signal handler call, not atexit
+        if signum is not None:
+            sys.exit(0)
 
     # Register cleanup handlers
     signal.signal(signal.SIGTERM, cleanup_handler)

claude_mpm/hooks/claude_hooks/hook_wrapper.sh

@@ -45,12 +45,12 @@ export CLAUDE_MPM_HOOK_DEBUG="true"
 
 # Debug log (optional)
 echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] PYTHONPATH: $PYTHONPATH" >> /tmp/hook-wrapper.log
-echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Running: $PYTHON_CMD $SCRIPT_DIR/hook_handler.py" >> /tmp/hook-wrapper.log
+echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Running: $PYTHON_CMD -m claude_mpm.hooks.claude_hooks.hook_handler" >> /tmp/hook-wrapper.log
 echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] SOCKETIO_PORT: $CLAUDE_MPM_SOCKETIO_PORT" >> /tmp/hook-wrapper.log
 
-# Run the Python hook handler with error handling
+# Run the Python hook handler as a module with error handling
 # Use exec to replace the shell process, but wrap in error handling
-if ! "$PYTHON_CMD" "$SCRIPT_DIR/hook_handler.py" "$@" 2>/tmp/hook-error.log; then
+if ! "$PYTHON_CMD" -m claude_mpm.hooks.claude_hooks.hook_handler "$@" 2>/tmp/hook-error.log; then
     # If the Python handler fails, always return continue to not block Claude
     echo '{"action": "continue"}'
     # Log the error for debugging

claude_mpm/services/agents/memory/agent_memory_manager.py

@@ -82,7 +82,7 @@ class AgentMemoryManager(MemoryServiceInterface):
         self._logger_name = None
 
         self.config = config or Config()
-        self.project_root = get_path_manager().get_project_root()
+        self.project_root = get_path_manager().project_root
         # Use current working directory by default, not project root
         self.working_directory = working_directory or Path(os.getcwd())
         self.memories_dir = self.working_directory / ".claude-mpm" / "memories"