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

core/fullscreen/renderer.py

@@ -51,6 +51,10 @@ class FullScreenRenderer:
         self.terminal_width = 80
         self.terminal_height = 24
 
+        # Frame buffering to eliminate flicker
+        self._frame_buffer = []
+        self._buffering_enabled = False
+
         logger.info("FullScreenRenderer initialized")
 
     def setup_terminal(self) -> bool:
@@ -163,10 +167,43 @@ class FullScreenRenderer:
             logger.error(f"Failed to restore terminal: {e}")
             return False
 
+    def begin_frame(self):
+        """Begin a new frame with buffering enabled.
+
+        All writes will be buffered until end_frame() is called.
+        This eliminates flicker by making the entire frame update atomic.
+        """
+        self._frame_buffer = []
+        self._buffering_enabled = True
+
+    def end_frame(self):
+        """End the current frame and flush all buffered writes.
+
+        Writes the entire buffered frame as a single operation,
+        eliminating visible flickering.
+        """
+        if self._buffering_enabled and self._frame_buffer:
+            # Write entire frame as single operation
+            sys.stdout.write(''.join(self._frame_buffer))
+            sys.stdout.flush()
+            self._frame_buffer = []
+        self._buffering_enabled = False
+
+    def _write(self, text: str):
+        """Internal write method that respects buffering.
+
+        Args:
+            text: Text to write (can include ANSI codes)
+        """
+        if self._buffering_enabled:
+            self._frame_buffer.append(text)
+        else:
+            sys.stdout.write(text)
+            sys.stdout.flush()
+
     def clear_screen(self):
         """Clear the entire screen."""
-        sys.stdout.write("\033[2J\033[H")
-        sys.stdout.flush()
+        self._write("\033[2J\033[H")
 
     def clear_line(self, row: int):
         """Clear a specific line.
@@ -174,8 +211,7 @@ class FullScreenRenderer:
         Args:
             row: Row number (1-based).
         """
-        sys.stdout.write(f"\033[{row};1H\033[K")
-        sys.stdout.flush()
+        self._write(f"\033[{row};1H\033[K")
 
     def move_cursor(self, x: int, y: int):
         """Move cursor to specific position.
@@ -184,15 +220,15 @@ class FullScreenRenderer:
             x: Column position (0-based).
             y: Row position (0-based).
         """
-        sys.stdout.write(f"\033[{y+1};{x+1}H")
+        self._write(f"\033[{y+1};{x+1}H")
 
     def hide_cursor(self):
         """Hide the cursor."""
-        sys.stdout.write("\033[?25l")
+        self._write("\033[?25l")
 
     def show_cursor(self):
         """Show the cursor."""
-        sys.stdout.write("\033[?25h")
+        self._write("\033[?25h")
 
     def write_raw(self, text: str):
         """Write raw text to terminal.
@@ -200,8 +236,7 @@ class FullScreenRenderer:
         Args:
             text: Text to write (can include ANSI codes).
         """
-        sys.stdout.write(text)
-        sys.stdout.flush()
+        self._write(text)
 
     def write_at(self, x: int, y: int, text: str, color: str = ColorPalette.RESET):
         """Write text at specific position with optional color.
@@ -214,8 +249,7 @@ class FullScreenRenderer:
         """
         if 0 <= x < self.terminal_width and 0 <= y < self.terminal_height:
             self.move_cursor(x, y)
