kollabor 0.4.9__py3-none-any.whl → 0.4.15__py3-none-any.whl

core/events/executor.py

@@ -3,32 +3,74 @@
 import asyncio
 import logging
 import time
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 from .models import Event, Hook, HookStatus
 from ..utils.error_utils import log_and_continue
 
 logger = logging.getLogger(__name__)
 
+# Configuration constants with safe limits
+DEFAULT_HOOK_TIMEOUT = 30
+DEFAULT_HOOK_RETRIES = 3
+DEFAULT_ERROR_ACTION = "continue"
+ABSOLUTE_MAX_RETRIES = 10
+MIN_TIMEOUT = 1
+MAX_TIMEOUT = 300  # 5 minutes
+VALID_ERROR_ACTIONS = {"continue", "stop"}
+
+# Absolute maximum time for all retry attempts combined (5 minutes)
+MAX_TOTAL_RETRY_DURATION = 300
+
 
 class HookExecutor:
     """Executes individual hooks with timeout and error handling.
-    
+
     This class is responsible for the safe execution of a single hook,
-    including timeout management, error handling, and status tracking.
+    including timeout management, error handling, status tracking, and retry logic.
+
+    Thread Safety:
+        Uses per-hook locks to prevent concurrent execution of the same hook,
+        avoiding race conditions on hook status mutations.
     """
-    
-    def __init__(self):
-        """Initialize the hook executor."""
-        logger.debug("HookExecutor initialized")
-    
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """Initialize the hook executor.
+
+        Args:
+            config: Configuration dictionary for hook execution settings.
+        """
+        self.config = config or {}
+        self._hook_locks: Dict[str, asyncio.Lock] = {}
+        self._locks_lock = asyncio.Lock()  # Lock for creating locks
+        logger.debug("HookExecutor initialized with config")
+
+    async def _get_hook_lock(self, hook_key: str) -> asyncio.Lock:
+        """Get or create a lock for a specific hook.
+
+        Args:
+            hook_key: The hook identifier (plugin_name.hook_name)
+
+        Returns:
+            asyncio.Lock for the specified hook
+        """
+        if hook_key not in self._hook_locks:
+            async with self._locks_lock:
+                # Double-check after acquiring lock
+                if hook_key not in self._hook_locks:
+                    self._hook_locks[hook_key] = asyncio.Lock()
+        return self._hook_locks[hook_key]
+
     async def execute_hook(self, hook: Hook, event: Event) -> Dict[str, Any]:
-        """Execute a single hook with error handling and timeout.
-        
+        """Execute a single hook with error handling, timeout, and retry logic.
+
+        Thread-safe: Uses per-hook locks to prevent concurrent execution of the
+        same hook, avoiding race conditions on hook status mutations.
+
         Args:
             hook: The hook to execute.
             event: The event being processed.
