codemaster-cli 2.2.0__py3-none-any.whl

vibe/cli/textual_ui/widgets/braille_renderer.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+import math
+
+# for more details on braille characters encoding, see: https://en.wikipedia.org/wiki/Braille_Patterns
+
+_BRAILLE_DOT_COUNT = 8
+
+
+def _braille_dot_index(x: int, y: int) -> int:
+    """returns the number associated with a dot in a braille character
+    x ∈ {0, 1}, y ∈ {0, 1, 2, 3}
+     -x->
+    | 1 4
+    y 2 5
+    | 3 6
+    V 7 8
+    """
+    if y < 3:  # noqa: PLR2004
+        return y + 1 + 3 * x
+    return 7 + x
+
+
+def _braille_char_from_dot_indices(indices: list[int]) -> str:
+    if any(n < 1 or n > _BRAILLE_DOT_COUNT for n in indices):
+        raise ValueError(f"Invalid braille dot indices: {indices}")
+    return chr(0x2800 + sum(2 ** (d - 1) for d in indices)) if indices else " "
+
+
+def render_braille(dot_coords: Iterable[complex], width: int, height: int) -> str:
+    """this function receives a list of dot coordinantes, a width and a height,
+    and returns a string representing these dots with braille characters.
+
+    Origin is (0,0) and is located at the top left:
+    0----x---->
+    |
+    y
+    |
+    V
+    """
+    dots_matrix: list[list[list[int]]] = [
+        [[] for _ in range(math.ceil(width / 2))] for _ in range(math.ceil(height / 4))
+    ]  # the list of dots for each character in the final str
+
+    for coord in dot_coords:
+        x = int(coord.real // 2)
+        y = int(coord.imag // 4)
+        sub_x = int(coord.real) % 2
+        sub_y = int(coord.imag) % 4
+        dots_matrix[y][x].append(_braille_dot_index(sub_x, sub_y))
+
+    braille_chars = [
+        [_braille_char_from_dot_indices(char_dots) for char_dots in row]
+        for row in dots_matrix
+    ]
+
+    return "\n".join("".join(row) for row in braille_chars)

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

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from vibe.cli.textual_ui.widgets.chat_input.body import ChatInputBody
+from vibe.cli.textual_ui.widgets.chat_input.container import ChatInputContainer
+from vibe.cli.textual_ui.widgets.chat_input.text_area import ChatTextArea
+
+__all__ = ["ChatInputBody", "ChatInputContainer", "ChatTextArea"]

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

@@ -0,0 +1,214 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.message import Message
+from textual.widget import Widget
+
+from vibe.cli.history_manager import HistoryManager
+from vibe.cli.textual_ui.widgets.chat_input.text_area import ChatTextArea, InputMode
+from vibe.cli.textual_ui.widgets.no_markup_static import NoMarkupStatic
+
+
+class ChatInputBody(Widget):
+    class Submitted(Message):
+        def __init__(self, value: str) -> None:
+            self.value = value
+            super().__init__()
+
+    def __init__(
+        self,
+        history_file: Path | None = None,
+        nuage_enabled: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.input_widget: ChatTextArea | None = None
+        self.prompt_widget: NoMarkupStatic | None = None
+        self._nuage_enabled = nuage_enabled
+
+        if history_file:
+            self.history = HistoryManager(history_file)
+        else:
+            self.history = None
+
+        self._completion_reset: Callable[[], None] | None = None
+
+    def compose(self) -> ComposeResult:
+        with Horizontal():
+            self.prompt_widget = NoMarkupStatic(">", id="prompt")
+            yield self.prompt_widget
+
+            self.input_widget = ChatTextArea(
+                id="input", nuage_enabled=self._nuage_enabled
+            )
+            yield self.input_widget
+
+    def on_mount(self) -> None:
+        if self.input_widget:
+            self.input_widget.focus()
+
+    def _parse_mode_and_text(self, text: str) -> tuple[InputMode, str]:
+        if text.startswith("!"):
+            return "!", text[1:]
+        elif text.startswith("/"):
+            return "/", text[1:]
+        elif text.startswith("&") and self._nuage_enabled:
+            return "&", text[1:]
+        else:
+            return ">", text
+
+    def _update_prompt(self) -> None:
+        if not self.input_widget or not self.prompt_widget:
+            return
+
+        self.prompt_widget.update(self.input_widget.input_mode)
+
+    def on_chat_text_area_mode_changed(self, event: ChatTextArea.ModeChanged) -> None:
+        if self.prompt_widget:
+            self.prompt_widget.update(event.mode)
+
+    def _load_history_entry(self, text: str, cursor_col: int | None = None) -> None:
+        if not self.input_widget:
+            return
+
+        mode, display_text = self._parse_mode_and_text(text)
+
+        self.input_widget._navigating_history = True
+        self.input_widget.set_mode(mode)
+        self.input_widget.load_text(display_text)
+
+        first_line = display_text.split("\n")[0]
+        col = cursor_col if cursor_col is not None else len(first_line)
+        cursor_pos = (0, col)
+
+        self.input_widget.move_cursor(cursor_pos)
+        self.input_widget._last_cursor_col = col
+        self.input_widget._cursor_pos_after_load = cursor_pos
+        self.input_widget._cursor_moved_since_load = False
+
+        self._update_prompt()
+        self._notify_completion_reset()
+
+    def on_chat_text_area_history_previous(
+        self, event: ChatTextArea.HistoryPrevious
+    ) -> None:
+        if not self.history or not self.input_widget:
+            return
+
+        if self.history._current_index == -1:
+            self.input_widget._original_text = self.input_widget.text
+
+        if (
+            self.history._current_index != -1
+            and self.input_widget._last_used_prefix is not None
+            and self.input_widget._last_used_prefix != event.prefix
+        ):
+            self.history.reset_navigation()
+
+        self.input_widget._last_used_prefix = event.prefix
+        previous = self.history.get_previous(
+            self.input_widget._original_text, prefix=event.prefix
+        )
+
+        if previous is not None:
+            self._load_history_entry(previous)
+
+    def on_chat_text_area_history_next(self, event: ChatTextArea.HistoryNext) -> None:
+        if not self.history or not self.input_widget:
+            return
+
+        if self.history._current_index == -1:
+            return
+
+        if (
+            self.input_widget._last_used_prefix is not None
+            and self.input_widget._last_used_prefix != event.prefix
+        ):
+            self.history.reset_navigation()
+
+        self.input_widget._last_used_prefix = event.prefix
+
+        has_next = any(
+            self.history._entries[i].startswith(event.prefix)
+            for i in range(self.history._current_index + 1, len(self.history._entries))
+        )
+
+        original_matches = self.input_widget._original_text.startswith(event.prefix)
+
+        if has_next or original_matches:
+            next_entry = self.history.get_next(prefix=event.prefix)
+            if next_entry is not None:
+                cursor_col = (
+                    len(event.prefix) if self.history._current_index == -1 else None
+                )
+                self._load_history_entry(next_entry, cursor_col=cursor_col)
+
+    def on_chat_text_area_history_reset(self, event: ChatTextArea.HistoryReset) -> None:
+        if self.history:
+            self.history.reset_navigation()
+        if self.input_widget:
+            self.input_widget._original_text = ""
+            self.input_widget._cursor_pos_after_load = None
+            self.input_widget._cursor_moved_since_load = False
+
+    def on_chat_text_area_submitted(self, event: ChatTextArea.Submitted) -> None:
+        event.stop()
+
+        if not self.input_widget:
+            return
+
+        value = event.value.strip()
+        if value:
+            if self.history:
+                self.history.add(value)
+                self.history.reset_navigation()
+
+            self.input_widget.clear_text()
+            self._update_prompt()
+
+            self._notify_completion_reset()
+
+            self.post_message(self.Submitted(value))
+
+    @property
+    def value(self) -> str:
+        if not self.input_widget:
+            return ""
+        return self.input_widget.get_full_text()
+
+    @value.setter
+    def value(self, text: str) -> None:
+        if self.input_widget:
+            mode, display_text = self._parse_mode_and_text(text)
+            self.input_widget.set_mode(mode)
+            self.input_widget.load_text(display_text)
+            self._update_prompt()
+
+    def focus_input(self) -> None:
+        if self.input_widget:
+            self.input_widget.focus()
+
+    def set_completion_reset_callback(
+        self, callback: Callable[[], None] | None
+    ) -> None:
+        self._completion_reset = callback
+
+    def _notify_completion_reset(self) -> None:
+        if self._completion_reset:
+            self._completion_reset()
+
+    def replace_input(self, text: str, cursor_offset: int | None = None) -> None:
+        if not self.input_widget:
+            return
+
+        self.input_widget.load_text(text)
+        self.input_widget.reset_history_state()
+        self._update_prompt()
+
+        if cursor_offset is not None:
+            self.input_widget.set_cursor_offset(max(0, min(cursor_offset, len(text))))

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

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Protocol
+
+from textual import events
+
+from vibe.cli.autocompletion.base import CompletionResult
+
+
+class CompletionController(Protocol):
+    def can_handle(self, text: str, cursor_index: int) -> bool: ...
+
+    def on_text_changed(self, text: str, cursor_index: int) -> None: ...
+
+    def on_key(
+        self, event: events.Key, text: str, cursor_index: int
+    ) -> CompletionResult: ...
+
+    def reset(self) -> None: ...
+
+
+class MultiCompletionManager:
+    def __init__(self, controllers: Sequence[CompletionController]) -> None:
+        self._controllers = list(controllers)
+        self._active: CompletionController | None = None
+
+    def on_text_changed(self, text: str, cursor_index: int) -> None:
+        candidate = None
+        for controller in self._controllers:
+            if controller.can_handle(text, cursor_index):
+                candidate = controller
+                break
+
+        if candidate is None:
+            if self._active is not None:
+                self._active.reset()
+                self._active = None
+            return
+
+        if candidate is not self._active:
+            if self._active is not None:
+                self._active.reset()
+            self._active = candidate
+
+        candidate.on_text_changed(text, cursor_index)
+
+    def on_key(
+        self, event: events.Key, text: str, cursor_index: int
+    ) -> CompletionResult:
+        if self._active is None:
+            return CompletionResult.IGNORED
+        return self._active.on_key(event, text, cursor_index)
+
+    def reset(self) -> None:
+        if self._active is not None:
+            self._active.reset()
+            self._active = None

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

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import Any
+
+from rich.text import Text
+from textual.widgets import Static
+
+
+class CompletionPopup(Static):
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__("", id="completion-popup", **kwargs)
+        self.styles.display = "none"
+        self.can_focus = False
+
+    def update_suggestions(
+        self, suggestions: list[tuple[str, str]], selected: int
+    ) -> None:
+        if not suggestions:
+            self.hide()
+            return
+
+        text = Text()
+        for idx, (label, description) in enumerate(suggestions):
+            if idx:
+                text.append("\n")
+
+            label_style = "bold reverse" if idx == selected else "bold"
+            description_style = "italic" if idx == selected else "dim"
+
+            text.append(label, style=label_style)
+            if description:
+                text.append("  ")
+                text.append(description, style=description_style)
+
+        self.update(text)
+        self.show()
+
+    def hide(self) -> None:
+        self.update("")
+        self.styles.display = "none"
+
+    def show(self) -> None:
+        self.styles.display = "block"

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

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.message import Message
+
+from vibe.cli.autocompletion.path_completion import PathCompletionController
+from vibe.cli.autocompletion.slash_command import SlashCommandController
+from vibe.cli.commands import CommandRegistry
+from vibe.cli.textual_ui.widgets.chat_input.body import ChatInputBody
+from vibe.cli.textual_ui.widgets.chat_input.completion_manager import (
+    MultiCompletionManager,
+)
+from vibe.cli.textual_ui.widgets.chat_input.completion_popup import CompletionPopup
+from vibe.cli.textual_ui.widgets.chat_input.text_area import ChatTextArea
+from vibe.core.agents import AgentSafety
+from vibe.core.autocompletion.completers import CommandCompleter, PathCompleter
+
+SAFETY_BORDER_CLASSES: dict[AgentSafety, str] = {
+    AgentSafety.SAFE: "border-safe",
+    AgentSafety.DESTRUCTIVE: "border-warning",
+    AgentSafety.YOLO: "border-error",
+}
+
+
+class ChatInputContainer(Vertical):
+    ID_INPUT_BOX = "input-box"
+
+    class Submitted(Message):
+        def __init__(self, value: str) -> None:
+            self.value = value
+            super().__init__()
+
+    def __init__(
+        self,
+        history_file: Path | None = None,
+        command_registry: CommandRegistry | None = None,
+        safety: AgentSafety = AgentSafety.NEUTRAL,
+        agent_name: str = "",
+        skill_entries_getter: Callable[[], list[tuple[str, str]]] | None = None,
+        nuage_enabled: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._history_file = history_file
+        self._command_registry = command_registry or CommandRegistry()
+        self._safety = safety
+        self._agent_name = agent_name
+        self._skill_entries_getter = skill_entries_getter
+        self._nuage_enabled = nuage_enabled
+
+        self._completion_manager = MultiCompletionManager([
+            SlashCommandController(CommandCompleter(self._get_slash_entries), self),
+            PathCompletionController(PathCompleter(), self),
+        ])
+        self._completion_popup: CompletionPopup | None = None
+        self._body: ChatInputBody | None = None
+
+    def _get_slash_entries(self) -> list[tuple[str, str]]:
+        entries = [
+            (alias, command.description)
+            for command in self._command_registry.commands.values()
+            for alias in sorted(command.aliases)
+        ]
+        if self._skill_entries_getter:
+            entries.extend(self._skill_entries_getter())
+        return sorted(entries)
+
+    def compose(self) -> ComposeResult:
+        self._completion_popup = CompletionPopup()
+        yield self._completion_popup
+
+        border_class = SAFETY_BORDER_CLASSES.get(self._safety, "")
+        with Vertical(id=self.ID_INPUT_BOX, classes=border_class) as input_box:
+            input_box.border_title = self._agent_name
+            self._body = ChatInputBody(
+                history_file=self._history_file,
+                id="input-body",
+                nuage_enabled=self._nuage_enabled,
+            )
+
+            yield self._body
+
+    def on_mount(self) -> None:
+        if not self._body:
+            return
+
+        self._body.set_completion_reset_callback(self._completion_manager.reset)
+        if self._body.input_widget:
+            self._body.input_widget.set_completion_manager(self._completion_manager)
+            self._body.focus_input()
+
+    @property
+    def input_widget(self) -> ChatTextArea | None:
+        return self._body.input_widget if self._body else None
+
+    @property
+    def value(self) -> str:
+        if not self._body:
+            return ""
+        return self._body.value
+
+    @value.setter
+    def value(self, text: str) -> None:
+        if not self._body:
+            return
+        self._body.value = text
+        widget = self._body.input_widget
+        if widget:
+            self._completion_manager.on_text_changed(
+                widget.get_full_text(), widget._get_full_cursor_offset()
+            )
+
+    def focus_input(self) -> None:
+        if self._body:
+            self._body.focus_input()
+
+    def render_completion_suggestions(
+        self, suggestions: list[tuple[str, str]], selected_index: int
+    ) -> None:
+        if self._completion_popup:
+            self._completion_popup.update_suggestions(suggestions, selected_index)
+
+    def clear_completion_suggestions(self) -> None:
+        if self._completion_popup:
+            self._completion_popup.hide()
+
+    def _format_insertion(self, replacement: str, suffix: str) -> str:
+        """Format the insertion text with appropriate spacing.
+
+        Args:
+            replacement: The text to insert
+            suffix: The text that follows the insertion point
+
+        Returns:
+            The formatted insertion text with spacing if needed
+        """
+        if replacement.startswith("@"):
+            if replacement.endswith("/"):
+                return replacement
+            # For @-prefixed completions, add space unless suffix starts with whitespace
+            return replacement + (" " if not suffix or not suffix[0].isspace() else "")
+
+        # For other completions, add space only if suffix exists and doesn't start with whitespace
+        return replacement + (" " if suffix and not suffix[0].isspace() else "")
+
+    def replace_completion_range(self, start: int, end: int, replacement: str) -> None:
+        widget = self.input_widget
+        if not widget or not self._body:
+            return
+        start, end, replacement = widget.adjust_from_full_text_coords(
+            start, end, replacement
+        )
+
+        text = widget.text
+        start = max(0, min(start, len(text)))
+        end = max(start, min(end, len(text)))
+
+        prefix = text[:start]
+        suffix = text[end:]
+        insertion = self._format_insertion(replacement, suffix)
+        new_text = f"{prefix}{insertion}{suffix}"
+
+        self._body.replace_input(new_text, cursor_offset=start + len(insertion))
+
+    def on_chat_input_body_submitted(self, event: ChatInputBody.Submitted) -> None:
+        event.stop()
+        self.post_message(self.Submitted(event.value))
+
+    def set_safety(self, safety: AgentSafety) -> None:
+        self._safety = safety
+
+        try:
+            input_box = self.get_widget_by_id(self.ID_INPUT_BOX)
+        except Exception:
+            return
+
+        for border_class in SAFETY_BORDER_CLASSES.values():
+            input_box.remove_class(border_class)
+
+        if safety in SAFETY_BORDER_CLASSES:
+            input_box.add_class(SAFETY_BORDER_CLASSES[safety])
+
+    def set_agent_name(self, name: str) -> None:
+        self._agent_name = name
+
+        try:
+            input_box = self.get_widget_by_id(self.ID_INPUT_BOX)
+            input_box.border_title = name
+        except Exception:
+            pass