kollabor 0.4.9__py3-none-any.whl

plugins/enhanced_input/state.py

@@ -0,0 +1,130 @@
+"""State management for Enhanced Input Plugin."""
+
+import time
+import random
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .config import InputConfig
+
+
+class PluginState:
+    """Manages runtime state for Enhanced Input Plugin."""
+
+    def __init__(self, config: 'InputConfig'):
+        """Initialize plugin state.
+
+        Args:
+            config: Plugin configuration instance.
+        """
+        self.config = config
+
+        # Randomization state
+        self.last_randomize_time = 0
+        self.current_random_style = config.style
+
+        # Cursor blinking state
+        self.cursor_visible = True
+        self.last_blink_time = 0
+
+        # Curated list of sophisticated styles matching user preferences
+        self.random_styles = [
+            # User's confirmed favorites
+            "dots_only", "brackets", "dotted", "dashed", "square",
+            # Clean classics
+            "rounded", "double", "thick", "underline", "minimal",
+            # New sophisticated mixed-weight styles
+            "mixed_weight", "typography", "sophisticated", "editorial",
+            "clean_corners", "refined", "gradient_line",
+            # Clean minimal lines
+            "lines_only", "thick_lines", "double_lines"
+        ]
+
+    def get_current_style(self) -> str:
+        """Get the current style, handling randomization.
+
+        Returns:
+            Current active style name.
+        """
+        current_time = time.time()
+
+        # Handle randomization
+        if self.config.randomize_style or self.config.style == "random":
+            if (current_time - self.last_randomize_time) >= self.config.randomize_interval:
+                self.current_random_style = self._get_random_style()
+                self.last_randomize_time = current_time
+            return self.current_random_style
+
+        return self.config.style
+
+    def _get_random_style(self) -> str:
+        """Get a random style from curated good styles.
+
+        Returns:
+            Random style name.
+        """
+        return random.choice(self.random_styles)
+
+    def update_cursor_blink(self, input_is_active: bool) -> None:
+        """Update cursor blinking state.
+
+        Args:
+            input_is_active: Whether input is currently active.
+        """
+        if not input_is_active:
+            self.cursor_visible = True
+            return
+
+        current_time = time.time()
+        if current_time - self.last_blink_time >= self.config.cursor_blink_rate:
+            self.cursor_visible = not self.cursor_visible
+            self.last_blink_time = current_time
+
+    def get_cursor_char(self, input_is_active: bool) -> str:
+        """Get the current cursor character.
+
+        Args:
+            input_is_active: Whether input is currently active.
+
+        Returns:
+            Cursor character to display.
+        """
+        if input_is_active:
+            return "█" if self.cursor_visible else " "
+        else:
+            return "█"
+
+    def is_input_active(self, renderer) -> bool:
+        """Determine if input is currently active.
+
+        Args:
+            renderer: Terminal renderer instance.
+
+        Returns:
+            True if input should be considered active.
+        """
+        writing_messages = getattr(renderer, 'writing_messages', False)
+        thinking_active = getattr(renderer, 'thinking_active', False)
+        conversation_active = getattr(renderer, 'conversation_active', True)
+
+        return not writing_messages and not thinking_active and conversation_active
+
+    def get_status_display(self) -> str:
+        """Get status display string for current style.
+
+        Returns:
+            Status string showing current style.
+        """
+        current_style = self.get_current_style()
+        if self.config.randomize_style or self.config.style == "random":
+            return f"{current_style} (random)"
+        return current_style
+
+    def reset_randomization(self) -> None:
+        """Reset randomization timer."""
+        self.last_randomize_time = 0
+
+    def reset_cursor_blink(self) -> None:
+        """Reset cursor blink state."""
+        self.cursor_visible = True
+        self.last_blink_time = 0

plugins/enhanced_input/text_processor.py

