kollabor 0.4.9__py3-none-any.whl

core/events/registry.py

@@ -0,0 +1,289 @@
+"""Hook registry for managing hook registration and lifecycle."""
+
+import logging
+from collections import defaultdict
+from typing import Any, Dict, List, Optional
+
+from .models import EventType, Hook, HookStatus
+
+logger = logging.getLogger(__name__)
+
+
+class HookRegistry:
+    """Manages hook registration, organization, and status tracking.
+    
+    This class is responsible for maintaining the registry of hooks,
+    organizing them by event type and priority, and tracking their status.
+    """
+    
+    def __init__(self):
+        """Initialize the hook registry."""
+        self.hooks: Dict[EventType, List[Hook]] = defaultdict(list)
+        self.hook_status: Dict[str, HookStatus] = {}
+        self.hook_metadata: Dict[str, Dict[str, Any]] = {}
+        logger.info("HookRegistry initialized")
+    
+    def register_hook(self, hook: Hook) -> bool:
+        """Register a hook with the registry.
+        
+        Args:
+            hook: The hook to register.
+            
+        Returns:
+            True if registration successful, False otherwise.
+        """
+        try:
+            hook_key = f"{hook.plugin_name}.{hook.name}"
+            
+            # Check for duplicate registration
+            if hook_key in self.hook_status:
+                logger.warning(f"Hook {hook_key} already registered, updating registration")
+                self._remove_hook_from_lists(hook_key)
+            
+            # Add hook to appropriate event type list
+            self.hooks[hook.event_type].append(hook)
+            
+            # Sort hooks by priority (highest first)
+            self.hooks[hook.event_type].sort(key=lambda h: h.priority, reverse=True)
+            
+            # Track hook status and metadata
+            self.hook_status[hook_key] = HookStatus.PENDING
+            self.hook_metadata[hook_key] = {
+                "event_type": hook.event_type.value,
+                "priority": hook.priority,
+                "plugin_name": hook.plugin_name,
+                "enabled": hook.enabled,
+                "timeout": hook.timeout,
+                "error_action": hook.error_action,
+                "registration_order": len(self.hook_status)
+            }
+            
+            logger.debug(f"Registered hook: {hook_key} for {hook.event_type.value} (priority: {hook.priority})")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to register hook {hook.plugin_name}.{hook.name}: {e}")
+            return False
+    
+    def unregister_hook(self, plugin_name: str, hook_name: str) -> bool:
+        """Unregister a hook from the registry.
+        
+        Args:
+            plugin_name: Name of the plugin that owns the hook.
+            hook_name: Name of the hook.
+            
+        Returns:
+            True if unregistration successful, False otherwise.
+        """
+        hook_key = f"{plugin_name}.{hook_name}"
+        
+        if hook_key not in self.hook_status:
+            logger.warning(f"Hook {hook_key} not found for unregistration")
+            return False
+        
+        try:
+            # Remove from hook lists
+            removed = self._remove_hook_from_lists(hook_key)
+            
+            if removed:
+                # Clean up status and metadata
+                del self.hook_status[hook_key]
+                del self.hook_metadata[hook_key]
+                logger.info(f"Unregistered hook: {hook_key}")
+                return True
+            else:
+                logger.warning(f"Hook {hook_key} not found in any event type lists")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Failed to unregister hook {hook_key}: {e}")
+            return False
+    
+    def get_hooks_for_event(self, event_type: EventType) -> List[Hook]:
+        """Get all hooks registered for a specific event type.
+        
+        Args:
+            event_type: The event type to get hooks for.
+            
+        Returns:
+            List of hooks sorted by priority (highest first).
+        """
+        hooks = self.hooks.get(event_type, [])
+        
+        # Filter out disabled hooks
+        enabled_hooks = [hook for hook in hooks if hook.enabled]
+        
+        #logger.debug(f"Retrieved {len(enabled_hooks)} enabled hooks for {event_type.value}")
+        return enabled_hooks
+    
+    def update_hook_status(self, hook_key: str, status: str) -> bool:
+        """Update the status of a registered hook.
+        
+        Args:
+            hook_key: Key identifying the hook (plugin_name.hook_name).
+            status: New status for the hook.
+            
+        Returns:
+            True if update successful, False otherwise.
+        """
+        try:
+            if hook_key not in self.hook_status:
+                logger.warning(f"Cannot update status for unknown hook: {hook_key}")
+                return False
+            
+            # Convert string status to HookStatus enum
+            status_mapping = {
+                "pending": HookStatus.PENDING,
+                "working": HookStatus.WORKING,
+                "completed": HookStatus.COMPLETED,
+                "failed": HookStatus.FAILED,
+                "timeout": HookStatus.TIMEOUT
+            }
+            
+            if status not in status_mapping:
+                logger.error(f"Invalid status '{status}' for hook {hook_key}")
+                return False
+            
+            old_status = self.hook_status[hook_key]
+            self.hook_status[hook_key] = status_mapping[status]
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to update status for hook {hook_key}: {e}")
+            return False
+    
+    def get_hook_status_summary(self) -> Dict[str, Any]:
+        """Get a summary of all hook statuses.
+        
+        Returns:
+            Dictionary with hook status statistics and details.
+        """
+        status_counts = defaultdict(int)
+        hook_details = {}
+        
+        for hook_key, status in self.hook_status.items():
+            status_counts[status.value] += 1
+            
+            metadata = self.hook_metadata.get(hook_key, {})
+            hook_details[hook_key] = {
+                "status": status.value,
+                "event_type": metadata.get("event_type", "unknown"),
+                "priority": metadata.get("priority", 0),
+                "enabled": metadata.get("enabled", True),
+                "plugin_name": metadata.get("plugin_name", "unknown")
+            }
+        
+        return {
+            "total_hooks": len(self.hook_status),
+            "status_counts": dict(status_counts),
+            "hook_details": hook_details
+        }
+    
+    def enable_hook(self, plugin_name: str, hook_name: str) -> bool:
+        """Enable a registered hook.
+        
+        Args:
+            plugin_name: Name of the plugin that owns the hook.
+            hook_name: Name of the hook.
+            
+        Returns:
+            True if hook was enabled, False otherwise.
+        """
+        return self._set_hook_enabled(plugin_name, hook_name, True)
+    
+    def disable_hook(self, plugin_name: str, hook_name: str) -> bool:
+        """Disable a registered hook.
+        
+        Args:
+            plugin_name: Name of the plugin that owns the hook.
+            hook_name: Name of the hook.
+            
+        Returns:
+            True if hook was disabled, False otherwise.
+        """
+        return self._set_hook_enabled(plugin_name, hook_name, False)
+    
+    def _set_hook_enabled(self, plugin_name: str, hook_name: str, enabled: bool) -> bool:
+        """Set the enabled state of a hook.
+        
+        Args:
+            plugin_name: Name of the plugin that owns the hook.
+            hook_name: Name of the hook.
+            enabled: Whether to enable or disable the hook.
+            
+        Returns:
+            True if state was changed, False otherwise.
+        """
+        hook_key = f"{plugin_name}.{hook_name}"
+        
+        # Find the hook in the registry
+        hook_found = False
+        for event_type, hooks in self.hooks.items():
+            for hook in hooks:
+                if f"{hook.plugin_name}.{hook.name}" == hook_key:
+                    hook.enabled = enabled
+                    hook_found = True
+                    
+                    # Update metadata
+                    if hook_key in self.hook_metadata:
+                        self.hook_metadata[hook_key]["enabled"] = enabled
+                    
+                    action = "enabled" if enabled else "disabled"
+                    logger.info(f"Hook {hook_key} {action}")
+                    break
+            if hook_found:
+                break
+        
+        if not hook_found:
+            logger.warning(f"Hook {hook_key} not found for enable/disable")
+            return False
+        
+        return True
+    
+    def _remove_hook_from_lists(self, hook_key: str) -> bool:
+        """Remove a hook from all event type lists.
+        
+        Args:
+            hook_key: Key identifying the hook to remove.
+            
+        Returns:
+            True if hook was found and removed, False otherwise.
+        """
+        removed = False
+        
+        for event_type, hooks in self.hooks.items():
+            # Find and remove hook from this event type's list
+            for i, hook in enumerate(hooks):
+                if f"{hook.plugin_name}.{hook.name}" == hook_key:
+                    del hooks[i]
+                    removed = True
+                    break
+        
+        return removed
+    
+    def get_registry_stats(self) -> Dict[str, Any]:
+        """Get comprehensive registry statistics.
+        
+        Returns:
+            Dictionary with detailed registry statistics.
+        """
+        event_type_counts = {}
+        priority_distribution = defaultdict(int)
+        plugin_counts = defaultdict(int)
+        
+        for event_type, hooks in self.hooks.items():
+            event_type_counts[event_type.value] = len(hooks)
+            
+            for hook in hooks:
+                priority_distribution[hook.priority] += 1
+                plugin_counts[hook.plugin_name] += 1
+        
+        return {
+            "total_hooks": len(self.hook_status),
+            "event_types": len(self.hooks),
+            "hooks_per_event_type": event_type_counts,
+            "priority_distribution": dict(priority_distribution),
+            "hooks_per_plugin": dict(plugin_counts),
+            "status_summary": self.get_hook_status_summary()
+        }

