codemaster-cli 2.2.0__py3-none-any.whl

vibe/cli/textual_ui/widgets/loading.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+from datetime import datetime
+import random
+from time import time
+from typing import ClassVar
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.widgets import Static
+
+from vibe.cli.textual_ui.widgets.no_markup_static import NoMarkupStatic
+from vibe.cli.textual_ui.widgets.spinner import SpinnerMixin, SpinnerType
+
+
+def _format_elapsed(seconds: int) -> str:
+    if seconds < 60:  # noqa: PLR2004
+        return f"{seconds}s"
+
+    minutes, secs = divmod(seconds, 60)
+    if minutes < 60:  # noqa: PLR2004
+        return f"{minutes}m{secs}s"
+
+    hours, mins = divmod(minutes, 60)
+    return f"{hours}h{mins}m{secs}s"
+
+
+class LoadingWidget(SpinnerMixin, Static):
+    TARGET_COLORS = ("#FFD800", "#FFAF00", "#FF8205", "#FA500F", "#E10500")
+    SPINNER_TYPE = SpinnerType.SNAKE
+
+    EASTER_EGGS: ClassVar[list[str]] = [
+        "Eating a chocolatine",
+        "Eating a pain au chocolat",
+        "Réflexion",
+        "Analyse",
+        "Contemplation",
+        "Synthèse",
+        "Reading Proust",
+        "Oui oui baguette",
+        "Counting Rs in strawberry",
+        "Seeding Mistral weights",
+        "Vibing",
+        "Sending good vibes",
+        "Petting le chat",
+    ]
+
+    EASTER_EGGS_HALLOWEEN: ClassVar[list[str]] = [
+        "Trick or treating",
+        "Carving pumpkins",
+        "Summoning spirits",
+        "Brewing potions",
+        "Haunting the terminal",
+        "Petting le chat noir",
+    ]
+
+    EASTER_EGGS_DECEMBER: ClassVar[list[str]] = [
+        "Wrapping presents",
+        "Decorating the tree",
+        "Drinking hot chocolate",
+        "Building snowmen",
+        "Writing holiday cards",
+    ]
+
+    def __init__(self, status: str | None = None) -> None:
+        super().__init__(classes="loading-widget")
+        self.init_spinner()
+        self.status = status or self._get_default_status()
+        self.current_color_index = 0
+        self.transition_progress = 0
+        self._status_widget: Static | None = None
+        self.hint_widget: Static | None = None
+        self.start_time: float | None = None
+        self._last_elapsed: int = -1
+        self._paused_total: float = 0.0
+        self._pause_start: float | None = None
+
+    def _get_easter_egg(self) -> str | None:
+        EASTER_EGG_PROBABILITY = 0.10
+        if random.random() < EASTER_EGG_PROBABILITY:
+            available_eggs = list(self.EASTER_EGGS)
+
+            OCTOBER = 10
+            HALLOWEEN_DAY = 31
+            DECEMBER = 12
+            now = datetime.now()
+            if now.month == OCTOBER and now.day == HALLOWEEN_DAY:
+                available_eggs.extend(self.EASTER_EGGS_HALLOWEEN)
+            if now.month == DECEMBER:
+                available_eggs.extend(self.EASTER_EGGS_DECEMBER)
+
+            return random.choice(available_eggs)
+        return None
+
+    def _get_default_status(self) -> str:
+        return self._get_easter_egg() or "Generating"
+
+    def _apply_easter_egg(self, status: str) -> str:
+        return self._get_easter_egg() or status
+
+    def pause_timer(self) -> None:
+        if self._pause_start is None:
+            self._pause_start = time()
+
+    def resume_timer(self) -> None:
+        if self._pause_start is not None:
+            self._paused_total += time() - self._pause_start
+            self._pause_start = None
+
+    def set_status(self, status: str) -> None:
+        self.status = self._apply_easter_egg(status)
+        self._update_animation()
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(classes="loading-container"):
+            self._indicator_widget = Static(
+                self._spinner.current_frame(), classes="loading-indicator"
+            )
+            yield self._indicator_widget
+
+            self._status_widget = Static("", classes="loading-status")
+            yield self._status_widget
+
+            self.hint_widget = NoMarkupStatic(
+                "(0s esc to interrupt)", classes="loading-hint"
+            )
+            yield self.hint_widget
+
+    def on_mount(self) -> None:
+        self.start_time = time()
+        self._update_animation()
+        self.start_spinner_timer()
+
+    def on_resize(self) -> None:
+        self.refresh_spinner()
+
+    def _update_spinner_frame(self) -> None:
+        if not self._is_spinning:
+            return
+        self._update_animation()
+
+    def _get_color_for_position(self, position: int) -> str:
+        current_color = self.TARGET_COLORS[self.current_color_index]
+        next_color = self.TARGET_COLORS[
+            (self.current_color_index + 1) % len(self.TARGET_COLORS)
+        ]
+        if position < self.transition_progress:
+            return next_color
+        return current_color
+
+    def _build_status_text(self) -> str:
+        parts = []
+        for i, char in enumerate(self.status):
+            color = self._get_color_for_position(1 + i)
+            parts.append(f"[{color}]{char}[/]")
+        ellipsis_start = 1 + len(self.status)
+        color_ellipsis = self._get_color_for_position(ellipsis_start)
+        parts.append(f"[{color_ellipsis}]… [/]")
+        return "".join(parts)
+
+    def _update_animation(self) -> None:
+        total_elements = 1 + len(self.status) + 1
+
+        if self._indicator_widget:
+            spinner_char = self._spinner.next_frame()
+            color = self._get_color_for_position(0)
+            self._indicator_widget.update(f"[{color}]{spinner_char}[/]")
+
+        if self._status_widget:
+            self._status_widget.update(self._build_status_text())
+
+        self.transition_progress += 1
+        if self.transition_progress > total_elements:
+            self.current_color_index = (self.current_color_index + 1) % len(
+                self.TARGET_COLORS
+            )
+            self.transition_progress = 0
+
+        if self.hint_widget and self.start_time is not None:
+            paused = self._paused_total + (
+                time() - self._pause_start if self._pause_start else 0
+            )
+            elapsed = int(time() - self.start_time - paused)
+            if elapsed != self._last_elapsed:
+                self._last_elapsed = elapsed
+                self.hint_widget.update(
+                    f"({_format_elapsed(elapsed)} esc to interrupt)"
+                )
+
+
+@contextmanager
+def paused_timer(loading_widget: LoadingWidget | None) -> Iterator[None]:
+    if loading_widget:
+        loading_widget.pause_timer()
+    try:
+        yield
+    finally:
+        if loading_widget:
+            loading_widget.resume_timer()

