kollabor 0.4.9__py3-none-any.whl

core/ui/widgets/base_widget.py

@@ -0,0 +1,136 @@
+"""Base widget class for modal UI components."""
+
+from abc import ABC, abstractmethod
+from typing import Any, List
+from ...io.key_parser import KeyPress
+
+
+class BaseWidget(ABC):
+    """Base class for all modal widgets.
+
+    Provides common functionality for rendering, input handling, and value management
+    across all widget types including checkboxes, dropdowns, text inputs, and sliders.
+    """
+
+    def __init__(self, config: dict, config_path: str, config_service=None):
+        """Initialize base widget.
+
+        Args:
+            config: Widget configuration dictionary containing display options.
+            config_path: Dot-notation path to config value (e.g., "core.llm.temperature").
+            config_service: ConfigService instance for reading/writing config values.
+        """
+        self.config = config
+        self.config_path = config_path
+        self.config_service = config_service
+        self.focused = False
+        self._pending_value = None
+
+    @abstractmethod
+    def render(self) -> List[str]:
+        """Render widget using existing ColorPalette.
+
+        Returns:
+            List of strings representing widget display lines.
+        """
+        pass
+
+    @abstractmethod
+    def handle_input(self, key_press: KeyPress) -> bool:
+        """Handle input, return True if consumed.
+
+        Args:
+            key_press: Key press event to handle.
+
+        Returns:
+            True if the key press was handled by this widget.
+        """
+        pass
+
+    def get_value(self) -> Any:
+        """Get current value from config system.
+
+        Returns:
+            Current configuration value for this widget's config path.
+        """
+        # Try to get real value from config service
+        if self.config_service:
+            try:
+                value = self.config_service.get(self.config_path)
+                # If we got a value, return it
+                if value is not None:
+                    return value
+            except Exception:
+                # Fall through to defaults if config access fails
+                pass
+
+        # Fallback to defaults for testing or when config service is unavailable
+        # Use reasonable defaults based on widget type
+        widget_type = self.__class__.__name__.lower()
+
+        if "checkbox" in widget_type:
+            return True
+        elif "slider" in widget_type:
+            # For sliders, check config for min/max and return middle value
+            min_val = self.config.get("min_value", 0)
+            max_val = self.config.get("max_value", 1)
+            return (min_val + max_val) / 2
+        elif "dropdown" in widget_type:
+            options = self.config.get("options", [])
+            return options[0] if options else "Unknown"
+        elif "text_input" in widget_type:
+            placeholder = self.config.get("placeholder", "")
+            return placeholder
+        else:
+            return ""
+
+    def set_value(self, value: Any):
+        """Set value (will be saved in Phase 3).
+
+        Args:
+            value: New value to set for this widget.
+        """
+        self._pending_value = value
+
+    def get_pending_value(self) -> Any:
+        """Get pending value if set, otherwise current value.
+
+        Returns:
+            Pending value if available, otherwise current config value.
+        """
+        return self._pending_value if self._pending_value is not None else self.get_value()
+
+    def has_pending_changes(self) -> bool:
+        """Check if widget has unsaved changes.
+
+        Returns:
+            True if there are pending changes to save.
+        """
+        return self._pending_value is not None
+
+    def set_focus(self, focused: bool):
+        """Set widget focus state.
+
+        Args:
+            focused: Whether widget should be focused.
+        """
+        self.focused = focused
+
+    def get_label(self) -> str:
+        """Get widget label from config.
+
+        Returns:
+            Label text for display.
+        """
+        return self.config.get("label", "Widget")
+
+    def is_valid_value(self, value: Any) -> bool:
+        """Validate if a value is acceptable for this widget.
+
+        Args:
+            value: Value to validate.
+
+        Returns:
+            True if value is valid for this widget type.
+        """
+        return True  # Base implementation accepts any value

core/ui/widgets/checkbox.py

