claude-mpm 4.1.1__py3-none-any.whl → 4.1.2__py3-none-any.whl

claude_mpm/experimental/cli_enhancements.py

@@ -27,21 +27,20 @@ Implements error handling and user guidance patterns from awesome-claude-code.
 
 import logging
 import sys
-from typing import Any, Dict, List, Optional
 
 import click
 
-from claude_mpm.hooks.validation_hooks import ValidationError, ValidationHooks
+from claude_mpm.hooks.validation_hooks import ValidationHooks
 from claude_mpm.utils.error_handler import (
     ErrorContext,
     MPMError,
     handle_errors,
-    suggest_setup_fix,
 )
 from claude_mpm.validation import AgentValidator, ValidationResult
 
 logger = logging.getLogger(__name__)
 
+
 class CLIContext:
     """Enhanced CLI context with validation and error handling."""
 
@@ -55,12 +54,14 @@ class CLIContext:
     def setup_logging(self, debug: bool = False) -> None:
         """Setup logging based on debug flag."""
         level = logging.DEBUG if debug else logging.INFO
-        format_str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s" if debug else "%(message)s"
+        format_str = (
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+            if debug
+            else "%(message)s"
+        )
 
         logging.basicConfig(
-            level=level,
-            format=format_str,
-            handlers=[logging.StreamHandler(sys.stdout)]
+            level=level, format=format_str, handlers=[logging.StreamHandler(sys.stdout)]
         )
         self.debug = debug
 
@@ -78,9 +79,9 @@ class CLIContext:
 
         # Check required directories
         required_dirs = [
-            Path.home() / '.claude-mpm',
-            Path.home() / '.claude-mpm' / 'profiles',
-            Path.home() / '.claude-mpm' / 'logs',
+            Path.home() / ".claude-mpm",
+            Path.home() / ".claude-mpm" / "profiles",
+            Path.home() / ".claude-mpm" / "logs",
         ]
 
         for dir_path in required_dirs:
@@ -94,8 +95,9 @@ class CLIContext:
 
         return all_passed
 
-    def handle_validation_result(self, result: ValidationResult,
-                               operation: str = "operation") -> None:
+    def handle_validation_result(
+        self, result: ValidationResult, operation: str = "operation"
+    ) -> None:
         """Handle validation results with user-friendly output."""
         if result.is_valid:
             if result.warnings:
@@ -116,13 +118,14 @@ class CLIContext:
 
             sys.exit(1)
 
+
 def create_enhanced_cli() -> click.Group:
     """Create enhanced CLI with better error handling."""
     cli_context = CLIContext()
 
     @click.group()
-    @click.option('--debug', is_flag=True, help='Enable debug logging')
-    @click.option('--dry-run', is_flag=True, help='Run without making changes')
+    @click.option("--debug", is_flag=True, help="Enable debug logging")
+    @click.option("--dry-run", is_flag=True, help="Run without making changes")
     @click.pass_context
     def cli(ctx, debug: bool, dry_run: bool):
         """Enhanced claude-mpm CLI with validation and error handling."""
@@ -131,6 +134,7 @@ def create_enhanced_cli() -> click.Group:
         cli_context.dry_run = dry_run
 
         if debug:
+            print("🐛 Debug mode enabled")
 
         if dry_run:
             print("🏃 Dry-run mode enabled")
@@ -154,7 +158,7 @@ def create_enhanced_cli() -> click.Group:
                 sys.exit(1)
 
     @cli.command()
-    @click.argument('profile_path', type=click.Path(exists=True))
+    @click.argument("profile_path", type=click.Path(exists=True))
     @click.pass_context
     @handle_errors(MPMError)
     async def validate_profile(ctx, profile_path: str):
@@ -167,14 +171,16 @@ def create_enhanced_cli() -> click.Group:
         # Run pre-load validation
         result = await cli_ctx.validation_hooks.run_pre_load_validation(profile)
 
-        cli_ctx.handle_validation_result(result, f"Profile validation for {profile.name}")
+        cli_ctx.handle_validation_result(
+            result, f"Profile validation for {profile.name}"
+        )
 
         if result.is_valid and result.locked_fields:
             print(f"\n🔒 Locked fields: {', '.join(result.locked_fields)}")
 
     @cli.command()
-    @click.option('--profile', '-p', help='Agent profile to load')
-    @click.option('--task', '-t', help='Task to execute')
+    @click.option("--profile", "-p", help="Agent profile to load")
+    @click.option("--task", "-t", help="Task to execute")
     @click.pass_context
     @handle_errors(MPMError)
     async def run_agent(ctx, profile: str, task: str):
@@ -189,8 +195,8 @@ def create_enhanced_cli() -> click.Group:
         if not profile_path.exists():
             # Try default locations
             default_locations = [
-                Path.home() / '.claude-mpm' / 'profiles' / f"{profile}.yaml",
-                Path.cwd() / 'agents' / f"{profile}.yaml",
+                Path.home() / ".claude-mpm" / "profiles" / f"{profile}.yaml",
+                Path.cwd() / "agents" / f"{profile}.yaml",
             ]
 
             for location in default_locations:
@@ -200,24 +206,26 @@ def create_enhanced_cli() -> click.Group:
             else:
                 raise MPMError(
                     f"Profile '{profile}' not found",
-                    details={'searched_locations': [str(p) for p in default_locations]},
+                    details={"searched_locations": [str(p) for p in default_locations]},
                     suggestions=[
                         "Check the profile name",
                         "Use 'mpm list-profiles' to see available profiles",
-                        "Create a new profile with 'mpm create-profile'"
-                    ]
+                        "Create a new profile with 'mpm create-profile'",
+                    ],
                 )
 
         # Run validation
         print(f"🔍 Validating profile: {profile_path.name}")
-        validation_result = await cli_ctx.validation_hooks.run_pre_load_validation(profile_path)
+        validation_result = await cli_ctx.validation_hooks.run_pre_load_validation(
+            profile_path
+        )
 
         if not validation_result.is_valid:
             cli_ctx.handle_validation_result(validation_result, "Profile validation")
             return
 
         # Validate task
-        print(f"🔍 Validating task...")
+        print("🔍 Validating task...")
         task_result = await cli_ctx.validation_hooks.run_pre_execute_validation(
             profile_path.stem, task
         )
@@ -242,14 +250,14 @@ def create_enhanced_cli() -> click.Group:
         cli_ctx = ctx.obj
 
         profile_locations = [
-            Path.home() / '.claude-mpm' / 'profiles',
-            Path.cwd() / 'agents',
+            Path.home() / ".claude-mpm" / "profiles",
+            Path.cwd() / "agents",
         ]
 
         all_profiles = []
         for location in profile_locations:
             if location.exists():
-                profiles = list(location.glob('*.yaml')) + list(location.glob('*.yml'))
+                profiles = list(location.glob("*.yaml")) + list(location.glob("*.yml"))
                 all_profiles.extend(profiles)
 
         if not all_profiles:
@@ -265,9 +273,9 @@ def create_enhanced_cli() -> click.Group:
             print(f"  {status} {profile.stem} ({profile})")
 
     @cli.command()
-    @click.argument('name')
-    @click.option('--role', '-r', required=True, help='Agent role')
-    @click.option('--category', '-c', default='analysis', help='Agent category')
+    @click.argument("name")
+    @click.option("--role", "-r", required=True, help="Agent role")
+    @click.option("--category", "-c", default="analysis", help="Agent category")
     @click.pass_context
     def create_profile(ctx, name: str, role: str, category: str):
         """Create a new agent profile from template."""
@@ -285,34 +293,41 @@ def create_enhanced_cli() -> click.Group:
         profile_content = generator.generate_profile(config)
 
         # Save profile
-        profile_dir = Path.home() / '.claude-mpm' / 'profiles'
+        profile_dir = Path.home() / ".claude-mpm" / "profiles"
         profile_dir.mkdir(parents=True, exist_ok=True)
 
         profile_path = profile_dir / f"{name.lower().replace(' ', '_')}.yaml"
 
-        if profile_path.exists() and not click.confirm(f"Profile {profile_path} exists. Overwrite?"):
+        if profile_path.exists() and not click.confirm(
+            f"Profile {profile_path} exists. Overwrite?"
+        ):
             print("Aborted")
             return
 
         if cli_ctx.dry_run:
             print(f"\n🏃 Dry-run mode - would create {profile_path}:")
             print("---")
-            print(profile_content[:500] + "..." if len(profile_content) > 500 else profile_content)
+            print(
+                profile_content[:500] + "..."
+                if len(profile_content) > 500
+                else profile_content
+            )
             print("---")
         else:
             profile_path.write_text(profile_content)
             print(f"✅ Created profile: {profile_path}")
 
             # Generate documentation
-            doc_path = profile_path.with_suffix('.md')
+            doc_path = profile_path.with_suffix(".md")
             doc_content = generator.generate_agent_documentation(config)
             doc_path.write_text(doc_content)
             print(f"📝 Created documentation: {doc_path}")
 
     return cli
 
+
 # Export the enhanced CLI
 enhanced_cli = create_enhanced_cli()
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     enhanced_cli()

claude_mpm/generators/agent_profile_generator.py

@@ -29,7 +29,7 @@ class AgentProfileGenerator:
         if not self.template_path.exists():
             raise FileNotFoundError(f"Template not found: {self.template_path}")
 
-        with open(self.template_path, "r") as f:
+        with open(self.template_path) as f:
             return yaml.safe_load(f)
 
     def generate_profile(self, config: Dict[str, Any]) -> str:
@@ -46,9 +46,7 @@ class AgentProfileGenerator:
         result = self._replace_placeholders(template_str, config)
 
         # Clean up any remaining placeholders
-        result = re.sub(r"\{\{[^}]+\}\}", "", result)
-
-        return result
+        return re.sub(r"\{\{[^}]+\}\}", "", result)
 
     def _replace_placeholders(self, template: str, values: Dict[str, Any]) -> str:
         """Replace template placeholders with actual values."""

claude_mpm/hooks/base_hook.py

