claude-mpm 3.9.9__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/services/memory_hook_service.py

@@ -0,0 +1,237 @@
+"""Memory hook service for registering memory-related hooks.
+
+This service handles:
+1. Memory hook registration with the hook service
+2. Memory management integration
+3. Hook lifecycle management
+
+Extracted from ClaudeRunner to follow Single Responsibility Principle.
+"""
+
+from typing import Any, Dict
+
+from claude_mpm.core.base_service import BaseService
+from claude_mpm.services.core.interfaces import MemoryHookInterface
+
+
+class MemoryHookService(BaseService, MemoryHookInterface):
+    """Service for managing memory-related hooks."""
+
+    def __init__(self, hook_service=None):
+        """Initialize the memory hook service.
+
+        Args:
+            hook_service: Hook service for registering hooks
+        """
+        super().__init__(name="memory_hook_service")
+        self.hook_service = hook_service
+        self.registered_hooks = []  # Track registered hook IDs
+
+    async def _initialize(self) -> None:
+        """Initialize the service. No special initialization needed."""
+        pass
+
+    async def _cleanup(self) -> None:
+        """Cleanup service resources. No cleanup needed."""
+        pass
+
+    def register_memory_hooks(self):
+        """Register memory-related hooks with the hook service.
+
+        WHY: Memory management is a cross-cutting concern that needs to be
+        integrated at various points in the Claude interaction lifecycle.
+        These hooks ensure memory is properly managed and persisted.
+
+        DESIGN DECISION: We register hooks for key lifecycle events:
+        - Before Claude interaction: Load relevant memories
+        - After Claude interaction: Save new memories
+        - On error: Ensure memory state is preserved
+        """
+        if not self.hook_service:
+            self.logger.debug(
+                "Hook service not available, skipping memory hook registration"
+            )
+            return
+
+        try:
+            # Create hook objects for the actual HookService interface
+            from claude_mpm.hooks.base_hook import (
+                HookContext,
+                HookResult,
+                PostDelegationHook,
+                PreDelegationHook,
+            )
+
+            # Create memory loading hook
+            class MemoryLoadHook(PreDelegationHook):
+                def __init__(self, memory_service):
+                    super().__init__(name="memory_load", priority=10)
+                    self.memory_service = memory_service
+
+                def execute(self, context: HookContext) -> HookResult:
+                    return self.memory_service._load_relevant_memories_hook(context)
+
+            # Create memory saving hook
+            class MemorySaveHook(PostDelegationHook):
+                def __init__(self, memory_service):
+                    super().__init__(name="memory_save", priority=90)
+                    self.memory_service = memory_service
+
+                def execute(self, context: HookContext) -> HookResult:
+                    return self.memory_service._save_new_memories_hook(context)
+
+            # Register the hook objects
+            load_hook = MemoryLoadHook(self)
+            save_hook = MemorySaveHook(self)
+
+            success1 = self.hook_service.register_hook(load_hook)
+            success2 = self.hook_service.register_hook(save_hook)
+
+            if success1:
+                self.registered_hooks.append("memory_load")
+            if success2:
+                self.registered_hooks.append("memory_save")
+
+            self.logger.debug("Memory hooks registered successfully")
+
+        except Exception as e:
+            self.logger.warning(f"Failed to register memory hooks: {e}")
+
+    def _load_relevant_memories_hook(self, context):
+        """Hook function to load relevant memories before Claude interaction.
+
+        Args:
+            context: Hook context containing interaction details
+
+        Returns:
+            HookResult with success status and any modifications
+        """
+        try:
+            # This would integrate with a memory service to load relevant memories
+            # For now, this is a placeholder for future memory integration
+            self.logger.debug("Loading relevant memories for interaction")
+
+            # Example: Load memories based on context
+            # if hasattr(context, 'prompt'):
+            #     relevant_memories = memory_service.search_memories(context.prompt)
+            #     context.memories = relevant_memories
+
+            from claude_mpm.hooks.base_hook import HookResult
+
+            return HookResult(success=True, data=context.data, modified=False)
+
+        except Exception as e:
+            self.logger.warning(f"Failed to load memories: {e}")
+            from claude_mpm.hooks.base_hook import HookResult
+
+            return HookResult(
+                success=False, data=context.data, modified=False, error=str(e)
+            )
+
+    def _load_relevant_memories(self, context):
+        """Legacy hook function for backward compatibility."""
+        result = self._load_relevant_memories_hook(context)
+        return result.data
+
+    def _save_new_memories_hook(self, context):
+        """Hook function to save new memories after Claude interaction.
+
+        Args:
+            context: Hook context containing interaction results
+
+        Returns:
+            HookResult with success status and any modifications
+        """
+        try:
+            # This would integrate with a memory service to save new memories
+            # For now, this is a placeholder for future memory integration
+            self.logger.debug("Saving new memories from interaction")
+
+            from claude_mpm.hooks.base_hook import HookResult
+
+            return HookResult(success=True, data=context.data, modified=False)
+
+        except Exception as e:
+            self.logger.warning(f"Failed to save memories: {e}")
+            from claude_mpm.hooks.base_hook import HookResult
+
+            return HookResult(
+                success=False, data=context.data, modified=False, error=str(e)
+            )
+
+    def _save_new_memories(self, context):
+        """Legacy hook function for backward compatibility."""
+        result = self._save_new_memories_hook(context)
+        return result.data
+
+    def _preserve_memory_state(self, context):
+        """Hook function to preserve memory state on interaction error.
+
+        Args:
+            context: Hook context containing error details
+        """
+        try:
+            # This would ensure memory state is preserved even if interaction fails
+            self.logger.debug("Preserving memory state after error")
+
+        except Exception as e:
+            self.logger.warning(f"Failed to preserve memory state: {e}")
+
+    def unregister_memory_hooks(self):
+        """Unregister memory-related hooks from the hook service."""
+        if not self.hook_service:
+            return
+
+        try:
+            self.hook_service.unregister_hook(
+                "before_claude_interaction", self._load_relevant_memories
+            )
+            self.hook_service.unregister_hook(
+                "after_claude_interaction", self._save_new_memories
+            )
+            self.hook_service.unregister_hook(
+                "on_interaction_error", self._preserve_memory_state
+            )
+
+            self.logger.debug("Memory hooks unregistered successfully")
+
+        except Exception as e:
+            self.logger.warning(f"Failed to unregister memory hooks: {e}")
+
+    def is_memory_enabled(self) -> bool:
+        """Check if memory functionality is enabled.
+
+        Returns:
+            bool: True if memory is enabled and available
+        """
+        # This would check if memory service is available and configured
+        # For now, return False as memory is not yet implemented
+        return False
+
+    def get_memory_status(self) -> dict:
+        """Get current memory system status.
+
+        Returns:
+            dict: Memory system status information
+        """
+        return {
+            "enabled": self.is_memory_enabled(),
+            "hooks_registered": self.hook_service is not None,
+            "service_available": True,
+        }
+
+    def get_hook_status(self) -> Dict[str, Any]:
+        """Get status of registered memory hooks.
+
+        Returns:
+            Dictionary with hook status information
+        """
+        return {
+            "registered_hooks": self.registered_hooks,
+            "hook_service_available": self.hook_service is not None,
+            "memory_enabled": self.is_memory_enabled(),
+            "total_hooks": len(self.registered_hooks),
+            "status": "active" if self.registered_hooks else "inactive",
+        }
+
+

