codemaster-cli 2.2.0__py3-none-any.whl

vibe/cli/textual_ui/external_editor.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+import shlex
+import subprocess
+import tempfile
+
+
+class ExternalEditor:
+    """Handles opening an external editor to edit prompt content."""
+
+    @staticmethod
+    def get_editor() -> str:
+        return os.environ.get("VISUAL") or os.environ.get("EDITOR") or "nano"
+
+    def edit(self, initial_content: str = "") -> str | None:
+        editor = self.get_editor()
+        fd, filepath = tempfile.mkstemp(suffix=".md", prefix="vibe_")
+        try:
+            with os.fdopen(fd, "w") as f:
+                f.write(initial_content)
+
+            parts = shlex.split(editor)
+            subprocess.run([*parts, filepath], check=True)
+
+            content = Path(filepath).read_text().rstrip()
+            return content if content != initial_content else None
+        except (OSError, subprocess.CalledProcessError):
+            return
+        finally:
+            Path(filepath).unlink(missing_ok=True)

vibe/cli/textual_ui/handlers/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from vibe.cli.textual_ui.handlers.event_handler import EventHandler
+
+__all__ = ["EventHandler"]

vibe/cli/textual_ui/handlers/event_handler.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+from vibe.cli.textual_ui.widgets.compact import CompactMessage
+from vibe.cli.textual_ui.widgets.messages import AssistantMessage, ReasoningMessage
+from vibe.cli.textual_ui.widgets.no_markup_static import NoMarkupStatic
+from vibe.cli.textual_ui.widgets.tools import ToolCallMessage, ToolResultMessage
+from vibe.core.tools.ui import ToolUIDataAdapter
+from vibe.core.types import (
+    AssistantEvent,
+    BaseEvent,
+    CompactEndEvent,
+    CompactStartEvent,
+    ReasoningEvent,
+    ToolCallEvent,
+    ToolResultEvent,
+    ToolStreamEvent,
+    UserMessageEvent,
+)
+from vibe.core.utils import TaggedText
+
+if TYPE_CHECKING:
+    from vibe.cli.textual_ui.widgets.loading import LoadingWidget
+
+
+class EventHandler:
+    def __init__(
+        self,
+        mount_callback: Callable,
+        scroll_callback: Callable,
+        get_tools_collapsed: Callable[[], bool],
+    ) -> None:
+        self.mount_callback = mount_callback
+        self.scroll_callback = scroll_callback
+        self.get_tools_collapsed = get_tools_collapsed
+        self.current_tool_call: ToolCallMessage | None = None
+        self.current_compact: CompactMessage | None = None
+
+    async def handle_event(
+        self,
+        event: BaseEvent,
+        loading_active: bool = False,
+        loading_widget: LoadingWidget | None = None,
+    ) -> ToolCallMessage | None:
+        match event:
+            case ToolCallEvent():
+                return await self._handle_tool_call(event, loading_widget)
+            case ToolResultEvent():
+                sanitized_event = self._sanitize_event(event)
+                await self._handle_tool_result(sanitized_event)
+            case ToolStreamEvent():
+                await self._handle_tool_stream(event)
+            case ReasoningEvent():
+                await self._handle_reasoning_message(event)
+            case AssistantEvent():
+                await self._handle_assistant_message(event)
+            case CompactStartEvent():
+                await self._handle_compact_start()
+            case CompactEndEvent():
+                await self._handle_compact_end(event)
+            case UserMessageEvent():
+                pass
+            case _:
+                await self._handle_unknown_event(event)
+        return None
+
+    def _sanitize_event(self, event: ToolResultEvent) -> ToolResultEvent:
+        if isinstance(event, ToolResultEvent):
+            return ToolResultEvent(
+                tool_name=event.tool_name,
+                tool_class=event.tool_class,
+                result=event.result,
+                error=TaggedText.from_string(event.error).message
+                if event.error
+                else None,
+                skipped=event.skipped,
+                skip_reason=TaggedText.from_string(event.skip_reason).message
+                if event.skip_reason
+                else None,
+                duration=event.duration,
+                tool_call_id=event.tool_call_id,
+            )
+        return event
+
+    async def _handle_tool_call(
+        self, event: ToolCallEvent, loading_widget: LoadingWidget | None = None
+    ) -> ToolCallMessage | None:
+        tool_call = ToolCallMessage(event)
+
+        if loading_widget and event.tool_class:
+            adapter = ToolUIDataAdapter(event.tool_class)
+            status_text = adapter.get_status_text()
+            loading_widget.set_status(status_text)
+
+        self.current_tool_call = tool_call
+        await self.mount_callback(tool_call)
+
+        return tool_call
+
+    async def _handle_tool_result(self, event: ToolResultEvent) -> None:
+        tools_collapsed = self.get_tools_collapsed()
+        tool_result = ToolResultMessage(
+            event, self.current_tool_call, collapsed=tools_collapsed
+        )
+        await self.mount_callback(tool_result)
+
+        self.current_tool_call = None
+
+    async def _handle_tool_stream(self, event: ToolStreamEvent) -> None:
+        if self.current_tool_call:
+            self.current_tool_call.set_stream_message(event.message)
+
+    async def _handle_assistant_message(self, event: AssistantEvent) -> None:
+        await self.mount_callback(AssistantMessage(event.content))
+
+    async def _handle_reasoning_message(self, event: ReasoningEvent) -> None:
+        tools_collapsed = self.get_tools_collapsed()
+        await self.mount_callback(
+            ReasoningMessage(event.content, collapsed=tools_collapsed)
+        )
+
+    async def _handle_compact_start(self) -> None:
+        compact_msg = CompactMessage()
+        self.current_compact = compact_msg
+        await self.mount_callback(compact_msg)
+
+    async def _handle_compact_end(self, event: CompactEndEvent) -> None:
+        if self.current_compact:
+            self.current_compact.set_complete(
+                old_tokens=event.old_context_tokens, new_tokens=event.new_context_tokens
+            )
+            self.current_compact = None
+
+    async def _handle_unknown_event(self, event: BaseEvent) -> None:
+        await self.mount_callback(NoMarkupStatic(str(event), classes="unknown-event"))
+
+    def stop_current_tool_call(self, success: bool = True) -> None:
+        if self.current_tool_call:
+            self.current_tool_call.stop_spinning(success=success)
+            self.current_tool_call = None
+
+    def stop_current_compact(self) -> None:
+        if self.current_compact:
+            self.current_compact.stop_spinning(success=False)
+            self.current_compact = None