@@ -0,0 +1,85 @@
+"""Checkbox widget for modal UI components."""
+
+import logging
+from typing import List
+from .base_widget import BaseWidget
+from ...io.key_parser import KeyPress
+from ...io.visual_effects import ColorPalette
+
+logger = logging.getLogger(__name__)
+
+
+class CheckboxWidget(BaseWidget):
+    """Interactive checkbox widget with ✓ symbol.
+
+    Displays as [ ] or [✓] and toggles state on Enter or Space key press.
+    Uses ColorPalette.BRIGHT for focus highlighting.
+    """
+
+    def __init__(self, config: dict, config_path: str, config_service=None):
+        """Initialize checkbox widget.
+
+        Args:
+            config: Widget configuration dictionary.
+            config_path: Dot-notation path to config value.
+            config_service: ConfigService instance for reading/writing config values.
+        """
+        super().__init__(config, config_path, config_service)
+
+    def render(self) -> List[str]:
+        """Render checkbox with current state.
+
+        Returns:
+            List containing single checkbox display line.
+        """
+        # Get current value (prefer pending value if available)
+        current_value = self.get_pending_value()
+        check = "✓" if current_value else " "
+        label = self.get_label()
+
+        logger.info(f"Checkbox render: value={current_value}, check='{check}', focused={self.focused}")
+
+        # Apply focus highlighting using existing ColorPalette
+        if self.focused:
+            rendered = f"{ColorPalette.BRIGHT_WHITE}  [{check}] {label}{ColorPalette.RESET}"
+        else:
+            rendered = f"  [{check}] {label}"
+
+        logger.info(f"Checkbox rendered as: '{rendered}'")
+        return [rendered]
+
+    def handle_input(self, key_press: KeyPress) -> bool:
+        """Handle checkbox input - toggle on Enter or Space.
+
+        Args:
+            key_press: Key press event to handle.
+
+        Returns:
+            True if key was handled (Enter or Space).
+        """
+        # Check for Enter key (name="Enter" or char="\r" or char="\n")
+        is_enter = key_press.name == "Enter" or key_press.char in ("\r", "\n")
+        # Check for Space key (name="Space" or char=" ")
+        is_space = key_press.name == "Space" or key_press.char == " "
+
+        logger.info(f"🔘 Checkbox handle_input: name={key_press.name}, char={repr(key_press.char)}, is_enter={is_enter}, is_space={is_space}")
+
+        if is_enter or is_space:
+            current_value = self.get_pending_value()
+            new_value = not current_value
+            logger.info(f"🔘 Checkbox TOGGLING: {current_value} → {new_value}")
+            self.set_value(new_value)
+            logger.info(f"🔘 Checkbox value after set: {self.get_pending_value()}, _pending={self._pending_value}")
+            return True
+        return False
+
+    def is_valid_value(self, value) -> bool:
+        """Validate checkbox value - must be boolean.
+
+        Args:
+            value: Value to validate.
+
+        Returns:
+            True if value is boolean.
+        """
+        return isinstance(value, bool)

core/ui/widgets/dropdown.py

@@ -0,0 +1,140 @@
+"""Dropdown widget for modal UI components."""
+
+from typing import List, Any
+from .base_widget import BaseWidget
+from ...io.key_parser import KeyPress
+from ...io.visual_effects import ColorPalette
+
+
+class DropdownWidget(BaseWidget):
+    """Interactive dropdown widget with ▼ indicator.
+
+    Displays as [value ▼] format and cycles through options on Enter.
+    Uses ColorPalette.BRIGHT for focus highlighting.
+    """
+
+    def __init__(self, config: dict, config_path: str, config_service=None):
+        """Initialize dropdown widget.
+
+        Args:
+            config: Widget configuration containing 'options' list.
+            config_path: Dot-notation path to config value.
+            config_service: ConfigService instance for reading/writing config values.
+        """
+        super().__init__(config, config_path, config_service)
+        self.options = config.get("options", [])
+        self._expanded = False
+
+    def render(self) -> List[str]:
+        """Render dropdown with current selection.
+
+        Returns:
+            List containing dropdown display line(s).
+        """
+        current_value = self.get_pending_value()
+        label = self.get_label()
+
+        # Display current selection with dropdown indicator
+        display_value = str(current_value) if current_value is not None else "None"
+
+        if self.focused:
+            main_line = f"{ColorPalette.BRIGHT_WHITE}  {label}: [{display_value} ▼]{ColorPalette.RESET}"
+        else:
+            main_line = f"  {label}: [{display_value} ▼]"
+
+        lines = [main_line]
+
+        # If expanded, show options (Phase 2B feature)
+        if self._expanded and self.focused:
+            for i, option in enumerate(self.options):
+                prefix = "    > " if option == current_value else "      "
+                option_line = f"{ColorPalette.DIM}{prefix}{option}{ColorPalette.RESET}"
+                lines.append(option_line)
+
+        return lines
+
+    def handle_input(self, key_press: KeyPress) -> bool:
+        """Handle dropdown input - cycle options or toggle expansion.
+
+        Args:
+            key_press: Key press event to handle.
+
+        Returns:
+            True if key was handled.
+        """
+        if key_press.name == "Enter":
+            if not self._expanded:
+                # Expand dropdown to show options
+                self._expanded = True
+                return True
+            else:
+                # Collapse dropdown
+                self._expanded = False
+                return True
+
+        elif key_press.name == "ArrowUp" and self._expanded:
+            # Navigate to previous option
+            self._cycle_option(-1)
+            return True
+
+        elif key_press.name == "ArrowDown" and self._expanded:
+            # Navigate to next option
+            self._cycle_option(1)
+            return True
+
+        elif key_press.name == "Escape" and self._expanded:
+            # Collapse dropdown without changing value
+            self._expanded = False
+            return True
+
+        # Quick cycling without expansion (for compact interaction)
+        elif key_press.name == "ArrowRight":
+            self._cycle_option(1)
+            return True
+
+        elif key_press.name == "ArrowLeft":
+            self._cycle_option(-1)
+            return True
+
+        return False
+
+    def _cycle_option(self, direction: int):
+        """Cycle through available options.
+
+        Args:
+            direction: 1 for next, -1 for previous.
+        """
+        if not self.options:
+            return
+
+        current_value = self.get_pending_value()
+
+        try:
+            current_index = self.options.index(current_value)
+        except ValueError:
+            # Current value not in options, start from beginning
+            current_index = -1 if direction == 1 else 0
+
+        new_index = (current_index + direction) % len(self.options)
+        self.set_value(self.options[new_index])
+
+    def set_focus(self, focused: bool):
+        """Set focus and collapse dropdown when losing focus.
+
+        Args:
+            focused: Whether widget should be focused.
+        """
+        super().set_focus(focused)
+        if not focused:
+            self._expanded = False
+
+    def is_valid_value(self, value: Any) -> bool:
+        """Validate dropdown value - must be in options list.
+
+        Args:
+            value: Value to validate.
+
+        Returns:
+            True if value is in the options list.
+        """
+        return value in self.options or not self.options

