kollabor 0.4.9__py3-none-any.whl

plugins/enhanced_input/box_styles.py

@@ -0,0 +1,142 @@
+"""Box drawing styles for enhanced input plugin."""
+
+import random
+from dataclasses import dataclass
+from typing import Dict, List
+
+
+@dataclass
+class BoxStyle:
+    """Represents a box drawing style with all character components."""
+
+    top_left: str
+    top_right: str
+    bottom_left: str
+    bottom_right: str
+    horizontal: str
+    vertical: str
+
+
+class BoxStyleRegistry:
+    """Registry for managing and providing box drawing styles."""
+
+    def __init__(self):
+        """Initialize the registry with all available styles."""
+        self._styles = self._build_styles()
+        self._curated_random_styles = [
+            # User's confirmed favorites
+            "dots_only", "brackets", "dotted", "dashed", "square",
+            # Clean classics
+            "rounded", "double", "thick", "underline", "minimal",
+            # 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_style(self, name: str) -> BoxStyle:
+        """Get a style by name.
+
+        Args:
+            name: Style name.
+
+        Returns:
+            BoxStyle object.
+
+        Raises:
+            KeyError: If style doesn't exist.
+        """
+        if name not in self._styles:
+            raise KeyError(f"Unknown box style: {name}")
+        return self._styles[name]
+
+    def get_random_style(self) -> BoxStyle:
+        """Get a random style from curated collection.
+
+        Returns:
+            Random BoxStyle object.
+        """
+        style_name = random.choice(self._curated_random_styles)
+        return self.get_style(style_name)
+
+    def get_random_style_name(self) -> str:
+        """Get a random style name from curated collection.
+
+        Returns:
+            Random style name.
+        """
+        return random.choice(self._curated_random_styles)
+
+    def list_styles(self) -> List[str]:
+        """Get list of all available style names.
+
+        Returns:
+            List of style names.
+        """
+        return list(self._styles.keys())
+
+    def register_style(self, name: str, style: BoxStyle) -> None:
+        """Register a new style.
+
+        Args:
+            name: Style name.
+            style: BoxStyle object.
+        """
+        self._styles[name] = style
+
+    def _build_styles(self) -> Dict[str, BoxStyle]:
+        """Build the complete styles dictionary.
+
+        Returns:
+            Dictionary of all box styles.
+        """
+        return {
+            # Classic box styles
+            "rounded": BoxStyle("╭", "╮", "╰", "╯", "─", "│"),
+            "square": BoxStyle("┌", "┐", "└", "┘", "─", "│"),
+            "double": BoxStyle("╔", "╗", "╚", "╝", "═", "║"),
+            "thick": BoxStyle("┏", "┓", "┗", "┛", "━", "┃"),
+            "dotted": BoxStyle("┌", "┐", "└", "┘", "┄", "┆"),
+            "dashed": BoxStyle("┌", "┐", "└", "┘", "┅", "┇"),
+
+            # Minimal styles
+            "minimal": BoxStyle(" ", " ", " ", " ", "─", " "),
+            "brackets": BoxStyle("⌜", "⌝", "⌞", "⌟", " ", " "),
+            "underline": BoxStyle("", "", "", "", "_", ""),
+
+            # Line-only styles
+            "lines_only": BoxStyle("", "", "", "", "─", ""),
+            "thick_lines": BoxStyle("", "", "", "", "━", ""),
+            "double_lines": BoxStyle("", "", "", "", "═", ""),
+            "dots_only": BoxStyle("", "", "", "", "┄", ""),
+            "gradient_line": BoxStyle("", "", "", "", "▁", ""),
+
+            # Decorative styles
+            "stars": BoxStyle("★", "★", "★", "★", "✦", "✧"),
+            "arrows": BoxStyle("↖", "↗", "↙", "↘", "→", "↕"),
+            "diamonds": BoxStyle("◆", "◆", "◆", "◆", "◇", "◈"),
+            "circles": BoxStyle("●", "●", "●", "●", "○", "◐"),
+            "waves": BoxStyle("~", "~", "~", "~", "≈", "∿"),
+
+            # Mixed weight styles
+            "mixed_weight": BoxStyle("┏", "┓", "┗", "┛", "┄", "│"),
+            "typography": BoxStyle("┌", "┐", "└", "┘", "━", "┆"),
+            "sophisticated": BoxStyle("╭", "╮", "╰", "╯", "━", "┆"),
+            "editorial": BoxStyle("┌", "┐", "└", "┘", "─", ""),
+            "clean_corners": BoxStyle("┌", "┐", "└", "┘", "", ""),
+            "refined": BoxStyle("╭", "╮", "╰", "╯", "", ""),
+
+            # Futuristic styles
+            "neon": BoxStyle("▓", "▓", "▓", "▓", "▔", "▐"),
+            "cyber": BoxStyle("◢", "◣", "◥", "◤", "▬", "▌"),
+            "matrix": BoxStyle("╔", "╗", "╚", "╝", "▓", "▓"),
+            "holo": BoxStyle("◊", "◊", "◊", "◊", "◈", "◈"),
+            "quantum": BoxStyle("⟨", "⟩", "⟨", "⟩", "⟷", "⟁"),
+            "neural": BoxStyle("⊙", "⊙", "⊙", "⊙", "⊚", "⊜"),
+            "plasma": BoxStyle("◬", "◭", "◪", "◫", "◯", "◎"),
+            "circuit": BoxStyle("┫", "┣", "┳", "┻", "╋", "╂"),
+            "laser": BoxStyle("", "", "", "", "▇", ""),
+            "scan": BoxStyle("", "", "", "", "▓", ""),
+            "energy": BoxStyle("", "", "", "", "-", ""),
+        }

plugins/enhanced_input/color_engine.py

@@ -0,0 +1,165 @@
+"""Color and gradient engine for enhanced input plugin."""
+
+from typing import List, Tuple
+
+
+class ColorEngine:
+    """Handles all color and gradient operations for enhanced input rendering."""
+
+    def __init__(self, config):
+        """Initialize color engine.
+
+        Args:
+            config: InputConfig object with plugin configuration.
+        """
+        self.config = config
+
+    def apply_color(self, text: str, color_type: str) -> str:
+        """Apply color formatting to text.
+
+        Args:
+            text: Text to color.
+            color_type: Color type ('border', 'text', 'placeholder').
+
+        Returns:
+            Colored text with ANSI codes.
+        """
+        # Check if gradient mode is enabled
+        gradient_mode = self.config.gradient_mode
+
+        if gradient_mode:
+            return self._apply_gradient_color(text, color_type)
+        else:
+            return self._apply_standard_color(text, color_type)
+
+    def _apply_gradient_color(self, text: str, color_type: str) -> str:
+        """Apply gradient coloring to text.
+
+        Args:
+            text: Text to color.
+            color_type: Color type.
+
+        Returns:
+            Text with gradient colors.
+        """
+        gradient_colors = self.config.gradient_colors
+
+        # Apply gradient based on color type
+        if color_type == 'border' and self.config.border_gradient:
+            return self.apply_gradient(text, gradient_colors)
+        elif color_type == 'text' and self.config.text_gradient:
+            return self.apply_gradient(text, gradient_colors)
+        elif color_type == 'placeholder':
+            # Always apply dim to placeholder regardless of gradient
+            return f"\033[2m{text}\033[0m"
+
+        return text
+
+    def _apply_standard_color(self, text: str, color_type: str) -> str:
+        """Apply standard color formatting.
+
+        Args:
+            text: Text to color.
+            color_type: Color type.
+
+        Returns:
+            Colored text with ANSI codes.
+        """
+        color_config = getattr(self.config, f'{color_type}_color', 'default')
+
+        if color_config == 'dim':
+            return f"\033[2m{text}\033[0m"
+        elif color_config == 'bright':
+            return f"\033[1m{text}\033[0m"
+        elif color_config == 'default':
+            return text
+        else:
+            return text
+
+    def apply_gradient(self, text: str, gradient_colors: List[str], is_background: bool = False) -> str:
+        """Apply gradient colors to text.
+
+        Args:
+            text: Text to apply gradient to.
+            gradient_colors: List of hex color strings.
+            is_background: Whether to apply as background colors.
+
+        Returns:
+            Text with gradient ANSI codes.
+        """
+        if len(gradient_colors) < 2 or len(text) == 0:
+            return text
+
+        # Convert hex colors to RGB
+        rgb_colors = [self._hex_to_rgb(color) for color in gradient_colors]
+
+        # Apply gradient character by character
+        result = ""
+        text_length = len(text)
+
+        for i, char in enumerate(text):
+            # Calculate position in gradient (0.0 to 1.0)
+            position = i / max(1, text_length - 1)
+
+            # Find which color segment we're in
+            segment_size = 1.0 / (len(rgb_colors) - 1)
+            segment_index = min(int(position / segment_size), len(rgb_colors) - 2)
+            local_position = (position - segment_index * segment_size) / segment_size
+
+            # Interpolate between colors
+            color1 = rgb_colors[segment_index]
+            color2 = rgb_colors[segment_index + 1]
+            interpolated = self._interpolate_color(color1, color2, local_position)
+
+            # Apply color to character
+            ansi_code = self._rgb_to_ansi(*interpolated, is_background)
+            result += f"{ansi_code}{char}"
+
+        # Reset color at the end
+        result += "\033[0m"
+        return result
+
+    def _hex_to_rgb(self, hex_color: str) -> Tuple[int, int, int]:
+        """Convert hex color to RGB tuple.
+
+        Args:
+            hex_color: Hex color string (e.g., '#1e3a8a').
+
+        Returns:
+            RGB tuple (r, g, b).
+        """
+        hex_color = hex_color.lstrip('#')
+        return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
+
+    def _rgb_to_ansi(self, r: int, g: int, b: int, is_background: bool = False) -> str:
+        """Convert RGB to ANSI escape code.
+
+        Args:
+            r: Red component (0-255).
+            g: Green component (0-255).
+            b: Blue component (0-255).
+            is_background: Whether this is a background color.
+
+        Returns:
+            ANSI escape sequence.
+        """
+        if is_background:
+            return f"\033[48;2;{r};{g};{b}m"
+        else:
+            return f"\033[38;2;{r};{g};{b}m"
+
+    def _interpolate_color(self, color1: Tuple[int, int, int], color2: Tuple[int, int, int], factor: float) -> Tuple[int, int, int]:
+        """Interpolate between two RGB colors.
+
+        Args:
+            color1: First RGB color tuple.
+            color2: Second RGB color tuple.
+            factor: Interpolation factor (0.0 to 1.0).
+
+        Returns:
+            Interpolated RGB tuple.
+        """
+        r = int(color1[0] + (color2[0] - color1[0]) * factor)
+        g = int(color1[1] + (color2[1] - color1[1]) * factor)
+        b = int(color1[2] + (color2[2] - color1[2]) * factor)
+        return (r, g, b)

plugins/enhanced_input/config.py

@@ -0,0 +1,150 @@
+"""Configuration management for Enhanced Input Plugin."""
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from core.config import ConfigManager
+
+
+@dataclass
+class InputConfig:
+    """Type-safe configuration for Enhanced Input Plugin."""
+
+    # Core settings
+    enabled: bool = True
+    style: str = "rounded"
+    width_mode: str = "auto"
+    placeholder: str = "Type your message here..."
+    show_placeholder: bool = True
+
+    # Dimensions
+    min_width: int = 60
+    max_width: int = 120
+    min_height: int = 3
+    max_height: int = 10
+
+    # Dynamic behavior
+    dynamic_sizing: bool = True
+    wrap_text: bool = True
+    randomize_style: bool = False
+    randomize_interval: float = 5.0
+
+    # Cursor settings
+    cursor_blink_rate: float = 0.5
+
+    # Status display
+    show_status: bool = True
+
+    # Color settings
+    border_color: str = "dim"
+    text_color: str = "dim"
+    placeholder_color: str = "dim"
+    gradient_mode: bool = True
+    gradient_colors: List[str] = None
+    border_gradient: bool = True
+    text_gradient: bool = True
+
+
+    def __post_init__(self):
+        """Initialize default gradient colors if not provided."""
+        if self.gradient_colors is None:
+            self.gradient_colors = ["#333333", "#999999", "#222222"]
+
+    @classmethod
+    def from_config_manager(cls, config: 'ConfigManager') -> 'InputConfig':
+        """Create InputConfig from ConfigManager.
+
+        Args:
+            config: Configuration manager instance.
+
+        Returns:
+            InputConfig instance with values from config.
+        """
+        colors_config = config.get("plugins.enhanced_input.colors", {})
+
+        # Ensure colors_config is a dictionary
+        if not isinstance(colors_config, dict):
+            colors_config = {}  # Fallback to empty dict
+
+        return cls(
+            enabled=config.get("plugins.enhanced_input.enabled", True),
+            style=config.get("plugins.enhanced_input.style", "rounded"),
+            width_mode=config.get("plugins.enhanced_input.width", "auto"),
+            placeholder=config.get("plugins.enhanced_input.placeholder", "Type your message here..."),
+            show_placeholder=config.get("plugins.enhanced_input.show_placeholder", True),
+
+            min_width=config.get("plugins.enhanced_input.min_width", 60),
+            max_width=config.get("plugins.enhanced_input.max_width", 120),
+            min_height=config.get("plugins.enhanced_input.min_height", 3),
+            max_height=config.get("plugins.enhanced_input.max_height", 10),
+
+            dynamic_sizing=config.get("plugins.enhanced_input.dynamic_sizing", True),
+            wrap_text=config.get("plugins.enhanced_input.wrap_text", True),
+            randomize_style=config.get("plugins.enhanced_input.randomize_style", False),
+            randomize_interval=config.get("plugins.enhanced_input.randomize_interval", 5.0),
+
+            cursor_blink_rate=config.get("plugins.enhanced_input.cursor_blink_rate", 0.5),
+            show_status=config.get("plugins.enhanced_input.show_status", True),
+
+            border_color=colors_config.get("border", "dim"),
+            text_color=colors_config.get("text", "dim"),
+            placeholder_color=colors_config.get("placeholder", "dim"),
+            gradient_mode=colors_config.get("gradient_mode", True),
+            gradient_colors=colors_config.get("gradient_colors", ["#333333", "#999999", "#222222"]),
+            border_gradient=colors_config.get("border_gradient", True),
+            text_gradient=colors_config.get("text_gradient", True)
+        )
+
+    def get_color_config(self) -> Dict[str, Any]:
+        """Get color configuration as dictionary for ColorEngine.
+
+        Returns:
+            Dictionary with color configuration.
+        """
+        return {
+            "border": self.border_color,
+            "text": self.text_color,
+            "placeholder": self.placeholder_color,
+            "gradient_mode": self.gradient_mode,
+            "gradient_colors": self.gradient_colors,
+            "border_gradient": self.border_gradient,
+            "text_gradient": self.text_gradient
+        }
+
+    def get_default_config_dict(self) -> Dict[str, Any]:
+        """Get default configuration as dictionary for plugin registration.
+
+        Returns:
+            Default configuration dictionary.
+        """
+        return {
+            "plugins": {
+                "enhanced_input": {
+                    "enabled": self.enabled,
+                    "style": self.style,
+                    "width": self.width_mode,
+                    "placeholder": self.placeholder,
+                    "show_placeholder": self.show_placeholder,
+                    "min_width": self.min_width,
+                    "max_width": self.max_width,
+                    "randomize_style": self.randomize_style,
+                    "randomize_interval": self.randomize_interval,
+                    "dynamic_sizing": self.dynamic_sizing,
+                    "min_height": self.min_height,
+                    "max_height": self.max_height,
+                    "wrap_text": self.wrap_text,
+                    "colors": {
+                        "border": self.border_color,
+                        "text": self.text_color,
+                        "placeholder": self.placeholder_color,
+                        "gradient_mode": self.gradient_mode,
+                        "gradient_colors": self.gradient_colors,
+                        "border_gradient": self.border_gradient,
+                        "text_gradient": self.text_gradient
+                    },
+                    "cursor_blink_rate": self.cursor_blink_rate,
+                    "show_status": self.show_status
+                }
+            }
+        }

plugins/enhanced_input/cursor_manager.py

@@ -0,0 +1,72 @@
+"""Cursor management for enhanced input plugin."""
+
+import time
+
+
+class CursorManager:
+    """Manages cursor positioning, blinking, and rendering."""
+
+    def __init__(self, config):
+        """Initialize cursor manager.
+
+        Args:
+            config: InputConfig object with plugin configuration.
+        """
+        self.config = config
+        self.cursor_visible = True
+        self.last_blink_time = 0
+        self.blink_interval = config.cursor_blink_rate
+
+    def insert_cursor(self, text: str, cursor_position: int, cursor_char: str = None) -> str:
+        """Insert cursor character at the specified position.
+
+        Args:
+            text: Text to insert cursor into.
+            cursor_position: Position to insert cursor (0-based).
+            cursor_char: Optional cursor character to use. If None, uses get_cursor_char().
+
+        Returns:
+            Text with cursor inserted.
+        """
+        if cursor_char is None:
+            cursor_char = self.get_cursor_char()
+        cursor_pos = max(0, min(cursor_position, len(text)))
+        return text[:cursor_pos] + cursor_char + text[cursor_pos:]
+
+    def get_cursor_char(self) -> str:
+        """Get the current cursor character.
+
+        Returns:
+            Cursor character ("▌" or " " based on blink state).
+        """
+        return "▌" if self.cursor_visible else " "
+
+    def update_blink_state(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.blink_interval:
+            self.cursor_visible = not self.cursor_visible
+            self.last_blink_time = current_time
+
+    def is_input_active(self, renderer) -> bool:
+        """Determine if input is currently active.
+
+        Args:
+            renderer: Terminal renderer object.
+
+        Returns:
+            True if input is active (not writing messages or thinking).
+        """
+        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

plugins/enhanced_input/geometry.py

@@ -0,0 +1,81 @@
+"""Geometry calculations for enhanced input plugin."""
+
+import shutil
+from typing import List
+
+
+class GeometryCalculator:
+    """Handles all layout and dimension calculations for enhanced input boxes."""
+
+    def __init__(self, config):
+        """Initialize geometry calculator.
+
+        Args:
+            config: InputConfig object with plugin configuration.
+        """
+        self.config = config
+
+    def calculate_box_width(self) -> int:
+        """Calculate the optimal box width.
+
+        Returns:
+            Box width in characters.
+        """
+        width_mode = self.config.width_mode
+
+        if width_mode == "auto":
+            terminal_width = self._get_terminal_width()
+            # Leave some margin on both sides
+            proposed_width = terminal_width - 4
+            # Apply min/max constraints
+            min_width = self.config.min_width
+            max_width = self.config.max_width
+            return max(min_width, min(max_width, proposed_width))
+        else:
+            # Fixed width mode - use configured width or sensible default
+            return getattr(self.config, 'fixed_width', 80)
+
+    def calculate_box_height(self, content_lines: List[str]) -> int:
+        """Calculate the box height based on content.
+
+        Args:
+            content_lines: List of content lines.
+
+        Returns:
+            Total box height including borders.
+        """
+        dynamic_sizing = self.config.dynamic_sizing
+
+        if not dynamic_sizing:
+            return 3  # Fixed: top border + content + bottom border
+
+        content_height = len(content_lines)
+        total_height = content_height + 2  # Add top and bottom borders
+
+        # Apply min/max constraints
+        min_height = self.config.min_height
+        max_height = self.config.max_height
+        return max(min_height, min(max_height, total_height))
+
+    def calculate_content_width(self, box_width: int) -> int:
+        """Calculate content area width.
+
+        Args:
+            box_width: Total box width.
+
+        Returns:
+            Content width (excluding borders and spaces).
+        """
+        # Width breakdown: │ + space + content + space + │ = box_width
+        return box_width - 4  # 2 border chars + 2 spaces
+
+    def _get_terminal_width(self) -> int:
+        """Get the current terminal width.
+
+        Returns:
+            Terminal width in columns.
+        """
+        try:
+            return shutil.get_terminal_size().columns
+        except:
+            return 80  # Default fallback