claude-mpm 3.9.2__tar.gz → 3.9.4__tar.gz

{claude_mpm-3.9.2/src/claude_mpm.egg-info → claude_mpm-3.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 3.9.2
+Version: 3.9.4
 Summary: Claude Multi-agent Project Manager - Clean orchestration with ticket management
 Home-page: https://github.com/bobmatnyc/claude-mpm
 Author: Claude MPM Team

claude_mpm-3.9.4/VERSION

@@ -0,0 +1 @@
+3.9.4

claude_mpm-3.9.4/src/claude_mpm/VERSION

@@ -0,0 +1 @@
+3.9.4

{claude_mpm-3.9.2 → claude_mpm-3.9.4}/src/claude_mpm/config/paths.py

@@ -33,6 +33,7 @@ class ClaudeMPMPaths:
     
     _instance: Optional['ClaudeMPMPaths'] = None
     _project_root: Optional[Path] = None
+    _is_installed: bool = False
     
     def __new__(cls) -> 'ClaudeMPMPaths':
         """Singleton pattern to ensure single instance."""
@@ -43,6 +44,7 @@ class ClaudeMPMPaths:
     def __init__(self):
         """Initialize paths if not already done."""
         if self._project_root is None:
+            self._is_installed = False
             self._detect_project_root()
     
     def _detect_project_root(self) -> None:
@@ -53,16 +55,29 @@ class ClaudeMPMPaths:
         1. Look for definitive project markers (pyproject.toml, setup.py)
         2. Look for combination of markers to ensure we're at the right level
         3. Walk up from current file location
+        4. Handle both development and installed environments
         """
         # Start from this file's location
         current = Path(__file__).resolve()
         
-        # Walk up the directory tree
+        # Check if we're in an installed environment (site-packages)
+        # In pip/pipx installs, the package is directly in site-packages
+        if 'site-packages' in str(current) or 'dist-packages' in str(current):
+            # We're in an installed environment
+            # The claude_mpm package directory itself is the "root" for resources
+            import claude_mpm
+            self._project_root = Path(claude_mpm.__file__).parent
+            self._is_installed = True
+            logger.debug(f"Installed environment detected, using package dir: {self._project_root}")
+            return
+        
+        # We're in a development environment, look for project markers
         for parent in current.parents:
             # Check for definitive project root indicators
             # Prioritize pyproject.toml and setup.py as they're only at root
             if (parent / 'pyproject.toml').exists() or (parent / 'setup.py').exists():
                 self._project_root = parent
+                self._is_installed = False
                 logger.debug(f"Project root detected at: {parent} (found pyproject.toml or setup.py)")
                 return
             
@@ -70,6 +85,7 @@ class ClaudeMPMPaths:
             # This combination is more likely to be the real project root
             if (parent / '.git').exists() and (parent / 'VERSION').exists():
                 self._project_root = parent
+                self._is_installed = False
                 logger.debug(f"Project root detected at: {parent} (found .git and VERSION)")
                 return
         
@@ -77,12 +93,14 @@ class ClaudeMPMPaths:
         for parent in current.parents:
             if parent.name == 'claude-mpm':
                 self._project_root = parent
+                self._is_installed = False
                 logger.debug(f"Project root detected at: {parent} (by directory name)")
                 return
         
         # Last resort fallback: 3 levels up from this file
         # paths.py is in src/claude_mpm/config/
         self._project_root = current.parent.parent.parent
+        self._is_installed = False
         logger.warning(f"Project root fallback to: {self._project_root}")
     
     @property
@@ -95,16 +113,26 @@ class ClaudeMPMPaths:
     @property
     def src_dir(self) -> Path:
         """Get the src directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # In installed environment, there's no src directory
+            # Return the package directory itself
+            return self.project_root.parent
         return self.project_root / "src"
     
     @property
     def claude_mpm_dir(self) -> Path:
         """Get the main claude_mpm package directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # In installed environment, project_root IS the claude_mpm directory
+            return self.project_root
         return self.src_dir / "claude_mpm"
     
     @property
     def agents_dir(self) -> Path:
         """Get the agents directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # In installed environment, agents is directly under the package
+            return self.project_root / "agents"
         return self.claude_mpm_dir / "agents"
     
     @property
@@ -140,36 +168,58 @@ class ClaudeMPMPaths:
     @property
     def scripts_dir(self) -> Path:
         """Get the scripts directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # In installed environment, scripts might be in a different location or not exist
+            # Return a path that won't cause issues but indicates it's not available
+            return Path.home() / '.claude-mpm' / 'scripts'
         return self.project_root / "scripts"
     
     @property
     def tests_dir(self) -> Path:
         """Get the tests directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # Tests aren't distributed with installed packages
+            return Path.home() / '.claude-mpm' / 'tests'
         return self.project_root / "tests"
     
     @property
     def docs_dir(self) -> Path:
         """Get the documentation directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # Docs might be installed separately or not at all
+            return Path.home() / '.claude-mpm' / 'docs'
         return self.project_root / "docs"
     
     @property
     def logs_dir(self) -> Path:
         """Get the logs directory (creates if doesn't exist)."""
-        logs = self.project_root / "logs"
-        logs.mkdir(exist_ok=True)
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # Use user's home directory for logs in installed environment
+            logs = Path.home() / '.claude-mpm' / 'logs'
+        else:
+            logs = self.project_root / "logs"
+        logs.mkdir(parents=True, exist_ok=True)
         return logs
     
     @property
     def temp_dir(self) -> Path:
         """Get the temporary files directory (creates if doesn't exist)."""
-        temp = self.project_root / ".tmp"
-        temp.mkdir(exist_ok=True)
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # Use user's home directory for temp files in installed environment
+            temp = Path.home() / '.claude-mpm' / '.tmp'
+        else:
+            temp = self.project_root / ".tmp"
+        temp.mkdir(parents=True, exist_ok=True)
         return temp
     
     @property
     def claude_mpm_dir_hidden(self) -> Path:
         """Get the hidden .claude-mpm directory (creates if doesn't exist)."""
-        hidden = self.project_root / ".claude-mpm"
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # Use current working directory in installed environment
+            hidden = Path.cwd() / ".claude-mpm"
+        else:
+            hidden = self.project_root / ".claude-mpm"
         hidden.mkdir(exist_ok=True)
         return hidden
     

{claude_mpm-3.9.2 → claude_mpm-3.9.4}/src/claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -21,6 +21,7 @@ import time
 import asyncio
 from pathlib import Path
 from collections import deque
+import threading
 
 # Import constants for configuration
 try:
@@ -87,6 +88,102 @@ except ImportError:
 # No fallback needed - we only use Socket.IO now
 
 
+
+class SocketIOConnectionPool:
+    """Connection pool for Socket.IO clients to prevent connection leaks."""
+    
+    def __init__(self, max_connections=3):
+        self.max_connections = max_connections
+        self.connections = []
+        self.last_cleanup = time.time()
+        
+    def get_connection(self, port):
+        """Get or create a connection to the specified port."""
+        if time.time() - self.last_cleanup > 60:
+            self._cleanup_dead_connections()
+            self.last_cleanup = time.time()
+        
+        for conn in self.connections:
+            if conn.get('port') == port and conn.get('client'):
+                client = conn['client']
+                if self._is_connection_alive(client):
+                    return client
+                else:
+                    self.connections.remove(conn)
+        
+        if len(self.connections) < self.max_connections:
+            client = self._create_connection(port)
+            if client:
+                self.connections.append({
+                    'port': port,
+                    'client': client,
+                    'created': time.time()
+                })
+                return client
+        
+        if self.connections:
+            oldest = min(self.connections, key=lambda x: x['created'])
+            self._close_connection(oldest['client'])
+            oldest['client'] = self._create_connection(port)
+            oldest['port'] = port
+            oldest['created'] = time.time()
+            return oldest['client']
+        
+        return None
+    
+    def _create_connection(self, port):
+        """Create a new Socket.IO connection."""
+        if not SOCKETIO_AVAILABLE:
+            return None
+        try:
+            client = socketio.Client(
+                reconnection=False,  # Disable auto-reconnect
+                logger=False,
+                engineio_logger=False
+            )
+            client.connect(f'http://localhost:{port}', 
+                          wait=True, 
+                          wait_timeout=NetworkConfig.SOCKET_WAIT_TIMEOUT)
+            if client.connected:
+                return client
+        except Exception:
+            pass
+        return None
+    
+    def _is_connection_alive(self, client):
+        """Check if a connection is still alive."""
+        try:
+            return client and client.connected
+        except:
+            return False
+    
+    def _close_connection(self, client):
+        """Safely close a connection."""
+        try:
+            if client:
+                client.disconnect()
+        except:
+            pass
+    
+    def _cleanup_dead_connections(self):
+        """Remove dead connections from the pool."""
+        self.connections = [
+            conn for conn in self.connections 
+            if self._is_connection_alive(conn.get('client'))
+        ]
+    
+    def close_all(self):
+        """Close all connections in the pool."""
+        for conn in self.connections:
+            self._close_connection(conn.get('client'))
+        self.connections.clear()
+
+
+# Global singleton handler instance
+_global_handler = None
+_handler_lock = threading.Lock()
+
+
 class ClaudeHookHandler:
     """Optimized hook handler with direct Socket.IO client.
     
@@ -99,8 +196,17 @@ class ClaudeHookHandler:
     
     def __init__(self):
         # Socket.IO client (persistent if possible)
-        self.sio_client = None
-        self.sio_connected = False
+        self.connection_pool = SocketIOConnectionPool(max_connections=3)
+        # Track events for periodic cleanup
+        self.events_processed = 0
+        self.last_cleanup = time.time()
+        
+        # Maximum sizes for tracking
+        self.MAX_DELEGATION_TRACKING = 200
+        self.MAX_PROMPT_TRACKING = 100
+        self.MAX_CACHE_AGE_SECONDS = 300
+        self.CLEANUP_INTERVAL_EVENTS = 100
+
         
         # Agent delegation tracking
         # Store recent Task delegations: session_id -> agent_type
@@ -179,6 +285,36 @@ class ClaudeHookHandler:
                 if key in self.delegation_requests:
                     del self.delegation_requests[key]
     
+    
+    def _cleanup_old_entries(self):
+        """Clean up old entries to prevent memory growth."""
+        cutoff_time = datetime.now().timestamp() - self.MAX_CACHE_AGE_SECONDS
+        
+        # Clean up delegation tracking dictionaries
+        for storage in [self.active_delegations, self.delegation_requests]:
+            if len(storage) > self.MAX_DELEGATION_TRACKING:
+                # Keep only the most recent entries
+                sorted_keys = sorted(storage.keys())
+                excess = len(storage) - self.MAX_DELEGATION_TRACKING
+                for key in sorted_keys[:excess]:
+                    del storage[key]
+        
+        # Clean up pending prompts
+        if len(self.pending_prompts) > self.MAX_PROMPT_TRACKING:
+            sorted_keys = sorted(self.pending_prompts.keys())
+            excess = len(self.pending_prompts) - self.MAX_PROMPT_TRACKING
+            for key in sorted_keys[:excess]:
+                del self.pending_prompts[key]
+        
+        # Clean up git branch cache
+        expired_keys = [
+            key for key, cache_time in self._git_branch_cache_time.items()
+            if datetime.now().timestamp() - cache_time > self.MAX_CACHE_AGE_SECONDS
+        ]
+        for key in expired_keys:
+            self._git_branch_cache.pop(key, None)
+            self._git_branch_cache_time.pop(key, None)
+
     def _get_delegation_agent_type(self, session_id: str) -> str:
         """Get the agent type for a session's active delegation."""
         # First try exact session match
@@ -455,97 +591,6 @@ class ClaudeHookHandler:
             self._git_branch_cache_time[cache_key] = current_time
             return 'Unknown'
     
-    def _get_socketio_client(self):
-        """Get or create Socket.IO client with improved reliability.
-        
-        WHY improved approach:
-        - Implements retry logic with exponential backoff
-        - Properly tests connection before returning
-        - Ensures connection persists across events
-        - Better error handling and recovery
-        """
-        if not SOCKETIO_AVAILABLE:
-            return None
-            
-        # Check if we have a connected client
-        if self.sio_client and self.sio_connected:
-            try:
-                # Test if still connected
-                if self.sio_client.connected:
-                    return self.sio_client
-                else:
-                    # Connection lost, clear it
-                    if DEBUG:
-                        print("Hook handler: Socket.IO connection lost, reconnecting...", file=sys.stderr)
-                    self.sio_connected = False
-            except:
-                self.sio_connected = False
-        
-        # Need to create or reconnect client
-        port = int(os.environ.get('CLAUDE_MPM_SOCKETIO_PORT', '8765'))
-        max_retries = RetryConfig.MAX_RETRIES
-        retry_delay = RetryConfig.INITIAL_RETRY_DELAY
-        
-        for attempt in range(max_retries):
-            try:
-                # Clean up old client if exists
-                if self.sio_client and not self.sio_connected:
-                    try:
-                        self.sio_client.disconnect()
-                    except:
-                        pass
-                    self.sio_client = None
-                
-                # Create new client
-                self.sio_client = socketio.Client(
-                    reconnection=True,  # Enable auto-reconnection
-                    reconnection_attempts=3,
-                    reconnection_delay=NetworkConfig.RECONNECTION_DELAY,
-                    reconnection_delay_max=2,
-                    logger=False,
-                    engineio_logger=False
-                )
-                
-                # Try to connect with proper wait
-                self.sio_client.connect(
-                    f'http://localhost:{port}', 
-                    wait=True, 
-                    wait_timeout=NetworkConfig.SOCKET_WAIT_TIMEOUT
-                )
-                
-                # Verify connection
-                if self.sio_client.connected:
-                    self.sio_connected = True
-                    if DEBUG:
-                        print(f"Hook handler: Successfully connected to Socket.IO server on port {port} (attempt {attempt + 1})", file=sys.stderr)
-                    return self.sio_client
-                    
-            except Exception as e:
-                if DEBUG and attempt == max_retries - 1:
-                    print(f"Hook handler: Failed to connect to Socket.IO after {max_retries} attempts: {e}", file=sys.stderr)
-                elif DEBUG:
-                    print(f"Hook handler: Connection attempt {attempt + 1} failed, retrying...", file=sys.stderr)
-                
-                # Exponential backoff with async delay
-                if attempt < max_retries - 1:
-                    # Use asyncio.sleep if in async context, otherwise fall back to time.sleep
-                    try:
-                        loop = asyncio.get_event_loop()
-                        if loop.is_running():
-                            # We're in an async context, use async sleep
-                            asyncio.create_task(asyncio.sleep(retry_delay))
-                        else:
-                            # Sync context, use regular sleep
-                            time.sleep(retry_delay)
-                    except:
-                        # Fallback to sync sleep if asyncio not available
-                        time.sleep(retry_delay)
-                    retry_delay *= 2  # Double the delay for next attempt
-        
-        # All attempts failed
-        self.sio_client = None
-        self.sio_connected = False
-        return None
     
     def handle(self):
         """Process hook event with minimal overhead and zero blocking delays.
@@ -565,6 +610,13 @@ class ClaudeHookHandler:
                 self._continue_execution()
                 return
             
+            # Increment event counter and perform periodic cleanup
+            self.events_processed += 1
+            if self.events_processed % self.CLEANUP_INTERVAL_EVENTS == 0:
+                self._cleanup_old_entries()
+                if DEBUG:
+                    print(f"🧹 Performed cleanup after {self.events_processed} events", file=sys.stderr)
+            
             # Route event to appropriate handler
             self._route_event(event)
             
@@ -647,7 +699,8 @@ class ClaudeHookHandler:
         # The daemon should be running when manager is active
         
         # Get Socket.IO client
-        client = self._get_socketio_client()
+        port = int(os.environ.get('CLAUDE_MPM_SOCKETIO_PORT', '8765'))
+        client = self.connection_pool.get_connection(port)
         if not client:
             if DEBUG:
                 print(f"Hook handler: No Socket.IO client available for event: hook.{event}", file=sys.stderr)
@@ -680,22 +733,18 @@ class ClaudeHookHandler:
                     print(f"✅ Successfully emitted Socket.IO event: hook.{event}", file=sys.stderr)
                 else:
                     print(f"⚠️ Event emitted but connection status uncertain: hook.{event}", file=sys.stderr)
-                    self.sio_connected = False  # Force reconnection next time
                     
         except Exception as e:
             if DEBUG:
                 print(f"❌ Socket.IO emit failed for hook.{event}: {e}", file=sys.stderr)
-            # Mark as disconnected so next call will reconnect
-            self.sio_connected = False
             
             # Try to reconnect immediately for critical events
             if event in ['subagent_stop', 'pre_tool']:
                 if DEBUG:
                     print(f"Hook handler: Attempting immediate reconnection for critical event: hook.{event}", file=sys.stderr)
-                # Clear the client to force reconnection
-                self.sio_client = None
                 # Try to get a new client and emit again
-                retry_client = self._get_socketio_client()
+                retry_port = int(os.environ.get('CLAUDE_MPM_SOCKETIO_PORT', '8765'))
+                retry_client = self.connection_pool.get_connection(retry_port)
                 if retry_client:
                     try:
                         retry_client.emit('claude_event', claude_event_data)
@@ -1667,18 +1716,31 @@ class ClaudeHookHandler:
             # Don't fail the delegation result - memory is optional
     
     def __del__(self):
-        """Cleanup Socket.IO client on handler destruction."""
-        if self.sio_client and self.sio_connected:
+        """Cleanup Socket.IO connections on handler destruction."""
+        if hasattr(self, 'connection_pool') and self.connection_pool:
             try:
-                self.sio_client.disconnect()
+                self.connection_pool.close_all()
             except:
                 pass
 
 
 def main():
-    """Entry point with comprehensive error handling."""
+    """Entry point with singleton pattern to prevent multiple instances."""
+    global _global_handler
+    
     try:
-        handler = ClaudeHookHandler()
+        # Use singleton pattern to prevent creating multiple instances
+        with _handler_lock:
+            if _global_handler is None:
+                _global_handler = ClaudeHookHandler()
+                if DEBUG:
+                    print(f"✅ Created new ClaudeHookHandler singleton (pid: {os.getpid()})", file=sys.stderr)
+            else:
+                if DEBUG:
+                    print(f"♻️ Reusing existing ClaudeHookHandler singleton (pid: {os.getpid()})", file=sys.stderr)
+            
+            handler = _global_handler
+        
         handler.handle()
     except Exception as e:
         # Always output continue action to not block Claude