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

core/io/key_parser.py

@@ -1,3 +1,10 @@
+"""Keyboard input parsing for terminal applications.
+
+This module provides comprehensive keyboard input parsing, including
+single character input, control key detection, and escape sequence
+handling for terminal applications.
+"""
+
 import logging
 from dataclasses import dataclass
 from enum import Enum

core/io/layout.py

@@ -1,4 +1,8 @@
-"""Layout management system for terminal rendering."""
+"""Layout management system for terminal rendering.
+
+This module provides comprehensive layout management for terminal rendering,
+including area management, adaptive sizing, and thinking animation support.
+"""
 
 import re
 from collections import deque
@@ -166,16 +170,24 @@ class ThinkingAnimationManager:
         Returns:
             List of formatted display lines.
         """
+        import time
+
         if not self.is_active or not self.messages:
             return []
 
         lines = []
         spinner = self.get_next_frame()
 
+        # Calculate elapsed time
+        elapsed = ""
+        if self.start_time:
+            duration = time.time() - self.start_time
+            elapsed = f" ({duration:.0f}s - esc to cancel)"
+
         for i, msg in enumerate(self.messages):
             if i == len(self.messages) - 1:
-                # Main thinking line with spinner
-                formatted_text = apply_effect_func(f"{spinner} Thinking: {msg}")
+                # Main thinking line with spinner and elapsed time
+                formatted_text = apply_effect_func(f"{spinner} Thinking{elapsed}: {msg}")
                 lines.append(formatted_text)
             else:
                 # Secondary thinking line

core/io/message_coordinator.py

@@ -3,22 +3,30 @@
 This coordinator solves the fundamental race condition where multiple
 message writing systems interfere with each other, causing messages
 to be overwritten or cleared unexpectedly.
+
+IMPORTANT: All terminal state changes (input rendering, clearing, buffer
+transitions) should go through this coordinator to prevent state bugs.
+
+This module provides atomic message display coordination and unified
+state management to prevent interference between different message
+writing systems.
 """
 
 import logging
-from typing import List, Tuple, Dict, Any
+from typing import List, Tuple, Dict, Any, Optional
 
 logger = logging.getLogger(__name__)
 
 
 class MessageDisplayCoordinator:
-    """Coordinates message display to prevent interference between systems.
+    """Coordinates message display AND render state to prevent interference.
 
     Key Features:
     - Atomic message sequences (all messages display together)
     - Unified state management (prevents clearing conflicts)
     - Proper ordering (system messages before responses)
     - Protection from interference (no race conditions)
+    - Buffer transition management (modal open/close state preservation)
     """
 
     def __init__(self, terminal_renderer):
@@ -31,8 +39,26 @@ class MessageDisplayCoordinator:
         self.message_queue: List[Tuple[str, str, Dict[str, Any]]] = []
         self.is_displaying = False
 
+        # Saved state for buffer transitions (modal, fullscreen, etc.)
+        self._saved_main_buffer_state: Optional[Dict[str, Any]] = None
+        self._in_alternate_buffer = False
+
         logger.debug("MessageDisplayCoordinator initialized")
 
+    def _capture_render_state(self) -> Dict[str, Any]:
+        """Capture current render state for later restoration.
+
+        Returns:
+            Dictionary containing render state snapshot.
+        """
+        return {
+            "writing_messages": self.terminal_renderer.writing_messages,
+            "input_line_written": self.terminal_renderer.input_line_written,
+            "last_line_count": self.terminal_renderer.last_line_count,
+            "conversation_active": self.terminal_renderer.conversation_active,
+            "thinking_active": self.terminal_renderer.thinking_active,
+        }
+
     def queue_message(self, message_type: str, content: str, **kwargs) -> None:
         """Queue a message for coordinated display.
 
@@ -92,6 +118,11 @@ class MessageDisplayCoordinator:
             self.terminal_renderer.writing_messages = False
             self.message_queue.clear()
             self.is_displaying = False
+            # Reset render state for clean input box rendering
+            # This prevents duplicate input boxes when render loop resumes
+            self.terminal_renderer.input_line_written = False
+            self.terminal_renderer.last_line_count = 0
+            self.terminal_renderer.invalidate_render_cache()
             logger.debug("Completed atomic message display")
 
     def display_message_sequence(
@@ -169,6 +200,16 @@ class MessageDisplayCoordinator:
                     format_style=MessageFormat.HIGHLIGHTED,  # Uses red color from _format_highlighted
                     **kwargs,
                 )