claude_mpm/services/port_manager.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+"""
+Port Manager for SocketIO Server
+
+Handles dynamic port selection, instance detection, and port availability checking.
+Ensures only one instance runs per port and provides fallback port selection.
+"""
+
+import json
+import os
+import socket
+import subprocess
+import time
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import psutil
+
+from ..core.logging_config import get_logger
+
+
+class PortManager:
+    """Manages port allocation and instance detection for SocketIO servers."""
+
+    # Port range for SocketIO servers
+    PORT_RANGE = range(8765, 8786)  # 8765-8785 (21 ports)
+    DEFAULT_PORT = 8765
+
+    def __init__(self, project_root: Optional[Path] = None):
+        self.logger = get_logger(__name__ + ".PortManager")
+        self.project_root = project_root or Path.cwd()
+        self.state_dir = self.project_root / ".claude-mpm"
+        self.state_dir.mkdir(exist_ok=True)
+        self.instances_file = self.state_dir / "socketio-instances.json"
+
+    def is_port_available(self, port: int) -> bool:
+        """Check if a port is available for binding."""
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                result = sock.bind(("localhost", port))
+                return True
+        except OSError:
+            return False
+
+    def is_claude_mpm_instance(self, port: int) -> Tuple[bool, Optional[Dict]]:
+        """Check if a port is being used by a claude-mpm SocketIO instance."""
+        instances = self.load_instances()
+
+        for instance_id, instance_info in instances.items():
+            if instance_info.get("port") == port:
+                # Check if the process is still running
+                pid = instance_info.get("pid")
+                if pid and self.is_process_running(pid):
+                    # Verify it's actually our process
+                    if self.is_our_socketio_process(pid):
+                        return True, instance_info
+                else:
+                    # Process is dead, clean up the instance
+                    self.remove_instance(instance_id)
+
+        return False, None
+
+    def is_process_running(self, pid: int) -> bool:
+        """Check if a process with given PID is running."""
+        try:
+            return psutil.pid_exists(pid)
+        except Exception:
+            return False
+
+    def is_our_socketio_process(self, pid: int) -> bool:
+        """Verify that a PID belongs to our SocketIO server."""
+        try:
+            process = psutil.Process(pid)
+            cmdline = " ".join(process.cmdline())
+
+            # Check if it's a Python process running our SocketIO daemon
+            return "python" in cmdline.lower() and (
+                "socketio_daemon" in cmdline or "claude-mpm" in cmdline
+            )
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            return False
+
+    def find_available_port(
+        self, preferred_port: Optional[int] = None
+    ) -> Optional[int]:
+        """Find an available port, preferring the specified port if given."""
+        # Try preferred port first
+        if preferred_port and preferred_port in self.PORT_RANGE:
+            if self.is_port_available(preferred_port):
+                is_ours, instance_info = self.is_claude_mpm_instance(preferred_port)
+                if not is_ours:
+                    return preferred_port
+                else:
+                    self.logger.warning(
+                        f"Port {preferred_port} is already used by claude-mpm instance: {instance_info}"
+                    )
+
+        # Try default port
+        if self.is_port_available(self.DEFAULT_PORT):
+            is_ours, instance_info = self.is_claude_mpm_instance(self.DEFAULT_PORT)
+            if not is_ours:
+                return self.DEFAULT_PORT
+            else:
+                self.logger.info(
+                    f"Default port {self.DEFAULT_PORT} is already used by claude-mpm instance"
+                )
+
+        # Try other ports in range
+        for port in self.PORT_RANGE:
+            if port == self.DEFAULT_PORT:
+                continue  # Already tried
+
+            if self.is_port_available(port):
+                is_ours, instance_info = self.is_claude_mpm_instance(port)
+                if not is_ours:
+                    self.logger.info(f"Selected available port: {port}")
+                    return port
+
+        self.logger.error(
+            f"No available ports in range {self.PORT_RANGE.start}-{self.PORT_RANGE.stop-1}"
+        )
+        return None
+
+    def register_instance(self, port: int, pid: int, host: str = "localhost") -> str:
+        """Register a new SocketIO server instance."""
+        instances = self.load_instances()
+
+        instance_id = f"socketio-{port}-{int(time.time())}"
+        instance_info = {
+            "port": port,
+            "pid": pid,
+            "host": host,
+            "start_time": time.time(),
+            "project_root": str(self.project_root),
+        }
+
+        instances[instance_id] = instance_info
+        self.save_instances(instances)
+
+        self.logger.info(
+            f"Registered SocketIO instance {instance_id} on port {port} (PID: {pid})"
+        )
+        return instance_id
+
+    def remove_instance(self, instance_id: str) -> bool:
+        """Remove a SocketIO server instance registration."""
+        instances = self.load_instances()
+
+        if instance_id in instances:
+            instance_info = instances.pop(instance_id)
+            self.save_instances(instances)
+            self.logger.info(
+                f"Removed SocketIO instance {instance_id} (port: {instance_info.get('port')})"
+            )
+            return True
+
+        return False
+
+    def load_instances(self) -> Dict:
+        """Load registered instances from file."""
+        try:
+            if self.instances_file.exists():
+                with open(self.instances_file, "r") as f:
+                    return json.load(f)
+        except Exception as e:
+            self.logger.warning(f"Failed to load instances file: {e}")
+
+        return {}
+
+    def save_instances(self, instances: Dict) -> None:
+        """Save registered instances to file."""
+        try:
+            with open(self.instances_file, "w") as f:
+                json.dump(instances, f, indent=2)
+        except Exception as e:
+            self.logger.error(f"Failed to save instances file: {e}")
+
+    def cleanup_dead_instances(self) -> int:
+        """Clean up instances for processes that are no longer running."""
+        instances = self.load_instances()
+        dead_instances = []
+
+        for instance_id, instance_info in instances.items():
+            pid = instance_info.get("pid")
+            if pid and not self.is_process_running(pid):
+                dead_instances.append(instance_id)
+
+        for instance_id in dead_instances:
+            self.remove_instance(instance_id)
+
+        if dead_instances:
+            self.logger.info(f"Cleaned up {len(dead_instances)} dead instances")
+
+        return len(dead_instances)
+
+    def list_active_instances(self) -> List[Dict]:
+        """List all active SocketIO instances."""
+        instances = self.load_instances()
+        active_instances = []
+
+        for instance_id, instance_info in instances.items():
+            pid = instance_info.get("pid")
+            if pid and self.is_process_running(pid):
+                instance_info["instance_id"] = instance_id
+                instance_info["running"] = True
+                active_instances.append(instance_info)
+
+        return active_instances
+
+    def get_instance_by_port(self, port: int) -> Optional[Dict]:
+        """Get instance information for a specific port."""
+        instances = self.load_instances()
+
+        for instance_id, instance_info in instances.items():
+            if instance_info.get("port") == port:
+                pid = instance_info.get("pid")
+                if pid and self.is_process_running(pid):
+                    instance_info["instance_id"] = instance_id
+                    instance_info["running"] = True
+                    return instance_info
+
+        return None

claude_mpm/services/project/__init__.py

@@ -16,6 +16,6 @@ from .analyzer import ProjectAnalyzer
 from .registry import ProjectRegistry
 
 __all__ = [
-    'ProjectAnalyzer',
-    'ProjectRegistry',
-]
+    "ProjectAnalyzer",
+    "ProjectRegistry",
+]