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

claude_mpm/services/claude_session_logger.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 """
 Claude Session Response Logger
 
@@ -9,11 +11,10 @@ Configuration via .claude-mpm/configuration.yaml.
 """
 
 import json
+import logging
 import os
 from datetime import datetime
-from pathlib import Path
-from typing import Dict, Any, Optional
-import logging
+from typing import Any, Dict, Optional
 
 # Import configuration manager
 from claude_mpm.core.config import Config
@@ -21,10 +22,11 @@ from claude_mpm.core.config import Config
 # Try to import async logger for performance optimization
 try:
     from claude_mpm.services.async_session_logger import (
+        AsyncSessionLogger,
         get_async_logger,
         log_response_async,
-        AsyncSessionLogger
     )
+
     ASYNC_AVAILABLE = True
 except ImportError:
     ASYNC_AVAILABLE = False
@@ -34,11 +36,16 @@ logger = logging.getLogger(__name__)
 
 class ClaudeSessionLogger:
     """Simplified response logger for Claude Code sessions."""
-    
-    def __init__(self, base_dir: Optional[Path] = None, use_async: Optional[bool] = None, config: Optional[Config] = None):
+
+    def __init__(
+        self,
+        base_dir: Optional[Path] = None,
+        use_async: Optional[bool] = None,
+        config: Optional[Config] = None,
+    ):
         """
         Initialize the session logger.
-        
+
         Args:
             base_dir: Base directory for responses. Overrides config.
             use_async: Use async logging if available. Overrides config.
@@ -48,92 +55,98 @@ class ClaudeSessionLogger:
         if config is None:
             config = Config()
         self.config = config
-        
+
         # Get response logging configuration
-        response_config = self.config.get('response_logging', {})
-        
+        response_config = self.config.get("response_logging", {})
+
         # Determine base directory
         if base_dir is None:
             # Check configuration first
-            base_dir = response_config.get('session_directory')
+            base_dir = response_config.get("session_directory")
             if not base_dir:
                 # Fall back to default response directory
-                base_dir = '.claude-mpm/responses'
+                base_dir = ".claude-mpm/responses"
             base_dir = Path(base_dir)
-        
+
         self.base_dir = Path(base_dir)
         self.base_dir.mkdir(parents=True, exist_ok=True)
-        
+
         # Try to get session ID from environment
         self.session_id = self._get_claude_session_id()
         self.response_counter = {}  # Track response count per session
-        
+
         # Determine if we should use async logging
         if use_async is None:
             # Check if response logging is enabled at all
-            if not response_config.get('enabled', True):
+            if not response_config.get("enabled", True):
                 logger.info("Response logging disabled in configuration")
                 use_async = False
             else:
                 # Check configuration for async preference
-                use_async = response_config.get('use_async', True)
-                
+                use_async = response_config.get("use_async", True)
+
                 # Check environment for backward compatibility
-                if os.environ.get('CLAUDE_USE_ASYNC_LOG'):
-                    env_async = os.environ.get('CLAUDE_USE_ASYNC_LOG', 'true').lower() == 'true'
-                    logger.info(f"Using CLAUDE_USE_ASYNC_LOG environment variable (deprecated): {env_async}")
+                if os.environ.get("CLAUDE_USE_ASYNC_LOG"):
+                    env_async = (
+                        os.environ.get("CLAUDE_USE_ASYNC_LOG", "true").lower() == "true"
+                    )
+                    logger.info(
+                        f"Using CLAUDE_USE_ASYNC_LOG environment variable (deprecated): {env_async}"
+                    )
                     use_async = env_async
-        
+
         self.use_async = use_async and ASYNC_AVAILABLE
         self._async_logger = None
-        
+
         if self.use_async:
             try:
                 self._async_logger = get_async_logger(config=config)
                 logger.info("Using async logger for improved performance")
             except Exception as e:
-                logger.warning(f"Failed to initialize async logger, falling back to sync: {e}")
+                logger.warning(
+                    f"Failed to initialize async logger, falling back to sync: {e}"
+                )
                 self.use_async = False
-        
+
     def _get_claude_session_id(self) -> Optional[str]:
         """
         Get the Claude Code session ID from environment.