vibe/cli/textual_ui/widgets/messages.py

@@ -0,0 +1,277 @@
+from __future__ import annotations
+
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Static
+from textual.widgets._markdown import MarkdownStream
+
+from vibe.cli.textual_ui.ansi_markdown import AnsiMarkdown as Markdown
+from vibe.cli.textual_ui.widgets.no_markup_static import NoMarkupStatic
+from vibe.cli.textual_ui.widgets.spinner import SpinnerMixin, SpinnerType
+
+
+class NonSelectableStatic(NoMarkupStatic):
+    @property
+    def text_selection(self) -> None:
+        return None
+
+    @text_selection.setter
+    def text_selection(self, value: Any) -> None:
+        pass
+
+    def get_selection(self, selection: Any) -> None:
+        return None
+
+
+class ExpandingBorder(NonSelectableStatic):
+    def render(self) -> str:
+        height = self.size.height
+        return "\n".join(["⎢"] * (height - 1) + ["⎣"])
+
+    def on_resize(self) -> None:
+        self.refresh()
+
+
+class UserMessage(Static):
+    def __init__(self, content: str, pending: bool = False) -> None:
+        super().__init__()
+        self.add_class("user-message")
+        self._content = content
+        self._pending = pending
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(classes="user-message-container"):
+            yield NoMarkupStatic(self._content, classes="user-message-content")
+            if self._pending:
+                self.add_class("pending")
+
+    async def set_pending(self, pending: bool) -> None:
+        if pending == self._pending:
+            return
+
+        self._pending = pending
+
+        if pending:
+            self.add_class("pending")
+            return
+
+        self.remove_class("pending")
+
+
+class StreamingMessageBase(Static):
+    def __init__(self, content: str) -> None:
+        super().__init__()
+        self._content = content
+        self._markdown: Markdown | None = None
+        self._stream: MarkdownStream | None = None
+        self._content_initialized = False
+
+    def _get_markdown(self) -> Markdown:
+        if self._markdown is None:
+            raise RuntimeError(
+                "Markdown widget not initialized. compose() must be called first."
+            )
+        return self._markdown
+
+    def _ensure_stream(self) -> MarkdownStream:
+        if self._stream is None:
+            self._stream = Markdown.get_stream(self._get_markdown())
+        return self._stream
+
+    async def append_content(self, content: str) -> None:
+        if not content:
+            return
+
+        self._content += content
+        if self._should_write_content():
+            stream = self._ensure_stream()
+            await stream.write(content)
+
+    async def write_initial_content(self) -> None:
+        if self._content_initialized:
+            return
+        if self._content and self._should_write_content():
+            stream = self._ensure_stream()
+            await stream.write(self._content)
+
+    async def stop_stream(self) -> None:
+        if self._stream is None:
+            return
+
+        await self._stream.stop()
+        self._stream = None
+
+    def _should_write_content(self) -> bool:
+        return True
+
+
+class AssistantMessage(StreamingMessageBase):
+    def __init__(self, content: str) -> None:
+        super().__init__(content)
+        self.add_class("assistant-message")
+
+    def compose(self) -> ComposeResult:
+        if self._content:
+            self._content_initialized = True
+        markdown = Markdown(self._content)
+        self._markdown = markdown
+        yield markdown
+
+
+class ReasoningMessage(SpinnerMixin, StreamingMessageBase):
+    SPINNER_TYPE = SpinnerType.PULSE
+    SPINNING_TEXT = "Thinking"
+    COMPLETED_TEXT = "Thought"
+
+    def __init__(self, content: str, collapsed: bool = True) -> None:
+        super().__init__(content)
+        self.add_class("reasoning-message")
+        self.collapsed = collapsed
+        self._indicator_widget: Static | None = None
+        self._triangle_widget: Static | None = None
+        self.init_spinner()
+
+    def compose(self) -> ComposeResult:
+        with Vertical(classes="reasoning-message-wrapper"):
+            with Horizontal(classes="reasoning-message-header"):
+                self._indicator_widget = NonSelectableStatic(
+                    self._spinner.current_frame(), classes="reasoning-indicator"
+                )
+                yield self._indicator_widget
+                self._status_text_widget = NoMarkupStatic(
+                    self.SPINNING_TEXT, classes="reasoning-collapsed-text"
+                )
+                yield self._status_text_widget
+                self._triangle_widget = NonSelectableStatic(
+                    "▶" if self.collapsed else "▼", classes="reasoning-triangle"
+                )
+                yield self._triangle_widget
+            markdown = Markdown("", classes="reasoning-message-content")
+            markdown.display = not self.collapsed
+            self._markdown = markdown
+            yield markdown
+
+    def on_mount(self) -> None:
+        self.start_spinner_timer()
+
+    def on_resize(self) -> None:
+        self.refresh_spinner()
+
+    async def on_click(self) -> None:
+        await self._toggle_collapsed()
+
+    async def _toggle_collapsed(self) -> None:
+        await self.set_collapsed(not self.collapsed)
+
+    def _should_write_content(self) -> bool:
+        return not self.collapsed
+
+    async def set_collapsed(self, collapsed: bool) -> None:
+        if self.collapsed == collapsed:
+            return
+
+        self.collapsed = collapsed
+        if self._triangle_widget:
+            self._triangle_widget.update("▶" if collapsed else "▼")
+        if self._markdown:
+            self._markdown.display = not collapsed
+            if not collapsed and self._content:
+                if self._stream is not None:
+                    await self._stream.stop()
+                    self._stream = None
+                await self._markdown.update("")
+                stream = self._ensure_stream()
+                await stream.write(self._content)
+
+
+class UserCommandMessage(Static):
+    def __init__(self, content: str) -> None:
+        super().__init__()
+        self.add_class("user-command-message")
+        self._content = content
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(classes="user-command-container"):
+            yield ExpandingBorder(classes="user-command-border")
+            with Vertical(classes="user-command-content"):
+                yield Markdown(self._content)
+
+
+class WhatsNewMessage(Static):
+    def __init__(self, content: str) -> None:
+        super().__init__()
+        self.add_class("whats-new-message")
+        self._content = content
+
+    def compose(self) -> ComposeResult:
+        yield Markdown(self._content)
+
+
+class InterruptMessage(Static):
+    def __init__(self) -> None:
+        super().__init__()
+        self.add_class("interrupt-message")
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(classes="interrupt-container"):
+            yield ExpandingBorder(classes="interrupt-border")
+            yield NoMarkupStatic(
+                "Interrupted · What should Vibe do instead?",
+                classes="interrupt-content",
+            )
+
+
+class BashOutputMessage(Static):
+    def __init__(self, command: str, cwd: str, output: str, exit_code: int) -> None:
+        super().__init__()
+        self.add_class("bash-output-message")
+        self._command = command
+        self._cwd = cwd
+        self._output = output.rstrip("\n")
+        self._exit_code = exit_code
+
+    def compose(self) -> ComposeResult:
+        status_class = "bash-success" if self._exit_code == 0 else "bash-error"
+        self.add_class(status_class)
+        with Horizontal(classes="bash-command-line"):
+            yield NonSelectableStatic("$ ", classes=f"bash-prompt {status_class}")
+            yield NoMarkupStatic(self._command, classes="bash-command")
+        with Horizontal(classes="bash-output-container"):
+            yield ExpandingBorder(classes="bash-output-border")
+            yield NoMarkupStatic(self._output, classes="bash-output")
+
+
+class ErrorMessage(Static):
+    def __init__(self, error: str, collapsed: bool = False) -> None:
+        super().__init__()
+        self.add_class("error-message")
+        self._error = error
+        self.collapsed = collapsed
+        self._content_widget: Static | None = None
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(classes="error-container"):
+            yield ExpandingBorder(classes="error-border")
+            self._content_widget = NoMarkupStatic(
+                f"Error: {self._error}", classes="error-content"
+            )
+            yield self._content_widget
+
+    def set_collapsed(self, collapsed: bool) -> None:
+        pass
+
+
+class WarningMessage(Static):
+    def __init__(self, message: str, show_border: bool = True) -> None:
+        super().__init__()
+        self.add_class("warning-message")
+        self._message = message
+        self._show_border = show_border
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(classes="warning-container"):
+            if self._show_border:
+                yield ExpandingBorder(classes="warning-border")
+            yield NoMarkupStatic(self._message, classes="warning-content")

