kollabor 0.4.9__py3-none-any.whl

core/fullscreen/renderer.py

@@ -0,0 +1,282 @@
+"""Full-screen renderer for plugin terminal output."""
+
+import sys
+import shutil
+import logging
+from typing import Tuple, Optional, Any
+from dataclasses import dataclass
+
+# Platform-specific imports for terminal control
+IS_WINDOWS = sys.platform == "win32"
+
+if IS_WINDOWS:
+    import ctypes
+    kernel32 = ctypes.windll.kernel32
+    STD_OUTPUT_HANDLE = -11
+    STD_INPUT_HANDLE = -10
+    ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+    ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200
+    ENABLE_ECHO_INPUT = 0x0004
+    ENABLE_LINE_INPUT = 0x0002
+    ENABLE_PROCESSED_INPUT = 0x0001
+else:
+    import termios
+    import tty
+
+from ..io.visual_effects import ColorPalette
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class TerminalSnapshot:
+    """Snapshot of terminal state for restoration."""
+    termios_settings: Any = None  # Unix termios settings
+    console_mode: Any = None  # Windows console mode
+    cursor_visible: bool = True
+    terminal_size: Tuple[int, int] = (80, 24)
+
+
+class FullScreenRenderer:
+    """Handles full-screen rendering with alternate buffer management.
+
+    This class provides direct terminal control for plugins, including
+    alternate buffer management, cursor control, and direct output.
+    """
+
+    def __init__(self):
+        """Initialize the full-screen renderer."""
+        self.active = False
+        self.terminal_snapshot: Optional[TerminalSnapshot] = None
+        self.terminal_width = 80
+        self.terminal_height = 24
+
+        logger.info("FullScreenRenderer initialized")
+
+    def setup_terminal(self) -> bool:
+        """Setup terminal for full-screen rendering.
+
+        Returns:
+            True if setup was successful, False otherwise.
+        """
+        try:
+            # Get terminal size
+            size = shutil.get_terminal_size()
+            self.terminal_width = size.columns
+            self.terminal_height = size.lines
+
+            # Save current terminal state
+            self.terminal_snapshot = TerminalSnapshot()
+            # CRITICAL FIX: Don't set raw mode when running within main application
+            # The main app already handles input properly via InputHandler
+            if sys.stdin.isatty():
+                if IS_WINDOWS:
+                    # Windows: Save console mode
+                    stdin_handle = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+                    mode = ctypes.c_ulong()
+                    kernel32.GetConsoleMode(stdin_handle, ctypes.byref(mode))
+                    self.terminal_snapshot.console_mode = mode.value
+
+                    # Enable VT processing for ANSI escape sequences
+                    stdout_handle = kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
+                    out_mode = ctypes.c_ulong()
+                    kernel32.GetConsoleMode(stdout_handle, ctypes.byref(out_mode))
+                    kernel32.SetConsoleMode(
+                        stdout_handle,
+                        out_mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING
+                    )
+                else:
+                    # Unix: Save termios settings
+                    self.terminal_snapshot.termios_settings = termios.tcgetattr(sys.stdin.fileno())
+                # Skip tty.setraw() - let main application handle input
+
+            # Enter alternate buffer and setup
+            sys.stdout.write("\033[?1049h")  # Enter alternate buffer
+            sys.stdout.flush()
+
+            # Clear and setup alternate buffer
+            self.clear_screen()
+            self.hide_cursor()
+            sys.stdout.flush()
+
+            # Fill screen with spaces to ensure clean state
+            for row in range(self.terminal_height):
+                sys.stdout.write(f"\033[{row+1};1H{' ' * self.terminal_width}")
+            sys.stdout.write("\033[H")  # Return to home
+            sys.stdout.flush()
+
+            self.active = True
+            logger.info(f"Terminal setup complete: {self.terminal_width}x{self.terminal_height}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to setup terminal: {e}")
+            return False
+
+    def restore_terminal(self) -> bool:
+        """Restore terminal to original state.
+
+        Returns:
+            True if restoration was successful, False otherwise.
+        """
+        try:
+            if not self.active:
+                return True
+
+            # Clear alternate buffer before exiting
+            self.clear_screen()
+            # Don't call show_cursor() - normal mode keeps cursor hidden anyway
+
+            # Exit alternate buffer (automatically restores screen and cursor position)
+            sys.stdout.write("\033[?1049l")  # Exit alternate buffer
+            sys.stdout.flush()
+
+            # CRITICAL FIX: Don't clear screen or move cursor - alternate buffer already restored everything
+            # Removed: sys.stdout.write("\033[2J") and sys.stdout.write("\033[H")
+            # The alternate buffer automatically restores the exact screen and cursor position
+
+            # Restore terminal settings
+            if self.terminal_snapshot and sys.stdin.isatty():
+                if IS_WINDOWS:
+                    # Windows: Restore console mode
+                    if self.terminal_snapshot.console_mode is not None:
+                        stdin_handle = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+                        kernel32.SetConsoleMode(
+                            stdin_handle,
+                            self.terminal_snapshot.console_mode
+                        )
+                else:
+                    # Unix: Restore termios settings
+                    if self.terminal_snapshot.termios_settings:
+                        termios.tcsetattr(
+                            sys.stdin.fileno(),
+                            termios.TCSADRAIN,
+                            self.terminal_snapshot.termios_settings
+                        )
+
+            self.active = False
+            self.terminal_snapshot = None
+            logger.info("Terminal restored successfully")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to restore terminal: {e}")
+            return False
+
+    def clear_screen(self):
+        """Clear the entire screen."""
+        sys.stdout.write("\033[2J\033[H")
+        sys.stdout.flush()
+
+    def clear_line(self, row: int):
+        """Clear a specific line.
+
+        Args:
+            row: Row number (1-based).
+        """
+        sys.stdout.write(f"\033[{row};1H\033[K")
+        sys.stdout.flush()
+
+    def move_cursor(self, x: int, y: int):
+        """Move cursor to specific position.
+
+        Args:
+            x: Column position (0-based).
+            y: Row position (0-based).
+        """
+        sys.stdout.write(f"\033[{y+1};{x+1}H")
+
+    def hide_cursor(self):
+        """Hide the cursor."""
+        sys.stdout.write("\033[?25l")
+
+    def show_cursor(self):
+        """Show the cursor."""
+        sys.stdout.write("\033[?25h")
+
+    def write_raw(self, text: str):
+        """Write raw text to terminal.
+
+        Args:
+            text: Text to write (can include ANSI codes).
+        """
+        sys.stdout.write(text)
+        sys.stdout.flush()
+
+    def write_at(self, x: int, y: int, text: str, color: str = ColorPalette.RESET):
+        """Write text at specific position with optional color.
+
+        Args:
+            x: Column position (0-based).
+            y: Row position (0-based).
+            text: Text to write.
+            color: ANSI color code.
+        """
+        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()
+
+    def draw_box(self, x: int, y: int, width: int, height: int,
+                 border_color: str = ColorPalette.WHITE,
+                 fill_color: str = ColorPalette.RESET):
+        """Draw a box at the specified position.
+
+        Args:
+            x: Left column (0-based).
+            y: Top row (0-based).
+            width: Box width.
+            height: Box height.
+            border_color: Color for border.
+            fill_color: Color for interior.
+        """
+        # Draw top border
+        self.write_at(x, y, f"{border_color}╭{'─' * (width-2)}╮{ColorPalette.RESET}")
+
+        # Draw sides and interior
+        for row in range(1, height-1):
+            self.write_at(x, y + row, f"{border_color}│{fill_color}{' ' * (width-2)}{border_color}│{ColorPalette.RESET}")
+
+        # Draw bottom border
+        if height > 1:
+            self.write_at(x, y + height - 1, f"{border_color}╰{'─' * (width-2)}╯{ColorPalette.RESET}")
+
+    def draw_line(self, x1: int, y1: int, x2: int, y2: int,
+                  char: str = "─", color: str = ColorPalette.WHITE):
+        """Draw a line between two points.
+
+        Args:
+            x1, y1: Start position.
+            x2, y2: End position.
+            char: Character to use for line.
+            color: Line color.
+        """
+        # Simple horizontal/vertical line implementation
+        if y1 == y2:  # Horizontal line
+            start_x, end_x = min(x1, x2), max(x1, x2)
+            line_text = char * (end_x - start_x + 1)
+            self.write_at(start_x, y1, line_text, color)
+        elif x1 == x2:  # Vertical line
+            start_y, end_y = min(y1, y2), max(y1, y2)
+            for y in range(start_y, end_y + 1):
+                self.write_at(x1, y, char, color)
+
+    def get_terminal_size(self) -> Tuple[int, int]:
+        """Get current terminal size.
+
+        Returns:
+            Tuple of (width, height).
+        """
+        return (self.terminal_width, self.terminal_height)
+
+    def is_active(self) -> bool:
+        """Check if renderer is currently active.
+
+        Returns:
+            True if renderer is active, False otherwise.
+        """
+        return self.active
+
+    def flush(self):
+        """Flush output buffer."""
+        sys.stdout.flush()

