mcp-proxy-adapter 3.1.5__py3-none-any.whl → 4.0.0__py3-none-any.whl

mcp_proxy_adapter/commands/command_registry.py

@@ -1,5 +1,20 @@
 """
 Module for registering and managing commands.
+
+Example: Registering a command instance (for dependency injection)
+---------------------------------------------------------------
+
+.. code-block:: python
+
+    from mcp_proxy_adapter.commands.command_registry import registry
+    from my_commands import MyCommand
+    
+    # Suppose MyCommand requires a service dependency
+    service = MyService()
+    my_command_instance = MyCommand(service=service)
+    registry.register(my_command_instance)
+
+    # Now, when the command is executed, the same instance (with dependencies) will be used
 """
 
 import importlib
@@ -26,6 +41,7 @@ class CommandRegistry:
         """
         self._commands: Dict[str, Type[Command]] = {}
         self._instances: Dict[str, Command] = {}
+        self._custom_commands: Dict[str, Type[Command]] = {}  # Custom commands with priority
     
     def register(self, command: Union[Type[Command], Command]) -> None:
         """
@@ -181,7 +197,7 @@ class CommandRegistry:
         Raises:
             NotFoundError: If command is not found.
         """
-        command_class = self.get_command(command_name)
+        command_class = self.get_command_with_priority(command_name)
         
         return {
             "name": command_name,
@@ -204,7 +220,7 @@ class CommandRegistry:
         Raises:
             NotFoundError: If command is not found
         """
-        command_class = self.get_command(command_name)
+        command_class = self.get_command_with_priority(command_name)
         return command_class.get_metadata()
     
     def get_all_metadata(self) -> Dict[str, Dict[str, Any]]:
@@ -215,8 +231,13 @@ class CommandRegistry:
             Dict with command names as keys and metadata as values
         """
         metadata = {}
-        for name, command_class in self._commands.items():
+        # Add custom commands first (they have priority)
+        for name, command_class in self._custom_commands.items():
             metadata[name] = command_class.get_metadata()
+        # Add built-in commands (custom commands will override if same name)
+        for name, command_class in self._commands.items():
+            if name not in self._custom_commands:  # Only add if not overridden by custom
+                metadata[name] = command_class.get_metadata()
         return metadata
     
     def get_all_commands_info(self) -> Dict[str, Dict[str, Any]]:
@@ -227,8 +248,13 @@ class CommandRegistry:
             Dictionary with information about all commands.
         """
         commands_info = {}
-        for name in self._commands:
+        # Add custom commands first (they have priority)
+        for name in self._custom_commands:
             commands_info[name] = self.get_command_info(name)
+        # Add built-in commands (custom commands will override if same name)
+        for name in self._commands:
+            if name not in self._custom_commands:  # Only add if not overridden by custom
+                commands_info[name] = self.get_command_info(name)
         return commands_info
     
     def discover_commands(self, package_path: str = "mcp_proxy_adapter.commands") -> None:
@@ -281,13 +307,239 @@ class CommandRegistry:
         except Exception as e:
             logger.error(f"Error discovering commands: {e}")
             