@@ -0,0 +1,115 @@
+"""Text processing utilities for enhanced input plugin."""
+
+import re
+from typing import List
+
+
+class TextProcessor:
+    """Handles text wrapping, truncation, and visual length calculations."""
+
+    def __init__(self, config):
+        """Initialize text processor.
+
+        Args:
+            config: InputConfig object with plugin configuration.
+        """
+        self.config = config
+
+    def wrap_text(self, text: str, width: int) -> List[str]:
+        """Wrap text to fit within the specified width.
+
+        Args:
+            text: Text to wrap.
+            width: Maximum width for each line.
+
+        Returns:
+            List of wrapped text lines.
+        """
+        wrap_text = self.config.wrap_text
+
+        if not wrap_text or not text:
+            return [text] if text else [""]
+
+        words = text.split()
+        lines = []
+        current_line = ""
+
+        for word in words:
+            # Check if adding this word would exceed the width
+            test_line = f"{current_line} {word}".strip()
+            if len(test_line) <= width:
+                current_line = test_line
+            else:
+                # Start a new line
+                if current_line:
+                    lines.append(current_line)
+                current_line = word
+
+        # Add the last line
+        if current_line:
+            lines.append(current_line)
+
+        return lines if lines else [""]
+
+    def get_visual_length(self, text: str) -> int:
+        """Get the visual length of text, excluding ANSI escape codes.
+
+        Args:
+            text: Text that may contain ANSI codes.
+
+        Returns:
+            Visual length of the text.
+        """
+        # Remove ANSI escape codes
+        ansi_escape = re.compile(r'\x1b\[[0-9;]*m')
+        clean_text = ansi_escape.sub('', text)
+        return len(clean_text)
+
+    def truncate_with_ellipsis(self, text: str, max_width: int) -> str:
+        """Truncate text with ellipsis if it exceeds max width.
+
+        Args:
+            text: Text to potentially truncate.
+            max_width: Maximum allowed width.
+
+        Returns:
+            Truncated text with ellipsis if needed.
+        """
+        visual_length = self.get_visual_length(text)
+        if visual_length > max_width:
+            # Truncate content but be careful with ANSI codes
+            return text[:max_width-3] + "..."
+        return text
+
+    def pad_to_width(self, text: str, target_width: int) -> str:
+        """Pad text to target width with spaces.
+
+        Args:
+            text: Text to pad.
+            target_width: Target width.
+
+        Returns:
+            Padded text.
+        """
+        visual_length = self.get_visual_length(text)
+        if visual_length < target_width:
+            padding_needed = target_width - visual_length
+            return text + " " * padding_needed
+        return text
+
+    def fit_text_to_width(self, text: str, target_width: int) -> str:
+        """Fit text to target width by truncating or padding as needed.
+
+        Args:
+            text: Text to fit.
+            target_width: Target width.
+
+        Returns:
+            Text fitted to target width.
+        """
+        visual_length = self.get_visual_length(text)
+
+        if visual_length > target_width:
+            return self.truncate_with_ellipsis(text, target_width)
+        else:
+            return self.pad_to_width(text, target_width)

plugins/enhanced_input_plugin.py

