claude-mpm 3.9.0__py3-none-any.whl → 3.9.4__py3-none-any.whl

claude_mpm/hooks/claude_hooks/hook_handler_fixed.py

@@ -0,0 +1,454 @@
+#!/usr/bin/env python3
+"""Optimized Claude Code hook handler with fixed memory management.
+
+MEMORY LEAK FIXES:
+1. Use singleton pattern for ClaudeHookHandler to prevent multiple instances
+2. Proper cleanup of Socket.IO connections with connection pooling
+3. Bounded dictionaries with automatic cleanup of old entries
+4. Improved git branch cache with proper expiration
+5. Better resource management and connection reuse
+
+WHY these fixes:
+- Singleton pattern ensures only one handler instance exists
+- Connection pooling prevents creating new connections for each event
+- Bounded dictionaries prevent unbounded memory growth
+- Regular cleanup prevents accumulation of stale data
+"""
+
+import json
+import sys
+import os
+import subprocess
+from datetime import datetime, timedelta
+import time
+import asyncio
+from pathlib import Path
+from collections import deque
+import weakref
+import gc
+
+# Import constants for configuration
+try:
+    from claude_mpm.core.constants import (
+        NetworkConfig,
+        TimeoutConfig,
+        RetryConfig
+    )
+except ImportError:
+    # Fallback values if constants module not available
+    class NetworkConfig:
+        SOCKETIO_PORT_RANGE = (8080, 8099)
+        RECONNECTION_DELAY = 0.5
+        SOCKET_WAIT_TIMEOUT = 1.0
+    class TimeoutConfig:
+        QUICK_TIMEOUT = 2.0
+        QUEUE_GET_TIMEOUT = 1.0
+    class RetryConfig:
+        MAX_RETRIES = 3
+        INITIAL_RETRY_DELAY = 0.1
+
+# Debug mode is enabled by default for better visibility into hook processing
+DEBUG = os.environ.get('CLAUDE_MPM_HOOK_DEBUG', 'true').lower() != 'false'
+
+# Socket.IO import
+try:
+    import socketio
+    SOCKETIO_AVAILABLE = True
+except ImportError:
+    SOCKETIO_AVAILABLE = False
+    socketio = None
+
+# Memory hooks and response tracking imports (simplified)
+MEMORY_HOOKS_AVAILABLE = False
+RESPONSE_TRACKING_AVAILABLE = False
+
+# Maximum size for tracking dictionaries to prevent unbounded growth
+MAX_DELEGATION_TRACKING = 100
+MAX_PROMPT_TRACKING = 50
+MAX_CACHE_AGE_SECONDS = 300  # 5 minutes
+CLEANUP_INTERVAL_EVENTS = 100  # Clean up every 100 events
+
+
+class SocketIOConnectionPool:
+    """Connection pool for Socket.IO clients to prevent connection leaks.
+    
+    WHY: Reuses connections instead of creating new ones for each event,
+    preventing the accumulation of zombie connections over time.
+    """
+    
+    def __init__(self, max_connections=3):
+        self.max_connections = max_connections
+        self.connections = []
+        self.current_index = 0
+        self.last_cleanup = time.time()
+        
+    def get_connection(self, port):
+        """Get or create a connection to the specified port."""
+        # Clean up dead connections periodically
+        if time.time() - self.last_cleanup > 60:  # Every minute
+            self._cleanup_dead_connections()
+            self.last_cleanup = time.time()
+        
+        # Look for existing connection to this port
+        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:
+                    # Remove dead connection
+                    self.connections.remove(conn)
+        
+        # Create new connection if under limit
+        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
+        
+        # Reuse oldest connection if at limit
+        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 to prevent zombies
+                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()
+
+
+class BoundedDict(dict):
+    """Dictionary with maximum size that removes oldest entries.
+    
+    WHY: Prevents unbounded memory growth by automatically removing
+    old entries when the size limit is reached.
+    """
+    
+    def __init__(self, max_size=100):
+        super().__init__()
+        self.max_size = max_size
+        self.access_times = {}
+        
+    def __setitem__(self, key, value):
+        # Remove oldest entries if at capacity
+        if len(self) >= self.max_size and key not in self:
+            # Find and remove the oldest entry
+            if self.access_times:
+                oldest_key = min(self.access_times, key=self.access_times.get)
+                del self[oldest_key]
+                del self.access_times[oldest_key]
+        
+        super().__setitem__(key, value)
+        self.access_times[key] = time.time()
+    
+    def __delitem__(self, key):
+        super().__delitem__(key)
+        self.access_times.pop(key, None)
+    
+    def cleanup_old_entries(self, max_age_seconds=300):
+        """Remove entries older than specified age."""
+        current_time = time.time()
+        keys_to_remove = [
+            key for key, access_time in self.access_times.items()
+            if current_time - access_time > max_age_seconds
+        ]
+        for key in keys_to_remove:
+            del self[key]
+
+
+class ClaudeHookHandler:
+    """Optimized hook handler with proper memory management.
+    
+    FIXES:
+    - Uses connection pooling for Socket.IO clients
+    - Bounded dictionaries prevent unbounded growth
+    - Regular cleanup of old entries
+    - Proper cache expiration
+    """
+    
+    # Class-level singleton instance
+    _instance = None
+    _instance_lock = None
+    
+    def __new__(cls):
+        """Implement singleton pattern to prevent multiple instances."""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self):
+        # Only initialize once
+        if self._initialized:
+            return
+        self._initialized = True
+        
+        # Socket.IO connection pool
+        self.connection_pool = SocketIOConnectionPool(max_connections=3)
+        
+        # Use bounded dictionaries to prevent unbounded memory growth
+        self.active_delegations = BoundedDict(MAX_DELEGATION_TRACKING)
+        self.delegation_requests = BoundedDict(MAX_DELEGATION_TRACKING)
+        self.pending_prompts = BoundedDict(MAX_PROMPT_TRACKING)
+        
+        # Limited delegation history
+        self.delegation_history = deque(maxlen=100)
+        
+        # Git branch cache with expiration
+        self._git_branch_cache = {}
+        self._git_branch_cache_time = {}
+        
+        # Track events processed for periodic cleanup
+        self.events_processed = 0
+        
+        # Initialize other components (simplified for brevity)
+        self.memory_hooks_initialized = False
+        self.pre_delegation_hook = None
+        self.post_delegation_hook = None
+        self.response_tracker = None
+        self.response_tracking_enabled = False
+        self.track_all_interactions = False
+        
+        if DEBUG:
+            print(f"✅ ClaudeHookHandler singleton initialized (pid: {os.getpid()})", file=sys.stderr)
+    
+    def _periodic_cleanup(self):
+        """Perform periodic cleanup of old data."""
+        self.events_processed += 1
+        
+        if self.events_processed % CLEANUP_INTERVAL_EVENTS == 0:
+            # Clean up old entries in bounded dictionaries
+            self.active_delegations.cleanup_old_entries(MAX_CACHE_AGE_SECONDS)
+            self.delegation_requests.cleanup_old_entries(MAX_CACHE_AGE_SECONDS)
+            self.pending_prompts.cleanup_old_entries(MAX_CACHE_AGE_SECONDS)
+            
+            # Clean up git branch cache
+            current_time = time.time()
+            expired_keys = [
+                key for key, cache_time in self._git_branch_cache_time.items()
+                if current_time - cache_time > MAX_CACHE_AGE_SECONDS
+            ]
+            for key in expired_keys:
+                self._git_branch_cache.pop(key, None)
+                self._git_branch_cache_time.pop(key, None)
+            
+            # Force garbage collection periodically
+            if self.events_processed % (CLEANUP_INTERVAL_EVENTS * 10) == 0:
+                gc.collect()
+                if DEBUG:
+                    print(f"🧹 Performed cleanup after {self.events_processed} events", file=sys.stderr)
+    
+    def _track_delegation(self, session_id: str, agent_type: str, request_data: dict = None):
+        """Track a new agent delegation with automatic cleanup."""
+        if session_id and agent_type and agent_type != 'unknown':
+            self.active_delegations[session_id] = agent_type
+            key = f"{session_id}:{datetime.now().timestamp()}"
+            self.delegation_history.append((key, agent_type))
+            
+            if request_data:
+                self.delegation_requests[session_id] = {
+                    'agent_type': agent_type,
+                    'request': request_data,
+                    'timestamp': datetime.now().isoformat()
+                }
+    
+    def _get_delegation_agent_type(self, session_id: str) -> str:
+        """Get the agent type for a session's active delegation."""
+        if session_id and session_id in self.active_delegations:
+            return self.active_delegations[session_id]
+        
+        # Check recent history
+        if session_id:
+            for key, agent_type in reversed(self.delegation_history):
+                if key.startswith(session_id):
+                    return agent_type
+        
+        return 'unknown'
+    
+    def _get_git_branch(self, working_dir: str = None) -> str:
+        """Get git branch with proper caching and expiration."""
+        if not working_dir:
+            working_dir = os.getcwd()
+        
+        cache_key = working_dir
+        current_time = time.time()
+        
+        # Check cache with expiration
+        if (cache_key in self._git_branch_cache and 
+            cache_key in self._git_branch_cache_time and
+            current_time - self._git_branch_cache_time[cache_key] < 30):
+            return self._git_branch_cache[cache_key]
+        
+        # Get git branch
+        try:
+            original_cwd = os.getcwd()
+            os.chdir(working_dir)
+            
+            result = subprocess.run(
+                ['git', 'branch', '--show-current'],
+                capture_output=True,
+                text=True,
+                timeout=TimeoutConfig.QUICK_TIMEOUT
+            )
+            
+            os.chdir(original_cwd)
+            
+            if result.returncode == 0 and result.stdout.strip():
+                branch = result.stdout.strip()
+                self._git_branch_cache[cache_key] = branch
+                self._git_branch_cache_time[cache_key] = current_time
+                return branch
+        except:
+            pass
+        
+        self._git_branch_cache[cache_key] = 'Unknown'
+        self._git_branch_cache_time[cache_key] = current_time
+        return 'Unknown'
+    
+    def _emit_socketio_event(self, namespace: str, event: str, data: dict):
+        """Emit Socket.IO event using connection pool."""
+        port = int(os.environ.get('CLAUDE_MPM_SOCKETIO_PORT', '8765'))
+        client = self.connection_pool.get_connection(port)
+        
+        if not client:
+            return
+        
+        try:
+            claude_event_data = {
+                'type': f'hook.{event}',
+                'timestamp': datetime.now().isoformat(),
+                'data': data
+            }
+            client.emit('claude_event', claude_event_data)
+        except Exception as e:
+            if DEBUG:
+                print(f"❌ Socket.IO emit failed: {e}", file=sys.stderr)
+    
+    def handle(self):
+        """Process hook event with minimal overhead."""
+        try:
+            # Perform periodic cleanup
+            self._periodic_cleanup()
+            
+            # Read and parse event
+            event = self._read_hook_event()
+            if not event:
+                self._continue_execution()
+                return
+            
+            # Route event to appropriate handler
+            self._route_event(event)
+            
+            # Always continue execution
+            self._continue_execution()
+            
+        except:
+            # Fail fast and silent
+            self._continue_execution()
+    
+    def _read_hook_event(self) -> dict:
+        """Read and parse hook event from stdin."""
+        try:
+            event_data = sys.stdin.read()
+            return json.loads(event_data)
+        except:
+            return None
+    
+    def _route_event(self, event: dict) -> None:
+        """Route event to appropriate handler based on type."""
+        hook_type = event.get('hook_event_name', 'unknown')
+        
+        # Simplified routing (implement actual handlers as needed)
+        if DEBUG:
+            print(f"📥 Processing {hook_type} event", file=sys.stderr)
+    
+    def _continue_execution(self) -> None:
+        """Send continue action to Claude."""
+        print(json.dumps({"action": "continue"}))
+    
+    def __del__(self):
+        """Cleanup when handler is destroyed."""
+        if hasattr(self, 'connection_pool'):
+            self.connection_pool.close_all()
+
+
+# Global singleton instance
+_handler_instance = None
+
+
+def get_handler():
+    """Get the singleton handler instance."""
+    global _handler_instance
+    if _handler_instance is None:
+        _handler_instance = ClaudeHookHandler()
+    return _handler_instance
+
+
+def main():
+    """Entry point with proper singleton usage."""
+    try:
+        handler = get_handler()
+        handler.handle()
+    except Exception as e:
+        # Always output continue action to not block Claude
+        print(json.dumps({"action": "continue"}))
+        if DEBUG:
+            print(f"Hook handler error: {e}", file=sys.stderr)
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