vibe/cli/textual_ui/widgets/approval_app.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+from typing import ClassVar
+
+from pydantic import BaseModel
+from textual import events
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Container, Vertical, VerticalScroll
+from textual.message import Message
+from textual.widgets import Static
+
+from vibe.cli.textual_ui.widgets.no_markup_static import NoMarkupStatic
+from vibe.cli.textual_ui.widgets.tool_widgets import get_approval_widget
+from vibe.core.config import VibeConfig
+
+
+class ApprovalApp(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("enter", "select", "Select", show=False),
+        Binding("1", "select_1", "Yes", show=False),
+        Binding("y", "select_1", "Yes", show=False),
+        Binding("2", "select_2", "Always Tool Session", show=False),
+        Binding("3", "select_3", "No", show=False),
+        Binding("n", "select_3", "No", show=False),
+    ]
+
+    class ApprovalGranted(Message):
+        def __init__(self, tool_name: str, tool_args: BaseModel) -> None:
+            super().__init__()
+            self.tool_name = tool_name
+            self.tool_args = tool_args
+
+    class ApprovalGrantedAlwaysTool(Message):
+        def __init__(
+            self, tool_name: str, tool_args: BaseModel, save_permanently: bool
+        ) -> None:
+            super().__init__()
+            self.tool_name = tool_name
+            self.tool_args = tool_args
+            self.save_permanently = save_permanently
+
+    class ApprovalRejected(Message):
+        def __init__(self, tool_name: str, tool_args: BaseModel) -> None:
+            super().__init__()
+            self.tool_name = tool_name
+            self.tool_args = tool_args
+
+    def __init__(
+        self, tool_name: str, tool_args: BaseModel, config: VibeConfig
+    ) -> None:
+        super().__init__(id="approval-app")
+        self.tool_name = tool_name
+        self.tool_args = tool_args
+        self.config = config
+        self.selected_option = 0
+        self.content_container: Vertical | None = None
+        self.title_widget: Static | None = None
+        self.tool_info_container: Vertical | None = None
+        self.option_widgets: list[Static] = []
+        self.help_widget: Static | None = None
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="approval-options"):
+            yield NoMarkupStatic("")
+            for _ in range(3):
+                widget = NoMarkupStatic("", classes="approval-option")
+                self.option_widgets.append(widget)
+                yield widget
+            yield NoMarkupStatic("")
+            self.help_widget = NoMarkupStatic(
+                "↑↓ navigate  Enter select  ESC reject", classes="approval-help"
+            )
+            yield self.help_widget
+
+        with Vertical(id="approval-content"):
+            self.title_widget = NoMarkupStatic(
+                f"⚠ {self.tool_name} command", classes="approval-title"
+            )
+            yield self.title_widget
+
+            with VerticalScroll(classes="approval-tool-info-scroll"):
+                self.tool_info_container = Vertical(
+                    classes="approval-tool-info-container"
+                )
+                yield self.tool_info_container
+
+    async def on_mount(self) -> None:
+        await self._update_tool_info()
+        self._update_options()
+        self.focus()
+
+    async def _update_tool_info(self) -> None:
+        if not self.tool_info_container:
+            return
+
+        approval_widget = get_approval_widget(self.tool_name, self.tool_args)
+        await self.tool_info_container.remove_children()
+        await self.tool_info_container.mount(approval_widget)
+
+    def _update_options(self) -> None:
+        options = [
+            ("Yes", "yes"),
+            (f"Yes and always allow {self.tool_name} for this session", "yes"),
+            ("No and tell the agent what to do instead", "no"),
+        ]
+
+        for idx, ((text, color_type), widget) in enumerate(
+            zip(options, self.option_widgets, strict=True)
+        ):
+            is_selected = idx == self.selected_option
+
+            cursor = "› " if is_selected else "  "
+            option_text = f"{cursor}{idx + 1}. {text}"
+
+            widget.update(option_text)
+
+            widget.remove_class("approval-cursor-selected")
+            widget.remove_class("approval-option-selected")
+            widget.remove_class("approval-option-yes")
+            widget.remove_class("approval-option-no")
+
+            if is_selected:
+                widget.add_class("approval-cursor-selected")
+                if color_type == "yes":
+                    widget.add_class("approval-option-yes")
+                else:
+                    widget.add_class("approval-option-no")
+            else:
+                widget.add_class("approval-option-selected")
+                if color_type == "yes":
+                    widget.add_class("approval-option-yes")
+                else:
+                    widget.add_class("approval-option-no")
+
+    def action_move_up(self) -> None:
+        self.selected_option = (self.selected_option - 1) % 3
+        self._update_options()
+
+    def action_move_down(self) -> None:
+        self.selected_option = (self.selected_option + 1) % 3
+        self._update_options()
+
+    def action_select(self) -> None:
+        self._handle_selection(self.selected_option)
+
+    def action_select_1(self) -> None:
+        self.selected_option = 0
+        self._handle_selection(0)
+
+    def action_select_2(self) -> None:
+        self.selected_option = 1
+        self._handle_selection(1)
+
+    def action_select_3(self) -> None:
+        self.selected_option = 2
+        self._handle_selection(2)
+
+    def action_reject(self) -> None:
+        self.selected_option = 2
+        self._handle_selection(2)
+
+    def _handle_selection(self, option: int) -> None:
+        match option:
+            case 0:
+                self.post_message(
+                    self.ApprovalGranted(
+                        tool_name=self.tool_name, tool_args=self.tool_args
+                    )
+                )
+            case 1:
+                self.post_message(
+                    self.ApprovalGrantedAlwaysTool(
+                        tool_name=self.tool_name,
+                        tool_args=self.tool_args,
+                        save_permanently=False,
+                    )
+                )
+            case 2:
+                self.post_message(
+                    self.ApprovalRejected(
+                        tool_name=self.tool_name, tool_args=self.tool_args
+                    )
+                )
+
+    def on_blur(self, event: events.Blur) -> None:
+        self.call_after_refresh(self.focus)