-            
+
         Returns:
             Dictionary with execution result and metadata.
         """
@@ -38,76 +80,164 @@ class HookExecutor:
             "success": False,
             "result": None,
             "error": None,
-            "duration_ms": 0
+            "duration_ms": 0,
+            "retry_count": 0,
+            "attempts": []
         }
-        
+
         if not hook.enabled:
             result_metadata["error"] = "hook_disabled"
             logger.debug(f"Skipping disabled hook: {hook_key}")
             return result_metadata
-        
+
         if event.cancelled:
             result_metadata["error"] = "event_cancelled"
             logger.debug(f"Skipping hook due to cancelled event: {hook_key}")
             return result_metadata
-        
-        # Track execution time
-        start_time = time.time()
-        
-        try:
-            # Update hook status to working
-            hook.status = HookStatus.WORKING
-            
-            # Execute hook with timeout
-            result = await asyncio.wait_for(
-                hook.callback(event.data, event),
-                timeout=hook.timeout
-            )
-            
-            # Calculate execution time
-            end_time = time.time()
-            result_metadata["duration_ms"] = max(1, int((end_time - start_time) * 1000))
-            
-            # Mark as successful
-            hook.status = HookStatus.COMPLETED
-            result_metadata["success"] = True
-            result_metadata["result"] = result
-            # Handle data transformation if hook returns modified data
-            if isinstance(result, dict) and "data" in result:
-                self._apply_data_transformation(event, result["data"])
-                logger.debug(f"Hook {hook_key} modified event data")
-                
-        except asyncio.TimeoutError:
-            end_time = time.time()
-            result_metadata["duration_ms"] = max(1, int((end_time - start_time) * 1000))
-            result_metadata["error"] = "timeout"
-            
-            hook.status = HookStatus.TIMEOUT
-            logger.warning(f"Hook {hook_key} timed out after {hook.timeout}s")
-            
-            # Handle timeout based on error action
-            if hook.error_action == "stop":
-                event.cancelled = True
-                logger.info(f"Event cancelled due to hook timeout: {hook_key}")
-                
-        except Exception as e:
-            end_time = time.time()
-            result_metadata["duration_ms"] = max(1, int((end_time - start_time) * 1000))
-            result_metadata["error"] = str(e)
-            
-            hook.status = HookStatus.FAILED
-            log_and_continue(logger, f"executing hook {hook_key}", e)
-            
-            # Handle error based on error action
-            if hook.error_action == "stop":
-                event.cancelled = True
-                logger.info(f"Event cancelled due to hook error: {hook_key}")
-        
+
+        # Acquire lock to prevent concurrent execution of the same hook
+        hook_lock = await self._get_hook_lock(hook_key)
+        async with hook_lock:
+            # Apply fallback defaults if values are None (for hooks created without registration)
+            hooks_config = self.config.get("hooks", {})
+            timeout = hook.timeout if hook.timeout is not None else hooks_config.get("default_timeout", DEFAULT_HOOK_TIMEOUT)
+            retry_attempts = hook.retry_attempts if hook.retry_attempts is not None else hooks_config.get("default_retries", DEFAULT_HOOK_RETRIES)
+            error_action = hook.error_action if hook.error_action is not None else hooks_config.get("default_error_action", DEFAULT_ERROR_ACTION)
+
+            # Validate and clamp timeout
+            if not isinstance(timeout, (int, float)) or timeout < MIN_TIMEOUT:
+                logger.warning(f"Invalid timeout {timeout} for {hook_key}, using minimum: {MIN_TIMEOUT}")
+                timeout = MIN_TIMEOUT
+            elif timeout > MAX_TIMEOUT:
+                logger.warning(f"Timeout {timeout} exceeds maximum for {hook_key}, capping at: {MAX_TIMEOUT}")
+                timeout = MAX_TIMEOUT
+
+            # Validate and cap retry attempts
+            if not isinstance(retry_attempts, int) or retry_attempts < 0:
+                logger.warning(f"Invalid retry_attempts {retry_attempts} for {hook_key}, using default: {DEFAULT_HOOK_RETRIES}")
+                retry_attempts = DEFAULT_HOOK_RETRIES
+            elif retry_attempts > ABSOLUTE_MAX_RETRIES:
+                logger.warning(
+                    f"Retry attempts {retry_attempts} exceeds absolute maximum for {hook_key}, "
+                    f"capping at: {ABSOLUTE_MAX_RETRIES}"
+                )
+                retry_attempts = ABSOLUTE_MAX_RETRIES
+
+            # Validate error_action
+            if error_action not in VALID_ERROR_ACTIONS:
+                logger.error(
+                    f"Invalid error_action '{error_action}' for {hook_key}, "
+                    f"must be one of {VALID_ERROR_ACTIONS}. Using default: '{DEFAULT_ERROR_ACTION}'"
+                )
+                error_action = DEFAULT_ERROR_ACTION
+
+            # Track overall execution time
+            overall_start = time.time()
+
+            # Retry loop with exponential backoff and absolute timeout
+            max_attempts = retry_attempts + 1  # Initial attempt + retries
+            for attempt in range(max_attempts):
+                # Check if we've exceeded the absolute maximum retry duration
+                elapsed_time = time.time() - overall_start
+                if elapsed_time > MAX_TOTAL_RETRY_DURATION:
+                    logger.error(
+                        f"Hook {hook_key} exceeded maximum total retry duration "
+                        f"({MAX_TOTAL_RETRY_DURATION}s). Aborting after {attempt} attempts."
+                    )
+                    result_metadata["error"] = "max_retry_duration_exceeded"
+                    result_metadata["retry_count"] = attempt
+                    break
+
+                attempt_start = time.time()
+                attempt_info = {"attempt": attempt + 1, "duration_ms": 0, "success": False, "error": None}
+
+                try:
+                    # Update hook status to working
+                    hook.status = HookStatus.WORKING
+
+                    # Execute hook with timeout
+                    result = await asyncio.wait_for(
+                        hook.callback(event.data, event),
+                        timeout=timeout
+                    )
+
+                    # Calculate attempt execution time
+                    attempt_end = time.time()
+                    attempt_info["duration_ms"] = max(1, int((attempt_end - attempt_start) * 1000))
+                    attempt_info["success"] = True
+                    result_metadata["attempts"].append(attempt_info)
+
+                    # Mark as successful
+                    hook.status = HookStatus.COMPLETED
+                    result_metadata["success"] = True
+                    result_metadata["result"] = result
+                    result_metadata["retry_count"] = attempt
+
+                    # Handle data transformation if hook returns modified data
+                    if isinstance(result, dict) and "data" in result:
+                        self._apply_data_transformation(event, result["data"])
+                        logger.debug(f"Hook {hook_key} modified event data")
+
+                    # Success - break out of retry loop
+                    break
+
+                except asyncio.TimeoutError:
+                    attempt_end = time.time()
+                    attempt_info["duration_ms"] = max(1, int((attempt_end - attempt_start) * 1000))
+                    attempt_info["error"] = "timeout"
+                    result_metadata["attempts"].append(attempt_info)
+
+                    hook.status = HookStatus.TIMEOUT
+                    logger.warning(f"Hook {hook_key} timed out after {timeout}s (attempt {attempt + 1}/{max_attempts})")
+
+                    # On final attempt, mark as error
+                    if attempt == max_attempts - 1:
+                        result_metadata["error"] = "timeout"
+                        result_metadata["retry_count"] = attempt
+
+                        # Handle timeout based on error action
+                        if error_action == "stop":
+                            event.cancelled = True
+                            logger.info(f"Event cancelled due to hook timeout: {hook_key}")
+                    else:
+                        # Wait before retry with exponential backoff
+                        backoff_delay = min(2 ** attempt, 30)  # Max 30 seconds
+                        logger.debug(f"Retrying hook {hook_key} in {backoff_delay}s")
+                        await asyncio.sleep(backoff_delay)
+
+                except Exception as e:
+                    attempt_end = time.time()
+                    attempt_info["duration_ms"] = max(1, int((attempt_end - attempt_start) * 1000))
+                    attempt_info["error"] = str(e)
+                    result_metadata["attempts"].append(attempt_info)
+
+                    hook.status = HookStatus.FAILED
+                    log_and_continue(logger, f"executing hook {hook_key} (attempt {attempt + 1}/{max_attempts})", e)
+
+                    # On final attempt, mark as error
+                    if attempt == max_attempts - 1:
+                        result_metadata["error"] = str(e)
+                        result_metadata["retry_count"] = attempt
+
+                        # Handle error based on error action
+                        if error_action == "stop":
+                            event.cancelled = True
+                            logger.info(f"Event cancelled due to hook error: {hook_key}")
+                    else:
+                        # Wait before retry with exponential backoff
+                        backoff_delay = min(2 ** attempt, 30)  # Max 30 seconds
+                        logger.debug(f"Retrying hook {hook_key} in {backoff_delay}s after error: {e}")
+                        await asyncio.sleep(backoff_delay)
+
+            # Calculate total execution time including retries
+            overall_end = time.time()
+            result_metadata["duration_ms"] = max(1, int((overall_end - overall_start) * 1000))
+
         return result_metadata
-    
+
     def _apply_data_transformation(self, event: Event, hook_data: Dict[str, Any]) -> None:
         """Apply data transformation from hook result to event.
