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

core/ui/config_widgets.py

@@ -209,58 +209,158 @@ class ConfigWidgetDefinitions:
                     ]
                 },
                 {
-                    "title": "LLM Settings",
+                    "title": "Application Settings",
                     "widgets": [
                         {
                             "type": "text_input",
-                            "label": "API URL",
-                            "config_path": "core.llm.api_url",
-                            "placeholder": "http://localhost:1234",
-                            "help": "LLM API endpoint URL"
+                            "label": "Application Name",
+                            "config_path": "application.name",
+                            "placeholder": "Kollabor CLI",
+                            "help": "Display name for the application"
                         },
                         {
                             "type": "text_input",
-                            "label": "Model",
-                            "config_path": "core.llm.model",
-                            "placeholder": "qwen/qwen3-4b",
-                            "help": "LLM model identifier"
+                            "label": "Version",
+                            "config_path": "application.version",
+                            "placeholder": "1.0.0",
+                            "help": "Current application version"
+                        }
+                    ]
+                },
+                {
+                    "title": "LLM Settings",
+                    "widgets": [
+                        {
+                            "type": "slider",
+                            "label": "Max History",
+                            "config_path": "core.llm.max_history",
+                            "min_value": 10,
+                            "max_value": 200,
+                            "step": 10,
+                            "help": "Maximum conversation history entries to keep"
+                        },
+                        {
+                            "type": "slider",
+                            "label": "Message History Limit",
+                            "config_path": "core.llm.message_history_limit",
+                            "min_value": 5,
+                            "max_value": 100,
+                            "step": 5,
+                            "help": "Messages sent to API per request"
+                        },
+                        {
+                            "type": "checkbox",
+                            "label": "Enable Streaming",
+                            "config_path": "core.llm.enable_streaming",
+                            "help": "Stream responses as they arrive"
                         },
                         {
                             "type": "slider",
-                            "label": "Temperature",
-                            "config_path": "core.llm.temperature",
+                            "label": "Processing Delay (sec)",
+                            "config_path": "core.llm.processing_delay",
                             "min_value": 0.0,
-                            "max_value": 2.0,
+                            "max_value": 1.0,
                             "step": 0.1,
-                            "help": "Creativity/randomness of responses (0.0-2.0)"
+                            "help": "Delay between processing steps"
                         },
                         {
                             "type": "slider",
-                            "label": "Max History",
-                            "config_path": "core.llm.max_history",
+                            "label": "Thinking Delay (sec)",
+                            "config_path": "core.llm.thinking_delay",
+                            "min_value": 0.0,
+                            "max_value": 1.0,
+                            "step": 0.1,
+                            "help": "Delay for thinking animation display"
+                        }
+                    ]
+                },
+                {
+                    "title": "Tool Execution Timeouts",
+                    "widgets": [
+                        {
+                            "type": "slider",
+                            "label": "Terminal Timeout (sec)",
+                            "config_path": "core.llm.terminal_timeout",
                             "min_value": 10,
-                            "max_value": 200,
+                            "max_value": 300,
                             "step": 10,
-                            "help": "Maximum conversation history entries"
+                            "help": "Timeout for terminal commands in seconds"
+                        },
+                        {
+                            "type": "slider",
+                            "label": "MCP Timeout (sec)",
+                            "config_path": "core.llm.mcp_timeout",
+                            "min_value": 10,
+                            "max_value": 300,
+                            "step": 10,
+                            "help": "Timeout for MCP tool calls in seconds"
                         }
                     ]
                 },
                 {
-                    "title": "Application Settings",
+                    "title": "Logging",
                     "widgets": [
                         {
-                            "type": "text_input",
-                            "label": "Application Name",
-                            "config_path": "application.name",
-                            "placeholder": "Kollabor CLI",
-                            "help": "Display name for the application"
+                            "type": "dropdown",
+                            "label": "Log Level",
+                            "config_path": "logging.level",
+                            "options": ["DEBUG", "INFO", "WARNING", "ERROR"],
+                            "help": "Application logging verbosity"
+                        }
+                    ]
+                },
+                {
+                    "title": "Hooks",
+                    "widgets": [
+                        {
+                            "type": "slider",
+                            "label": "Default Timeout (sec)",
+                            "config_path": "hooks.default_timeout",
+                            "min_value": 5,
+                            "max_value": 120,
+                            "step": 5,
+                            "help": "Default hook execution timeout"
                         },
                         {
-                            "type": "text_input",
-                            "label": "Version",
-                            "config_path": "application.version",
-                            "placeholder": "1.0.0",
-                            "help": "Current application version"
+                            "type": "slider",
+                            "label": "Default Retries",
+                            "config_path": "hooks.default_retries",
+                            "min_value": 0,
+                            "max_value": 10,
+                            "step": 1,
+                            "help": "Number of retry attempts for failed hooks"
+                        }
+                    ]
+                },
+                {
+                    "title": "Performance Thresholds",
+                    "widgets": [
+                        {
+                            "type": "slider",
+                            "label": "Failure Rate Warning",
+                            "config_path": "performance.failure_rate_warning",
+                            "min_value": 0.01,
+                            "max_value": 0.5,
+                            "step": 0.01,
+                            "help": "Failure rate to trigger warning (0.05 = 5%)"
+                        },
+                        {
+                            "type": "slider",
+                            "label": "Failure Rate Critical",
+                            "config_path": "performance.failure_rate_critical",
+                            "min_value": 0.05,
+                            "max_value": 0.5,
+                            "step": 0.01,
+                            "help": "Failure rate to trigger critical alert (0.15 = 15%)"
+                        },
+                        {
+                            "type": "slider",
+                            "label": "Degradation Threshold",
+                            "config_path": "performance.degradation_threshold",
+                            "min_value": 0.05,
+                            "max_value": 0.5,
+                            "step": 0.01,
+                            "help": "Performance degradation threshold (0.15 = 15%)"
                         }
                     ]
                 },