vibe/cli/textual_ui/widgets/banner/banner.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.reactive import reactive
+from textual.widgets import Static
+
+from vibe import __version__
+from vibe.cli.textual_ui.widgets.banner.petit_chat import PetitChat
+from vibe.cli.textual_ui.widgets.no_markup_static import NoMarkupStatic
+from vibe.core.config import VibeConfig
+from vibe.core.skills.manager import SkillManager
+
+
+@dataclass
+class BannerState:
+    active_model: str = ""
+    models_count: int = 0
+    mcp_servers_count: int = 0
+    skills_count: int = 0
+
+
+class Banner(Static):
+    state = reactive(BannerState(), init=False)
+
+    def __init__(
+        self, config: VibeConfig, skill_manager: SkillManager, **kwargs: Any
+    ) -> None:
+        super().__init__(**kwargs)
+        self.can_focus = False
+        self._initial_state = BannerState(
+            active_model=config.active_model,
+            models_count=len(config.models),
+            mcp_servers_count=len(config.mcp_servers),
+            skills_count=len(skill_manager.available_skills),
+        )
+        self._animated = not config.disable_welcome_banner_animation
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(id="banner-container"):
+            yield PetitChat(animate=self._animated)
+
+            with Vertical(id="banner-info"):
+                with Horizontal(classes="banner-line"):
+                    yield NoMarkupStatic("codeMaster", id="banner-brand")
+                    yield NoMarkupStatic(" ", classes="banner-spacer")
+                    yield NoMarkupStatic(f"v{__version__} · ", classes="banner-meta")
+                    yield NoMarkupStatic("", id="banner-model")
+                with Horizontal(classes="banner-line"):
+                    yield NoMarkupStatic("", id="banner-meta-counts")
+                with Horizontal(classes="banner-line"):
+                    yield NoMarkupStatic("Type ", classes="banner-meta")
+                    yield NoMarkupStatic("/help", classes="banner-cmd")
+                    yield NoMarkupStatic(" for more information", classes="banner-meta")
+
+    def on_mount(self) -> None:
+        self.state = self._initial_state
+
+    def watch_state(self) -> None:
+        self.query_one("#banner-model", NoMarkupStatic).update(self.state.active_model)
+        self.query_one("#banner-meta-counts", NoMarkupStatic).update(
+            self._format_meta_counts()
+        )
+
+    def freeze_animation(self) -> None:
+        if self._animated:
+            self.query_one(PetitChat).freeze_animation()
+
+    def set_state(self, config: VibeConfig, skill_manager: SkillManager) -> None:
+        self.state = BannerState(
+            active_model=config.active_model,
+            models_count=len(config.models),
+            mcp_servers_count=len(config.mcp_servers),
+            skills_count=len(skill_manager.available_skills),
+        )
+
+    def _format_meta_counts(self) -> str:
+        return (
+            f"{self.state.models_count} model{'s' if self.state.models_count != 1 else ''}"
+            f" · {self.state.mcp_servers_count} MCP server{'s' if self.state.mcp_servers_count != 1 else ''}"
+            f" · {self.state.skills_count} skill{'s' if self.state.skills_count != 1 else ''}"
+        )