-        
+
         Args:
             event: The event to modify.
             hook_data: Data transformation from hook.
@@ -119,13 +249,13 @@ class HookExecutor:
                 logger.warning(f"Hook returned non-dict data transformation: {type(hook_data)}")
         except Exception as e:
             log_and_continue(logger, "applying hook data transformation", e)
-    
+
     def get_execution_stats(self, results: List[Dict[str, Any]]) -> Dict[str, Any]:
         """Get execution statistics from a list of hook results.
-        
+
         Args:
             results: List of hook execution results.
-            
+
         Returns:
             Dictionary with execution statistics.
         """
@@ -138,12 +268,12 @@ class HookExecutor:
                 "total_duration_ms": 0,
                 "avg_duration_ms": 0
             }
-        
+
         successful = sum(1 for r in results if r.get("success", False))
         failed = sum(1 for r in results if r.get("error") and r["error"] not in ["timeout", "hook_disabled", "event_cancelled"])
         timed_out = sum(1 for r in results if r.get("error") == "timeout")
         total_duration = sum(r.get("duration_ms", 0) for r in results)
-        
+
         return {
             "total_hooks": len(results),
             "successful": successful,
@@ -151,4 +281,4 @@ class HookExecutor:
             "timed_out": timed_out,
             "total_duration_ms": total_duration,
             "avg_duration_ms": int(total_duration / len(results)) if results else 0
-        }
+        }

