claude-mpm 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

claude_mpm/services/hook_service.py

@@ -1,388 +0,0 @@
-"""Centralized hook service for claude-mpm."""
-
-import asyncio
-import json
-import logging
-import os
-import sys
-import time
-import traceback
-from collections import defaultdict
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Type, Union
-
-from flask import Flask, jsonify, request
-from flask_cors import CORS
-
-# Add parent directory to path for imports
-sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-from claude_mpm.hooks.base_hook import (
-    BaseHook, HookContext, HookResult, HookType,
-    SubmitHook, PreDelegationHook, PostDelegationHook, TicketExtractionHook
-)
-from claude_mpm.core.logger import get_logger
-
-logger = get_logger(__name__)
-
-
-class HookRegistry:
-    """Registry for managing hooks."""
-    
-    def __init__(self):
-        """Initialize empty hook registry."""
-        self._hooks: Dict[HookType, List[BaseHook]] = defaultdict(list)
-        self._hook_instances: Dict[str, BaseHook] = {}
-        self._lock = asyncio.Lock()
-        
-    def register(self, hook: BaseHook, hook_type: Optional[HookType] = None) -> bool:
-        """Register a hook instance.
-        
-        Args:
-            hook: Hook instance to register
-            hook_type: Optional hook type override
-            
-        Returns:
-            True if registered successfully
-        """
-        try:
-            # Determine hook type
-            if hook_type is None:
-                if isinstance(hook, SubmitHook):
-                    hook_type = HookType.SUBMIT
-                elif isinstance(hook, PreDelegationHook):
-                    hook_type = HookType.PRE_DELEGATION
-                elif isinstance(hook, PostDelegationHook):
-                    hook_type = HookType.POST_DELEGATION
-                elif isinstance(hook, TicketExtractionHook):
-                    hook_type = HookType.TICKET_EXTRACTION
-                else:
-                    hook_type = HookType.CUSTOM
-                    
-            # Check for duplicate names
-            if hook.name in self._hook_instances:
-                logger.warning(f"Hook '{hook.name}' already registered, replacing")
-                self.unregister(hook.name)
-                
-            # Register hook
-            self._hooks[hook_type].append(hook)
-            self._hook_instances[hook.name] = hook
-            
-            # Sort by priority
-            self._hooks[hook_type].sort()
-            
-            logger.info(f"Registered hook '{hook.name}' for type {hook_type.value}")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Failed to register hook '{hook.name}': {e}")
-            return False
-            
-    def unregister(self, hook_name: str) -> bool:
-        """Unregister a hook by name.
-        
-        Args:
-            hook_name: Name of hook to unregister
-            
-        Returns:
-            True if unregistered successfully
-        """
-        try:
-            if hook_name not in self._hook_instances:
-                logger.warning(f"Hook '{hook_name}' not found")
-                return False
-                
-            hook = self._hook_instances[hook_name]
-            
-            # Remove from type list
-            for hook_list in self._hooks.values():
-                if hook in hook_list:
-                    hook_list.remove(hook)
-                    
-            # Remove from instances
-            del self._hook_instances[hook_name]
-            
-            logger.info(f"Unregistered hook '{hook_name}'")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Failed to unregister hook '{hook_name}': {e}")
-            return False
-            
-    def get_hooks(self, hook_type: HookType) -> List[BaseHook]:
-        """Get all hooks for a given type.
-        
-        Args:
-            hook_type: Type of hooks to retrieve
-            
-        Returns:
-            List of hooks sorted by priority
-        """
-        return [h for h in self._hooks[hook_type] if h.enabled]
-        
-    def get_hook(self, hook_name: str) -> Optional[BaseHook]:
-        """Get a specific hook by name.
-        
-        Args:
-            hook_name: Name of hook to retrieve
-            
-        Returns:
-            Hook instance or None if not found
-        """
-        return self._hook_instances.get(hook_name)
-        
-    def list_hooks(self) -> Dict[str, List[Dict[str, Any]]]:
-        """List all registered hooks.
-        
-        Returns:
-            Dictionary mapping hook types to hook info
-        """
-        result = {}
-        for hook_type, hooks in self._hooks.items():
-            result[hook_type.value] = [
-                {
-                    'name': h.name,
-                    'priority': h.priority,
-                    'enabled': h.enabled,
-                    'class': h.__class__.__name__
-                }
-                for h in hooks
-            ]
-        return result
-
-
-class HookService:
-    """Centralized service for managing and executing hooks."""
-    
-    def __init__(self, port: int = 5001):
-        """Initialize hook service.
-        
-        Args:
-            port: Port to run service on
-        """
-        self.port = port
-        self.registry = HookRegistry()
-        self.app = Flask(__name__)
-        CORS(self.app)
-        self._setup_routes()
-        self._load_builtin_hooks()
-        
-    def _setup_routes(self):
-        """Setup Flask routes for hook service."""
-        
-        @self.app.route('/health', methods=['GET'])
-        def health():
-            """Health check endpoint."""
-            return jsonify({
-                'status': 'healthy',
-                'timestamp': datetime.now().isoformat(),
-                'hooks_count': sum(len(h) for h in self.registry._hooks.values())
-            })
-            
-        @self.app.route('/hooks/list', methods=['GET'])
-        def list_hooks():
-            """List all registered hooks."""
-            return jsonify({
-                'status': 'success',
-                'hooks': self.registry.list_hooks()
-            })
-            
-        @self.app.route('/hooks/execute', methods=['POST'])
-        def execute_hook():
-            """Execute a specific hook or all hooks of a type."""
-            try:
-                data = request.json
-                hook_type = HookType(data.get('hook_type'))
-                context_data = data.get('context', {})
-                metadata = data.get('metadata', {})
-                specific_hook = data.get('hook_name')
-                
-                # Create context
-                context = HookContext(
-                    hook_type=hook_type,
-                    data=context_data,
-                    metadata=metadata,
-                    timestamp=datetime.now()
-                )
-                
-                # Execute hooks
-                if specific_hook:
-                    hook = self.registry.get_hook(specific_hook)
-                    if not hook:
-                        return jsonify({
-                            'status': 'error',
-                            'error': f"Hook '{specific_hook}' not found"
-                        }), 404
-                    results = [self._execute_single_hook(hook, context)]
-                else:
-                    results = self._execute_hooks(hook_type, context)
-                    
-                return jsonify({
-                    'status': 'success',
-                    'results': results
-                })
-                
-            except Exception as e:
-                logger.error(f"Hook execution error: {e}")
-                return jsonify({
-                    'status': 'error',
-                    'error': str(e)
-                }), 500
-                
-        @self.app.route('/hooks/register', methods=['POST'])
-        def register_hook():
-            """Register a new hook (for dynamic registration)."""
-            try:
-                data = request.json
-                # This would need to dynamically create hook instances
-                # For now, return not implemented
-                return jsonify({
-                    'status': 'error',
-                    'error': 'Dynamic registration not yet implemented'
-                }), 501
-                
-            except Exception as e:
-                logger.error(f"Hook registration error: {e}")
-                return jsonify({
-                    'status': 'error',
-                    'error': str(e)
-                }), 500
-                
-    def _load_builtin_hooks(self):
-        """Load built-in hooks from hooks directory."""
-        import importlib.util
-        import inspect
-        
-        hooks_dir = Path(__file__).parent.parent / 'hooks' / 'builtin'
-        if hooks_dir.exists():
-            for hook_file in hooks_dir.glob('*.py'):
-                if hook_file.name.startswith('_'):
-                    continue
-                try:
-                    # Load the module
-                    module_name = hook_file.stem
-                    spec = importlib.util.spec_from_file_location(module_name, hook_file)
-                    module = importlib.util.module_from_spec(spec)
-                    spec.loader.exec_module(module)
-                    
-                    # Find and instantiate hook classes
-                    for name, obj in inspect.getmembers(module):
-                        if (inspect.isclass(obj) and 
-                            issubclass(obj, BaseHook) and 
-                            obj is not BaseHook and
-                            not name.startswith('_')):
-                            # Instantiate and register the hook
-                            hook_instance = obj()
-                            self.registry.register(hook_instance)
-                            logger.info(f"Loaded hook '{hook_instance.name}' from {hook_file}")
-                            
-                except Exception as e:
-                    logger.error(f"Failed to load hook from {hook_file}: {e}")
-                    
-    def _execute_single_hook(self, hook: BaseHook, context: HookContext) -> Dict[str, Any]:
-        """Execute a single hook.
-        
-        Args:
-            hook: Hook to execute
-            context: Context for execution
-            
-        Returns:
-            Execution result dictionary
-        """
-        start_time = time.time()
-        try:
-            # Validate hook
-            if not hook.validate(context):
-                return {
-                    'hook_name': hook.name,
-                    'success': False,
-                    'error': 'Validation failed',
-                    'execution_time_ms': 0
-                }
-                
-            # Execute hook
-            if hasattr(hook, '_async') and hook._async:
-                # Run async hook
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
-                result = loop.run_until_complete(hook.async_execute(context))
-                loop.close()
-            else:
-                result = hook.execute(context)
-                
-            # Add execution time
-            execution_time = (time.time() - start_time) * 1000
-            result.execution_time_ms = execution_time
-            
-            return {
-                'hook_name': hook.name,
-                'success': result.success,
-                'data': result.data,
-                'error': result.error,
-                'modified': result.modified,
-                'metadata': result.metadata,
-                'execution_time_ms': execution_time
-            }
-            
-        except Exception as e:
-            logger.error(f"Hook '{hook.name}' execution failed: {e}")
-            return {
-                'hook_name': hook.name,
-                'success': False,
-                'error': str(e),
-                'traceback': traceback.format_exc(),
-                'execution_time_ms': (time.time() - start_time) * 1000
-            }
-            
-    def _execute_hooks(self, hook_type: HookType, context: HookContext) -> List[Dict[str, Any]]:
-        """Execute all hooks of a given type.
-        
-        Args:
-            hook_type: Type of hooks to execute
-            context: Context for execution
-            
-        Returns:
-            List of execution results
-        """
-        hooks = self.registry.get_hooks(hook_type)
-        results = []
-        
-        for hook in hooks:
-            result = self._execute_single_hook(hook, context)
-            results.append(result)
-            
-            # If hook modified data, update context for next hook
-            if result.get('modified') and result.get('data'):
-                context.data.update(result['data'])
-                
-        return results
-        
-    def run(self):
-        """Run the hook service."""
-        logger.info(f"Starting hook service on port {self.port}")
-        self.app.run(host='0.0.0.0', port=self.port, debug=False)
-
-
-def main():
-    """Main entry point for hook service."""
-    import argparse
-    
-    parser = argparse.ArgumentParser(description='Claude MPM Hook Service')
-    parser.add_argument('--port', type=int, default=5001, help='Port to run service on')
-    parser.add_argument('--log-level', default='INFO', help='Logging level')
-    args = parser.parse_args()
-    
-    # Configure logging
-    logging.basicConfig(
-        level=getattr(logging, args.log_level.upper()),
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-    )
-    
-    # Create and run service
-    service = HookService(port=args.port)
-    service.run()
-
-
-if __name__ == '__main__':
-    main()