claude_mpm/utils/paths.py

@@ -5,6 +5,7 @@ to avoid duplication across the codebase.
 """
 
 import os
+import sys
 from pathlib import Path
 from typing import Optional, Union, List
 from functools import lru_cache
@@ -45,11 +46,17 @@ class PathResolver:
         try:
             import claude_mpm
             module_path = Path(claude_mpm.__file__).parent
-            # Go up to find the src directory, then one more for root
+            
+            # Check if we're in a development environment (has src/ directory)
             if module_path.parent.name == 'src':
+                # Development structure: project_root/src/claude_mpm/
                 return module_path.parent.parent
-            # Otherwise, assume we're in site-packages
+            
+            # Check if we're in an installed environment (site-packages)
+            # In this case, the module itself IS the framework root for resources
+            # No src/ directory exists in installed packages
             return module_path
+            
         except ImportError:
             pass
         
@@ -78,22 +85,50 @@ class PathResolver:
         Raises:
             FileNotFoundError: If agents directory doesn't exist
         """
+        # Try using importlib.resources first (Python 3.9+)
+        try:
+            if sys.version_info >= (3, 9):
+                from importlib.resources import files
+                agents_path = files('claude_mpm').joinpath('agents')
+                if agents_path.exists():
+                    return Path(str(agents_path))
+            else:
+                # For Python 3.7-3.8, use the backport approach
+                from importlib import resources
+                with resources.path('claude_mpm', 'agents') as agents_path:
+                    if agents_path.exists():
+                        return agents_path
+        except (ImportError, ModuleNotFoundError, TypeError):
+            # Fall back to manual detection if importlib.resources fails
+            pass
+        
+        # Fallback to manual detection
         framework_root = cls.get_framework_root()
         