vibe/cli/textual_ui/widgets/banner/petit_chat.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.timer import Timer
+from textual.widgets import Static
+
+from vibe.cli.textual_ui.widgets.braille_renderer import render_braille
+
+WIDTH = 22
+HEIGHT = 12
+STARTING_DOTS = [
+    set[int](),
+    {6, 7, 15, 19},
+    {5, 8, 14, 16, 18, 20},
+    {4, 6, 7, 14, 17, 20},
+    {3, 5, 10, 11, 12, 14, 20},
+    {3, 5, 9, 13, 14, 16, 18, 20},
+    {3, 5, 8, 13, 17, 21},
+    {3, 6, 7, 8, 11, 14, 15, 16, 18, 19, 20},
+    {4, 5, 8, 12, 17, 19},
+    {6, 7, 8, 13, 18, 20},
+    {9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20},
+    set[int](),
+]
+QUEUE_RIGHT_TO_MID = {
+    "remove": {1j + 6, 1j + 7, 2j + 8, 3j + 4, 3j + 6, 3j + 7, 8j + 4, 8j + 5},
+    "add": {1j + 4, 2j + 3, 3j + 3, 3j + 5, 7j + 5, 8j + 3, 9j + 4, 9j + 5},
+}
+QUEUE_MID_TO_RIGHT = {
+    "remove": QUEUE_RIGHT_TO_MID["add"],
+    "add": QUEUE_RIGHT_TO_MID["remove"],
+}
+QUEUE_MID_TO_LEFT = {
+    "remove": {1j + 4, 2j + 5, 3j + 3, 3j + 5, 7j + 5, 8j + 3, 9j + 4, 9j + 5},
+    "add": {1j + 1, 1j + 2, 2j, 3j + 1, 3j + 2, 3j + 4, 8j + 4, 8j + 5},
+}
+QUEUE_LEFT_TO_MID = {
+    "remove": QUEUE_MID_TO_LEFT["add"],
+    "add": QUEUE_MID_TO_LEFT["remove"],
+}
+WAIT = {"remove": set[int](), "add": set[int]()}
+HEAD_RIGHT = {"remove": {5j + 16, 5j + 18, 6j + 17}, "add": {5j + 17, 5j + 19, 6j + 18}}
+HEAD_LEFT = {"remove": {5j + 17, 5j + 19, 6j + 18}, "add": {5j + 16, 5j + 18, 6j + 17}}
+HEAD_DOWN = {
+    "remove": {
+        1j + 15,
+        1j + 19,
+        2j + 14,
+        2j + 16,
+        2j + 18,
+        2j + 20,
+        3j + 17,
+        5j + 17,
+        5j + 19,
+        6j + 13,
+        6j + 18,
+        6j + 21,
+        7j + 14,
+        7j + 15,
+        7j + 16,
+        7j + 19,
+        7j + 20,
+    },
+    "add": {
+        2j + 15,
+        2j + 19,
+        3j + 16,
+        3j + 18,
+        4j + 17,
+        6j + 14,
+        6j + 17,
+        6j + 19,
+        6j + 20,
+        7j + 13,
+        7j + 18,
+        7j + 21,
+        8j + 14,
+        8j + 15,
+        8j + 16,
+        8j + 18,
+        8j + 20,
+    },
+}
+HEAD_UP = {
+    "remove": {
+        2j + 15,
+        2j + 19,
+        3j + 16,
+        3j + 18,
+        4j + 17,
+        6j + 14,
+        6j + 17,
+        6j + 19,
+        6j + 20,
+        7j + 13,
+        7j + 18,
+        7j + 21,
+        8j + 14,
+        8j + 15,
+        8j + 16,
+        8j + 18,
+        8j + 20,
+    },
+    "add": {
+        1j + 15,
+        1j + 19,
+        2j + 14,
+        2j + 16,
+        2j + 18,
+        2j + 20,
+        3j + 17,
+        5j + 17,
+        5j + 19,
+        6j + 13,
+        6j + 18,
+        6j + 21,
+        7j + 14,
+        7j + 15,
+        7j + 16,
+        7j + 18,
+        7j + 19,
+        7j + 20,
+    },
+}
+BLINK_EYES_HEAD_HIGH = [
+    {"remove": {5j + 16, 5j + 18}, "add": set[int]()},
+    {"remove": set[int](), "add": {5j + 16, 5j + 18}},
+]
+BLINK_EYES_HEAD_LOW = [
+    {"remove": {6j + 17, 6j + 19}, "add": set[int]()},
+    {"remove": set[int](), "add": {6j + 17, 6j + 19}},
+]
+TRANSITIONS = [
+    *BLINK_EYES_HEAD_HIGH,
+    WAIT,
+    QUEUE_RIGHT_TO_MID,
+    HEAD_RIGHT,
+    WAIT,
+    QUEUE_MID_TO_LEFT,
+    WAIT,
+    QUEUE_LEFT_TO_MID,
+    WAIT,
+    HEAD_DOWN,
+    WAIT,
+    QUEUE_MID_TO_RIGHT,
+    *BLINK_EYES_HEAD_LOW,
+    WAIT,
+    QUEUE_RIGHT_TO_MID,
+    WAIT,
+    QUEUE_MID_TO_LEFT,
+    WAIT,
+    HEAD_UP,
+    WAIT,
+    QUEUE_LEFT_TO_MID,
+    HEAD_LEFT,
+    WAIT,
+    QUEUE_MID_TO_RIGHT,
+]
+# cf render_braille() docstring for coordinates convention
+
+
+class PetitChat(Static):
+    def __init__(self, animate: bool = True, **kwargs: Any) -> None:
+        super().__init__(**kwargs, classes="banner-chat")
+        self._dots = {1j * y + x for y, row in enumerate(STARTING_DOTS) for x in row}
+        self._transition_index = 0
+        self._do_animate = animate
+        self._freeze_requested = False
+        self._timer: Timer | None = None
+
+    def compose(self) -> ComposeResult:
+        yield Static(render_braille(self._dots, WIDTH, HEIGHT), classes="petit-chat")
+
+    def on_mount(self) -> None:
+        self._inner = self.query_one(".petit-chat", Static)
+        if self._do_animate:
+            self._timer = self.set_interval(0.16, self._apply_next_transition)
+
+    def freeze_animation(self) -> None:
+        self._freeze_requested = True
+
+    def _apply_next_transition(self) -> None:
+        if self._freeze_requested and self._transition_index == 0:
+            if self._timer:
+                self._timer.stop()
+            self._timer = None
+            return
+
+        transition = TRANSITIONS[self._transition_index]
+        self._dots -= transition["remove"]
+        self._dots |= transition["add"]
+        self._transition_index = (self._transition_index + 1) % len(TRANSITIONS)
+        self._inner.update(render_braille(self._dots, WIDTH, HEIGHT))