+            elif message_type == "info":
+                # For info messages, use MessageType.SYSTEM with plain format
+                from .message_renderer import MessageType, MessageFormat
+
+                self.terminal_renderer.message_renderer.conversation_renderer.write_message(
+                    content,
+                    message_type=MessageType.SYSTEM,
+                    format_style=MessageFormat.PLAIN,
+                    **kwargs,
+                )
             else:
                 logger.warning(f"Unknown message type: {message_type}")
                 # Fallback to regular message
@@ -202,3 +243,71 @@ class MessageDisplayCoordinator:
             "is_displaying": self.is_displaying,
             "queued_types": [msg[0] for msg in self.message_queue],
         }
+
+    # === Buffer Transition Management ===
+    # These methods handle state preservation during modal/fullscreen transitions
+
+    def enter_alternate_buffer(self) -> None:
+        """Mark entering alternate buffer and pause render loop.
+
+        Call this BEFORE opening a modal or entering fullscreen mode.
+        Captures current render state for potential restoration.
+        """
+        if self._in_alternate_buffer:
+            logger.warning("Already in alternate buffer")
+            return
+
+        # Capture state BEFORE modifying anything
+        self._saved_main_buffer_state = self._capture_render_state()
+        logger.debug(f"Captured render state: {self._saved_main_buffer_state}")
+
+        self._in_alternate_buffer = True
+        # Prevent render loop interference during modal
+        self.terminal_renderer.writing_messages = True
+        logger.debug("Entered alternate buffer mode")
+
+    def exit_alternate_buffer(self, restore_state: bool = False) -> None:
+        """Exit alternate buffer mode and reset render state.
+
+        Call this AFTER closing a modal or exiting fullscreen mode.
+
+        Args:
+            restore_state: If True, restore captured state. If False (default),
+                          reset to clean state for fresh input rendering.
+        """
+        if not self._in_alternate_buffer:
+            logger.warning("Not in alternate buffer")
+            return
+
+        self._in_alternate_buffer = False
+
+        if restore_state and self._saved_main_buffer_state:
+            # Restore previously captured state
+            self.terminal_renderer.writing_messages = self._saved_main_buffer_state[
+                "writing_messages"
+            ]
+            self.terminal_renderer.input_line_written = self._saved_main_buffer_state[
+                "input_line_written"
+            ]
+            self.terminal_renderer.last_line_count = self._saved_main_buffer_state[
+                "last_line_count"
+            ]
+            logger.debug(f"Restored render state: {self._saved_main_buffer_state}")
+        else:
+            # Reset to clean state (default - prevents duplicate input boxes)
+            self.terminal_renderer.writing_messages = False
+            self.terminal_renderer.input_line_written = False
+            self.terminal_renderer.last_line_count = 0
+            logger.debug("Reset to clean render state")
+
+        # Always invalidate cache after buffer transition
+        self.terminal_renderer.invalidate_render_cache()
+        self._saved_main_buffer_state = None
+
+    def get_saved_state(self) -> Optional[Dict[str, Any]]:
+        """Get the saved render state (for debugging).
+
+        Returns:
+            Saved state dict if in alternate buffer, None otherwise.
+        """
+        return self._saved_main_buffer_state

core/io/message_renderer.py

@@ -1,6 +1,12 @@
-"""Message rendering system for conversation display."""
+"""Message rendering system for conversation display.
+
+This module provides comprehensive message rendering for conversation display,
+including message formatting, conversation buffer management, and streaming
+response support.
+"""
 
 import logging
+import re
 from collections import deque
 from dataclasses import dataclass
 from enum import Enum
@@ -10,6 +16,102 @@ from typing import List, Optional, Dict, Any, Callable
 logger = logging.getLogger(__name__)
 
 