core/fullscreen/session.py

@@ -0,0 +1,324 @@
+"""Full-screen session management."""
+
+import asyncio
+import logging
+import sys
+from typing import Optional
+from dataclasses import dataclass
+
+# Platform-specific imports for input handling
+IS_WINDOWS = sys.platform == "win32"
+
+if IS_WINDOWS:
+    import msvcrt
+else:
+    import select
+
+from ..io.key_parser import KeyParser, KeyPress
+from .plugin import FullScreenPlugin
+from .renderer import FullScreenRenderer
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SessionStats:
+    """Statistics for a full-screen session."""
+    start_time: float
+    end_time: Optional[float] = None
+    frame_count: int = 0
+    input_events: int = 0
+    average_fps: float = 0.0
+
+    @property
+    def duration(self) -> float:
+        """Get session duration in seconds."""
+        end = self.end_time or asyncio.get_event_loop().time()
+        return end - self.start_time
+
+
+class FullScreenSession:
+    """Manages a full-screen plugin execution session.
+
+    This class handles the complete lifecycle of running a full-screen plugin,
+    including terminal setup, input handling, rendering loop, and cleanup.
+    """
+
+    def __init__(self, plugin: FullScreenPlugin, event_bus=None, target_fps: float = 60.0):
+        """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.
+        """
+        self.plugin = plugin
+        self.event_bus = event_bus
+        self.target_fps = target_fps
+        self.frame_delay = 1.0 / target_fps
+
+        # Session state
+        self.running = False
+        self.renderer = FullScreenRenderer()
+        self.key_parser = KeyParser()
+        self.stats = SessionStats(start_time=0)
+
+        # CRITICAL FIX: Input routing through events
+        self.pending_input = asyncio.Queue()
+        self.input_hook_registered = False
+
+        logger.info(f"Created session for plugin: {plugin.name}")
+
+    async def _register_input_hook(self):
+        """Register hook to receive input from InputHandler."""
+        if self.event_bus and not self.input_hook_registered:
+            try:
+                from ..events.models import Hook, HookPriority, EventType
+                hook = Hook(
+                    name="fullscreen_input",
+                    plugin_name=f"fullscreen_session_{self.plugin.name}",
+                    event_type=EventType.FULLSCREEN_INPUT,
+                    priority=HookPriority.DISPLAY.value,
+                    callback=self._handle_fullscreen_input
+                )
+                success = await self.event_bus.register_hook(hook)
+                if success:
+                    self.input_hook_registered = True
+                    logger.info(f"✅ Registered FULLSCREEN_INPUT hook for {self.plugin.name}")
+                else:
+                    logger.error(f"❌ Failed to register FULLSCREEN_INPUT hook for {self.plugin.name}")
+            except Exception as e:
+                logger.error(f"Error registering fullscreen input hook: {e}")
+
+    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}")
+                await self.pending_input.put(key_press)
+                return {"success": True, "handled": True}
+            print(f"❌ CRITICAL: No key_press in event data: {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)}
+
+    async def run(self) -> bool:
+        """Run the full-screen session.
+
+        Returns:
+            True if session completed successfully, False if error occurred.
+        """
+        try:
+            # Initialize session
+            if not await self._initialize():
+                return False
+
+            logger.info(f"Starting full-screen session for {self.plugin.name}")
+            self.running = True
+            self.stats.start_time = asyncio.get_event_loop().time()
+
+            # Main session loop
+            await self._session_loop()
+
+            logger.info(f"Session completed for {self.plugin.name}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Session error for {self.plugin.name}: {e}")
+            return False
+
+        finally:
+            await self._cleanup()
+
+    async def _initialize(self) -> bool:
+        """Initialize the session.
+
+        Returns:
+            True if initialization successful, False otherwise.
+        """
+        try:
+            # CRITICAL FIX: Register input hook before terminal setup
+            try:
+                await self._register_input_hook()
+            except Exception as e:
+                logger.warning(f"Input hook registration failed: {e}")
+                # Continue anyway, input might still work via fallback
+
+            # Setup terminal
+            if not self.renderer.setup_terminal():
+                logger.error("Failed to setup terminal")
+                return False
+
+            # Initialize plugin
+            if not await self.plugin.initialize(self.renderer):
+                logger.error(f"Failed to initialize plugin {self.plugin.name}")
+                return False
+
+            # Start plugin
+            await self.plugin.on_start()
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Session initialization failed: {e}")
+            return False
+
+    async def _session_loop(self):
+        """Main session loop handling rendering and input."""
+        last_frame_time = asyncio.get_event_loop().time()
+
+        while self.running:
+            current_time = asyncio.get_event_loop().time()
+            delta_time = current_time - last_frame_time
+
+            try:
+                # Handle input
+                if await self._handle_input():
+                    break  # Exit requested
+
+                # Render frame
+                if not await self.plugin.render_frame(delta_time):
+                    break  # Plugin requested exit
+
+                self.stats.frame_count += 1
+                last_frame_time = current_time
+
+                # Frame rate limiting
+                await asyncio.sleep(max(0, self.frame_delay - delta_time))
+
+            except Exception as e:
+                logger.error(f"Error in session loop: {e}")
+                break
+
+    async def _handle_input(self) -> bool:
+        """Handle input events.
+
+        Returns:
+            True if exit was requested, False otherwise.
+        """
+        try:
+            # Check for available input (non-blocking)
+            if not sys.stdin.isatty():
+                return False
+
+            # Platform-specific input checking
+            has_input = False
+            char = None
+
+            if IS_WINDOWS:
+                # Windows: Use msvcrt to check for input
+                if msvcrt.kbhit():
+                    has_input = True
+                    char_bytes = msvcrt.getch()
+                    char = char_bytes.decode("utf-8", errors="ignore") if char_bytes else None
+
+                    # Handle extended keys on Windows (arrow keys, etc.)
+                    if char_bytes and char_bytes[0] in (0, 224):
+                        ext_char = msvcrt.getch()
+                        ext_code = ext_char[0] if ext_char else 0
+                        # Map Windows extended key codes to escape sequences
+                        win_key_map = {
+                            72: "\x1b[A",  # ArrowUp
+                            80: "\x1b[B",  # ArrowDown
+                            75: "\x1b[D",  # ArrowLeft
+                            77: "\x1b[C",  # ArrowRight
+                            71: "\x1b[H",  # Home
+                            79: "\x1b[F",  # End
+                            83: "\x1b[3~",  # Delete
+                        }
+                        if ext_code in win_key_map:
+                            # Process escape sequence character by character
+                            for c in win_key_map[ext_code]:
+                                if not hasattr(self, '_key_parser'):
+                                    self._key_parser = KeyParser()
+                                key_press = self._key_parser.parse_char(c)
+                            if key_press:
+                                self.stats.input_events += 1
+                                return await self.plugin.handle_input(key_press)
+                        return False
+            else:
+                # Unix: Use select to check for input without blocking
+                ready, _, _ = select.select([sys.stdin], [], [], 0)
+                if ready:
+                    has_input = True
+                    char = sys.stdin.read(1)
+
+            if not has_input or not char:
+                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)
+            if not key_press:
+                # Check for standalone ESC key
+                key_press = self._key_parser.check_for_standalone_escape()
+                if not key_press:
+                    return False
+
+            self.stats.input_events += 1
+
+            # Let plugin handle input (plugin decides if it wants to exit)
+            return await self.plugin.handle_input(key_press)
+
+        except Exception as e:
+            logger.error(f"Error handling input: {e}")
+            return False
+
+    async def _cleanup(self):
+        """Clean up session resources."""
+        try:
+            self.running = False
+            self.stats.end_time = asyncio.get_event_loop().time()
+
+            # Calculate final stats
+            if self.stats.duration > 0:
+                self.stats.average_fps = self.stats.frame_count / self.stats.duration
+
+            # Stop plugin
+            await self.plugin.on_stop()
+
+            # Restore terminal
+            self.renderer.restore_terminal()
+
+            # Unregister input hook if it was registered
+            if self.input_hook_registered and self.event_bus:
+                try:
+                    hook_id = f"fullscreen_session_{self.plugin.name}.fullscreen_input"
+                    await self.event_bus.unregister_hook(hook_id)
+                    self.input_hook_registered = False
+                    logger.info(f"✅ Unregistered FULLSCREEN_INPUT hook for {self.plugin.name}")
+                except Exception as e:
+                    logger.error(f"Error unregistering hook: {e}")
+
+            # Cleanup plugin
+            await self.plugin.cleanup()
+
+            logger.info(f"Session cleanup complete for {self.plugin.name}")
+            logger.info(f"Session stats: {self.stats.frame_count} frames, "
+                       f"{self.stats.average_fps:.1f} fps, "
+                       f"{self.stats.input_events} inputs, "
+                       f"{self.stats.duration:.1f}s duration")
+
+        except Exception as e:
+            logger.error(f"Error during session cleanup: {e}")
+
+    def stop(self):
+        """Stop the session gracefully."""
+        self.running = False
+        logger.info(f"Stop requested for session: {self.plugin.name}")
+
+    def get_stats(self) -> SessionStats:
+        """Get current session statistics.
+
+        Returns:
+            Current session statistics.
+        """
+        return self.stats