-        
+
         Returns:
             Session ID if available, None otherwise
         """
         # Claude Code may set various environment variables
         # Check common patterns
         session_id = None
-        
+
         # Check for CLAUDE_SESSION_ID
-        session_id = os.environ.get('CLAUDE_SESSION_ID')
-        
+        session_id = os.environ.get("CLAUDE_SESSION_ID")
+
         # Check for ANTHROPIC_SESSION_ID
         if not session_id:
-            session_id = os.environ.get('ANTHROPIC_SESSION_ID')
-        
+            session_id = os.environ.get("ANTHROPIC_SESSION_ID")
+
         # Check for generic SESSION_ID
         if not session_id:
-            session_id = os.environ.get('SESSION_ID')
-        
+            session_id = os.environ.get("SESSION_ID")
+
         # Generate a default based on timestamp if nothing found
         if not session_id:
             # Use a timestamp-based session ID as fallback
-            session_id = datetime.now().strftime('%Y%m%d_%H%M%S')
+            session_id = datetime.now().strftime("%Y%m%d_%H%M%S")
             logger.info(f"No Claude session ID found, using generated: {session_id}")
         else:
             logger.info(f"Using Claude session ID: {session_id}")
-        
+
         return session_id
-    
+
     def _generate_filename(self, agent: Optional[str] = None) -> str:
         """
         Generate a flat filename with session ID, agent, and timestamp.
-        
+
         Args:
             agent: Optional agent name
-            
+
         Returns:
             Filename in format: [session_id]-[agent]-timestamp.json
         """
@@ -141,116 +154,118 @@ class ClaudeSessionLogger:
         agent_name = agent or "unknown"
         # Sanitize agent name (replace spaces with underscores, lowercase)
         agent_name = agent_name.replace(" ", "_").lower()
-        
+
         # Generate timestamp with microseconds for uniqueness
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
-        
+
         # Create filename: session_id-agent-timestamp.json
         filename = f"{self.session_id}-{agent_name}-{timestamp}.json"
         return filename
-    
+
     def log_response(
         self,
         request_summary: str,
         response_content: str,
         metadata: Optional[Dict[str, Any]] = None,
-        agent: Optional[str] = None
+        agent: Optional[str] = None,
     ) -> Optional[Path]:
         """
         Log a response to the session directory.
-        
+
         Args:
             request_summary: Brief summary of the request
             response_content: The full response content
             metadata: Optional metadata (agent name, model, etc.)
             agent: Optional agent name (overrides metadata)
-            
+
         Returns:
             Path to the saved response file, or None if disabled
         """
         # Check if logging is actually enabled
-        response_config = self.config.get('response_logging', {})
-        if not response_config.get('enabled', True):
+        response_config = self.config.get("response_logging", {})
+        if not response_config.get("enabled", True):
             logger.debug("Response logging is disabled in configuration")
             return None
-            
+
         if not self.session_id:
             return None
-        
+
         # Use async logger if available for better performance
         if self.use_async and self._async_logger:
             success = self._async_logger.log_response(
                 request_summary=request_summary,
                 response_content=response_content,
                 metadata=metadata,
-                agent=agent
+                agent=agent,
             )
             if success:
                 # Return expected path for compatibility
                 # Async logger uses timestamp-based names, so we can't return exact path
                 return self.base_dir / "async_response.json"
             return None
-        
+
         # Fall back to synchronous logging
         # Ensure base directory exists (flat structure, no subdirs)
         self.base_dir.mkdir(parents=True, exist_ok=True)
-        
+
         # Extract agent name from parameter or metadata
         agent_name = agent or (metadata.get("agent") if metadata else None) or "unknown"
-        
+
         # Generate filename with flat structure
         filename = self._generate_filename(agent_name)
         file_path = self.base_dir / filename
-        
+
         # Prepare response data with standardized field names
         response_data = {
             "timestamp": datetime.now().isoformat(),
             "session_id": self.session_id,
             "request": request_summary,  # Standardized field name
             "response": response_content,  # Already correct
-            "agent": agent or (metadata.get("agent") if metadata else None) or "unknown",  # Standardized field name
-            "metadata": metadata or {}
+            "agent": agent
+            or (metadata.get("agent") if metadata else None)
+            or "unknown",  # Standardized field name
+            "metadata": metadata or {},
         }
-        
+
         # Save response
         try:
-            with open(file_path, 'w', encoding='utf-8') as f:
+            with open(file_path, "w", encoding="utf-8") as f:
                 json.dump(response_data, f, indent=2, ensure_ascii=False)
-            
+
             logger.debug(f"Logged response to {filename} for session {self.session_id}")
             return file_path
-            
+
         except Exception as e:
             logger.error(f"Failed to log response: {e}")
             return None
-    
+
     def set_session_id(self, session_id: str) -> None:
         """
         Manually set the session ID.
