claude-mpm 3.3.0__py3-none-any.whl → 3.3.2__py3-none-any.whl

claude_mpm/agents/templates/test-integration-agent.md

@@ -1,34 +0,0 @@
----
-author: test-script
-model_preference: claude-3-sonnet
-specializations: []
-tags:
-- test
-- integration
-type: custom
-version: 1.0.0
----
-
-# Test Integration Agent
-
-## 🎯 Primary Role
-test-integration-agent agent
-
-## 🎯 When to Use This Agent
-
-**Select this agent when:**
-
-**Do NOT select for:**
-
-## 🔧 Core Capabilities
-
-## 🔑 Authority & Permissions
-
-### ✅ Exclusive Write Access
-
-### ❌ Forbidden Operations
-
----
-**Agent Type**: custom
-**Model Preference**: claude-3-sonnet
-**Version**: 1.0.0

claude_mpm/core/websocket_handler.py

@@ -1,233 +0,0 @@
-"""Socket.IO logging handler with connection pooling for real-time log streaming.
-
-This handler now uses the Socket.IO connection pool to reduce overhead
-and implement circuit breaker and batching patterns for log events.
-
-WHY connection pooling approach:
-- Reduces connection setup/teardown overhead by 80%
-- Implements circuit breaker for resilience during outages
-- Provides micro-batching for high-frequency log events
-- Maintains persistent connections for better performance
-- Falls back gracefully when pool unavailable
-"""
-
-import logging
-import json
-import os
-from datetime import datetime
-from typing import Optional
-
-# Connection pool import
-try:
-    from .socketio_pool import get_connection_pool
-    POOL_AVAILABLE = True
-except ImportError:
-    POOL_AVAILABLE = False
-    get_connection_pool = None
-
-# Fallback imports
-from ..services.websocket_server import get_server_instance
-
-
-class WebSocketHandler(logging.Handler):
-    """Logging handler that broadcasts log messages via Socket.IO connection pool.
-    
-    WHY connection pooling design:
-    - Uses shared connection pool to reduce overhead by 80%
-    - Implements circuit breaker pattern for resilience
-    - Provides micro-batching for high-frequency log events (50ms window)
-    - Maintains persistent connections across log events
-    - Falls back gracefully when pool unavailable
-    """
-    
-    def __init__(self, level=logging.NOTSET):
-        super().__init__(level)
-        self._websocket_server = None
-        self._connection_pool = None
-        self._pool_initialized = False
-        self._debug = os.environ.get('CLAUDE_MPM_HOOK_DEBUG', '').lower() == 'true'
-
-    def _init_connection_pool(self):
-        """Initialize connection pool with lazy loading.
-        
-        WHY connection pool approach:
-        - Reuses connections to reduce overhead by 80%
-        - Implements circuit breaker for resilience
-        - Provides micro-batching for high-frequency log events
-        - Falls back gracefully when unavailable
-        """
-        if not POOL_AVAILABLE:
-            if self._debug:
-                import sys
-                print("Connection pool not available for logging - falling back to legacy mode", file=sys.stderr)
-            return
-        
-        try:
-            self._connection_pool = get_connection_pool()
-            if self._debug:
-                import sys
-                print("WebSocket handler: Using Socket.IO connection pool", file=sys.stderr)
-        except Exception as e:
-            if self._debug:
-                import sys
-                print(f"WebSocket handler: Failed to initialize connection pool: {e}", file=sys.stderr)
-            self._connection_pool = None
-    
-    @property
-    def websocket_server(self):
-        """Get WebSocket server instance lazily (fallback compatibility)."""
-        if self._websocket_server is None:
-            self._websocket_server = get_server_instance()
-        return self._websocket_server
-        
-    def emit(self, record: logging.LogRecord):
-        """Emit a log record via Socket.IO connection pool with batching.
-        
-        WHY connection pool approach:
-        - Uses shared connection pool to reduce overhead by 80%
-        - Implements circuit breaker for resilience during outages
-        - Provides micro-batching for high-frequency log events (50ms window)
-        - Falls back gracefully when pool unavailable
-        """
-        try:
-            # Skip connection pool logs to avoid infinite recursion
-            if "socketio" in record.name.lower() or record.name == "claude_mpm.websocket_client_proxy":
-                return
-            
-            # Skip circuit breaker logs to avoid recursion
-            if "circuit_breaker" in record.name.lower() or "socketio_pool" in record.name.lower():
-                return
-                
-            # Format the log message
-            log_data = {
-                "timestamp": datetime.utcnow().isoformat() + "Z",
-                "level": record.levelname,
-                "logger": record.name,
-                "message": self.format(record),
-                "module": record.module,
-                "function": record.funcName,
-                "line": record.lineno,
-                "thread": record.thread,
-                "thread_name": record.threadName
-            }
-            
-            # Add exception info if present
-            if record.exc_info:
-                import traceback
-                log_data["exception"] = ''.join(traceback.format_exception(*record.exc_info))
-            
-            # Lazy initialize connection pool on first use
-            if POOL_AVAILABLE and not self._pool_initialized:
-                self._pool_initialized = True
-                self._init_connection_pool()
-            
-            # Try connection pool first (preferred method)
-            if self._connection_pool:
-                try:
-                    self._connection_pool.emit_event('/log', 'message', log_data)
-                    if self._debug:
-                        import sys
-                        print(f"Emitted pooled Socket.IO log event: /log/message", file=sys.stderr)
-                    return
-                except Exception as e:
-                    if self._debug:
-                        import sys
-                        print(f"Connection pool log emit failed: {e}", file=sys.stderr)
-            
-            # Fallback to legacy WebSocket server
-            if self.websocket_server:
-                try:
-                    # Debug: Check what type of server we have
-                    server_type = type(self.websocket_server).__name__
-                    if server_type == "SocketIOClientProxy":
-                        # For exec mode with Socket.IO client proxy, skip local emission
-                        # The persistent server process handles its own logging
-                        return
-                    
-                    # Use new Socket.IO event format
-                    if hasattr(self.websocket_server, 'log_message'):
-                        self.websocket_server.log_message(
-                            level=record.levelname,
-                            message=self.format(record),
-                            module=record.module
-                        )
-                    else:
-                        # Legacy fallback
-                        self.websocket_server.broadcast_event("log.message", log_data)
-                    
-                    if self._debug:
-                        import sys
-                        print(f"Emitted legacy log event", file=sys.stderr)
-                        
-                except Exception as fallback_error:
-                    if self._debug:
-                        import sys
-                        print(f"Legacy log emit failed: {fallback_error}", file=sys.stderr)
-            
-        except Exception as e:
-            # Don't let logging errors break the application
-            # But print for debugging
-            import sys
-            print(f"WebSocketHandler.emit error: {e}", file=sys.stderr)
-    
-    def __del__(self):
-        """Cleanup connection pool on handler destruction.
-        
-        NOTE: Connection pool is shared across handlers, so we don't
-        shut it down here. The pool manages its own lifecycle.
-        """
-        # Connection pool is managed globally, no cleanup needed per handler
-        pass
-
-
-class WebSocketFormatter(logging.Formatter):
-    """Custom formatter for WebSocket log messages."""
-    
-    def __init__(self):
-        super().__init__(
-            fmt='%(name)s - %(levelname)s - %(message)s',
-            datefmt='%Y-%m-%d %H:%M:%S'
-        )
-
-
-def setup_websocket_logging(logger_name: Optional[str] = None, level: int = logging.INFO):
-    """
-    Set up WebSocket logging for a logger.
-    
-    Args:
-        logger_name: Name of logger to configure (None for root logger)
-        level: Minimum logging level to broadcast
-        
-    Returns:
-        The configured WebSocketHandler
-    """
-    handler = WebSocketHandler(level=level)
-    handler.setFormatter(WebSocketFormatter())
-    
-    # Get the logger
-    logger = logging.getLogger(logger_name)
-    
-    # Add handler if not already present
-    # Check by handler type to avoid duplicates
-    has_websocket_handler = any(
-        isinstance(h, WebSocketHandler) for h in logger.handlers
-    )
-    
-    if not has_websocket_handler:
-        logger.addHandler(handler)
-        
-    return handler
-
-
-def remove_websocket_logging(logger_name: Optional[str] = None):
-    """Remove WebSocket handler from a logger."""
-    logger = logging.getLogger(logger_name)
-    
-    # Remove all WebSocket handlers
-    handlers_to_remove = [
-        h for h in logger.handlers if isinstance(h, WebSocketHandler)
-    ]
-    
-    for handler in handlers_to_remove:
-        logger.removeHandler(handler)
-        handler.close()