core/io/__init__.py

@@ -0,0 +1,52 @@
+"""Input/Output subsystem for Kollabor CLI."""
+
+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 .terminal_state import TerminalState, TerminalCapabilities, TerminalMode
+from .layout import LayoutManager, LayoutArea, ThinkingAnimationManager
+from .status_renderer import StatusRenderer, StatusMetric, StatusFormat
+from .message_renderer import (
+    MessageRenderer,
+    ConversationMessage,
+    MessageType,
+    MessageFormat,
+)
+
+__all__ = [
+    # Core components
+    "InputHandler",
+    "TerminalRenderer",
+    # Input handling
+    "KeyParser",
+    "KeyPress",
+    "KeyType",
+    "BufferManager",
+    "InputErrorHandler",
+    "ErrorType",
+    "ErrorSeverity",
+    # Visual effects
+    "VisualEffects",
+    "ColorPalette",
+    "EffectType",
+    # Terminal management
+    "TerminalState",
+    "TerminalCapabilities",
+    "TerminalMode",
+    # Layout management
+    "LayoutManager",
+    "LayoutArea",
+    "ThinkingAnimationManager",
+    # Status rendering
+    "StatusRenderer",
+    "StatusMetric",
+    "StatusFormat",
+    # Message rendering
+    "MessageRenderer",
+    "ConversationMessage",
+    "MessageType",
+    "MessageFormat",
+]