core/events/models.py

@@ -88,6 +88,14 @@ class EventType(Enum):
     # Command output display events
     COMMAND_OUTPUT_DISPLAY = "command_output_display"
 
+    # Message injection events (SDK extension points)
+    ADD_MESSAGE = "add_message"
+    PRE_MESSAGE_INJECT = "pre_message_inject"
+    POST_MESSAGE_INJECT = "post_message_inject"
+
+    # LLM continuation control (SDK extension point)
+    TRIGGER_LLM_CONTINUE = "trigger_llm_continue"
+
     # Command menu events (enhanced)
     COMMAND_MENU_FILTER = "command_menu_filter"
 
@@ -96,6 +104,7 @@ class EventType(Enum):
     STATUS_MODAL_TRIGGER = "status_modal_trigger"
     STATUS_MODAL_RENDER = "status_modal_render"
     LIVE_MODAL_TRIGGER = "live_modal_trigger"
+    MODAL_COMMAND_SELECTED = "modal_command_selected"
 
     # Rendering control events
     PAUSE_RENDERING = "pause_rendering"
@@ -113,10 +122,11 @@ class EventType(Enum):
     STATUS_TAKEOVER_END = "status_takeover_end"
 
 
+
 @dataclass
 class Hook:
     """Hook definition for the event system.
-    
+
     Attributes:
         name: Unique name for the hook.
         plugin_name: Name of the plugin that owns this hook.
@@ -124,9 +134,9 @@ class Hook:
         priority: Execution priority (higher numbers execute first).
         callback: Async function to call when event occurs.
         enabled: Whether the hook is currently enabled.
-        timeout: Maximum execution time in seconds.
-        retry_attempts: Number of retry attempts on failure.
-        error_action: Action to take on error ("continue" or "stop").
+        timeout: Maximum execution time in seconds (None = use config default, then 30).
+        retry_attempts: Number of retry attempts on failure (None = use config default, then 3).
+        error_action: Action to take on error (None = use config default, then "continue").
         status: Current execution status.
         status_area: Status area identifier.
         icon_set: Icons for different states.
@@ -137,13 +147,13 @@ class Hook:
     priority: int
     callback: Callable
     enabled: bool = True
-    timeout: int = 30
-    retry_attempts: int = 3
-    error_action: str = "continue"
+    timeout: Optional[int] = None
+    retry_attempts: Optional[int] = None
+    error_action: Optional[str] = None
     status: HookStatus = HookStatus.PENDING
     status_area: str = "A"
     icon_set: Dict[str, str] = field(default_factory=lambda: {
-        "thinking": "[THINK]", "processing": "[PROC]", "complete": "[OK]", "error": "[ERR]"
+        "thinking": "[think]", "processing": "[proc]", "complete": "[ok]", "error": "[err]"
     })
 
 
@@ -219,6 +229,14 @@ class ParameterDefinition:
     validation: Optional[str] = None
 
 
+@dataclass
+class SubcommandInfo:
+    """Info about a subcommand for menu display."""
+    name: str
+    args: str  # e.g., "<name> <command>" or "[name]"
+    description: str
+
+
 @dataclass
 class CommandDefinition:
     """Complete definition of a slash command."""
@@ -234,6 +252,7 @@ class CommandDefinition:
     icon: str = ""
     hidden: bool = False
     enabled: bool = True
+    subcommands: List[SubcommandInfo] = field(default_factory=list)
 
 
 @dataclass

core/fullscreen/command_integration.py

@@ -27,15 +27,22 @@ class FullScreenCommandIntegrator:
     - Maps commands to plugin execution
     """
 