+    def register_custom_command(self, command: Union[Type[Command], Command]) -> None:
+        """
+        Register a custom command with priority over built-in commands.
+        
+        Args:
+            command: Command class or instance to register.
+            
+        Raises:
+            ValueError: If command with the same name is already registered.
+        """
+        # Determine if this is a class or an instance
+        if isinstance(command, type) and issubclass(command, Command):
+            command_class = command
+            command_instance = None
+        elif isinstance(command, Command):
+            command_class = command.__class__
+            command_instance = command
+        else:
+            raise ValueError(f"Invalid command type: {type(command)}. Expected Command class or instance.")
+            
+        # Get command name
+        if not hasattr(command_class, "name") or not command_class.name:
+            # Use class name if name attribute is not set
+            command_name = command_class.__name__.lower()
+            if command_name.endswith("command"):
+                command_name = command_name[:-7]  # Remove "command" suffix
+        else:
+            command_name = command_class.name
+            
+        if command_name in self._custom_commands:
+            logger.debug(f"Custom command '{command_name}' is already registered, skipping")
+            raise ValueError(f"Custom command '{command_name}' is already registered")
+            
+        logger.debug(f"Registering custom command: {command_name}")
+        self._custom_commands[command_name] = command_class
+        
+        # Store instance if provided
+        if command_instance:
+            logger.debug(f"Storing custom instance for command: {command_name}")
+            self._instances[command_name] = command_instance
+    
+    def unregister_custom_command(self, command_name: str) -> None:
+        """
+        Remove custom command from registry.
+        
+        Args:
+            command_name: Command name to remove.
+            
+        Raises:
+            NotFoundError: If command is not found.
+        """
+        if command_name not in self._custom_commands:
+            raise NotFoundError(f"Custom command '{command_name}' not found")
+            
+        logger.debug(f"Unregistering custom command: {command_name}")
+        del self._custom_commands[command_name]
+        
+        # Also remove from instances if present
+        if command_name in self._instances:
+            del self._instances[command_name]
+    
+    def custom_command_exists(self, command_name: str) -> bool:
+        """
+        Check if custom command exists.
+        
+        Args:
+            command_name: Command name to check.
+            
+        Returns:
+            True if custom command exists, False otherwise.
+        """
+        return command_name in self._custom_commands
+    
+    def get_custom_command(self, command_name: str) -> Type[Command]:
+        """
+        Get custom command class.
+        
+        Args:
+            command_name: Command name.
+            
+        Returns:
+            Command class.
+            
+        Raises:
+            NotFoundError: If command is not found.
+        """
+        if command_name not in self._custom_commands:
+            raise NotFoundError(f"Custom command '{command_name}' not found")
+        return self._custom_commands[command_name]
+    
+    def get_all_custom_commands(self) -> Dict[str, Type[Command]]:
+        """
+        Get all custom commands.
+        
+        Returns:
+            Dictionary with custom command names as keys and classes as values.
+        """
+        return self._custom_commands.copy()
+    
+    def get_priority_command(self, command_name: str) -> Optional[Type[Command]]:
+        """
+        Get command with priority (custom commands first, then built-in).
+        
+        Args:
+            command_name: Command name.
+            
+        Returns:
+            Command class if found, None otherwise.
+        """
+        # First check custom commands
+        if command_name in self._custom_commands:
+            return self._custom_commands[command_name]
+        
+        # Then check built-in commands
+        if command_name in self._commands:
+            return self._commands[command_name]
+        
+        return None
+    
+    def command_exists_with_priority(self, command_name: str) -> bool:
+        """
+        Check if command exists (custom or built-in).
+        
+        Args:
+            command_name: Command name to check.
+            
+        Returns:
+            True if command exists, False otherwise.
+        """
+        return (command_name in self._custom_commands or 
+                command_name in self._commands)
+    
+    def get_command_with_priority(self, command_name: str) -> Type[Command]:
+        """
+        Get command with priority (custom commands first, then built-in).
+        
+        Args:
+            command_name: Command name.
+            
+        Returns:
+            Command class.
+            
+        Raises:
+            NotFoundError: If command is not found.
+        """
+        # First check custom commands
+        if command_name in self._custom_commands:
+            return self._custom_commands[command_name]
+        
+        # Then check built-in commands
+        if command_name in self._commands:
+            return self._commands[command_name]
+        
+        raise NotFoundError(f"Command '{command_name}' not found")
+    
     def clear(self) -> None:
         """
-        Clears command registry.
+        Clear all registered commands.
         """
-        logger.debug("Clearing command registry")
+        logger.debug("Clearing all registered commands")
         self._commands.clear()
         self._instances.clear()