core/ui/widgets/label.py

@@ -0,0 +1,78 @@
+"""Label widget for read-only value display."""
+
+from typing import Any, Dict, List, Optional
+from .base_widget import BaseWidget
+from ...io.visual_effects import ColorPalette
+
+
+class LabelWidget(BaseWidget):
+    """Read-only label widget for displaying status values.
+
+    Unlike other widgets, this doesn't allow user interaction -
+    it simply displays a label and value pair.
+    """
+
+    def __init__(self, label: str, value: str = "", help_text: str = "",
+                 config_path: str = "", current_value: Any = None, **kwargs):
+        """Initialize label widget.
+
+        Args:
+            label: Display label text.
+            value: Value to display (can also be set via current_value).
+            help_text: Optional help text.
+            config_path: Config path (usually empty for labels).
+            current_value: Alternative way to set value.
+            **kwargs: Additional configuration.
+        """
+        config = {
+            "label": label,
+            "value": value or str(current_value or ""),
+            "help": help_text,
+            **kwargs
+        }
+        super().__init__(config, config_path, None)
+        self._value = value or str(current_value or "")
+
+    def render(self) -> List[str]:
+        """Render the label widget.
+
+        Returns:
+            List containing single label display line.
+        """
+        label = self.config.get("label", "")
+        value = self._value
+
+        # Format: "  Label: Value" (matching other widgets' indentation)
+        if self.focused:
+            rendered = f"{ColorPalette.BRIGHT_WHITE}  {label}: {value}{ColorPalette.RESET}"
+        else:
+            rendered = f"  {label}: {value}"
+
+        return [rendered]
+
+    def handle_input(self, key_press) -> bool:
+        """Handle input (no-op for labels).
+
+        Args:
+            key_press: Key press event.
+
+        Returns:
+            False - labels don't consume input.
+        """
+        return False
+
+    def get_value(self) -> str:
+        """Get the label value.
+
+        Returns:
+            Current value string.
+        """
+        return self._value
+
+    def set_value(self, value: Any) -> None:
+        """Set the label value.
+
+        Args:
+            value: New value to display.
+        """
+        self._value = str(value)

core/ui/widgets/slider.py