vibe/cli/textual_ui/widgets/no_markup_static.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from typing import Any
+
+from textual.visual import VisualType
+from textual.widgets import Static
+
+
+class NoMarkupStatic(Static):
+    def __init__(self, content: VisualType = "", **kwargs: Any) -> None:
+        super().__init__(content, markup=False, **kwargs)

vibe/cli/textual_ui/widgets/path_display.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from vibe.cli.textual_ui.widgets.no_markup_static import NoMarkupStatic
+
+
+class PathDisplay(NoMarkupStatic):
+    def __init__(self, path: Path | str) -> None:
+        super().__init__()
+        self.can_focus = False
+        self._path = Path(path)
+        self._update_display()
+
+    def _update_display(self) -> None:
+        path_str = str(self._path)
+        try:
+            home = Path.home()
+            if self._path.is_relative_to(home):
+                path_str = f"~/{self._path.relative_to(home)}"
+        except (ValueError, OSError):
+            pass
+
+        self.update(path_str)
+
+    def set_path(self, path: Path | str) -> None:
+        self._path = Path(path)
+        self._update_display()

vibe/cli/textual_ui/widgets/proxy_setup_app.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+from typing import ClassVar
+
+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 Input, Static
+
+from vibe.cli.textual_ui.widgets.no_markup_static import NoMarkupStatic
+from vibe.core.proxy_setup import (
+    SUPPORTED_PROXY_VARS,
+    get_current_proxy_settings,
+    set_proxy_var,
+    unset_proxy_var,
+)
+
+
+class ProxySetupApp(Container):
+    can_focus = True
+    can_focus_children = True
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("up", "focus_previous", "Up", show=False),
+        Binding("down", "focus_next", "Down", show=False),
+    ]
+
+    class ProxySetupClosed(Message):
+        def __init__(self, saved: bool, error: str | None = None) -> None:
+            super().__init__()
+            self.saved = saved
+            self.error = error
+
+    def __init__(self) -> None:
+        super().__init__(id="proxysetup-app")
+        self.inputs: dict[str, Input] = {}
+        self.initial_values: dict[str, str | None] = {}
+
+    def compose(self) -> ComposeResult:
+        self.initial_values = get_current_proxy_settings()
+
+        with Vertical(id="proxysetup-content"):
+            yield NoMarkupStatic("Proxy Configuration", classes="settings-title")
+            yield NoMarkupStatic("")
+
+            for key, description in SUPPORTED_PROXY_VARS.items():
+                yield Static(
+                    f"[bold ansi_blue]{key}[/]  [dim]{description}[/dim]",
+                    classes="proxy-label-line",
+                )
+
+                initial_value = self.initial_values.get(key) or ""
+                input_widget = Input(
+                    value=initial_value,
+                    placeholder="NOT SET",
+                    id=f"proxy-input-{key}",
+                    classes="proxy-input",
+                )
+                self.inputs[key] = input_widget
+                yield input_widget
+
+                yield NoMarkupStatic("")
+
+            yield NoMarkupStatic(
+                "↑↓ navigate  Enter save & exit  ESC cancel", classes="settings-help"
+            )
+
+    def focus(self, scroll_visible: bool = True) -> ProxySetupApp:
+        """Override focus to focus the first input widget."""
+        if self.inputs:
+            first_input = list(self.inputs.values())[0]
+            first_input.focus(scroll_visible=scroll_visible)
+        else:
+            super().focus(scroll_visible=scroll_visible)
+        return self
+
+    def action_focus_next(self) -> None:
+        inputs = list(self.inputs.values())
+        focused = self.screen.focused
+        if focused is not None and isinstance(focused, Input) and focused in inputs:
+            idx = inputs.index(focused)
+            next_idx = (idx + 1) % len(inputs)
+            inputs[next_idx].focus()
+
+    def action_focus_previous(self) -> None:
+        inputs = list(self.inputs.values())
+        focused = self.screen.focused
+        if focused is not None and isinstance(focused, Input) and focused in inputs:
+            idx = inputs.index(focused)
+            prev_idx = (idx - 1) % len(inputs)
+            inputs[prev_idx].focus()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        self._save_and_close()
+
+    def on_blur(self, _event: events.Blur) -> None:
+        self.call_after_refresh(self._refocus_if_needed)
+
+    def on_input_blurred(self, _event: Input.Blurred) -> None:
+        self.call_after_refresh(self._refocus_if_needed)
+
+    def _refocus_if_needed(self) -> None:
+        if self.has_focus or any(inp.has_focus for inp in self.inputs.values()):
+            return
+        self.focus()
+
+    def _save_and_close(self) -> None:
+        try:
+            for key, input_widget in self.inputs.items():
+                new_value = input_widget.value.strip()
+                old_value = self.initial_values.get(key) or ""
+
+                if new_value != old_value:
+                    if new_value:
+                        set_proxy_var(key, new_value)
+                    else:
+                        unset_proxy_var(key)
+        except Exception as e:
+            self.post_message(self.ProxySetupClosed(saved=False, error=str(e)))
+            return
+
+        self.post_message(self.ProxySetupClosed(saved=True))
+
+    def action_close(self) -> None:
+        self.post_message(self.ProxySetupClosed(saved=False))