-        # Check for development structure
-        agents_dir = framework_root / 'src' / 'claude_mpm' / 'agents'
+        # First check if we're in development structure (framework_root is project root)
+        # This happens when framework_root has a src/ directory
+        if (framework_root / 'src').exists():
+            agents_dir = framework_root / 'src' / 'claude_mpm' / 'agents'
+            if agents_dir.exists():
+                return agents_dir
+        
+        # Otherwise we're in installed structure (framework_root is claude_mpm package)
+        # In pip/pipx installs, framework_root already points to claude_mpm package
+        agents_dir = framework_root / 'agents'
         if agents_dir.exists():
             return agents_dir
         
-        # Check for installed structure
+        # Last fallback for edge cases
         agents_dir = framework_root / 'claude_mpm' / 'agents'
         if agents_dir.exists():
             return agents_dir
         
         raise FileNotFoundError(
             f"Agents directory not found. Searched in:\n"
-            f"  - {framework_root / 'src' / 'claude_mpm' / 'agents'}\n"
-            f"  - {framework_root / 'claude_mpm' / 'agents'}"
+            f"  - importlib.resources lookup\n"
+            f"  - {framework_root / 'src' / 'claude_mpm' / 'agents'} (development)\n"
+            f"  - {framework_root / 'agents'} (installed)\n"
+            f"  - {framework_root / 'claude_mpm' / 'agents'} (fallback)"
         )
     
     @classmethod