@@ -0,0 +1,185 @@
+"""Slider widget for modal UI components."""
+
+from typing import List
+from .base_widget import BaseWidget
+from ...io.key_parser import KeyPress
+from ...io.visual_effects import ColorPalette
+
+
+class SliderWidget(BaseWidget):
+    """Interactive slider widget with █░ visual bar.
+
+    Displays numeric value with visual progress bar and responds to arrow keys.
+    Uses ColorPalette.BRIGHT for focus highlighting.
+    """
+
+    def __init__(self, config: dict, config_path: str, config_service=None):
+        """Initialize slider widget.
+
+        Args:
+            config: Widget configuration with min_value, max_value, step values.
+            config_path: Dot-notation path to config value.
+            config_service: ConfigService instance for reading/writing config values.
+        """
+        super().__init__(config, config_path, config_service)
+        # Support both naming conventions: min/max and min_value/max_value
+        self.min_value = config.get("min_value") or config.get("min", 0.0)
+        self.max_value = config.get("max_value") or config.get("max", 1.0)
+        self.step = config.get("step", 0.1)
+        self.bar_width = config.get("bar_width", 20)
+        self.decimal_places = config.get("decimal_places", 1)
+
+    def render(self) -> List[str]:
+        """Render slider with visual progress bar.
+
+        Returns:
+            List containing slider display line.
+        """
+        # Get current value and ensure it's numeric
+        current_value = self.get_pending_value()
+        try:
+            value = float(current_value) if current_value is not None else self.min_value
+        except (TypeError, ValueError):
+            value = self.min_value
+
+        # Clamp value to valid range
+        value = max(self.min_value, min(self.max_value, value))
+
+        label = self.get_label()
+
+        # Create visual slider bar using existing characters
+        progress = (value - self.min_value) / max(0.001, self.max_value - self.min_value)
+        filled = int(progress * self.bar_width)
+        bar = "█" * filled + "░" * (self.bar_width - filled)
+
+        # Format value display - show as integer if no decimal places needed
+        if self.decimal_places == 0:
+            value_display = f"{int(value)}"
+        else:
+            value_display = f"{value:.{self.decimal_places}f}"
+
+        # Show range info when focused
+        if self.focused:
+            range_info = f" ({self.min_value}–{self.max_value})"
+            main_line = f"{ColorPalette.BRIGHT_WHITE}  {label}: {value_display} [{bar}]{range_info}{ColorPalette.RESET}"
+        else:
+            main_line = f"  {label}: {value_display} [{bar}]"
+
+        return [main_line]
+
+    def handle_input(self, key_press: KeyPress) -> bool:
+        """Handle slider input - arrow keys adjust value.
+
+        Args:
+            key_press: Key press event to handle.
+
+        Returns:
+            True if key was handled.
+        """
+        current_value = self.get_pending_value()
+        try:
+            value = float(current_value) if current_value is not None else self.min_value
+        except (TypeError, ValueError):
+            value = self.min_value
+
+        # Clamp current value to valid range
+        value = max(self.min_value, min(self.max_value, value))
+
+        if key_press.name == "ArrowRight" or key_press.name == "ArrowUp":
+            # Increase value
+            new_value = min(self.max_value, value + self.step)
+            self.set_value(new_value)
+            return True
+
+        elif key_press.name == "ArrowLeft" or key_press.name == "ArrowDown":
+            # Decrease value
+            new_value = max(self.min_value, value - self.step)
+            self.set_value(new_value)
+            return True
+
+        elif key_press.name == "Home":
+            # Set to minimum value
+            self.set_value(self.min_value)
+            return True
+
+        elif key_press.name == "End":
+            # Set to maximum value
+            self.set_value(self.max_value)
+            return True
+
+        elif key_press.name == "Ctrl+ArrowRight":
+            # Large step increase
+            large_step = self.step * 10
+            new_value = min(self.max_value, value + large_step)
+            self.set_value(new_value)
+            return True
+
+        elif key_press.name == "Ctrl+ArrowLeft":
+            # Large step decrease
+            large_step = self.step * 10
+            new_value = max(self.min_value, value - large_step)
+            self.set_value(new_value)
+            return True
+
+        # Handle direct numeric input for precise values
+        elif key_press.char and isinstance(key_press.char, str) and key_press.char.isdigit():
+            # Allow typing numbers (basic implementation)
+            try:
+                # Convert single digit to step-based movement
+                digit = int(key_press.char)
+                target_progress = digit / 10.0  # 0-9 maps to 0%-90%
+                target_value = self.min_value + target_progress * (self.max_value - self.min_value)
+                target_value = max(self.min_value, min(self.max_value, target_value))
+                self.set_value(target_value)
+                return True
+            except ValueError:
+                pass
+
+        return False
+
+    def set_value(self, value):
+        """Set slider value with validation and clamping.
+
+        Args:
+            value: New numeric value.
+        """
+        try:
+            numeric_value = float(value)
+            # Clamp to valid range
+            clamped_value = max(self.min_value, min(self.max_value, numeric_value))
+            # Round to step precision
+            stepped_value = round(clamped_value / self.step) * self.step
+            super().set_value(stepped_value)
+        except (TypeError, ValueError):
+            # Invalid value, set to minimum
+            super().set_value(self.min_value)
+
+    def is_valid_value(self, value) -> bool:
+        """Validate slider value - must be numeric and in range.
+
+        Args:
+            value: Value to validate.
+
+        Returns:
+            True if value is numeric and within min/max range.
+        """
+        try:
+            numeric_value = float(value)
+            return self.min_value <= numeric_value <= self.max_value
+        except (TypeError, ValueError):
+            return False
+
+    def get_progress_percentage(self) -> float:
+        """Get current value as percentage of range.
+
+        Returns:
+            Progress as percentage (0.0 to 1.0).
+        """
+        current_value = self.get_pending_value()
+        try:
+            value = float(current_value) if current_value is not None else self.min_value
+        except (TypeError, ValueError):
+            value = self.min_value
+
+        value = max(self.min_value, min(self.max_value, value))
+        return (value - self.min_value) / max(0.001, self.max_value - self.min_value)