core/ui/live_modal_renderer.py

@@ -75,9 +75,10 @@ class LiveModalRenderer:
             width, height = self.terminal_state.get_size()
 
             # Create layout for fullscreen modal
+            # Use most of the screen, minimal margin for header/footer
             layout = ModalLayout(
                 width=width - 4,  # Leave margin
-                height=height - 2,
+                height=height - 4,  # Minimal margin for borders
                 start_row=1,
                 start_col=2,
                 center_horizontal=True,

core/ui/modal_actions.py

@@ -91,6 +91,11 @@ class ModalActionHandler:
 
             if success:
                 logger.info(f"Successfully saved {len(changes)} configuration changes")
+
+                # Trigger hot reload for all registered services
+                self.config_service._notify_reload_callbacks()
+                logger.info("Hot reload callbacks triggered")
+
                 return {
                     "success": True,
                     "message": f"Saved {len(changes)} configuration changes",

core/ui/modal_overlay_renderer.py

@@ -311,63 +311,3 @@ class ModalOverlayRenderer:
             "has_saved_state": self.saved_state is not None,
             "terminal_size": self.terminal_state.get_size()
         }
-
-
-class ModalDisplayCoordinator:
-    """Coordinates modal display with input system without chat interference.
-
-    This coordinator ensures modal display updates happen through
-    the overlay system rather than the conversation pipeline.
-    """
-
-    def __init__(self, modal_overlay_renderer: ModalOverlayRenderer):
-        """Initialize modal display coordinator.
-
-        Args:
-            modal_overlay_renderer: ModalOverlayRenderer instance.
-        """
-        self.overlay_renderer = modal_overlay_renderer
-        self.event_handlers = {}
-
-    def register_modal_event_handler(self, event_type: str, handler) -> None:
-        """Register event handler for modal interactions.
-
-        Args:
-            event_type: Type of event to handle.
-            handler: Event handler function.
-        """
-        self.event_handlers[event_type] = handler
-
-    def handle_modal_widget_change(self, widget_data: Dict[str, Any]) -> bool:
-        """Handle widget state change in modal.
-
-        Args:
-            widget_data: Widget state change information.
-
-        Returns:
-            True if change was handled successfully.
-        """
-        try:
-            # Trigger modal refresh through overlay system (not chat system)
-            return self.overlay_renderer.refresh_modal_display()
-
-        except Exception as e:
-            logger.error(f"Failed to handle modal widget change: {e}")
-            return False
-
-    def handle_modal_navigation(self, navigation_data: Dict[str, Any]) -> bool:
-        """Handle navigation in modal (arrow keys, tab, etc.).
-
-        Args:
-            navigation_data: Navigation event information.
-
-        Returns:
-            True if navigation was handled successfully.
-        """
-        try:
-            # Process navigation and refresh modal display
-            return self.overlay_renderer.refresh_modal_display()
-
-        except Exception as e:
-            logger.error(f"Failed to handle modal navigation: {e}")
-            return False

core/ui/modal_renderer.py

@@ -16,6 +16,9 @@ from .modal_state_manager import ModalStateManager, ModalLayout, ModalDisplayMod
 
 logger = logging.getLogger(__name__)
 
+# Maximum modal width to prevent overly wide modals
+MAX_MODAL_WIDTH = 80
+
 
 class ModalRenderer:
     """Modal overlay renderer using existing visual effects system."""
@@ -49,6 +52,11 @@ class ModalRenderer:
         self.visible_height = 20  # Number of widget lines visible at once
         self._save_confirm_active = False  # For save confirmation prompt
 
+        # Command list selection (for modals with "commands" sections)
+        self.command_items: List[Dict] = []  # Flat list of all command items
+        self.selected_command_index = 0
+        self.has_command_sections = False
+
         # Action handling
         self.action_handler = ModalActionHandler(config_service) if config_service else None
 
@@ -62,6 +70,9 @@ class ModalRenderer:
             Modal interaction result.
         """
         try:
+            # Reset command selection state for fresh modal
+            self._command_selected = False
+
             # FIXED: Use overlay system instead of chat pipeline clearing
             # No more clear_active_area() - that only clears display, not buffers
 
@@ -130,9 +141,10 @@ class ModalRenderer:
         border_color = ColorPalette.GREY
         title_color = ColorPalette.BRIGHT_WHITE
         footer_color = ColorPalette.GREY
-        # Use dynamic terminal width instead of hardcoded values
+        # Use dynamic terminal width, capped at MAX_MODAL_WIDTH (80 cols)
         terminal_width = getattr(self.terminal_renderer.terminal_state, 'width', 80) if self.terminal_renderer else 80
-        width = min(int(ui_config.width or terminal_width), terminal_width)
+        requested_width = int(ui_config.width or MAX_MODAL_WIDTH)
+        width = min(requested_width, terminal_width, MAX_MODAL_WIDTH)
         title = ui_config.title or "Modal"
 
         lines = []
@@ -176,6 +188,9 @@ class ModalRenderer:
         Returns:
             List of content lines with rendered widgets.
         """
+        # Store config for scroll calculations (needed for non-selectable items)
+        self._last_modal_config = modal_config
+
         all_lines = []  # All content lines before pagination
         border_color = ColorPalette.GREY  # Modal border color
 
@@ -187,6 +202,12 @@ class ModalRenderer:
             self.widgets = self._create_widgets(modal_config)
             if self.widgets:
                 self.widgets[0].set_focus(True)
+            # Reset command selection for command-style modals
+            self.selected_command_index = 0
+
+        # Always rebuild command_items list (but preserve selected_command_index)
+        self.command_items = []
+        self.has_command_sections = False
 
         # Build all content lines with widget indices
         widget_index = 0
@@ -220,6 +241,103 @@ class ModalRenderer:
 
                         widget_index += 1
 
+            # Handle "commands" format (used by help modal, etc.)
+            section_commands = section.get("commands", [])
+            if section_commands and not section_widgets:
+                self.has_command_sections = True
+                for cmd_idx, cmd in enumerate(section_commands):
+                    name = cmd.get("name", "")
+                    description = cmd.get("description", "")
+                    is_selectable = cmd.get("selectable", True)  # Default to selectable
+
+                    # Truncate name and description BEFORE adding ANSI codes
+                    # Layout: "  > name                    description" = ~34 chars prefix + description
+                    max_name_len = 26
+                    if len(name) > max_name_len:
+                        name = name[:max_name_len - 3] + "..."
+
+                    max_desc_len = width - 38  # Account for prefix, name padding, and borders
+                    if len(description) > max_desc_len:
+                        description = description[:max_desc_len - 3] + "..."
+
+                    if is_selectable:
+                        # Track command item with its global index (only for selectable items)
+                        global_cmd_idx = len(self.command_items)
+                        self.command_items.append(cmd)
+
+                        # Check if this item is selected
+                        is_selected = (global_cmd_idx == self.selected_command_index)
+
+                        # Format command line with selection indicator
+                        if is_selected:
+                            # Highlight selected item with lime color
+                            cmd_text = f"  {ColorPalette.LIME_LIGHT}> {name:<26}{ColorPalette.RESET} {description}"
+                        else:
+                            cmd_text = f"    {name:<26} {description}"
+                        widget_line_map.append(-2)  # Command entry (use -2 to distinguish from headers)
+                    else:
+                        # Non-selectable info item - render dimmed
+                        cmd_text = f"    {ColorPalette.DIM}{name:<26} {description}{ColorPalette.RESET}"
+                        widget_line_map.append(-4)  # Non-selectable info line
+
+                    modal_line = f"│{self._pad_line_with_ansi(cmd_text, width-2)}│"
+                    all_lines.append(f"{border_color}{modal_line}{ColorPalette.RESET}")
+
+            # Also handle "sessions" format (used by resume modal, etc.)
+            section_sessions = section.get("sessions", [])
+            if section_sessions and not section_widgets and not section_commands:
+                self.has_command_sections = True
+                for sess_idx, sess in enumerate(section_sessions):
+                    # Track session item with its global index
+                    global_sess_idx = len(self.command_items)
+                    # Convert session format to command format for selection handling
+                    cmd_item = {
+                        "name": sess.get("title", sess.get("id", "Unknown")),
+                        "description": sess.get("subtitle", ""),
+                        "session_id": sess.get("id") or sess.get("metadata", {}).get("session_id", ""),
+                        "action": sess.get("action", "resume_session"),  # Use session's action or default
+                        "exit_mode": sess.get("exit_mode", "normal"),  # How to exit modal before handling
+                        "metadata": sess.get("metadata", {})
+                    }
+                    self.command_items.append(cmd_item)
+
+                    title = sess.get("title", sess.get("id", "Unknown"))
+                    subtitle = sess.get("subtitle", "")
+
+                    # Check if this item is selected
+                    is_selected = (global_sess_idx == self.selected_command_index)
+
+                    # Format session line with selection indicator
+                    # Truncate title BEFORE adding ANSI codes to avoid mid-code truncation
+                    max_title_len = width - 8  # Account for "  > " prefix and borders
+                    if len(title) > max_title_len:
+                        title = title[:max_title_len - 3] + "..."
+
+                    if is_selected:
+                        # Highlight selected item with lime color
+                        sess_text = f"  {ColorPalette.LIME_LIGHT}> {title}{ColorPalette.RESET}"
+                    else:
+                        sess_text = f"    {title}"
+
+                    modal_line = f"│{self._pad_line_with_ansi(sess_text, width-2)}│"
+                    all_lines.append(f"{border_color}{modal_line}{ColorPalette.RESET}")
+                    widget_line_map.append(-2)  # Session entry
+
+                    # Add subtitle on a second line if present
+                    if subtitle:
+                        # Truncate subtitle BEFORE adding ANSI codes
+                        max_sub_len = width - 10  # Account for "      " prefix and borders
+                        if len(subtitle) > max_sub_len:
+                            subtitle = subtitle[:max_sub_len - 3] + "..."
+
+                        if is_selected:
+                            sub_text = f"      {ColorPalette.GREY}{subtitle}{ColorPalette.RESET}"
+                        else:
+                            sub_text = f"      {ColorPalette.DIM}{subtitle}{ColorPalette.RESET}"
+                        sub_line = f"│{self._pad_line_with_ansi(sub_text, width-2)}│"
+                        all_lines.append(f"{border_color}{sub_line}{ColorPalette.RESET}")
+                        widget_line_map.append(-3)  # Subtitle line (non-selectable)
+
             # Add blank line after each section (except the last one)
             if section_idx < len(sections) - 1:
                 blank_line = f"│{' ' * (width-2)}│"
@@ -251,10 +369,20 @@ class ModalRenderer:
 
         # Apply scroll offset and return visible lines
         total_lines = len(all_lines)
+
+        # Clamp scroll offset to valid range (fixes wrap-around from first to last item)
+        max_scroll = max(0, total_lines - self.visible_height)
+        self.scroll_offset = max(0, min(self.scroll_offset, max_scroll))
+
         end_offset = min(self.scroll_offset + self.visible_height, total_lines)
         visible_lines = all_lines[self.scroll_offset:end_offset]
 
-        # Add scroll indicator if needed
+        # Pad to fixed height (visible_height) to prevent height changes when scrolling
+        while len(visible_lines) < self.visible_height:
+            empty_line = f"│{' ' * (width-2)}│"
+            visible_lines.append(f"{border_color}{empty_line}{ColorPalette.RESET}")
+
+        # Add scroll indicator if needed (always at the same position)
         if total_lines > self.visible_height:
             scroll_info = f" [{self.scroll_offset + 1}-{end_offset}/{total_lines}] "
             if self.scroll_offset > 0:
@@ -263,6 +391,10 @@ class ModalRenderer:
                 scroll_info = f"{scroll_info}↓"
             indicator_line = f"│{scroll_info.center(width-2)}│"
             visible_lines.append(f"{ColorPalette.DIM}{indicator_line}{ColorPalette.RESET}")
+        else:
+            # Add empty indicator line to maintain fixed height
+            empty_indicator = f"│{' ' * (width-2)}│"
+            visible_lines.append(f"{border_color}{empty_indicator}{ColorPalette.RESET}")
 
         return visible_lines
 
@@ -291,10 +423,12 @@ class ModalRenderer:
             # This completely bypasses write_message() and conversation buffers
 
             # Create modal layout configuration
-            content_width = max(len(line) for line in lines) if lines else 80
-            # Constrain to terminal width, leaving space for borders
+            # Use visible width (strip ANSI) for accurate layout calculation
+            visible_widths = [len(self._strip_ansi(line)) for line in lines] if lines else [MAX_MODAL_WIDTH]
+            content_width = max(visible_widths)
+            # Constrain to terminal width and MAX_MODAL_WIDTH (80 cols)
             terminal_width = getattr(self.terminal_renderer.terminal_state, 'width', 80) if self.terminal_renderer else 80
-            width = min(content_width + 4, terminal_width - 2)  # Add padding but leave space for borders
+            width = min(content_width, terminal_width - 2, MAX_MODAL_WIDTH)  # Cap at 80 cols
             height = len(lines)
             layout = ModalLayout(
                 width=width,
@@ -379,7 +513,8 @@ class ModalRenderer:
             logger.error(f"Widget config missing 'type' field: {e}")
             raise ValueError(f"Widget config missing required 'type' field: {config}")
 
-        config_path = config.get("config_path", "core.ui.unknown")
+        # Support both "config_path" (for config-bound widgets) and "field" (for form modals)
+        config_path = config.get("config_path") or config.get("field", "core.ui.unknown")
 
         # Get current value from config service if available
         current_value = None
@@ -440,6 +575,68 @@ class ModalRenderer:
         Returns:
             True if navigation was handled.
         """
+        # Handle command-style modal navigation (no widgets, just command items)
+        if self.has_command_sections and self.command_items and not self.widgets:
+            old_index = self.selected_command_index
+            lines_per_item = 2  # Approximate lines per command item
+
+            # Calculate total content height (including non-selectable items)
+            # Use a larger estimate to account for section headers and non-selectable items
+            total_content_lines = self._estimate_total_content_lines()
+            max_scroll = max(0, total_content_lines - self.visible_height)
+
+            if key_press.name == "ArrowDown" or key_press.name == "Tab":
+                if self.selected_command_index < len(self.command_items) - 1:
+                    # Move to next selectable item
+                    self.selected_command_index += 1
+                elif self.scroll_offset < max_scroll:
+                    # At last selectable item but more content below - just scroll
+                    self.scroll_offset = min(self.scroll_offset + 2, max_scroll)
+                    return True  # Don't change selection, just scrolled
+                else:
+                    # At bottom of content - wrap to top
+                    self.selected_command_index = 0
+                    self.scroll_offset = 0
+                    return True
+            elif key_press.name == "ArrowUp":
+                if self.selected_command_index > 0:
+                    # Move to previous selectable item
+                    self.selected_command_index -= 1
+                elif self.scroll_offset > 0:
+                    # At first selectable item but can scroll up - just scroll
+                    self.scroll_offset = max(0, self.scroll_offset - 2)
+                    return True  # Don't change selection, just scrolled
+                else:
+                    # At top of content - wrap to bottom
+                    self.selected_command_index = len(self.command_items) - 1
+                    self.scroll_offset = max_scroll
+                    return True
+            elif key_press.name == "PageDown":
+                self.selected_command_index = min(self.selected_command_index + 10, len(self.command_items) - 1)
+                # Also scroll to bottom if at last item
+                if self.selected_command_index == len(self.command_items) - 1:
+                    self.scroll_offset = max_scroll
+            elif key_press.name == "PageUp":
+                self.selected_command_index = max(self.selected_command_index - 10, 0)
+                # Also scroll to top if at first item
+                if self.selected_command_index == 0:
+                    self.scroll_offset = 0
+            else:
+                return False
+
+            # Update scroll offset to keep selection visible
+            selected_line = self.selected_command_index * lines_per_item
+
+            # Scroll down if selection is below visible area
+            if selected_line >= self.scroll_offset + self.visible_height - 2:
+                self.scroll_offset = max(0, selected_line - self.visible_height + 4)
+
+            # Scroll up if selection is above visible area
+            if selected_line < self.scroll_offset:
+                self.scroll_offset = max(0, selected_line - 2)
+
+            return True
+
         if not self.widgets:
             return False
 
@@ -490,6 +687,17 @@ class ModalRenderer:
         Returns:
             True if input was handled by a widget.
         """
+        # Handle Enter key for command-style modals
+        logger.info(f"🔧 _handle_widget_input: has_command_sections={self.has_command_sections}, "
+                    f"command_items={len(self.command_items) if self.command_items else 0}, "
+                    f"widgets={len(self.widgets) if self.widgets else 0}")
+        if self.has_command_sections and self.command_items and not self.widgets:
+            if key_press.name == "Enter" or key_press.char == "\r":
+                # Mark that a command was selected
+                self._command_selected = True
+                logger.info(f"🎯 Command selected! _command_selected={self._command_selected}")
+                return True
+            return False
 
         if not self.widgets or self.focused_widget_index >= len(self.widgets):
             return False
@@ -499,6 +707,25 @@ class ModalRenderer:
         result = focused_widget.handle_input(key_press)
         return result
 
+    def get_selected_command(self) -> Optional[Dict]:
+        """Get the currently selected command item.
+
+        Returns:
+            Selected command dict or None.
+        """
+        if self.has_command_sections and self.command_items:
+            if 0 <= self.selected_command_index < len(self.command_items):
+                return self.command_items[self.selected_command_index]
+        return None
+
+    def was_command_selected(self) -> bool:
+        """Check if a command was selected via Enter.
+
+        Returns:
+            True if a command was selected.
+        """
+        return getattr(self, '_command_selected', False)
+
     def _get_widget_values(self) -> Dict[str, Any]:
         """Get all widget values for saving.
 
@@ -545,6 +772,40 @@ class ModalRenderer:
         """
         return re.sub(r'\033\[[0-9;]*m', '', text)
 
+    def _estimate_total_content_lines(self) -> int:
+        """Estimate total content lines including non-selectable items.
+
+        Used for scroll calculations when there are non-selectable items
+        at the end of the modal content.
+
+        Returns:
+            Estimated total number of content lines.
+        """
+        if not hasattr(self, '_last_modal_config') or not self._last_modal_config:
+            # Fallback: use command items count * 2 (approximate)
+            return len(self.command_items) * 2 if self.command_items else 0
+
+        total_lines = 0
+        sections = self._last_modal_config.get("sections", [])
+
+        for section in sections:
+            # Section header
+            if section.get("title"):
+                total_lines += 1
+
+            # Count all commands (selectable and non-selectable)
+            commands = section.get("commands", [])
+            total_lines += len(commands)
+
+            # Count sessions
+            sessions = section.get("sessions", [])
+            total_lines += len(sessions)
+
+            # Blank line between sections
+            total_lines += 1
+
+        return total_lines
+
     def _pad_line_with_ansi(self, line: str, target_width: int) -> str:
         """Pad line to target width, accounting for ANSI escape codes.