-        
+
         Args:
             session_id: The session ID to use
         """
         self.session_id = session_id
         logger.info(f"Session ID set to: {session_id}")
-    
+
     def get_session_path(self) -> Optional[Path]:
         """
         Get the path to the responses directory.
-        
+
         Note: With flat structure, returns the base directory.
-        
+
         Returns:
             Path to responses directory, or None if no session
         """
         if not self.session_id:
             return None
         return self.base_dir
-    
+
     def is_enabled(self) -> bool:
         """
         Check if logging is enabled.
-        
+
         Returns:
             True if logging is enabled (session ID available)
         """
@@ -264,10 +279,10 @@ _logger_instance = None
 def get_session_logger(config: Optional[Config] = None) -> ClaudeSessionLogger:
     """
     Get the singleton session logger instance.
-    
+
     Args:
         config: Optional configuration instance to use
-    
+
     Returns:
         The shared ClaudeSessionLogger instance
     """
@@ -281,19 +296,19 @@ def log_response(
     request_summary: str,
     response_content: str,
     metadata: Optional[Dict[str, Any]] = None,
-    agent: Optional[str] = None
+    agent: Optional[str] = None,
 ) -> Optional[Path]:
     """
     Convenience function to log a response.
-    
+
     Args:
         request_summary: Brief summary of the request
         response_content: The full response content
         metadata: Optional metadata
         agent: Optional agent name