@@ -0,0 +1,385 @@
+"""Enhanced Input Plugin for Kollabor CLI - Refactored Version.
+
+Provides enhanced input rendering with bordered boxes using Unicode box-drawing characters.
+Now built with modular components following DRY principles.
+"""
+
+import logging
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, TYPE_CHECKING
+
+logger = logging.getLogger(__name__)
+
+# Add parent directory to path so we can import from chat_app
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from core.events import Event, EventType, Hook, HookPriority
+
+# Import our modular components
+from plugins.enhanced_input.config import InputConfig
+from plugins.enhanced_input.state import PluginState
+from plugins.enhanced_input.box_styles import BoxStyleRegistry
+from plugins.enhanced_input.color_engine import ColorEngine
+from plugins.enhanced_input.geometry import GeometryCalculator
+from plugins.enhanced_input.text_processor import TextProcessor
+from plugins.enhanced_input.cursor_manager import CursorManager
+from plugins.enhanced_input.box_renderer import BoxRenderer
+
+# Type hints (only needed for type checking)
+if TYPE_CHECKING:
+    from core.config import ConfigManager
+    from core.storage import StateManager
+    from core.events import EventBus
+    from core.io.terminal_renderer import TerminalRenderer
+
+
+class EnhancedInputPlugin:
+    """Plugin that renders enhanced bordered input boxes using modular components."""
+
+    @staticmethod
+    def get_default_config() -> Dict[str, Any]:
+        """Get the default configuration for the enhanced input plugin.
+
+        Returns:
+            Default configuration dictionary for the enhanced input plugin.
+        """
+        # Use the default config from InputConfig
+        default_config = InputConfig()
+        return default_config.get_default_config_dict()
+
+    @staticmethod
+    def get_startup_info(config: 'ConfigManager') -> List[str]:
+        """Get startup information to display for this plugin.
+
+        Args:
+            config: Configuration manager instance.
+
+        Returns:
+            List of strings to display during startup.
+        """
+        enabled = config.get('plugins.enhanced_input.enabled', True)
+        style = config.get('plugins.enhanced_input.style', 'rounded')
+        return [
+            f"Enabled: {enabled}",
+            f"Style: {style}",
+            f"Unicode box drawing support"
+        ]
+
+    @staticmethod
+    def get_config_widgets() -> Dict[str, Any]:
+        """Get configuration widgets for this plugin.
+
+        Returns:
+            Widget section definition for the config modal.
+        """
+        return {
+            "title": "Enhanced Input Plugin",
+            "widgets": [
+                {
+                    "type": "dropdown",
+                    "label": "Box Style",
+                    "config_path": "plugins.enhanced_input.style",
+                    "options": ["rounded", "square", "double", "thick", "thin"],
+                    "help": "Visual style of the input box border"
+                },
+                {
+                    "type": "text_input",
+                    "label": "Width",
+                    "config_path": "plugins.enhanced_input.width",
+                    "placeholder": "auto",
+                    "help": "Box width (auto, pixels, or percentage)"
+                },
+                {
+                    "type": "text_input",
+                    "label": "Placeholder Text",
+                    "config_path": "plugins.enhanced_input.placeholder",
+                    "placeholder": "Type your message here...",
+                    "help": "Text shown when input is empty"
+                },
+                {
+                    "type": "checkbox",
+                    "label": "Show Placeholder",
+                    "config_path": "plugins.enhanced_input.show_placeholder",
+                    "help": "Display placeholder text when input is empty"
+                },
+                {
+                    "type": "slider",
+                    "label": "Min Width",
+                    "config_path": "plugins.enhanced_input.min_width",
+                    "min_value": 20,
+                    "max_value": 200,
+                    "step": 10,
+                    "help": "Minimum box width in characters"
+                },
+                {
+                    "type": "slider",
+                    "label": "Max Width",
+                    "config_path": "plugins.enhanced_input.max_width",
+                    "min_value": 40,
+                    "max_value": 300,
+                    "step": 10,
+                    "help": "Maximum box width in characters"
+                },
+                {
+                    "type": "checkbox",
+                    "label": "Randomize Style",
+                    "config_path": "plugins.enhanced_input.randomize_style",
+                    "help": "Randomly change box style periodically"
+                },
+                {
+                    "type": "slider",
+                    "label": "Randomize Interval",
+                    "config_path": "plugins.enhanced_input.randomize_interval",
+                    "min_value": 1.0,
+                    "max_value": 60.0,
+                    "step": 1.0,
+                    "help": "Seconds between style randomizations"
+                },
+                {
+                    "type": "checkbox",
+                    "label": "Dynamic Sizing",
+                    "config_path": "plugins.enhanced_input.dynamic_sizing",
+                    "help": "Automatically resize box based on content"
+                },
+                {
+                    "type": "slider",
+                    "label": "Min Height",
+                    "config_path": "plugins.enhanced_input.min_height",
+                    "min_value": 1,
+                    "max_value": 20,
+                    "step": 1,
+                    "help": "Minimum box height in lines"
+                },
+                {
+                    "type": "slider",
+                    "label": "Max Height",
+                    "config_path": "plugins.enhanced_input.max_height",
+                    "min_value": 3,
+                    "max_value": 50,
+                    "step": 1,
+                    "help": "Maximum box height in lines"
+                },
+                {
+                    "type": "checkbox",
+                    "label": "Wrap Text",
+                    "config_path": "plugins.enhanced_input.wrap_text",
+                    "help": "Enable text wrapping in input box"
+                },
+                {
+                    "type": "slider",
+                    "label": "Cursor Blink Rate",
+                    "config_path": "plugins.enhanced_input.cursor_blink_rate",
+                    "min_value": 0.1,
+                    "max_value": 2.0,
+                    "step": 0.1,
+                    "help": "Cursor blink speed in seconds"
+                },
+                {
+                    "type": "checkbox",
+                    "label": "Show Status",
+                    "config_path": "plugins.enhanced_input.show_status",
+                    "help": "Display status information below input box"
+                }
+            ]
+        }
+
+    def __init__(self, name: str, state_manager: 'StateManager', event_bus: 'EventBus',
+                 renderer: 'TerminalRenderer', config: 'ConfigManager') -> None:
+        """Initialize the enhanced input plugin.
+
+        Args:
+            name: Plugin name.
+            state_manager: State management system.
+            event_bus: Event bus for hook registration.
+            renderer: Terminal renderer.
+            config: Configuration manager.
+        """
+        self.name = name
+        self.state_manager = state_manager
+        self.event_bus = event_bus
+        self.renderer = renderer
+
+        # Initialize configuration
+        self.config = InputConfig.from_config_manager(config)
+
+        # Initialize state management
+        self.state = PluginState(self.config)
+
+        # Initialize modular components
+        self.box_styles = BoxStyleRegistry()
+        self.color_engine = ColorEngine(self.config)
+        self.geometry = GeometryCalculator(self.config)
+        self.text_processor = TextProcessor(self.config)
+        self.cursor_manager = CursorManager(self.config)
+        self.box_renderer = BoxRenderer(self.box_styles, self.color_engine, self.geometry, self.text_processor)
+
+        # Register hooks for input rendering
+        self.hooks = [
+            Hook(
+                name="render_fancy_input",
+                plugin_name=self.name,
+                event_type=EventType.INPUT_RENDER,
+                priority=HookPriority.DISPLAY.value,
+                callback=self._render_fancy_input
+            )
+        ]
+
+    def get_status_lines(self) -> Dict[str, List[str]]:
+        """Get status lines for the enhanced input plugin organized by area.
+
+        Returns:
+            Dictionary with status lines organized by area A, B, C.
+        """
+        # Check if status display is enabled for this plugin
+        if not self.config.show_status:
+            return {"A": [], "B": [], "C": []}
+
+        # UI-related status goes in area C
+        if not self.config.enabled:
+            return {"A": [], "B": [], "C": ["Enhanced Input: Off"]}
+
+        style_display = self.state.get_status_display()
+
+        return {
+            "A": [],
+            "B": [],
+            "C": [
+                f"Input: {style_display}",
+                f"Width: {self.config.width_mode}"
+            ]
+        }
+
+    async def _render_fancy_input(self, data: Dict[str, Any], event: Event) -> Dict[str, Any]:
+        """Render the fancy input box using modular components.
+
+        Args:
+            data: Event data containing input information.
+            event: The event object.
+
+        Returns:
+            Modified event data.
+        """
+        if not self.config.enabled:
+            return {"status": "disabled"}
+
+        # Get input buffer and cursor position from renderer
+        input_text = getattr(self.renderer, 'input_buffer', '')
+        cursor_position = getattr(self.renderer, 'cursor_position', len(input_text))
+
+        # Determine if input is active and update cursor state
+        input_is_active = self.state.is_input_active(self.renderer)
+        self.state.update_cursor_blink(input_is_active)
+
+        # Get cursor character
+        cursor_char = self.state.get_cursor_char(input_is_active)
+
+        # Insert cursor at correct position
+        text_with_cursor = self.cursor_manager.insert_cursor(
+            input_text, cursor_position, cursor_char
+        )
+
+        # Prepare content with prompt
+        if input_text:
+            content_with_cursor = f"> {text_with_cursor}"
+        elif self.config.show_placeholder:
+            colored_placeholder = self.color_engine.apply_color(
+                self.config.placeholder, 'placeholder'
+            )
+            content_with_cursor = f"> {cursor_char}{colored_placeholder}"
+        else:
+            content_with_cursor = f"> {cursor_char}"
+
+        # Calculate box dimensions
+        box_width = self.geometry.calculate_box_width()
+        content_width = self.geometry.calculate_content_width(box_width)
+
+        # Process text (wrapping if enabled)
+        content_lines = self.text_processor.wrap_text(content_with_cursor, content_width)
+
+        # Calculate dynamic height
+        box_height = self.geometry.calculate_box_height(content_lines)
+
+        # Get current style
+        current_style = self.state.get_current_style()
+
+        # Render the complete box
+        fancy_lines = self.box_renderer.render_box(
+            content_lines=content_lines,
+            box_width=box_width,
+            style_name=current_style
+        )
+
+        # Store the fancy input lines for the renderer to use
+        data["fancy_input_lines"] = fancy_lines
+
+        return {"status": "rendered", "lines": len(fancy_lines), "fancy_input_lines": fancy_lines}
+
+    async def initialize(self) -> None:
+        """Initialize the plugin."""
+        pass
+
+    async def register_hooks(self) -> None:
+        """Register all plugin hooks with the event bus."""
+        for hook in self.hooks:
+            await self.event_bus.register_hook(hook)
+
+        # Register status view
+        await self._register_status_view()
+
+    async def _register_status_view(self) -> None:
+        """Register enhanced input status view."""
+        try:
+            # Check if renderer has status registry
+            if (hasattr(self.renderer, 'status_renderer') and
+                self.renderer.status_renderer and
+                hasattr(self.renderer.status_renderer, 'status_registry') and
+                self.renderer.status_renderer.status_registry):
+
+                from core.io.status_renderer import StatusViewConfig, BlockConfig
+
+                # Create input UI view
+                input_view = StatusViewConfig(
+                    name="Input UI",
+                    plugin_source="enhanced_input",
+                    priority=200,  # Lower than core views
+                    blocks=[
+                        BlockConfig(
+                            width_fraction=1.0,
+                            content_provider=self._get_input_ui_content,
+                            title="Input UI",
+                            priority=100
+                        )
+                    ]
+                )
+
+                registry = self.renderer.status_renderer.status_registry
+                registry.register_status_view("enhanced_input", input_view)
+                logger.info(" Enhanced Input registered 'Input UI' status view")
+
+            else:
+                logger.debug("Status registry not available - cannot register status view")
+
+        except Exception as e:
+            logger.error(f"Failed to register enhanced input status view: {e}")
+
+    def _get_input_ui_content(self) -> List[str]:
+        """Get input UI content for status view."""
+        try:
+            if not self.config.enabled:
+                return ["Input: - Off"]
+
+            style_display = self.state.get_status_display()
+
+            return [
+                f"Input: {style_display} ··· Width: {self.config.width_mode}"
+            ]
+
+        except Exception as e:
+            logger.error(f"Error getting input UI content: {e}")
+            return ["Input UI: Error"]
+
+
+    async def shutdown(self) -> None:
+        """Shutdown the plugin."""
+        pass

plugins/fullscreen/__init__.py

@@ -0,0 +1,9 @@
+"""Full-screen plugins directory."""
+
+from .matrix_plugin import MatrixRainPlugin
+from .example_plugin import ExamplePlugin
+
+__all__ = [
+    "MatrixRainPlugin",
+    "ExamplePlugin"
+]