codemaster-cli 2.2.0__py3-none-any.whl

vibe/cli/textual_ui/widgets/chat_input/text_area.py

@@ -0,0 +1,365 @@
+from __future__ import annotations
+
+from typing import Any, ClassVar, Literal
+
+from textual import events
+from textual.binding import Binding
+from textual.message import Message
+from textual.widgets import TextArea
+
+from vibe.cli.autocompletion.base import CompletionResult
+from vibe.cli.textual_ui.external_editor import ExternalEditor
+from vibe.cli.textual_ui.widgets.chat_input.completion_manager import (
+    MultiCompletionManager,
+)
+
+InputMode = Literal["!", "/", ">", "&"]
+
+
+class ChatTextArea(TextArea):
+    BINDINGS: ClassVar[list[Binding]] = [
+        Binding(
+            "shift+enter,ctrl+j",
+            "insert_newline",
+            "New Line",
+            show=False,
+            priority=True,
+        ),
+        Binding("ctrl+g", "open_external_editor", "External Editor", show=False),
+    ]
+
+    DEFAULT_MODE: ClassVar[Literal[">"]] = ">"
+
+    class Submitted(Message):
+        def __init__(self, value: str) -> None:
+            self.value = value
+            super().__init__()
+
+    class HistoryPrevious(Message):
+        def __init__(self, prefix: str) -> None:
+            self.prefix = prefix
+            super().__init__()
+
+    class HistoryNext(Message):
+        def __init__(self, prefix: str) -> None:
+            self.prefix = prefix
+            super().__init__()
+
+    class HistoryReset(Message):
+        """Message sent when history navigation should be reset."""
+
+    class ModeChanged(Message):
+        """Message sent when the input mode changes (>, !, /, &)."""
+
+        def __init__(self, mode: InputMode) -> None:
+            self.mode = mode
+            super().__init__()
+
+    def __init__(self, nuage_enabled: bool = False, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._nuage_enabled = nuage_enabled
+        self._input_mode: InputMode = self.DEFAULT_MODE
+        self._history_prefix: str | None = None
+        self._last_text = ""
+        self._navigating_history = False
+        self._last_cursor_col: int = 0
+        self._last_used_prefix: str | None = None
+        self._original_text: str = ""
+        self._cursor_pos_after_load: tuple[int, int] | None = None
+        self._cursor_moved_since_load: bool = False
+        self._completion_manager: MultiCompletionManager | None = None
+        self._app_has_focus: bool = True
+
+    def on_blur(self, event: events.Blur) -> None:
+        if self._app_has_focus:
+            self.call_after_refresh(self.focus)
+
+    def set_app_focus(self, has_focus: bool) -> None:
+        self._app_has_focus = has_focus
+        self.cursor_blink = has_focus
+        if has_focus and not self.has_focus:
+            self.call_after_refresh(self.focus)
+
+    def on_click(self, event: events.Click) -> None:
+        self._mark_cursor_moved_if_needed()
+
+    def action_insert_newline(self) -> None:
+        self.insert("\n")
+
+    def action_open_external_editor(self) -> None:
+        editor = ExternalEditor()
+        current_text = self.get_full_text()
+
+        with self.app.suspend():
+            result = editor.edit(current_text)
+
+        if result is not None:
+            self.clear()
+            self.insert(result)
+
+    def on_text_area_changed(self, event: TextArea.Changed) -> None:
+        if not self._navigating_history and self.text != self._last_text:
+            self._reset_prefix()
+            self._original_text = ""
+            self._cursor_pos_after_load = None
+            self._cursor_moved_since_load = False
+            self.post_message(self.HistoryReset())
+        self._last_text = self.text
+        was_navigating_history = self._navigating_history
+        self._navigating_history = False
+
+        if self._completion_manager and not was_navigating_history:
+            self._completion_manager.on_text_changed(
+                self.get_full_text(), self._get_full_cursor_offset()
+            )
+
+    def _reset_prefix(self) -> None:
+        self._history_prefix = None
+        self._last_used_prefix = None
+
+    def _mark_cursor_moved_if_needed(self) -> None:
+        if (
+            self._cursor_pos_after_load is not None
+            and not self._cursor_moved_since_load
+            and self.cursor_location != self._cursor_pos_after_load
+        ):
+            self._cursor_moved_since_load = True
+            self._reset_prefix()
+
+    def _get_prefix_up_to_cursor(self) -> str:
+        cursor_row, cursor_col = self.cursor_location
+        lines = self.text.split("\n")
+        if cursor_row < len(lines):
+            visible_prefix = lines[cursor_row][:cursor_col]
+            if cursor_row == 0 and self._input_mode != self.DEFAULT_MODE:
+                return self._input_mode + visible_prefix
+            return visible_prefix
+        return ""
+
+    def _handle_history_up(self) -> bool:
+        cursor_row, cursor_col = self.cursor_location
+        if cursor_row == 0:
+            if self._history_prefix is not None and cursor_col != self._last_cursor_col:
+                self._reset_prefix()
+                self._last_cursor_col = 0
+
+            if self._history_prefix is None:
+                self._history_prefix = self._get_prefix_up_to_cursor()
+
+            self._navigating_history = True
+            self.post_message(self.HistoryPrevious(self._history_prefix))
+            return True
+        return False
+
+    def _handle_history_down(self) -> bool:
+        cursor_row, cursor_col = self.cursor_location
+        total_lines = self.text.count("\n") + 1
+
+        on_first_line_unmoved = cursor_row == 0 and not self._cursor_moved_since_load
+        on_last_line = cursor_row == total_lines - 1
+
+        should_intercept = (
+            on_first_line_unmoved and self._history_prefix is not None
+        ) or on_last_line
+
+        if not should_intercept:
+            return False
+
+        if self._history_prefix is not None and cursor_col != self._last_cursor_col:
+            self._reset_prefix()
+            self._last_cursor_col = 0
+
+        if self._history_prefix is None:
+            self._history_prefix = self._get_prefix_up_to_cursor()
+
+        self._navigating_history = True
+        self.post_message(self.HistoryNext(self._history_prefix))
+        return True
+
+    async def _on_key(self, event: events.Key) -> None:  # noqa: PLR0911
+        self._mark_cursor_moved_if_needed()
+
+        manager = self._completion_manager
+        if manager:
+            match manager.on_key(
+                event, self.get_full_text(), self._get_full_cursor_offset()
+            ):
+                case CompletionResult.HANDLED:
+                    event.prevent_default()
+                    event.stop()
+                    return
+                case CompletionResult.SUBMIT:
+                    event.prevent_default()
+                    event.stop()
+                    value = self.get_full_text().strip()
+                    if value:
+                        self._reset_prefix()
+                        self.post_message(self.Submitted(value))
+                    return
+
+        if event.key == "enter":
+            event.prevent_default()
+            event.stop()
+            value = self.get_full_text().strip()
+            if value:
+                self._reset_prefix()
+                self.post_message(self.Submitted(value))
+            return
+
+        if event.key == "shift+enter":
+            event.prevent_default()
+            event.stop()
+            return
+
+        if (
+            event.character
+            and event.character in self.mode_characters
+            and not self.text
+            and self._input_mode == self.DEFAULT_MODE
+        ):
+            self._set_mode(event.character)
+            event.prevent_default()
+            event.stop()
+            return
+
+        if event.key == "backspace" and self._should_reset_mode_on_backspace():
+            self._set_mode(self.DEFAULT_MODE)
+            event.prevent_default()
+            event.stop()
+            return
+
+        if event.key == "up" and self._handle_history_up():
+            event.prevent_default()
+            event.stop()
+            return
+
+        if event.key == "down" and self._handle_history_down():
+            event.prevent_default()
+            event.stop()
+            return
+
+        await super()._on_key(event)
+        self._mark_cursor_moved_if_needed()
+
+    def set_completion_manager(self, manager: MultiCompletionManager | None) -> None:
+        self._completion_manager = manager
+        if self._completion_manager:
+            self._completion_manager.on_text_changed(
+                self.get_full_text(), self._get_full_cursor_offset()
+            )
+
+    def get_cursor_offset(self) -> int:
+        text = self.text
+        row, col = self.cursor_location
+
+        if not text:
+            return 0
+
+        lines = text.split("\n")
+        row = max(0, min(row, len(lines) - 1))
+        col = max(0, col)
+
+        offset = sum(len(lines[i]) + 1 for i in range(row))
+        return offset + min(col, len(lines[row]))
+
+    def set_cursor_offset(self, offset: int) -> None:
+        text = self.text
+        if offset <= 0:
+            self.move_cursor((0, 0))
+            return
+
+        if offset >= len(text):
+            lines = text.split("\n")
+            if not lines:
+                self.move_cursor((0, 0))
+                return
+            last_row = len(lines) - 1
+            self.move_cursor((last_row, len(lines[last_row])))
+            return
+
+        remaining = offset
+        lines = text.split("\n")
+
+        for row, line in enumerate(lines):
+            line_length = len(line)
+            if remaining <= line_length:
+                self.move_cursor((row, remaining))
+                return
+            remaining -= line_length + 1
+
+        last_row = len(lines) - 1
+        self.move_cursor((last_row, len(lines[last_row])))
+
+    def reset_history_state(self) -> None:
+        self._reset_prefix()
+        self._original_text = ""
+        self._cursor_pos_after_load = None
+        self._cursor_moved_since_load = False
+        self._last_text = self.text
+
+    def clear_text(self) -> None:
+        self.clear()
+        self.reset_history_state()
+        self._set_mode(self.DEFAULT_MODE)
+
+    def _set_mode(self, mode: InputMode) -> None:
+        if self._input_mode == mode:
+            return
+        self._input_mode = mode
+        self.post_message(self.ModeChanged(mode))
+        if self._completion_manager:
+            self._completion_manager.on_text_changed(
+                self.get_full_text(), self._get_full_cursor_offset()
+            )
+
+    def _should_reset_mode_on_backspace(self) -> bool:
+        return (
+            self._input_mode != self.DEFAULT_MODE
+            and not self.text
+            and self.get_cursor_offset() == 0
+        )
+
+    def get_full_text(self) -> str:
+        if self._input_mode != self.DEFAULT_MODE:
+            return self._input_mode + self.text
+        return self.text
+
+    def _get_full_cursor_offset(self) -> int:
+        return self.get_cursor_offset() + self._get_mode_prefix_length()
+
+    def _get_mode_prefix_length(self) -> int:
+        return {">": 0, "/": 1, "!": 1, "&": 1}[self._input_mode]
+
+    @property
+    def mode_characters(self) -> set[InputMode]:
+        chars: set[InputMode] = {"!", "/"}
+        if self._nuage_enabled:
+            chars.add("&")
+        return chars
+
+    @property
+    def input_mode(self) -> InputMode:
+        return self._input_mode
+
+    def set_mode(self, mode: InputMode) -> None:
+        if self._input_mode != mode:
+            self._input_mode = mode
+            self.post_message(self.ModeChanged(mode))
+
+    def adjust_from_full_text_coords(
+        self, start: int, end: int, replacement: str
+    ) -> tuple[int, int, str]:
+        """Translate from full-text coordinates to widget coordinates.
+
+        The completion manager works with 'full text' that includes the mode prefix.
+        This adjusts coordinates and replacement text for the actual widget text.
+        """
+        mode_len = self._get_mode_prefix_length()
+
+        adj_start = max(0, start - mode_len)
+        adj_end = max(adj_start, end - mode_len)
+
+        if mode_len > 0 and replacement.startswith(self._input_mode):
+            replacement = replacement[mode_len:]
+
+        return adj_start, adj_end, replacement

vibe/cli/textual_ui/widgets/compact.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from textual.message import Message
+
+from vibe.cli.textual_ui.widgets.status_message import StatusMessage
+from vibe.core.utils import compact_reduction_display
+
+
+class CompactMessage(StatusMessage):
+    class Completed(Message):
+        def __init__(self, compact_widget: CompactMessage) -> None:
+            super().__init__()
+            self.compact_widget = compact_widget
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.add_class("compact-message")
+        self.old_tokens: int | None = None
+        self.new_tokens: int | None = None
+        self.error_message: str | None = None
+
+    def get_content(self) -> str:
+        if self._is_spinning:
+            return "Compacting conversation history..."
+
+        if self.error_message:
+            return f"Error: {self.error_message}"
+
+        return compact_reduction_display(self.old_tokens, self.new_tokens)
+
+    def set_complete(
+        self, old_tokens: int | None = None, new_tokens: int | None = None
+    ) -> None:
+        self.old_tokens = old_tokens
+        self.new_tokens = new_tokens
+        self.stop_spinning(success=True)
+        self.post_message(self.Completed(self))
+
+    def set_error(self, error_message: str) -> None:
+        self.error_message = error_message
+        self.stop_spinning(success=False)

vibe/cli/textual_ui/widgets/config_app.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar, TypedDict
+
+from textual import events
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Container, Vertical
+from textual.message import Message
+from textual.widgets import Static
+
+from vibe.cli.textual_ui.widgets.no_markup_static import NoMarkupStatic
+
+if TYPE_CHECKING:
+    from vibe.core.config import VibeConfig
+
+
+class SettingDefinition(TypedDict):
+    key: str
+    label: str
+    type: str
+    options: list[str]
+
+
+class ConfigApp(Container):
+    can_focus = True
+    can_focus_children = False
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("up", "move_up", "Up", show=False),
+        Binding("down", "move_down", "Down", show=False),
+        Binding("space", "toggle_setting", "Toggle", show=False),
+        Binding("enter", "cycle", "Next", show=False),
+    ]
+
+    class SettingChanged(Message):
+        def __init__(self, key: str, value: str) -> None:
+            super().__init__()
+            self.key = key
+            self.value = value
+
+    class ConfigClosed(Message):
+        def __init__(self, changes: dict[str, str | bool]) -> None:
+            super().__init__()
+            self.changes = changes
+
+    def __init__(self, config: VibeConfig) -> None:
+        super().__init__(id="config-app")
+        self.config = config
+        self.selected_index = 0
+        self.changes: dict[str, str] = {}
+
+        self.settings: list[SettingDefinition] = [
+            {
+                "key": "active_model",
+                "label": "Model",
+                "type": "cycle",
+                "options": [m.alias for m in self.config.models],
+            },
+            {
+                "key": "autocopy_to_clipboard",
+                "label": "Auto-copy",
+                "type": "cycle",
+                "options": ["On", "Off"],
+            },
+        ]
+
+        self.title_widget: Static | None = None
+        self.setting_widgets: list[Static] = []
+        self.help_widget: Static | None = None
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="config-content"):
+            self.title_widget = NoMarkupStatic("Settings", classes="settings-title")
+            yield self.title_widget
+
+            yield NoMarkupStatic("")
+
+            for _ in self.settings:
+                widget = NoMarkupStatic("", classes="settings-option")
+                self.setting_widgets.append(widget)
+                yield widget
+
+            yield NoMarkupStatic("")
+
+            self.help_widget = NoMarkupStatic(
+                "↑↓ navigate  Space/Enter toggle  ESC exit", classes="settings-help"
+            )
+            yield self.help_widget
+
+    def on_mount(self) -> None:
+        self._update_display()
+        self.focus()
+
+    def _get_display_value(self, setting: SettingDefinition) -> str:
+        key = setting["key"]
+        if key in self.changes:
+            return self.changes[key]
+        raw_value = getattr(self.config, key, "")
+        if isinstance(raw_value, bool):
+            return "On" if raw_value else "Off"
+        return str(raw_value)
+
+    def _update_display(self) -> None:
+        for i, (setting, widget) in enumerate(
+            zip(self.settings, self.setting_widgets, strict=True)
+        ):
+            is_selected = i == self.selected_index
+            cursor = "› " if is_selected else "  "
+
+            label: str = setting["label"]
+            value: str = self._get_display_value(setting)
+
+            text = f"{cursor}{label}: {value}"
+
+            widget.update(text)
+
+            widget.remove_class("settings-cursor-selected")
+            widget.remove_class("settings-value-cycle-selected")
+            widget.remove_class("settings-value-cycle-unselected")
+
+            if is_selected:
+                widget.add_class("settings-value-cycle-selected")
+            else:
+                widget.add_class("settings-value-cycle-unselected")
+
+    def action_move_up(self) -> None:
+        self.selected_index = (self.selected_index - 1) % len(self.settings)
+        self._update_display()
+
+    def action_move_down(self) -> None:
+        self.selected_index = (self.selected_index + 1) % len(self.settings)
+        self._update_display()
+
+    def action_toggle_setting(self) -> None:
+        setting = self.settings[self.selected_index]
+        key: str = setting["key"]
+        current: str = self._get_display_value(setting)
+
+        options: list[str] = setting["options"]
+        new_value = ""
+        try:
+            current_idx = options.index(current)
+            next_idx = (current_idx + 1) % len(options)
+            new_value = options[next_idx]
+        except (ValueError, IndexError):
+            new_value = options[0] if options else current
+
+        self.changes[key] = new_value
+
+        self.post_message(self.SettingChanged(key=key, value=new_value))
+
+        self._update_display()
+
+    def action_cycle(self) -> None:
+        self.action_toggle_setting()
+
+    def _convert_changes_for_save(self) -> dict[str, str | bool]:
+        result: dict[str, str | bool] = {}
+        for key, value in self.changes.items():
+            if value in {"On", "Off"}:
+                result[key] = value == "On"
+            else:
+                result[key] = value
+        return result
+
+    def action_close(self) -> None:
+        self.post_message(self.ConfigClosed(changes=self._convert_changes_for_save()))
+
+    def on_blur(self, event: events.Blur) -> None:
+        self.call_after_refresh(self.focus)