+        self._custom_commands.clear()
+    
+    def reload_config_and_commands(self, package_path: str = "mcp_proxy_adapter.commands") -> Dict[str, Any]:
+        """
+        Reload configuration and rediscover commands.
+        
+        Args:
+            package_path: Path to package with commands.
+            
+        Returns:
+            Dictionary with reload information including:
+            - config_reloaded: Whether config was reloaded
+            - commands_discovered: Number of commands discovered
+            - custom_commands_preserved: Number of custom commands preserved
+            - total_commands: Total number of commands after reload
+        """
+        logger.info("🔄 Starting configuration and commands reload...")
+        
+        # Store current custom commands
+        custom_commands_backup = self._custom_commands.copy()
+        
+        # Reload configuration
+        try:
+            from mcp_proxy_adapter.config import config
+            config.load_config()
+            config_reloaded = True
+            logger.info("✅ Configuration reloaded successfully")
+        except Exception as e:
+            logger.error(f"❌ Failed to reload configuration: {e}")
+            config_reloaded = False
+        
+        # Reinitialize logging with new configuration
+        try:
+            from mcp_proxy_adapter.core.logging import setup_logging
+            setup_logging()
+            logger.info("✅ Logging reinitialized with new configuration")
+        except Exception as e:
+            logger.error(f"❌ Failed to reinitialize logging: {e}")
+        
+        # Clear all commands except custom ones
+        self._commands.clear()
+        self._instances.clear()
+        
+        # Restore custom commands
+        self._custom_commands = custom_commands_backup
+        custom_commands_preserved = len(custom_commands_backup)
+        
+        # Rediscover commands
+        try:
+            commands_discovered = self.discover_commands(package_path)
+            logger.info(f"✅ Rediscovered {commands_discovered} commands")
+        except Exception as e:
+            logger.error(f"❌ Failed to rediscover commands: {e}")
+            commands_discovered = 0
+        
+        # Get final counts
+        total_commands = len(self._commands)
+        built_in_commands = total_commands - custom_commands_preserved
+        custom_commands = custom_commands_preserved
+        
+        result = {
+            "config_reloaded": config_reloaded,
+            "commands_discovered": commands_discovered,
+            "custom_commands_preserved": custom_commands_preserved,
+            "total_commands": total_commands,
+            "built_in_commands": built_in_commands,
+            "custom_commands": custom_commands
+        }
+        
+        logger.info(f"🔄 Reload completed: {result}")
+        return result
 
 
 # Global command registry instance

mcp_proxy_adapter/commands/help_command.py