+class DisplayFilterRegistry:
+    """Registry for message display filters.
+
+    Plugins can register filter functions that transform message content
+    before display. This allows plugins to strip/transform their own
+    XML commands without hardcoding patterns in core.
+
+    Example:
+        # In plugin initialize():
+        DisplayFilterRegistry.register(
+            "my_plugin",
+            self._strip_my_xml,
+            message_types=[MessageType.ASSISTANT]
+        )
+
+        # Filter function signature:
+        def _strip_my_xml(content: str, message_type: 'MessageType') -> str:
+            return re.sub(r"<my-tag>.*?</my-tag>", "", content)
+    """
+
+    _filters: Dict[str, Dict[str, Any]] = {}
+
+    @classmethod
+    def register(
+        cls,
+        name: str,
+        filter_fn: Callable[[str, "MessageType"], str],
+        message_types: Optional[List["MessageType"]] = None,
+        priority: int = 100,
+    ) -> None:
+        """Register a display filter.
+
+        Args:
+            name: Unique name for this filter (usually plugin name).
+            filter_fn: Function that takes (content, message_type) and returns transformed content.
+            message_types: List of message types to apply filter to (None = all types).
+            priority: Execution priority (higher = runs first).
+        """
+        cls._filters[name] = {
+            "fn": filter_fn,
+            "message_types": message_types,
+            "priority": priority,
+        }
+        logger.debug(f"Registered display filter: {name}")
+
+    @classmethod
+    def unregister(cls, name: str) -> None:
+        """Unregister a display filter.
+
+        Args:
+            name: Name of the filter to remove.
+        """
+        if name in cls._filters:
+            del cls._filters[name]
+            logger.debug(f"Unregistered display filter: {name}")
+
+    @classmethod
+    def apply_filters(cls, content: str, message_type: "MessageType") -> str:
+        """Apply all registered filters to content.
+
+        Args:
+            content: Original message content.
+            message_type: Type of message being displayed.
+
+        Returns:
+            Transformed content after all applicable filters.
+        """
+        if not cls._filters:
+            return content
+
+        # Sort by priority (higher first)
+        sorted_filters = sorted(
+            cls._filters.items(),
+            key=lambda x: x[1]["priority"],
+            reverse=True,
+        )
+
+        for name, filter_info in sorted_filters:
+            # Check if filter applies to this message type
+            allowed_types = filter_info["message_types"]
+            if allowed_types is not None and message_type not in allowed_types:
+                continue
+
+            try:
+                content = filter_info["fn"](content, message_type)
+            except Exception as e:
+                logger.error(f"Display filter '{name}' failed: {e}")
+
+        return content
+
+    @classmethod
+    def clear(cls) -> None:
+        """Clear all registered filters (useful for testing)."""
+        cls._filters.clear()
+
+
 class MessageType(Enum):
     """Types of messages in conversation."""
 
@@ -281,12 +383,19 @@ class ConversationRenderer:
             immediate_display: Whether to display immediately.
             **metadata: Additional message metadata.
         """
+        # Apply registered display filters (plugins can strip their XML commands)
+        display_content = DisplayFilterRegistry.apply_filters(content, message_type)
+        display_content = display_content.strip()
+
+        if not display_content:
+            return  # Nothing to display after filtering
+
         # Add to buffer
-        self.buffer.add_message(content, message_type, format_style, **metadata)
+        self.buffer.add_message(display_content, message_type, format_style, **metadata)
 
         # Display immediately if requested
         if immediate_display:
-            self._display_message_immediately(content, message_type, format_style)
+            self._display_message_immediately(display_content, message_type, format_style)
 
     def start_streaming_response(self) -> None:
         """Start a streaming response by setting up the display area."""
@@ -308,8 +417,19 @@ class ConversationRenderer:
             content: User message content.
             **metadata: Additional metadata.
         """
+        # Strip hidden system message blocks (used for plugin instruction injection)
+        display_content = re.sub(
+            r"<sys_msg>.*?</sys_msg>\s*",
+            "",
+            content,
+            flags=re.DOTALL,
+        ).strip()
+
+        if not display_content:
+            return  # Nothing to display after stripping
+
         self.write_message(
-            content, MessageType.USER, MessageFormat.GRADIENT, **metadata
+            display_content, MessageType.USER, MessageFormat.GRADIENT, **metadata
         )
 
     def write_system_message(self, content: str, **metadata) -> None:
@@ -391,6 +511,11 @@ class ConversationRenderer:
 
         try:
             # Write to terminal
+            line_count = formatted_content.count('\n') + 1
+            logger.info(
+                f"DISPLAY: Printing {message_type.value} message: "
+                f"{len(content)} chars, {line_count} lines"
+            )
             print(formatted_content, flush=self.flush_immediately)
             # Add blank line for visual separation between messages
             print("", flush=self.flush_immediately)