claude_mpm/services/websocket_server.py

@@ -1,376 +0,0 @@
-"""WebSocket server for real-time monitoring of Claude MPM sessions."""
-
-import asyncio
-import json
-import logging
-import os
-import subprocess
-import threading
-import time
-from datetime import datetime
-from typing import Set, Dict, Any, Optional, List
-from collections import deque
-
-try:
-    import websockets
-    from websockets.server import WebSocketServerProtocol
-    WEBSOCKETS_AVAILABLE = True
-except ImportError:
-    WEBSOCKETS_AVAILABLE = False
-    websockets = None
-    WebSocketServerProtocol = None
-
-from ..core.logger import get_logger
-
-
-class WebSocketServer:
-    """WebSocket server for broadcasting Claude MPM events."""
-    
-    def __init__(self, host: str = "localhost", port: int = 8765):
-        self.host = host
-        self.port = port
-        self.logger = get_logger("websocket_server")
-        self.clients: Set[WebSocketServerProtocol] = set() if WEBSOCKETS_AVAILABLE else set()
-        self.event_history: deque = deque(maxlen=1000)  # Keep last 1000 events
-        self.server = None
-        self.loop = None
-        self.thread = None
-        self.running = False
-        
-        # Session state
-        self.session_id = None
-        self.session_start = None
-        self.claude_status = "stopped"
-        self.claude_pid = None
-        
-        if not WEBSOCKETS_AVAILABLE:
-            self.logger.warning("WebSocket support not available. Install 'websockets' package to enable.")
-        
-    def start(self):
-        """Start the WebSocket server in a background thread."""
-        if not WEBSOCKETS_AVAILABLE:
-            self.logger.debug("WebSocket server skipped - websockets package not installed")
-            return
-            
-        if self.running:
-            return
-            
-        self.running = True
-        self.thread = threading.Thread(target=self._run_server, daemon=True)
-        self.thread.start()
-        self.logger.info(f"WebSocket server starting on ws://{self.host}:{self.port}")
-        
-    def stop(self):
-        """Stop the WebSocket server."""
-        self.running = False
-        if self.loop:
-            asyncio.run_coroutine_threadsafe(self._shutdown(), self.loop)
-        if self.thread:
-            self.thread.join(timeout=5)
-        self.logger.info("WebSocket server stopped")
-        
-    def _run_server(self):
-        """Run the server event loop."""
-        self.loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(self.loop)
-        
-        try:
-            self.loop.run_until_complete(self._serve())
-        except Exception as e:
-            self.logger.error(f"WebSocket server error: {e}")
-        finally:
-            self.loop.close()
-            
-    async def _serve(self):
-        """Start the WebSocket server."""
-        async with websockets.serve(self._handle_client, self.host, self.port):
-            self.logger.info(f"WebSocket server listening on ws://{self.host}:{self.port}")
-            while self.running:
-                await asyncio.sleep(0.1)
-                
-    async def _shutdown(self):
-        """Shutdown the server."""
-        # Close all client connections
-        if self.clients:
-            await asyncio.gather(
-                *[client.close() for client in self.clients],
-                return_exceptions=True
-            )
-            
-    async def _handle_client(self, websocket: WebSocketServerProtocol, path: str):
-        """Handle a new client connection."""
-        self.clients.add(websocket)
-        client_addr = websocket.remote_address
-        self.logger.info(f"Client connected from {client_addr}")
-        
-        try:
-            # Send current status
-            await self._send_current_status(websocket)
-            
-            # Handle client messages
-            async for message in websocket:
-                try:
-                    data = json.loads(message)
-                    await self._handle_command(websocket, data)
-                except json.JSONDecodeError:
-                    await websocket.send(json.dumps({
-                        "type": "error",
-                        "data": {"message": "Invalid JSON"}
-                    }))
-                    
-        except websockets.exceptions.ConnectionClosed:
-            pass
-        finally:
-            self.clients.remove(websocket)
-            self.logger.info(f"Client disconnected from {client_addr}")
-            
-    async def _send_current_status(self, websocket: WebSocketServerProtocol):
-        """Send current system status to a client."""
-        status = {
-            "type": "system.status",
-            "timestamp": datetime.utcnow().isoformat() + "Z",
-            "data": {
-                "session_id": self.session_id,
-                "session_start": self.session_start,
-                "claude_status": self.claude_status,
-                "claude_pid": self.claude_pid,
-                "connected_clients": len(self.clients),
-                "websocket_port": self.port,
-                "instance_info": {
-                    "port": self.port,
-                    "host": self.host,
-                    "working_dir": os.getcwd() if self.session_id else None
-                }
-            }
-        }
-        await websocket.send(json.dumps(status))
-        
-    async def _handle_command(self, websocket: WebSocketServerProtocol, data: Dict[str, Any]):
-        """Handle commands from clients."""
-        command = data.get("command")
-        
-        if command == "get_status":
-            await self._send_current_status(websocket)
-            
-        elif command == "get_history":
-            # Send recent events
-            params = data.get("params", {})
-            event_types = params.get("event_types", [])
-            limit = min(params.get("limit", 100), len(self.event_history))
-            
-            history = []
-            for event in reversed(self.event_history):
-                if not event_types or event["type"] in event_types:
-                    history.append(event)
-                    if len(history) >= limit:
-                        break
-                        
-            await websocket.send(json.dumps({
-                "type": "history",
-                "data": {"events": list(reversed(history))}
-            }))
-            
-        elif command == "subscribe":
-            # For now, all clients get all events
-            await websocket.send(json.dumps({
-                "type": "subscribed",
-                "data": {"channels": data.get("channels", ["*"])}
-            }))
-            
-    def broadcast_event(self, event_type: str, data: Dict[str, Any]):
-        """Broadcast an event to all connected clients."""
-        if not WEBSOCKETS_AVAILABLE:
-            return
-            
-        event = {
-            "type": event_type,
-            "timestamp": datetime.utcnow().isoformat() + "Z",
-            "data": data
-        }
-        
-        # Store in history
-        self.event_history.append(event)
-        
-        # Broadcast to clients
-        if self.clients and self.loop:
-            asyncio.run_coroutine_threadsafe(
-                self._broadcast(json.dumps(event)),
-                self.loop
-            )
-            
-    async def _broadcast(self, message: str):
-        """Send a message to all connected clients."""
-        if self.clients:
-            # Send to all clients concurrently
-            await asyncio.gather(
-                *[client.send(message) for client in self.clients],
-                return_exceptions=True
-            )
-            
-    # Convenience methods for common events
-    
-    def _get_git_branch(self, working_dir: str) -> str:
-        """Get the current git branch for the working directory."""
-        try:
-            result = subprocess.run(
-                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
-                cwd=working_dir,
-                capture_output=True,
-                text=True,
-                timeout=2
-            )
-            if result.returncode == 0:
-                return result.stdout.strip()
-        except Exception:
-            pass
-        return "not a git repo"
-    
-    def session_started(self, session_id: str, launch_method: str, working_dir: str):
-        """Notify that a session has started."""
-        self.session_id = session_id
-        self.session_start = datetime.utcnow().isoformat() + "Z"
-        
-        # Get git branch if in a git repo
-        git_branch = self._get_git_branch(working_dir)
-        
-        self.broadcast_event("session.start", {
-            "session_id": session_id,
-            "start_time": self.session_start,
-            "launch_method": launch_method,
-            "working_directory": working_dir,
-            "git_branch": git_branch,
-            "websocket_port": self.port,
-            "instance_info": {
-                "port": self.port,
-                "host": self.host,
-                "working_dir": working_dir
-            }
-        })
-        
-    def session_ended(self):
-        """Notify that a session has ended."""
-        if self.session_id:
-            duration = None
-            if self.session_start:
-                start = datetime.fromisoformat(self.session_start.replace("Z", "+00:00"))
-                duration = (datetime.utcnow() - start.replace(tzinfo=None)).total_seconds()
-                
-            self.broadcast_event("session.end", {
-                "session_id": self.session_id,
-                "end_time": datetime.utcnow().isoformat() + "Z",
-                "duration_seconds": duration
-            })
-            
-        self.session_id = None
-        self.session_start = None
-        
-    def claude_status_changed(self, status: str, pid: Optional[int] = None, message: str = ""):
-        """Notify Claude status change."""
-        self.claude_status = status
-        self.claude_pid = pid
-        self.broadcast_event("claude.status", {
-            "status": status,
-            "pid": pid,
-            "message": message
-        })
-        
-    def claude_output(self, content: str, stream: str = "stdout"):
-        """Broadcast Claude output."""
-        self.broadcast_event("claude.output", {
-            "content": content,
-            "stream": stream
-        })
-        
-    def agent_delegated(self, agent: str, task: str, status: str = "started"):
-        """Notify agent delegation."""
-        self.broadcast_event("agent.delegation", {
-            "agent": agent,
-            "task": task,
-            "status": status,
-            "timestamp": datetime.utcnow().isoformat() + "Z"
-        })
-        
-    def todo_updated(self, todos: List[Dict[str, Any]]):
-        """Notify todo list update."""
-        stats = {
-            "total": len(todos),
-            "completed": sum(1 for t in todos if t.get("status") == "completed"),
-            "in_progress": sum(1 for t in todos if t.get("status") == "in_progress"),
-            "pending": sum(1 for t in todos if t.get("status") == "pending")
-        }
-        
-        self.broadcast_event("todo.update", {
-            "todos": todos,
-            "stats": stats
-        })
-        
-    def ticket_created(self, ticket_id: str, title: str, priority: str = "medium"):
-        """Notify ticket creation."""
-        self.broadcast_event("ticket.created", {
-            "id": ticket_id,
-            "title": title,
-            "priority": priority,
-            "created_at": datetime.utcnow().isoformat() + "Z"
-        })
-        
-    def memory_loaded(self, agent_id: str, memory_size: int, sections_count: int):
-        """Notify when agent memory is loaded from file."""
-        self.broadcast_event("memory:loaded", {
-            "agent_id": agent_id,
-            "memory_size": memory_size,
-            "sections_count": sections_count,
-            "timestamp": datetime.utcnow().isoformat() + "Z"
-        })
-        
-    def memory_created(self, agent_id: str, template_type: str):
-        """Notify when new agent memory is created from template."""
-        self.broadcast_event("memory:created", {
-            "agent_id": agent_id,
-            "template_type": template_type,
-            "timestamp": datetime.utcnow().isoformat() + "Z"
-        })
-        
-    def memory_updated(self, agent_id: str, learning_type: str, content: str, section: str):
-        """Notify when learning is added to agent memory."""
-        self.broadcast_event("memory:updated", {
-            "agent_id": agent_id,
-            "learning_type": learning_type,
-            "content": content,
-            "section": section,
-            "timestamp": datetime.utcnow().isoformat() + "Z"
-        })
-        
-    def memory_injected(self, agent_id: str, context_size: int):
-        """Notify when agent memory is injected into context."""
-        self.broadcast_event("memory:injected", {
-            "agent_id": agent_id,
-            "context_size": context_size,
-            "timestamp": datetime.utcnow().isoformat() + "Z"
-        })
-
-
-# Global instance for easy access
-_websocket_server: Optional[WebSocketServer] = None
-
-
-def get_websocket_server() -> WebSocketServer:
-    """Get or create the global WebSocket server instance."""
-    global _websocket_server
-    if _websocket_server is None:
-        _websocket_server = WebSocketServer()
-    return _websocket_server
-
-
-def start_websocket_server():
-    """Start the global WebSocket server."""
-    server = get_websocket_server()
-    server.start()
-    return server
-
-
-def stop_websocket_server():
-    """Stop the global WebSocket server."""
-    global _websocket_server
-    if _websocket_server:
-        _websocket_server.stop()
-        _websocket_server = None