vibe/cli/textual_ui/widgets/context_progress.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from textual.reactive import reactive
+
+from vibe.cli.textual_ui.widgets.no_markup_static import NoMarkupStatic
+
+
+@dataclass
+class TokenState:
+    max_tokens: int = 0
+    current_tokens: int = 0
+
+
+class ContextProgress(NoMarkupStatic):
+    tokens = reactive(TokenState())
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+
+    def watch_tokens(self, new_state: TokenState) -> None:
+        if new_state.max_tokens == 0:
+            self.update("")
+            return
+
+        ratio = min(1, new_state.current_tokens / new_state.max_tokens)
+        text = f"{ratio:.0%} of {new_state.max_tokens // 1000}k tokens"
+        self.update(text)

vibe/cli/textual_ui/widgets/load_more.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.message import Message
+from textual.widgets import Button, Static
+
+
+class HistoryLoadMoreRequested(Message):
+    pass
+
+
+class HistoryLoadMoreMessage(Static):
+    def __init__(self) -> None:
+        super().__init__()
+        self.add_class("history-load-more-message")
+        self._label_widget: Button | None = None
+        self._remaining: int | None = None
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(classes="history-load-more-container"):
+            self._label_widget = Button(
+                self._label_text(), classes="history-load-more-button"
+            )
+            yield self._label_widget
+
+    def _label_text(self) -> str:
+        if self._remaining is None:
+            return "Load more messages"
+        return f"Load more messages ({self._remaining})"
+
+    def set_enabled(self, enabled: bool) -> None:
+        if self._label_widget:
+            self._label_widget.disabled = not enabled
+
+    def set_remaining(self, remaining: int | None) -> None:
+        self._remaining = remaining
+        if self._label_widget:
+            self._label_widget.label = self._label_text()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        event.stop()
+        self.post_message(HistoryLoadMoreRequested())