claude_mpm/services/hook_service_manager.py

@@ -1,223 +0,0 @@
-"""Hook service lifecycle manager for claude-mpm."""
-
-import os
-import sys
-import time
-import socket
-import signal
-import atexit
-import subprocess
-from pathlib import Path
-from typing import Optional, Tuple
-import json
-import psutil
-import logging
-
-try:
-    from ..core.logger import get_logger
-    from ..config.hook_config import HookConfig
-except ImportError:
-    from core.logger import get_logger
-    from config.hook_config import HookConfig
-
-
-class HookServiceManager:
-    """Manages the hook service lifecycle."""
-    
-    def __init__(self, port: Optional[int] = None, log_dir: Optional[Path] = None):
-        """Initialize hook service manager.
-        
-        Args:
-            port: Specific port to use (if None, will find available port)
-            log_dir: Directory for hook service logs
-        """
-        self.logger = get_logger("hook_service_manager")
-        self.config = HookConfig()
-        self.port = port or self._find_available_port()
-        self.log_dir = log_dir or self.config.HOOK_SERVICE_LOG_DIR
-        self.log_dir.mkdir(parents=True, exist_ok=True)
-        
-        # Process management
-        self.pid_dir = self.config.HOOK_SERVICE_PID_DIR
-        self.pid_dir.mkdir(parents=True, exist_ok=True)
-        self.pid_file = self.pid_dir / f"hook_service_{self.port}.pid"
-        self.process = None
-        self._service_started = False
-        
-        # Register cleanup
-        atexit.register(self.stop_service)
-        signal.signal(signal.SIGTERM, lambda sig, frame: self.stop_service())
-        signal.signal(signal.SIGINT, lambda sig, frame: self.stop_service())
-    
-    def _find_available_port(self) -> int:
-        """Find an available port in the configured range."""
-        start = self.config.PORT_RANGE_START
-        end = self.config.PORT_RANGE_END
-        for port in range(start, end):
-            if self._is_port_available(port):
-                return port
-        raise RuntimeError(f"No available ports found in range {start}-{end}")
-    
-    def _is_port_available(self, port: int) -> bool:
-        """Check if a port is available."""
-        try:
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                s.bind(('localhost', port))
-                return True
-        except OSError:
-            return False
-    
-    def _check_existing_service(self) -> bool:
-        """Check if hook service is already running on the port."""
-        if self.pid_file.exists():
-            try:
-                pid = int(self.pid_file.read_text().strip())
-                # Check if process exists and is our hook service
-                if psutil.pid_exists(pid):
-                    process = psutil.Process(pid)
-                    if 'python' in process.name().lower() and 'hook_service.py' in ' '.join(process.cmdline()):
-                        # Test if service is responsive
-                        if self._test_service_health():
-                            self.logger.info(f"Found existing hook service on port {self.port} (PID: {pid})")
-                            return True
-                        else:
-                            self.logger.warning(f"Existing hook service on port {self.port} is not responding")
-                            self._cleanup_stale_pidfile()
-            except (ValueError, psutil.NoSuchProcess, psutil.AccessDenied) as e:
-                self.logger.debug(f"Error checking existing service: {e}")
-                self._cleanup_stale_pidfile()
-        
-        return False
-    
-    def _cleanup_stale_pidfile(self):
-        """Remove stale PID file."""
-        if self.pid_file.exists():
-            self.pid_file.unlink()
-    
-    def _test_service_health(self) -> bool:
-        """Test if the hook service is healthy."""
-        import requests
-        try:
-            url = self.config.get_hook_service_url(self.port) + self.config.HEALTH_ENDPOINT
-            response = requests.get(url, timeout=self.config.HEALTH_CHECK_TIMEOUT)
-            return response.status_code == 200
-        except:
-            return False
-    
-    def start_service(self, force: bool = False) -> bool:
-        """Start the hook service if not already running.
-        
-        Args:
-            force: Force restart even if service is already running
-            
-        Returns:
-            True if service was started or already running, False on error
-        """
-        # Check if already running
-        if not force and self._check_existing_service():
-            self._service_started = True
-            return True
-        
-        # Stop any existing service if forcing
-        if force:
-            self.stop_service()
-        
-        # Start new service
-        try:
-            # Find hook service script
-            hook_service_path = self._find_hook_service_script()
-            if not hook_service_path:
-                self.logger.warning("Hook service script not found")
-                return False
-            
-            # Prepare log files
-            stdout_log = self.log_dir / f"hook_service_{self.port}.log"
-            stderr_log = self.log_dir / f"hook_service_{self.port}.error.log"
-            
-            # Start subprocess
-            cmd = [
-                sys.executable,
-                str(hook_service_path),
-                "--port", str(self.port),
-                "--log-level", "INFO"
-            ]
-            
-            self.logger.info(f"Starting hook service on port {self.port}")
-            
-            with open(stdout_log, 'a') as stdout_file, open(stderr_log, 'a') as stderr_file:
-                self.process = subprocess.Popen(
-                    cmd,
-                    stdout=stdout_file,
-                    stderr=stderr_file,
-                    start_new_session=True  # Detach from parent process group
-                )
-            
-            # Wait for service to start
-            start_wait = int(self.config.SERVICE_START_TIMEOUT * 10)  # Convert to tenths of seconds
-            for _ in range(start_wait):
-                if self._test_service_health():
-                    # Save PID
-                    self.pid_file.write_text(str(self.process.pid))
-                    self._service_started = True
-                    self.logger.info(f"Hook service started successfully on port {self.port} (PID: {self.process.pid})")
-                    return True
-                time.sleep(0.1)
-            
-            # Service didn't start properly
-            self.logger.error("Hook service failed to start within timeout")
-            self.stop_service()
-            return False
-            
-        except Exception as e:
-            self.logger.error(f"Failed to start hook service: {e}")
-            return False
-    
-    def _find_hook_service_script(self) -> Optional[Path]:
-        """Find the hook service script."""
-        # Try different locations
-        possible_paths = [
-            # Relative to this file (same directory)
-            Path(__file__).parent / "hook_service.py",
-            # In src/services directory
-            Path(__file__).parent.parent / "services" / "hook_service.py",
-            # In project root
-            Path(__file__).parent.parent.parent / "hook_service.py",
-        ]
-        
-        for path in possible_paths:
-            if path.exists():
-                return path
-        
-        return None
-    
-    def stop_service(self):
-        """Stop the hook service if running."""
-        if self.process and self.process.poll() is None:
-            self.logger.info(f"Stopping hook service on port {self.port}")
-            try:
-                self.process.terminate()
-                self.process.wait(timeout=5)
-            except subprocess.TimeoutExpired:
-                self.process.kill()
-                self.process.wait()
-            finally:
-                self.process = None
-        
-        # Clean up PID file
-        if self.pid_file.exists():
-            self.pid_file.unlink()
-        
-        self._service_started = False
-    
-    def get_service_info(self) -> dict:
-        """Get information about the running service."""
-        return {
-            "running": self._service_started and self._test_service_health(),
-            "port": self.port,
-            "pid": self.process.pid if self.process else None,
-            "url": self.config.get_hook_service_url(self.port)
-        }
-    
-    def is_available(self) -> bool:
-        """Check if hook service is available and healthy."""
-        return self._service_started and self._test_service_health()