core/fullscreen/__init__.py

@@ -0,0 +1,19 @@
+"""Full-screen plugin framework for terminal takeover.
+
+This module provides a reusable framework for plugins to take complete
+terminal control using the proven modal system architecture.
+"""
+
+from .manager import FullScreenManager
+from .renderer import FullScreenRenderer
+from .plugin import FullScreenPlugin
+from .session import FullScreenSession
+from .command_integration import FullScreenCommandIntegrator
+
+__all__ = [
+    "FullScreenManager",
+    "FullScreenRenderer",
+    "FullScreenPlugin",
+    "FullScreenSession",
+    "FullScreenCommandIntegrator"
+]

core/fullscreen/command_integration.py

@@ -0,0 +1,290 @@
+"""Fullscreen plugin command integration system.
+
+This module handles automatic discovery and registration of slash commands
+for fullscreen plugins, enabling dynamic plugin-to-command mapping.
+"""
+
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional, Type
+import importlib.util
+import sys
+
+from ..events.models import CommandDefinition, CommandMode, CommandCategory
+from ..commands.registry import SlashCommandRegistry
+from .plugin import FullScreenPlugin
+
+logger = logging.getLogger(__name__)
+
+
+class FullScreenCommandIntegrator:
+    """Integrates fullscreen plugins with the slash command system.
+
+    This class:
+    - Discovers fullscreen plugins in plugins/fullscreen/
+    - Auto-registers slash commands based on plugin metadata
+    - Handles dynamic plugin loading/unloading
+    - Maps commands to plugin execution
+    """
+
+    def __init__(self, command_registry: SlashCommandRegistry, event_bus):
+        """Initialize the fullscreen command integrator.
+
+        Args:
+            command_registry: Slash command registry for registration
+            event_bus: Event bus for communication
+        """
+        self.command_registry = command_registry
+        self.event_bus = event_bus
+        self.registered_plugins: Dict[str, Type[FullScreenPlugin]] = {}
+        self.plugin_instances: Dict[str, FullScreenPlugin] = {}
+        self._fullscreen_manager = None
+
+        logger.info("FullScreen command integrator initialized")
+
+    def discover_and_register_plugins(self, plugins_dir: Path) -> int:
+        """Discover and register all fullscreen plugins.
+
+        Args:
+            plugins_dir: Base plugins directory
+
+        Returns:
+            Number of plugins registered
+        """
+        fullscreen_dir = plugins_dir / "fullscreen"
+        if not fullscreen_dir.exists():
+            logger.info("No fullscreen plugins directory found")
+            return 0
+
+        registered_count = 0
+
+        # Scan for Python files in fullscreen directory
+        for plugin_file in fullscreen_dir.glob("*.py"):
+            if plugin_file.name.startswith("__"):
+                continue
+
+            try:
+                plugin_class = self._load_plugin_class(plugin_file)
+                if plugin_class:
+                    if self._register_plugin_commands(plugin_class):
+                        registered_count += 1
+                        logger.info(f"Registered commands for plugin: {plugin_class.__name__}")
+            except Exception as e:
+                logger.error(f"Failed to load plugin {plugin_file.name}: {e}")
+
+        logger.info(f"Discovered and registered {registered_count} fullscreen plugins")
+        return registered_count
+
+    def _load_plugin_class(self, plugin_file: Path) -> Optional[Type[FullScreenPlugin]]:
+        """Load a plugin class from a Python file.
+
+        Args:
+            plugin_file: Path to the plugin Python file
+
+        Returns:
+            Plugin class or None if not found/invalid
+        """
+        try:
+            # Create module spec and load
+            module_name = f"plugins.fullscreen.{plugin_file.stem}"
+            spec = importlib.util.spec_from_file_location(module_name, plugin_file)
+            if not spec or not spec.loader:
+                return None
+
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[module_name] = module
+            spec.loader.exec_module(module)
+
+            # Find FullScreenPlugin subclass
+            for attr_name in dir(module):
+                attr = getattr(module, attr_name)
+                if (isinstance(attr, type) and
+                    issubclass(attr, FullScreenPlugin) and
+                    attr != FullScreenPlugin):
+                    return attr
+
+            logger.warning(f"No FullScreenPlugin subclass found in {plugin_file.name}")
+            return None
+
+        except Exception as e:
+            logger.error(f"Error loading plugin class from {plugin_file}: {e}")
+            return None
+
+    def _register_plugin_commands(self, plugin_class: Type[FullScreenPlugin]) -> bool:
+        """Register slash commands for a plugin class.
+
+        Args:
+            plugin_class: The plugin class to register commands for
+
+        Returns:
+            True if registration successful
+        """
+        try:
+            # Create temporary instance to get metadata
+            temp_instance = plugin_class()
+            metadata = temp_instance.metadata
+
+            if not metadata:
+                logger.warning(f"Plugin {plugin_class.__name__} has no metadata")
+                return False
+
+            # Store plugin class for later instantiation
+            self.registered_plugins[metadata.name] = plugin_class
+
+            # Register primary command (plugin name)
+            primary_command = CommandDefinition(
+                name=metadata.name,
+                aliases=metadata.aliases or [],
+                description=metadata.description,
+                category=CommandCategory.SYSTEM,
+                mode=CommandMode.INSTANT,
+                handler=self._create_plugin_handler(metadata.name),
+                icon=metadata.icon,
+                plugin_name="fullscreen_integrator"
+            )
+
+            success = self.command_registry.register_command(primary_command)
+            if not success:
+                logger.error(f"Failed to register primary command for {metadata.name}")
+                return False
+
+            # Register alias commands if any
+            for alias in (metadata.aliases or []):
+                alias_command = CommandDefinition(
+                    name=alias,
+                    aliases=[],
+                    description=f"{metadata.description} (alias)",
+                    category=CommandCategory.SYSTEM,
+                    mode=CommandMode.INSTANT,
+                    handler=self._create_plugin_handler(metadata.name),
+                    icon=metadata.icon,
+                    plugin_name="fullscreen_integrator"
+                )
+
+                alias_success = self.command_registry.register_command(alias_command)
+                if alias_success:
+                    logger.debug(f"Registered alias command: {alias} -> {metadata.name}")
+                else:
+                    logger.warning(f"Failed to register alias command: {alias}")
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Error registering commands for {plugin_class.__name__}: {e}")
+            return False
+
+    def _create_plugin_handler(self, plugin_name: str):
+        """Create a command handler for a specific plugin.
+
+        Args:
+            plugin_name: Name of the plugin to handle
+
+        Returns:
+            Async command handler function
+        """
+        async def handler(command):
+            """Handle command execution for fullscreen plugin."""
+            try:
+                # Get or create fullscreen manager
+                if not self._fullscreen_manager:
+                    from . import FullScreenManager
+                    self._fullscreen_manager = FullScreenManager(self.event_bus, None)
+
+                # Get or create plugin instance
+                if plugin_name not in self.plugin_instances:
+                    plugin_class = self.registered_plugins.get(plugin_name)
+                    if not plugin_class:
+                        raise ValueError(f"Plugin class not found: {plugin_name}")
+
+                    plugin_instance = plugin_class()
+                    self.plugin_instances[plugin_name] = plugin_instance
+                    self._fullscreen_manager.register_plugin(plugin_instance)
+                    logger.debug(f"Created and registered plugin instance: {plugin_name}")
+
+                # Launch the plugin
+                success = await self._fullscreen_manager.launch_plugin(plugin_name)
+
+                if success:
+                    from ..events.models import CommandResult
+                    return CommandResult(
+                        success=True,
+                        message="",  # No message to avoid display artifacts
+                        display_type="success"
+                    )
+                else:
+                    from ..events.models import CommandResult
+                    return CommandResult(
+                        success=False,
+                        message=f"Failed to launch {plugin_name} plugin",
+                        display_type="error"
+                    )
+
+            except Exception as e:
+                logger.error(f"Error executing plugin {plugin_name}: {e}")
+                from ..events.models import CommandResult
+                return CommandResult(
+                    success=False,
+                    message=f"Plugin error: {str(e)}",
+                    display_type="error"
+                )
+
+        return handler
+
+    def unregister_plugin(self, plugin_name: str) -> bool:
+        """Unregister a plugin and its commands.
+
+        Args:
+            plugin_name: Name of plugin to unregister
+
+        Returns:
+            True if successful
+        """
+        try:
+            # Remove from our tracking
+            if plugin_name in self.registered_plugins:
+                plugin_class = self.registered_plugins[plugin_name]
+                temp_instance = plugin_class()
+                metadata = temp_instance.metadata
+
+                # Unregister all commands for this plugin
+                self.command_registry.unregister_command(metadata.name)
+                for alias in (metadata.aliases or []):
+                    self.command_registry.unregister_command(alias)
+
+                del self.registered_plugins[plugin_name]
+
+                if plugin_name in self.plugin_instances:
+                    del self.plugin_instances[plugin_name]
+
+                logger.info(f"Unregistered plugin: {plugin_name}")
+                return True
+
+            return False
+
+        except Exception as e:
+            logger.error(f"Error unregistering plugin {plugin_name}: {e}")
+            return False
+
+    def get_registered_plugins(self) -> List[str]:
+        """Get list of registered plugin names.
+
+        Returns:
+            List of plugin names
+        """
+        return list(self.registered_plugins.keys())
+
+    def reload_plugins(self, plugins_dir: Path) -> int:
+        """Reload all fullscreen plugins from directory.
+
+        Args:
+            plugins_dir: Base plugins directory
+
+        Returns:
+            Number of plugins reloaded
+        """
+        # Unregister all current plugins
+        for plugin_name in list(self.registered_plugins.keys()):
+            self.unregister_plugin(plugin_name)
+
+        # Re-discover and register
+        return self.discover_and_register_plugins(plugins_dir)

core/fullscreen/components/__init__.py

@@ -0,0 +1,12 @@
+"""Full-screen plugin components and utilities."""
+
+from .drawing import DrawingPrimitives
+from .animation import AnimationFramework
+from .matrix_components import MatrixColumn, MatrixRenderer
+
+__all__ = [
+    "DrawingPrimitives",
+    "AnimationFramework",
+    "MatrixColumn",
+    "MatrixRenderer"
+]