-            sys.stdout.write(f"{color}{text}{ColorPalette.RESET}")
-            sys.stdout.flush()
+            self._write(f"{color}{text}{ColorPalette.RESET}")
 
     def draw_box(self, x: int, y: int, width: int, height: int,
                  border_color: str = ColorPalette.WHITE,
@@ -278,5 +312,10 @@ class FullScreenRenderer:
         return self.active
 
     def flush(self):
-        """Flush output buffer."""
-        sys.stdout.flush()
+        """Flush output buffer.
+
+        If frame buffering is enabled, this does nothing.
+        Use end_frame() to flush buffered content.
+        """
+        if not self._buffering_enabled:
+            sys.stdout.flush()

core/fullscreen/session.py

@@ -44,18 +44,19 @@ class FullScreenSession:
     including terminal setup, input handling, rendering loop, and cleanup.
     """
 
-    def __init__(self, plugin: FullScreenPlugin, event_bus=None, target_fps: float = 60.0):
+    def __init__(self, plugin: FullScreenPlugin, event_bus=None, target_fps: float = None):
         """Initialize a full-screen session.
 
         Args:
             plugin: The plugin to run.
             event_bus: Event bus for input routing (optional, falls back to direct stdin).
-            target_fps: Target frame rate for rendering.
+            target_fps: Target frame rate for rendering (None = use plugin's target_fps).
         """
         self.plugin = plugin
         self.event_bus = event_bus
-        self.target_fps = target_fps
-        self.frame_delay = 1.0 / target_fps
+        # Use plugin's target_fps if not explicitly overridden
+        self.target_fps = target_fps if target_fps is not None else getattr(plugin, 'target_fps', 20.0)
+        self.frame_delay = 1.0 / self.target_fps
 
         # Session state
         self.running = False
@@ -93,17 +94,14 @@ class FullScreenSession:
     async def _handle_fullscreen_input(self, event_data, context=None):
         """Handle FULLSCREEN_INPUT events from InputHandler."""
         try:
-            print(f"🎯 CRITICAL: Session received FULLSCREEN_INPUT event: {event_data}")
             key_press = event_data.get('key_press')
             if key_press:
-                print(f"🎯 CRITICAL: Adding key to pending_input queue: {key_press.name} ({key_press.char})")
-                logger.info(f"🎯 Session received input: {key_press.name}")
+                logger.debug(f"Session received input: {key_press.name}")
                 await self.pending_input.put(key_press)
                 return {"success": True, "handled": True}
-            print(f"❌ CRITICAL: No key_press in event data: {event_data}")
+            logger.warning("No key_press in FULLSCREEN_INPUT event data")
             return {"success": False, "error": "No key_press in event data"}
         except Exception as e:
-            print(f"❌ CRITICAL: Exception in _handle_fullscreen_input: {e}")
             logger.error(f"Error handling fullscreen input: {e}")
             return {"success": False, "error": str(e)}
 
@@ -181,8 +179,16 @@ class FullScreenSession:
                 if await self._handle_input():
                     break  # Exit requested
 
+                # Begin buffered frame (eliminates flicker)
+                self.renderer.begin_frame()
+
                 # Render frame
-                if not await self.plugin.render_frame(delta_time):
+                should_continue = await self.plugin.render_frame(delta_time)
+
+                # End frame and flush all buffered writes atomically
+                self.renderer.end_frame()
+
+                if not should_continue:
                     break  # Plugin requested exit
 
                 self.stats.frame_count += 1
@@ -202,6 +208,17 @@ class FullScreenSession:
             True if exit was requested, False otherwise.
         """
         try:
+            # Priority 1: Check pending_input queue (from event-routed input)
+            try:
+                key_press = self.pending_input.get_nowait()
+                if key_press:
+                    logger.info(f"Processing queued input: {key_press.name} ({key_press.char})")
+                    self.stats.input_events += 1
+                    return await self.plugin.handle_input(key_press)
+            except asyncio.QueueEmpty:
+                pass  # No queued input, try fallback
+
+            # Priority 2: Direct stdin reading (fallback when main input loop not running)
             # Check for available input (non-blocking)
             if not sys.stdin.isatty():
                 return False
@@ -246,19 +263,39 @@ class FullScreenSession:
                 ready, _, _ = select.select([sys.stdin], [], [], 0)
                 if ready:
                     has_input = True
-                    char = sys.stdin.read(1)
+                    # Read all available characters at once
+                    import fcntl
+                    import os as os_module
+                    # Set non-blocking mode temporarily
+                    fd = sys.stdin.fileno()
+                    old_flags = fcntl.fcntl(fd, fcntl.F_GETFL)
+                    fcntl.fcntl(fd, fcntl.F_SETFL, old_flags | os_module.O_NONBLOCK)
+                    try:
+                        chars = sys.stdin.read(32)  # Read up to 32 chars
+                    except (IOError, BlockingIOError):
+                        chars = ""
+                    finally:
+                        fcntl.fcntl(fd, fcntl.F_SETFL, old_flags)
+
+                    if not chars:
+                        return False
 
-            if not has_input or not char:
+            if not has_input:
                 return False
 
             # Use the actual key parser for proper parsing
             if not hasattr(self, '_key_parser'):
                 self._key_parser = KeyParser()
 
-            # Parse the input character properly
-            key_press = self._key_parser.parse_char(char)
+            # Parse all characters through the key parser
+            key_press = None
+            for char in chars:
+                key_press = self._key_parser.parse_char(char)
+                if key_press:
+                    break
+
+            # If still no key press, check for standalone ESC
             if not key_press:
-                # Check for standalone ESC key
                 key_press = self._key_parser.check_for_standalone_escape()
                 if not key_press:
                     return False

core/io/__init__.py

@@ -1,14 +1,29 @@
-"""Input/Output subsystem for Kollabor CLI."""
+"""Input/Output subsystem for Kollabor CLI.
+
+This module provides comprehensive input/output handling for the Kollabor CLI application,
+including terminal rendering, input processing, message display, and visual effects.
+"""
 
 from .input_handler import InputHandler
 from .terminal_renderer import TerminalRenderer
 from .key_parser import KeyParser, KeyPress, KeyType
 from .buffer_manager import BufferManager
 from .input_errors import InputErrorHandler, ErrorType, ErrorSeverity
-from .visual_effects import VisualEffects, ColorPalette, EffectType
+from .visual_effects import (
+    VisualEffects,
+    ColorPalette,
+    EffectType,
+    ColorSupport,
+    get_color_support,
+    set_color_support,
+    reset_color_support,
+    detect_color_support,
+    rgb_to_256,
+    color_code,
+)
 from .terminal_state import TerminalState, TerminalCapabilities, TerminalMode
 from .layout import LayoutManager, LayoutArea, ThinkingAnimationManager
-from .status_renderer import StatusRenderer, StatusMetric, StatusFormat
+from .status_renderer import StatusRenderer, StatusViewRegistry, StatusViewConfig, BlockConfig
 from .message_renderer import (
     MessageRenderer,
     ConversationMessage,
@@ -32,6 +47,14 @@ __all__ = [
     "VisualEffects",
     "ColorPalette",
     "EffectType",
+    # Color support detection
+    "ColorSupport",
+    "get_color_support",
+    "set_color_support",
+    "reset_color_support",
+    "detect_color_support",
+    "rgb_to_256",
+    "color_code",
     # Terminal management
     "TerminalState",
     "TerminalCapabilities",
@@ -42,8 +65,9 @@ __all__ = [
     "ThinkingAnimationManager",
     # Status rendering
     "StatusRenderer",
-    "StatusMetric",
-    "StatusFormat",
+    "StatusViewRegistry",
+    "StatusViewConfig",
+    "BlockConfig",
     # Message rendering
     "MessageRenderer",
     "ConversationMessage",

core/io/buffer_manager.py

@@ -1,4 +1,9 @@
-"""Input buffer management for terminal input handling."""
+"""Input buffer management for terminal input handling.
+
+This module provides comprehensive buffer management for terminal input, including
+character insertion/deletion, cursor movement, history navigation, and
+input validation.
+"""
 
 import logging
 from typing import List, Tuple

core/io/config_status_view.py

@@ -1,9 +1,13 @@
-"""Configuration status view for displaying config errors and status."""
+"""Configuration status view for displaying config errors and status.
+
+This module provides a status view component for monitoring configuration
+errors, validation warnings, and overall configuration health status.
+"""
 
 import logging
 from typing import Dict, Any, Optional, List
 
-from .status_renderer import StatusViewConfig, StatusMetric
+from .status_renderer import StatusViewConfig
 
 logger = logging.getLogger(__name__)
 
@@ -114,7 +118,7 @@ class ConfigStatusView:
 
         # Normal status - only show if explicitly requested
         if data.get("show_normal_status", False):
-            return "[OK] Config: OK"
+            return "[ok] Config: OK"
 
         # No status line needed for normal operation
         return None
@@ -244,29 +248,3 @@ class ConfigStatusView:
 
         # Normal status - show healthy config
         return ["Config: OK", "No errors or warnings"]
-
-    def _get_config_status_metrics(self) -> List[StatusMetric]:
-        """Get configuration status as StatusMetric objects.
-
-        Returns:
-            List of StatusMetric objects for display.
-        """
-        status_data = self.get_status_data()
-
-        if not self.should_display(status_data):
-            return []
-
-        status_line = self.format_status_line(status_data)
-        if not status_line:
-            return []
-
-        color_scheme = self.get_color_scheme(status_data)
-
-        return [
-            StatusMetric(
-                name="config",
-                value=status_line,
-                color=color_scheme,
-                unit="",
-            )
-        ]