claude_mpm/services/json_rpc_hook_manager.py

@@ -1,92 +0,0 @@
-"""JSON-RPC based hook manager that replaces the HTTP service."""
-
-from pathlib import Path
-from typing import Optional, Dict, Any
-
-from ..hooks.json_rpc_hook_client import JSONRPCHookClient
-from ..core.logger import get_logger
-
-
-class JSONRPCHookManager:
-    """Manager for JSON-RPC based hooks (no HTTP server required)."""
-    
-    def __init__(self, log_dir: Optional[Path] = None):
-        """Initialize JSON-RPC hook manager.
-        
-        Args:
-            log_dir: Log directory (unused but kept for compatibility)
-        """
-        self.logger = get_logger(self.__class__.__name__)
-        self.log_dir = log_dir
-        self.client = None
-        self._available = False
-        
-    def start_service(self) -> bool:
-        """Initialize the JSON-RPC hook client.
-        
-        Returns:
-            True if initialization successful
-        """
-        try:
-            self.client = JSONRPCHookClient()
-            health = self.client.health_check()
-            
-            if health['status'] == 'healthy':
-                self._available = True
-                self.logger.info(f"JSON-RPC hook client initialized with {health['hook_count']} hooks")
-                return True
-            else:
-                self.logger.warning(f"JSON-RPC hook client unhealthy: {health.get('error', 'Unknown error')}")
-                return False
-                
-        except Exception as e:
-            self.logger.error(f"Failed to initialize JSON-RPC hook client: {e}")
-            return False
-            
-    def stop_service(self):
-        """Stop the hook service (no-op for JSON-RPC)."""
-        self._available = False
-        self.client = None
-        self.logger.info("JSON-RPC hook client stopped")
-        
-    def is_available(self) -> bool:
-        """Check if hook service is available.
-        
-        Returns:
-            True if available
-        """
-        return self._available and self.client is not None
-        
-    def get_service_info(self) -> Dict[str, Any]:
-        """Get service information.
-        
-        Returns:
-            Service info dictionary
-        """
-        if not self.is_available():
-            return {
-                'running': False,
-                'type': 'json-rpc'
-            }
-            
-        health = self.client.health_check()
-        return {
-            'running': True,
-            'type': 'json-rpc',
-            'hook_count': health.get('hook_count', 0),
-            'discovered_hooks': health.get('discovered_hooks', [])
-        }
-        
-    def get_client(self) -> Optional[JSONRPCHookClient]:
-        """Get the hook client instance.
-        
-        Returns:
-            Hook client if available, None otherwise
-        """
-        return self.client if self.is_available() else None
-        
-    # Compatibility properties for HTTP service
-    @property
-    def port(self) -> Optional[int]:
-        """Compatibility property - always returns None for JSON-RPC."""
-        return None