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

core/io/terminal_renderer.py

@@ -1,15 +1,21 @@
-"""Terminal rendering system for Kollabor CLI."""
+"""Terminal rendering system for Kollabor CLI.
 
+This module provides comprehensive terminal rendering for the Kollabor CLI
+application, including visual effects, layout management, message
+display, and terminal state management.
+"""
+
+import asyncio
 import logging
 from collections import deque
-from typing import List, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, List, Optional
 
-from .visual_effects import VisualEffects
-from .terminal_state import TerminalState
 from .layout import LayoutManager, ThinkingAnimationManager
-from .status_renderer import StatusRenderer
-from .message_renderer import MessageRenderer
 from .message_coordinator import MessageDisplayCoordinator
+from .message_renderer import MessageRenderer
+from .status_renderer import StatusRenderer
+from .terminal_state import TerminalState
+from .visual_effects import VisualEffects
 
 if TYPE_CHECKING:
     from ..config.manager import ConfigManager
@@ -59,7 +65,6 @@ class TerminalRenderer:
         # Interface properties
         self.input_buffer = ""
         self.cursor_position = 0
-        self.status_areas = {"A": [], "B": [], "C": []}
         self.thinking_active = False
 
         # State management
@@ -165,9 +170,9 @@ class TerminalRenderer:
         """Set the thinking text effect.
 
         Args:
-            effect: Effect type - "dim", "shimmer", or "normal"
+            effect: Effect type - "dim", "shimmer", "pulse", "scramble", or "none"
         """
-        if effect in ["dim", "shimmer", "normal"]:
+        if effect in ["dim", "shimmer", "pulse", "scramble", "none", "normal"]:
             self.thinking_effect = effect
             self.visual_effects.configure_effect("thinking", enabled=True)
             logger.debug(f"Set thinking effect to: {effect}")
@@ -181,9 +186,7 @@ class TerminalRenderer:
             speed: Number of frames between shimmer updates
             wave_width: Number of characters in the shimmer wave
         """
-        self.visual_effects.configure_effect(
-            "thinking", speed=speed, width=wave_width
-        )
+        self.visual_effects.configure_effect("thinking", speed=speed, width=wave_width)
         logger.debug(f"Configured shimmer: speed={speed}, wave_width={wave_width}")
 
     def configure_thinking_limit(self, limit: int) -> None:
@@ -201,14 +204,15 @@ class TerminalRenderer:
         This method renders dynamic interface parts:
         thinking animation, input prompt, and status lines.
         """
-        # logger.info("[START] render_active_area() called")
-
         # CRITICAL: Skip ALL rendering when modal is active to prevent interference
         if hasattr(self, "input_handler") and self.input_handler:
             try:
                 from ..events.models import CommandMode
 
-                if self.input_handler.command_mode in (CommandMode.MODAL, CommandMode.LIVE_MODAL):
+                if self.input_handler.command_mode in (
+                    CommandMode.MODAL,
+                    CommandMode.LIVE_MODAL,
+                ):
                     return
             except Exception as e:
                 logger.error(f"Error checking modal state: {e}")
@@ -243,23 +247,51 @@ class TerminalRenderer:
             if not has_enhanced_input:
                 return
 
-        # Update terminal size and invalidate cache if resized
+        # Update terminal size and invalidate cache if resized (with 0.9s debouncing)
         old_size = self.terminal_state.get_size()
-        self.terminal_state.update_size()
-        terminal_width, terminal_height = self.terminal_state.get_size()
 
-        # Check for terminal resize and invalidate cache if needed
-        if old_size != (terminal_width, terminal_height):
-            self.invalidate_render_cache()
-            logger.debug(
-                f"Terminal resize detected: {old_size} -> ({terminal_width}, {terminal_height})"
-            )
+        # Check if resize has settled (0.9s debounce to prevent rapid re-renders)
+        resize_settled = self.terminal_state.check_and_clear_resize_flag()
+
+        size_changed = False
+        if resize_settled:
+            # Resize has settled - poll actual terminal size
+            self.terminal_state.update_size()
+            terminal_width, terminal_height = self.terminal_state.get_size()
+
+            # Only trigger aggressive clearing if width reduced by 10% or more
+            # Small reductions don't cause artifacts, so we skip clearing for minor changes
+            # Height changes don't matter for clearing (only width affects layout)
+            width_reduction = (old_size[0] - terminal_width) / old_size[0]
+            if terminal_width < old_size[0] and width_reduction >= 0.1:
+                size_changed = True
+                self.invalidate_render_cache()
+
+                # Note: Input buffer and cursor position are preserved on resize
+                # Active area will be cleared by _render_lines() using aggressive clearing
+                logger.debug(
+                    f"Terminal width reduced by {width_reduction*100:.1f}% ({old_size[0]} -> {terminal_width}) - will use aggressive clearing"
+                )
+            elif old_size != (terminal_width, terminal_height):
+                # Size increased or small reduction - just invalidate cache, no aggressive clearing
+                self.invalidate_render_cache()
+                logger.debug(
+                    f"Terminal size changed: {old_size[0]}x{old_size[1]} -> {terminal_width}x{terminal_height} - cache invalidated, no clearing"
+                )
+        else:
+            # No resize or still debouncing - use current size
+            terminal_width, terminal_height = old_size
 
         self.layout_manager.set_terminal_size(terminal_width, terminal_height)
         self.status_renderer.set_terminal_width(terminal_width)
 
         lines = []
 