-        
+
     Returns:
         Path to the saved response file
     """
     logger = get_session_logger()
-    return logger.log_response(request_summary, response_content, metadata, agent)
+    return logger.log_response(request_summary, response_content, metadata, agent)

claude_mpm/services/command_handler_service.py

@@ -0,0 +1,217 @@
+"""Command handler service for processing MPM commands.
+
+This service handles:
+1. MPM command parsing and validation
+2. Command execution and routing
+3. Command logging and error handling
+4. Integration with CLI modules
+
+Extracted from ClaudeRunner to follow Single Responsibility Principle.
+"""
+
+from typing import Any, Dict, List
+
+from claude_mpm.core.base_service import BaseService
+from claude_mpm.services.core.interfaces import CommandHandlerInterface
+
+
+class CommandHandlerService(BaseService, CommandHandlerInterface):
+    """Service for handling MPM commands."""
+
+    def __init__(self, project_logger=None):
+        """Initialize the command handler service.
+
+        Args:
+            project_logger: Optional project logger for command logging
+        """
+        super().__init__(name="command_handler_service")
+        self.project_logger = project_logger
+
+    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 handle_mpm_command(self, prompt: str) -> bool:
+        """Handle /mpm: commands directly without going to Claude.
+
+        Args:
+            prompt: The full prompt starting with "/mpm:"
+
+        Returns:
+            bool: True if command was handled successfully, False otherwise
+        """
+        try:
+            # Extract command and arguments
+            command_line = prompt[5:].strip()  # Remove "/mpm:"
+            parts = command_line.split()
+
+            if not parts:
+                print("No command specified. Available commands: test, agents")
+                return True
+
+            command = parts[0]
+            args = parts[1:]
+
+            # Route to appropriate handler
+            if command == "test":
+                return self._handle_test_command(args)
+            elif command == "agents":
+                return self._handle_agents_command(args)
+            else:
+                print(f"Unknown command: {command}")
+                print("Available commands: test, agents")
+                return True
+
+        except KeyboardInterrupt:
+            print("\nCommand interrupted")
+            return False
+        except Exception as e:
+            print(f"Error executing command: {e}")
+            self._log_command_error(f"Failed to execute /mpm: command: {e}")
+            return False
+
+    def _handle_test_command(self, args: list) -> bool:
+        """Handle the test command.
+
+        Args:
+            args: Command arguments
+
+        Returns:
+            bool: True if successful
+        """
+        print("Hello World")
+        self._log_command_success("Executed /mpm:test command")
+        return True
+
+    def _handle_agents_command(self, args: list) -> bool:
+        """Handle the agents command - display deployed agent versions.
+
+        WHY: This provides users with a quick way to check deployed agent versions
+        directly from within Claude Code, maintaining consistency with CLI behavior.
+
+        Args:
+            args: Command arguments
+
+        Returns:
+            bool: True if successful, False if error occurred
+        """
+        try:
+            from claude_mpm.cli import _get_agent_versions_display
+
+            agent_versions = _get_agent_versions_display()
+            if agent_versions:
+                print(agent_versions)
+            else:
+                print("No deployed agents found")
+                print("\nTo deploy agents, run: claude-mpm --mpm:agents deploy")
+
+            self._log_command_success("Executed /mpm:agents command")
+            return True
+
+        except ImportError as e:
+            print(f"Error: CLI module not available: {e}")
+            return False
+        except Exception as e:
+            print(f"Error getting agent versions: {e}")
+            return False
+
+    def _log_command_success(self, message: str):
+        """Log successful command execution.
+
+        Args:
+            message: Success message to log
+        """
+        if self.project_logger:
+            self.project_logger.log_system(message, level="INFO", component="command")
+
+    def _log_command_error(self, message: str):
+        """Log command execution error.
+
+        Args:
+            message: Error message to log
+        """
+        if self.project_logger:
+            self.project_logger.log_system(message, level="ERROR", component="command")
+
+    def is_mpm_command(self, prompt: str) -> bool:
+        """Check if a prompt is an MPM command.
+
+        Args:
+            prompt: The prompt to check
+
+        Returns:
+            bool: True if the prompt is an MPM command
+        """
+        return prompt.strip().startswith("/mpm:")
+
+    def get_available_commands(self) -> List[str]:
+        """Get list of available MPM commands.
+
+        Returns:
+            List: List of available command names
+        """
+        return ["test", "agents"]
+
+    # Implementation of abstract methods from CommandHandlerInterface
+
+    def handle_command(self, command: str, args: List[str]) -> Dict[str, Any]:
+        """Handle an MPM command.
+
+        Args:
+            command: Command name to execute
+            args: Command arguments
+
+        Returns:
+            Dictionary with command execution results
+        """
+        try:
+            if command == "test":
+                success = self._handle_test_command(args)
+                return {
+                    "success": success,
+                    "command": command,
+                    "args": args,
+                    "message": "Test command executed"
+                    if success
+                    else "Test command failed",
+                }
+            elif command == "agents":
+                success = self._handle_agents_command(args)
+                return {
+                    "success": success,
+                    "command": command,
+                    "args": args,
+                    "message": "Agents command executed"
+                    if success
+                    else "Agents command failed",
+                }
+            else:
+                return {
+                    "success": False,
+                    "command": command,
+                    "args": args,
+                    "error": f"Unknown command: {command}",
+                    "available_commands": self.get_available_commands(),
+                }
+        except Exception as e:
+            return {"success": False, "command": command, "args": args, "error": str(e)}
+
+    def get_command_help(self, command: str) -> str:
+        """Get help text for a specific command.
+
+        Args:
+            command: Command name
+
+        Returns:
+            Help text for the command
+        """
+        help_text = {
+            "test": "Test command - prints 'Hello World' to verify MPM command functionality",
+            "agents": "Agents command - displays information about deployed agents and their versions",
+        }
+
+        return help_text.get(command, f"No help available for command: {command}")

claude_mpm/services/communication/__init__.py

@@ -13,9 +13,10 @@ Services:
 """
 
 from .socketio import SocketIOServer
+
 # from .websocket import SocketIOClientManager  # Module has import issues
 
 __all__ = [
-    'SocketIOServer',
+    "SocketIOServer",
     # 'SocketIOClientManager',
-]
+]