@@ -183,11 +183,10 @@ class HelpCommand(Command):
         Raises:
             NotFoundError: If specified command not found
         """
-        try:
-            logger.debug(f"HelpCommand.execute начало: cmdname={cmdname}, kwargs={kwargs}")
+        logger.debug(f"HelpCommand.execute начало: cmdname={cmdname}, kwargs={kwargs}")
 
+        try:
             # Handle case when cmdname is provided
-            # Important: explicitly check for None or empty string
             if cmdname is not None and cmdname != "":
                 logger.debug(f"Обработка запроса для конкретной команды: {cmdname}")
                 try:
@@ -196,77 +195,67 @@ class HelpCommand(Command):
                     logger.debug(f"Получены метаданные для команды {cmdname}")
                     return HelpResult(command_info=command_metadata)
                 except NotFoundError:
-                    # If command not found, raise error
                     logger.warning(f"Команда '{cmdname}' не найдена")
-                    raise NotFoundError(f"Command '{cmdname}' not found")
-                except Exception as e:
-                    logger.error(f"Ошибка при получении метаданных команды {cmdname}: {e}")
-                    logger.debug(f"Трассировка: {traceback.format_exc()}")
-                    # Создаем пустой результат вместо ошибки
-                    return HelpResult(command_info={
-                        "name": cmdname,
-                        "summary": "Command information unavailable",
-                        "description": f"Error retrieving metadata: {str(e)}",
-                        "params": {},
-                        "examples": []
+                    # Получаем список всех команд
+                    all_commands = list(registry.get_all_metadata().keys())
+                    if all_commands:
+                        example_cmd = all_commands[0]
+                        example = {
+                            "command": "help",
+                            "params": {"cmdname": example_cmd}
+                        }
+                        note = f"Use help with an existing command name to get detailed info. For example: help with cmdname '{example_cmd}'. To list all commands: call help without parameters."
+                    else:
+                        example = {"command": "help"}
+                        note = "No commands registered. To list all commands: call help without parameters."
+                    return HelpResult(commands_info={
+                        "commands": {},
+                        "error": f"Command '{cmdname}' not found",
+                        "example": example,
+                        "note": note
                     })
 
             # Otherwise, return information about all available commands
-            # and tool metadata
             logger.debug("Обработка запроса для всех команд")
 
-            try:
-                # Get metadata for all commands
-                all_metadata = registry.get_all_metadata()
-                logger.debug(f"Получены метаданные для {len(all_metadata)} команд")
+            # Get metadata for all commands
+            all_metadata = registry.get_all_metadata()
+            logger.debug(f"Получены метаданные для {len(all_metadata)} команд")
 
-                # Prepare response format with tool metadata
-                result = {
-                    "tool_info": {
-                        "name": "MCP-Proxy API Service",
-                        "description": "JSON-RPC API for microservice command execution",
-                        "version": "1.0.0"
-                    },
-                    "help_usage": {
-                        "description": "Get information about commands",
-                        "examples": [
-                            {"command": "help", "description": "List of all available commands"},
-                            {"command": "help", "params": {"cmdname": "command_name"}, "description": "Get detailed information about a specific command"}
-                        ]
-                    },
-                    "commands": {}
-                }
+            # Prepare response format with tool metadata
+            result = {
+                "tool_info": {
+                    "name": "MCP-Proxy API Service",
+                    "description": "JSON-RPC API for microservice command execution",
+                    "version": "1.0.0"
+                },
+                "help_usage": {
+                    "description": "Get information about commands",
+                    "examples": [
+                        {"command": "help", "description": "List of all available commands"},
+                        {"command": "help", "params": {"cmdname": "command_name"}, "description": "Get detailed information about a specific command"}
+                    ]
+                },
+                "commands": {}
+            }
 
-                # Add brief information about commands
-                for name, metadata in all_metadata.items():
-                    try:
-                        logger.debug(f"Обработка метаданных команды {name}")
-                        # Безопасное получение параметров с проверкой на наличие ключей
-                        result["commands"][name] = {
-                            "summary": metadata.get("summary", ""),
-                            "params_count": len(metadata.get("params", {}))
-                        }
-                    except Exception as e:
-                        logger.error(f"Ошибка при обработке метаданных команды {name}: {e}")
-                        logger.debug(f"Метаданные команды {name}: {metadata}")
-                        # Пропускаем проблемную команду
-                        continue
+            # Add brief information about commands
+            for name, metadata in all_metadata.items():
+                try:
+                    logger.debug(f"Обработка метаданных команды {name}")
+                    # Безопасное получение параметров с проверкой на наличие ключей
+                    result["commands"][name] = {
+                        "summary": metadata.get("summary", ""),
+                        "params_count": len(metadata.get("params", {}))
+                    }
+                except Exception as e:
+                    logger.error(f"Ошибка при обработке метаданных команды {name}: {e}")
+                    logger.debug(f"Метаданные команды {name}: {metadata}")
+                    # Пропускаем проблемную команду
+                    continue
 
-                logger.debug(f"HelpCommand.execute завершение: возвращаем результат с {len(result['commands'])} командами")
-                return HelpResult(commands_info=result)
-            except Exception as e:
-                logger.error(f"Ошибка при получении списка команд: {e}")
-                logger.debug(f"Трассировка: {traceback.format_exc()}")
-                # Создаем пустой результат вместо ошибки
-                return HelpResult(commands_info={
-                    "tool_info": {
-                        "name": "MCP-Proxy API Service",
-                        "description": "JSON-RPC API for microservice command execution",
-                        "version": "1.0.0"
-                    },
-                    "commands": {},
-                    "error": str(e)
-                })
+            logger.debug(f"HelpCommand.execute завершение: возвращаем результат с {len(result['commands'])} командами")
+            return HelpResult(commands_info=result)
         except Exception as e:
             logger.error(f"Неожиданная ошибка в HelpCommand.execute: {e}")
             logger.debug(f"Трассировка: {traceback.format_exc()}")