-    def __init__(self, command_registry: SlashCommandRegistry, event_bus):
+    def __init__(self, command_registry: SlashCommandRegistry, event_bus,
+                 config=None, profile_manager=None, terminal_renderer=None):
         """Initialize the fullscreen command integrator.
 
         Args:
             command_registry: Slash command registry for registration
             event_bus: Event bus for communication
+            config: Optional config service for plugins that need it
+            profile_manager: Optional profile manager for plugins that need it
+            terminal_renderer: Optional terminal renderer for fullscreen manager
         """
         self.command_registry = command_registry
         self.event_bus = event_bus
+        self.config = config
+        self.profile_manager = profile_manager
+        self.terminal_renderer = terminal_renderer
         self.registered_plugins: Dict[str, Type[FullScreenPlugin]] = {}
         self.plugin_instances: Dict[str, FullScreenPlugin] = {}
         self._fullscreen_manager = None
@@ -136,7 +143,7 @@ class FullScreenCommandIntegrator:
                 name=metadata.name,
                 aliases=metadata.aliases or [],
                 description=metadata.description,
-                category=CommandCategory.SYSTEM,
+                category=CommandCategory.CUSTOM,  # Fullscreen plugins are custom/plugins
                 mode=CommandMode.INSTANT,
                 handler=self._create_plugin_handler(metadata.name),
                 icon=metadata.icon,
@@ -148,24 +155,10 @@ class FullScreenCommandIntegrator:
                 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}")
+            # Aliases are stored in the primary command's aliases field
+            # No need to register them separately - registry handles alias lookups
+            if metadata.aliases:
+                logger.debug(f"Command {metadata.name} has aliases: {metadata.aliases}")
 
             return True
 
@@ -188,7 +181,7 @@ class FullScreenCommandIntegrator:
                 # Get or create fullscreen manager
                 if not self._fullscreen_manager:
                     from . import FullScreenManager
-                    self._fullscreen_manager = FullScreenManager(self.event_bus, None)
+                    self._fullscreen_manager = FullScreenManager(self.event_bus, self.terminal_renderer)
 
                 # Get or create plugin instance
                 if plugin_name not in self.plugin_instances:
@@ -197,6 +190,11 @@ class FullScreenCommandIntegrator:
                         raise ValueError(f"Plugin class not found: {plugin_name}")
 
                     plugin_instance = plugin_class()
+
+                    # Pass managers to plugins that need them (e.g., setup wizard)
+                    if hasattr(plugin_instance, 'set_managers'):
+                        plugin_instance.set_managers(self.config, self.profile_manager)
+
                     self.plugin_instances[plugin_name] = plugin_instance
                     self._fullscreen_manager.register_plugin(plugin_instance)
                     logger.debug(f"Created and registered plugin instance: {plugin_name}")
@@ -246,10 +244,8 @@ class FullScreenCommandIntegrator:
                 temp_instance = plugin_class()
                 metadata = temp_instance.metadata
 
-                # Unregister all commands for this plugin
+                # Unregister the primary command (aliases are handled by registry)
                 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]
 

core/fullscreen/components/__init__.py

@@ -3,10 +3,19 @@
 from .drawing import DrawingPrimitives
 from .animation import AnimationFramework
 from .matrix_components import MatrixColumn, MatrixRenderer
+from .space_shooter_components import (
+    Star, Ship, Enemy, Laser, Explosion, SpaceShooterRenderer
+)
 
 __all__ = [
     "DrawingPrimitives",
     "AnimationFramework",
     "MatrixColumn",
-    "MatrixRenderer"
+    "MatrixRenderer",
+    "Star",
+    "Ship",
+    "Enemy",
+    "Laser",
+    "Explosion",
+    "SpaceShooterRenderer"
 ]

core/fullscreen/components/matrix_components.py

@@ -168,8 +168,7 @@ class MatrixRenderer:
         for column in self.columns:
             column.render(renderer)
 
-        # Flush output
-        renderer.flush()
+        # Note: Flushing is handled by session's end_frame() for flicker-free rendering
 
     def reset(self):
         """Reset the Matrix renderer."""