+        # Add safety buffer line at top of active area
+        # This provides a "clear zone" for aggressive clearing during resize
+        # without deleting conversation content above the active area
+        lines.append("")
+
         # Add thinking animation if active
         if self.thinking_active:
             thinking_lines = self.thinking_animation.get_display_lines(
@@ -290,15 +322,15 @@ class TerminalRenderer:
                 # Replace status with status modal
                 lines.extend(status_modal_lines)
             else:
-                # Update status areas and render normally
-                self._update_status_areas()
+                # Render status views
                 status_lines = self.status_renderer.render_horizontal_layout(
                     self.visual_effects.apply_status_colors
                 )
                 lines.extend(status_lines)
 
         # Clear previous render and write new content
-        await self._render_lines(lines)
+        # Pass resize flag to ensure aggressive clearing is used when size changed
+        await self._render_lines(lines, size_changed=size_changed)
 
     async def _render_input_area(self, lines: List[str]) -> None:
         """Render the input area, checking for plugin overrides.
@@ -346,9 +378,7 @@ class TerminalRenderer:
             )
 
             # Insert cursor character at position
-            text_with_cursor = (
-                buffer_text[:cursor_pos] + "▌" + buffer_text[cursor_pos:]
-            )
+            text_with_cursor = buffer_text[:cursor_pos] + "▌" + buffer_text[cursor_pos:]
             lines.append(f"> {text_with_cursor}")
 
     def _write(self, text: str) -> None:
@@ -358,7 +388,7 @@ class TerminalRenderer:
             text: Text to write.
         """
         # Collect in buffer if buffered mode is active
-        if hasattr(self, '_write_buffer') and self._write_buffer is not None:
+        if hasattr(self, "_write_buffer") and self._write_buffer is not None:
             self._write_buffer.append(text)
         else:
             self.terminal_state.write_raw(text)
@@ -369,9 +399,9 @@ class TerminalRenderer:
 
     def _flush_buffered_write(self) -> None:
         """Flush all buffered writes at once to reduce flickering."""
-        if hasattr(self, '_write_buffer') and self._write_buffer:
+        if hasattr(self, "_write_buffer") and self._write_buffer:
             # Join all buffered content and write in one operation
-            self.terminal_state.write_raw(''.join(self._write_buffer))
+            self.terminal_state.write_raw("".join(self._write_buffer))
         self._write_buffer = None
 
     def _get_terminal_width(self) -> int:
@@ -462,23 +492,17 @@ class TerminalRenderer:
 
         return []
 
-    def _update_status_areas(self) -> None:
-        """Update status areas for rendering."""
-        for area_name, content in self.status_areas.items():
-            self.status_renderer.update_area_content(area_name, content)
-
-    async def _render_lines(self, lines: List[str]) -> None:
+    async def _render_lines(self, lines: List[str], size_changed: bool = False) -> None:
         """Render lines to terminal with proper clearing.
 
         Args:
             lines: Lines to render.
+            size_changed: True if terminal size changed (triggers aggressive clearing).
         """
         # RENDER OPTIMIZATION: Only render if content actually changed
         # Check if render caching is enabled via config
         if self._app_config is not None:
-            cache_enabled = self._app_config.get(
-                "terminal.render_cache_enabled", True
-            )
+            cache_enabled = self._app_config.get("terminal.render_cache_enabled", True)
         else:
             cache_enabled = self._render_cache_enabled  # Fallback to local setting
 
@@ -491,25 +515,32 @@ class TerminalRenderer:
 
         current_line_count = len(lines)
 
-        # Check if terminal was resized - if so, use aggressive clearing
-        resize_occurred = self.terminal_state.check_and_clear_resize_flag()
-
         # Use buffered write to reduce flickering (especially on Windows)
         # Start buffering BEFORE clearing so clear+redraw happens atomically
         self._start_buffered_write()
+        
+        if size_changed:
+            await asyncio.sleep(1)
 
         # Clear previous active area (now buffered to reduce flicker)
         if self.input_line_written and hasattr(self, "last_line_count"):
-            if resize_occurred:
+            if size_changed:
                 # RESIZE FIX: On resize, restore to saved cursor position (where active area started)
                 # and clear everything from there to bottom of screen
                 logger.debug(
-                    "🔄 Terminal resize detected - restoring cursor and clearing"
+                    f"🔄 Terminal resize detected (size_changed={size_changed}) - restoring cursor and clearing"
                 )
 
                 if self.active_area_start_position:
                     # Restore to where active area started before resize
                     self._write("\033[u")  # Restore cursor position
+                    # Move up extra lines to catch box drawing artifacts above saved position
+                    self._write("\033[6A")  # Move up 1 line (into safety buffer zone)
+                    self._write("\033[1A")  # Move up 1 line (into safety buffer zone)
+                    self._write("\n")
+                    self._write("\n")
+                    self._write("\n")
+                    self._write("\n")
                     # Clear from that position to end of screen
                     self._write("\033[J")  # Clear from cursor to end of screen
                 else:
@@ -531,20 +562,35 @@ class TerminalRenderer:
             if i > 0:
                 self._write("\n")
             self._write(f"\r{line}")
+             
 
         # Hide cursor
         self._write("\033[?25l")  # Write hide cursor to buffer too
-
+        
+        # Add small sleep to let terminal process ANSI escape sequences on resize
+        # This prevents visual artifacts when the terminal is still processing
+        if size_changed:
+            await asyncio.sleep(.1)
         # Flush all writes at once
         self._flush_buffered_write()
 
+        # Add small sleep to let terminal process ANSI escape sequences on resize
+        # This prevents visual artifacts when the terminal is still processing
+        if size_changed:
+            await asyncio.sleep(.4)
+
         # Remember line count for next render
         self.last_line_count = current_line_count
         self.input_line_written = True
 
-    def clear_active_area(self) -> None:
-        """Clear the active area before writing conversation messages."""
-        if self.input_line_written and hasattr(self, "last_line_count"):
+    def clear_active_area(self, force: bool = False) -> None:
+        """Clear the active area before writing conversation messages.
+
+        Args:
+            force: If True, clear regardless of input_line_written state.
+                   Use for exit cleanup.
+        """
+        if (force or self.input_line_written) and hasattr(self, "last_line_count"):
             self.terminal_state.clear_line()
             for _ in range(self.last_line_count - 1):
                 self.terminal_state.move_cursor_up(1)

core/io/terminal_state.py

@@ -1,4 +1,9 @@
-"""Terminal state management for rendering system."""
+"""Terminal state management for rendering system.
+
+This module provides comprehensive terminal state management for rendering
+systems, including mode switching, capability detection, and
+cross-platform terminal control.
+"""
 
 import logging
 import os
@@ -145,7 +150,7 @@ class TerminalState:
         self._last_size = (0, 0)
         self._resize_occurred = False  # Track if terminal resize happened
         self._last_resize_time = 0  # Track when last resize signal arrived
-        self._resize_debounce_delay = 0.2  # Wait 200ms for resize to settle
+        self._resize_debounce_delay = .9  # Wait 200ms for resize to settle
 
         # Initialize terminal state
         self._initialize_terminal()
@@ -275,8 +280,20 @@ class TerminalState:
                 new_mode |= ENABLE_VIRTUAL_TERMINAL_INPUT
                 kernel32.SetConsoleMode(stdin_handle, new_mode)
             else:
-                # Unix: Use tty.setraw
-                tty.setraw(sys.stdin.fileno())
+                # Unix: Set raw mode with flow control disabled
+                # tty.setraw() doesn't disable IXON, so Ctrl+S (XOFF) gets
+                # intercepted by terminal driver. We need to manually clear IXON.
+                fd = sys.stdin.fileno()
+                tty.setraw(fd)
+                # Now disable XON/XOFF flow control so Ctrl+S reaches the app
+                attrs = termios.tcgetattr(fd)
+                attrs[0] &= ~termios.IXON  # Disable XOFF (Ctrl+S) interception
+                attrs[0] &= ~termios.IXOFF  # Disable XON (Ctrl+Q) interception
+                termios.tcsetattr(fd, termios.TCSANOW, attrs)
+                # Ensure stdin is in blocking mode (not non-blocking)
+                import fcntl
+                flags = fcntl.fcntl(fd, fcntl.F_GETFL)
+                fcntl.fcntl(fd, fcntl.F_SETFL, flags & ~os.O_NONBLOCK)
             self.current_mode = TerminalMode.RAW
             logger.debug("Entered raw terminal mode")
             return True