@@ -260,6 +295,70 @@ class PathResolver:
         logger.debug(f"Found {len(matches)} files matching '{pattern}' in {root}")
         return matches
     
+    @classmethod
+    def get_package_resource_path(cls, resource_path: str) -> Path:
+        """Get the path to a resource within the claude_mpm package.
+        
+        This method handles both development and installed environments correctly.
+        
+        Args:
+            resource_path: Relative path within the claude_mpm package (e.g., 'agents/templates')
+            
+        Returns:
+            Path: Full path to the resource
+            
+        Raises:
+            FileNotFoundError: If the resource doesn't exist
+        """
+        # Try using importlib.resources first (most reliable for installed packages)
+        try:
+            if sys.version_info >= (3, 9):
+                from importlib.resources import files
+                resource = files('claude_mpm').joinpath(resource_path)
+                if resource.exists():
+                    return Path(str(resource))
+            else:
+                # For Python 3.7-3.8
+                from importlib import resources
+                parts = resource_path.split('/')
+                if len(parts) == 1:
+                    with resources.path('claude_mpm', parts[0]) as p:
+                        if p.exists():
+                            return p
+                else:
+                    # For nested paths, navigate step by step
+                    package = 'claude_mpm'
+                    for part in parts[:-1]:
+                        package = f"{package}.{part}"
+                    with resources.path(package, parts[-1]) as p:
+                        if p.exists():
+                            return p
+        except (ImportError, ModuleNotFoundError, TypeError, AttributeError):
+            # Fall back to file system detection
+            pass
+        
+        # Fallback: Use file system detection
+        import claude_mpm
+        module_path = Path(claude_mpm.__file__).parent
+        resource = module_path / resource_path
+        
+        if resource.exists():
+            return resource
+        
+        # Try with framework root
+        framework_root = cls.get_framework_root()
+        if (framework_root / 'src').exists():
+            # Development environment
+            resource = framework_root / 'src' / 'claude_mpm' / resource_path
+        else:
+            # Installed environment
+            resource = framework_root / resource_path
+        
+        if resource.exists():
+            return resource
+        
+        raise FileNotFoundError(f"Resource not found: {resource_path}")
+    
     @classmethod
     def clear_cache(cls):
         """Clear all cached path lookups.
@@ -288,4 +387,9 @@ def get_project_root() -> Path:
 
 def find_file_upwards(filename: str, start_path: Optional[Path] = None) -> Optional[Path]:
     """Search for a file by traversing up the directory tree."""
-    return PathResolver.find_file_upwards(filename, start_path)
+    return PathResolver.find_file_upwards(filename, start_path)
+
+
+def get_package_resource_path(resource_path: str) -> Path:
+    """Get the path to a resource within the claude_mpm package."""
+    return PathResolver.get_package_resource_path(resource_path)

{claude_mpm-3.9.0.dist-info → claude_mpm-3.9.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 3.9.0
+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