@@ -6,7 +6,7 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, Optional
 
 logger = logging.getLogger(__name__)
 
@@ -75,7 +75,6 @@ class BaseHook(ABC):
         Returns:
             HookResult with execution results
         """
-        pass
 
     async def async_execute(self, context: HookContext) -> HookResult:
         """Async version of execute. Override for async hooks."""

claude_mpm/hooks/claude_hooks/connection_pool.py

@@ -59,8 +59,7 @@ class SocketIOConnectionPool:
                 client = conn["client"]
                 if self._is_connection_alive(client):
                     return client
-                else:
-                    self.connections.remove(conn)
+                self.connections.remove(conn)
 
         if len(self.connections) < self.max_connections:
             client = self._create_connection(port)
@@ -82,7 +81,7 @@ class SocketIOConnectionPool:
 
     def _create_connection(self, port: int) -> Optional[Any]:
         """Create a new Socket.IO connection with persistent keep-alive.
-        
+
         WHY persistent connections:
         - Maintains connection throughout handler lifecycle
         - Automatic reconnection on disconnect
@@ -100,32 +99,38 @@ class SocketIOConnectionPool:
                 logger=False,
                 engineio_logger=False,
             )
-            
+
             # Set up event handlers for connection lifecycle
-            @client.on('connect')
+            @client.on("connect")
             def on_connect():
                 pass  # Connection established
-            
-            @client.on('disconnect')
+
+            @client.on("disconnect")
             def on_disconnect():
                 pass  # Will automatically try to reconnect
-            
+
             client.connect(
                 f"http://localhost:{port}",
                 wait=True,  # Wait for connection to establish
                 wait_timeout=NetworkConfig.SOCKET_WAIT_TIMEOUT,
-                transports=['websocket', 'polling'],  # Try WebSocket first, fall back to polling
+                transports=[
+                    "websocket",
+                    "polling",
+                ],  # Try WebSocket first, fall back to polling
             )
-            
+
             if client.connected:
                 # Send a keep-alive ping to establish the connection
                 try:
-                    client.emit('ping', {
-                        'type': 'system',
-                        'subtype': 'ping',
-                        'timestamp': time.time(),
-                        'source': 'connection_pool'
-                    })
+                    client.emit(
+                        "ping",
+                        {
+                            "type": "system",
+                            "subtype": "ping",
+                            "timestamp": time.time(),
+                            "source": "connection_pool",
+                        },
+                    )
                 except:
                     pass  # Ignore ping errors
                 return client
@@ -135,7 +140,7 @@ class SocketIOConnectionPool:
 
     def _is_connection_alive(self, client: Any) -> bool:
         """Check if a connection is still alive.
-        
+
         WHY enhanced check:
         - Verifies actual connection state
         - Attempts to ping server for liveness check
@@ -144,21 +149,24 @@ class SocketIOConnectionPool:
         try:
             if not client:
                 return False
-            
+
             # Check basic connection state
             if not client.connected:
                 return False
-            
+
             # Try a quick ping to verify connection is truly alive
             # This helps detect zombie connections
             try:
                 # Just emit a ping, don't wait for response (faster)
-                client.emit('ping', {
-                    'type': 'system',
-                    'subtype': 'ping',
-                    'timestamp': time.time(),
-                    'source': 'connection_pool'
-                })
+                client.emit(
+                    "ping",
+                    {
+                        "type": "system",
+                        "subtype": "ping",
+                        "timestamp": time.time(),
+                        "source": "connection_pool",
+                    },
+                )
                 return True
             except:
                 # If ping fails, connection might be dead
@@ -176,7 +184,7 @@ class SocketIOConnectionPool:
 
     def _cleanup_dead_connections(self) -> None:
         """Remove dead connections from the pool and attempt reconnection.
-        
+
         WHY proactive reconnection:
         - Maintains pool health
         - Ensures connections are ready when needed
@@ -202,3 +210,41 @@ class SocketIOConnectionPool:
         for conn in self.connections:
             self._close_connection(conn.get("client"))
         self.connections.clear()
+
+    def emit(self, event: str, data: Dict[str, Any]) -> bool:
+        """Emit an event through the connection pool.
+
+        This method provides backward compatibility for the deprecated
+        connection pool. It attempts to send events directly to the
+        Socket.IO server.
+
+        Args:
+            event: Event name (e.g., "claude_event")
+            data: Event data dictionary
+
+        Returns:
+            bool: True if event was sent successfully
+        """
+        if not SOCKETIO_AVAILABLE:
+            return False
+
+        # Try multiple ports in the range
+        for port in range(
+            NetworkConfig.SOCKETIO_PORT_RANGE[0],
+            NetworkConfig.SOCKETIO_PORT_RANGE[1] + 1,
+        ):
+            client = self.get_connection(port)
+            if client:
+                try:
+                    # Emit the event
+                    client.emit(event, data)
+                    return True
+                except Exception:
+                    # Try next port
+                    continue
+
+        return False
+
+    def cleanup(self) -> None:
+        """Cleanup all connections (alias for close_all)."""
+        self.close_all()