codemaster-cli 2.2.0__py3-none-any.whl

vibe/cli/textual_ui/widgets/status_message.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from typing import Any, ClassVar
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.widgets import Static
+
+from vibe.cli.textual_ui.widgets.messages import NonSelectableStatic
+from vibe.cli.textual_ui.widgets.no_markup_static import NoMarkupStatic
+from vibe.cli.textual_ui.widgets.spinner import SpinnerMixin, SpinnerType
+
+
+class StatusMessage(SpinnerMixin, NoMarkupStatic):
+    SPINNER_TYPE: ClassVar[SpinnerType] = SpinnerType.PULSE
+
+    def __init__(self, initial_text: str = "", **kwargs: Any) -> None:
+        self._initial_text = initial_text
+        self._indicator_widget: Static | None = None
+        self._text_widget: NoMarkupStatic | None = None
+        self.success = True
+        self.init_spinner()
+        super().__init__(**kwargs)
+
+    def compose(self) -> ComposeResult:
+        with Horizontal():
+            self._indicator_widget = NonSelectableStatic(
+                self._spinner.current_frame(), classes="status-indicator-icon"
+            )
+            yield self._indicator_widget
+            self._text_widget = NoMarkupStatic("", classes="status-indicator-text")
+            yield self._text_widget
+
+    def on_mount(self) -> None:
+        self.update_display()
+        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_display()
+
+    def update_display(self) -> None:
+        if not self._indicator_widget or not self._text_widget:
+            return
+
+        content = self.get_content()
+
+        if self._is_spinning:
+            self._indicator_widget.update(self._spinner.next_frame())
+            self._indicator_widget.remove_class("success")
+            self._indicator_widget.remove_class("error")
+        elif self.success:
+            self._indicator_widget.update("✓")
+            self._indicator_widget.add_class("success")
+            self._indicator_widget.remove_class("error")
+        else:
+            self._indicator_widget.update("✕")
+            self._indicator_widget.add_class("error")
+            self._indicator_widget.remove_class("success")
+
+        self._text_widget.update(content)
+
+    def get_content(self) -> str:
+        return self._initial_text
+
+    def stop_spinning(self, success: bool = True) -> None:
+        self._is_spinning = False
+        self.success = success
+        if self._spinner_timer:
+            self._spinner_timer.stop()
+            self._spinner_timer = None
+        self.update_display()

vibe/cli/textual_ui/widgets/teleport_message.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from vibe.cli.textual_ui.widgets.status_message import StatusMessage
+
+
+class TeleportMessage(StatusMessage):
+    def __init__(self) -> None:
+        super().__init__()
+        self.add_class("teleport-message")
+        self._status: str = "Teleporting..."
+        self._final_url: str | None = None
+        self._error: str | None = None
+
+    def get_content(self) -> str:
+        if self._error:
+            return f"Teleport failed: {self._error}"
+        if self._final_url:
+            return f"Teleported to Nuage: {self._final_url}"
+        return self._status
+
+    def set_status(self, status: str) -> None:
+        self._status = status
+        self.update_display()
+
+    def set_complete(self, url: str) -> None:
+        self._final_url = url
+        self.stop_spinning(success=True)
+
+    def set_error(self, error: str) -> None:
+        self._error = error
+        self.stop_spinning(success=False)

vibe/cli/textual_ui/widgets/tool_widgets.py

@@ -0,0 +1,371 @@
+from __future__ import annotations
+
+import difflib
+from pathlib import Path
+
+from pydantic import BaseModel
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Static
+
+from vibe.cli.textual_ui.ansi_markdown import AnsiMarkdown as Markdown
+from vibe.cli.textual_ui.widgets.no_markup_static import NoMarkupStatic
+from vibe.core.tools.builtins.ask_user_question import AskUserQuestionResult
+from vibe.core.tools.builtins.bash import BashArgs, BashResult
+from vibe.core.tools.builtins.grep import GrepArgs, GrepResult
+from vibe.core.tools.builtins.read_file import ReadFileArgs, ReadFileResult
+from vibe.core.tools.builtins.search_replace import (
+    SEARCH_REPLACE_BLOCK_RE,
+    SearchReplaceArgs,
+    SearchReplaceResult,
+)
+from vibe.core.tools.builtins.todo import TodoArgs, TodoResult
+from vibe.core.tools.builtins.write_file import WriteFileArgs, WriteFileResult
+
+
+def _truncate_lines(content: str, max_lines: int) -> tuple[str, str | None]:
+    """Truncate content to max_lines, returning (content, truncation_info)."""
+    lines = content.split("\n")
+    if len(lines) <= max_lines:
+        return content, None
+    remaining = len(lines) - max_lines
+    return "\n".join(lines[:max_lines]), f"… ({remaining} more lines)"
+
+
+def parse_search_replace_to_diff(content: str) -> list[str]:
+    """Parse SEARCH/REPLACE blocks and generate unified diff lines."""
+    all_diff_lines: list[str] = []
+    matches = SEARCH_REPLACE_BLOCK_RE.findall(content)
+    if not matches:
+        return [content[:500]] if content else []
+
+    for i, (search_text, replace_text) in enumerate(matches):
+        if i > 0:
+            all_diff_lines.append("")  # Separator between blocks
+        search_lines = search_text.strip().split("\n")
+        replace_lines = replace_text.strip().split("\n")
+        diff = difflib.unified_diff(search_lines, replace_lines, lineterm="", n=2)
+        all_diff_lines.extend(list(diff)[2:])  # Skip file headers
+
+    return all_diff_lines
+
+
+def render_diff_line(line: str) -> Static:
+    """Render a single diff line with appropriate styling."""
+    if line.startswith("---") or line.startswith("+++"):
+        return NoMarkupStatic(line, classes="diff-header")
+    elif line.startswith("-"):
+        return NoMarkupStatic(line, classes="diff-removed")
+    elif line.startswith("+"):
+        return NoMarkupStatic(line, classes="diff-added")
+    elif line.startswith("@@"):
+        return NoMarkupStatic(line, classes="diff-range")
+    else:
+        return NoMarkupStatic(line, classes="diff-context")
+
+
+class ToolApprovalWidget[TArgs: BaseModel](Vertical):
+    """Base class for approval widgets with typed args."""
+
+    def __init__(self, args: TArgs) -> None:
+        super().__init__()
+        self.args = args
+        self.add_class("tool-approval-widget")
+
+    def compose(self) -> ComposeResult:
+        MAX_MSG_SIZE = 150
+        for field_name in type(self.args).model_fields:
+            value = getattr(self.args, field_name)
+            if value is None or value in ("", []):
+                continue
+            value_str = str(value)
+            if len(value_str) > MAX_MSG_SIZE:
+                hidden = len(value_str) - MAX_MSG_SIZE
+                value_str = value_str[:MAX_MSG_SIZE] + f"… ({hidden} more characters)"
+            yield NoMarkupStatic(
+                f"{field_name}: {value_str}", classes="approval-description"
+            )
+
+
+class ToolResultWidget[TResult: BaseModel](Static):
+    """Base class for result widgets with typed result."""
+
+    def __init__(
+        self,
+        result: TResult | None,
+        success: bool,
+        message: str,
+        collapsed: bool = True,
+        warnings: list[str] | None = None,
+    ) -> None:
+        super().__init__()
+        self.result = result
+        self.success = success
+        self.message = message
+        self.collapsed = collapsed
+        self.warnings = warnings or []
+        self.add_class("tool-result-widget")
+
+    def _footer(self, extra: str | None = None) -> ComposeResult:
+        """Yield the footer with optional extra info."""
+        if extra:
+            yield NoMarkupStatic(extra, classes="tool-result-hint")
+
+    def compose(self) -> ComposeResult:
+        """Default: show result fields."""
+        if not self.collapsed and self.result:
+            for field_name in type(self.result).model_fields:
+                value = getattr(self.result, field_name)
+                if value is not None and value not in ("", []):
+                    yield NoMarkupStatic(
+                        f"{field_name}: {value}", classes="tool-result-detail"
+                    )
+        yield from self._footer()
+
+
+class BashApprovalWidget(ToolApprovalWidget[BashArgs]):
+    def compose(self) -> ComposeResult:
+        yield Markdown(f"```bash\n{self.args.command}\n```")
+
+
+class BashResultWidget(ToolResultWidget[BashResult]):
+    def compose(self) -> ComposeResult:
+        if not self.result:
+            yield from self._footer()
+            return
+        if self.collapsed:
+            truncation_info = None
+            if self.result.stdout:
+                content, truncation_info = _truncate_lines(self.result.stdout, 10)
+                yield NoMarkupStatic(content, classes="tool-result-detail")
+            else:
+                yield NoMarkupStatic("(no content)", classes="tool-result-detail")
+            yield from self._footer(truncation_info)
+            return
+        yield NoMarkupStatic(
+            f"returncode: {self.result.returncode}", classes="tool-result-detail"
+        )
+        if self.result.stdout:
+            sep = "\n" if "\n" in self.result.stdout else " "
+            yield NoMarkupStatic(
+                f"stdout:{sep}{self.result.stdout}", classes="tool-result-detail"
+            )
+        if self.result.stderr:
+            sep = "\n" if "\n" in self.result.stderr else " "
+            yield NoMarkupStatic(
+                f"stderr:{sep}{self.result.stderr}", classes="tool-result-detail"
+            )
+        yield from self._footer()
+
+
+class WriteFileApprovalWidget(ToolApprovalWidget[WriteFileArgs]):
+    def compose(self) -> ComposeResult:
+        path = Path(self.args.path)
+        file_extension = path.suffix.lstrip(".") or "text"
+
+        yield NoMarkupStatic(f"File: {self.args.path}", classes="approval-description")
+        yield NoMarkupStatic("")
+        yield Markdown(f"```{file_extension}\n{self.args.content}\n```")
+
+
+class WriteFileResultWidget(ToolResultWidget[WriteFileResult]):
+    def compose(self) -> ComposeResult:
+        if not self.result:
+            yield from self._footer()
+            return
+        ext = Path(self.result.path).suffix.lstrip(".") or "text"
+        if self.collapsed:
+            truncation_info = None
+            if self.result.content:
+                content, truncation_info = _truncate_lines(self.result.content, 10)
+                yield Markdown(f"```{ext}\n{content}\n```")
+            yield from self._footer(truncation_info)
+            return
+        yield NoMarkupStatic(f"Path: {self.result.path}", classes="tool-result-detail")
+        yield NoMarkupStatic(
+            f"Bytes: {self.result.bytes_written}", classes="tool-result-detail"
+        )
+        if self.result.content:
+            yield NoMarkupStatic("")
+            content, _ = _truncate_lines(self.result.content, 10)
+            yield Markdown(f"```{ext}\n{content}\n```")
+        yield from self._footer()
+
+
+class SearchReplaceApprovalWidget(ToolApprovalWidget[SearchReplaceArgs]):
+    def compose(self) -> ComposeResult:
+        yield NoMarkupStatic(
+            f"File: {self.args.file_path}", classes="approval-description"
+        )
+        yield NoMarkupStatic("")
+
+        diff_lines = parse_search_replace_to_diff(self.args.content)
+        for line in diff_lines:
+            yield render_diff_line(line)
+
+
+class SearchReplaceResultWidget(ToolResultWidget[SearchReplaceResult]):
+    def compose(self) -> ComposeResult:
+        if not self.result:
+            yield from self._footer()
+            return
+        for warning in self.warnings:
+            yield NoMarkupStatic(f"⚠ {warning}", classes="tool-result-warning")
+        if self.result.content:
+            for line in parse_search_replace_to_diff(self.result.content):
+                yield render_diff_line(line)
+        yield from self._footer()
+
+
+class TodoApprovalWidget(ToolApprovalWidget[TodoArgs]):
+    def compose(self) -> ComposeResult:
+        yield NoMarkupStatic(
+            f"Action: {self.args.action}", classes="approval-description"
+        )
+        if self.args.todos:
+            yield NoMarkupStatic(
+                f"Todos: {len(self.args.todos)} items", classes="approval-description"
+            )
+
+
+class TodoResultWidget(ToolResultWidget[TodoResult]):
+    def compose(self) -> ComposeResult:
+        if not self.result or not self.result.todos:
+            yield NoMarkupStatic("No todos", classes="todo-empty")
+            yield from self._footer()
+            return
+
+        by_status: dict[str, list] = {
+            "in_progress": [],
+            "pending": [],
+            "completed": [],
+            "cancelled": [],
+        }
+        for todo in self.result.todos:
+            status = (
+                todo.status.value if hasattr(todo.status, "value") else str(todo.status)
+            )
+            if status in by_status:
+                by_status[status].append(todo)
+
+        for status in ["in_progress", "pending", "completed", "cancelled"]:
+            for todo in by_status[status]:
+                icon = self._get_status_icon(status)
+                yield NoMarkupStatic(f"{icon} {todo.content}", classes=f"todo-{status}")
+        yield from self._footer()
+
+    def _get_status_icon(self, status: str) -> str:
+        icons = {"pending": "☐", "in_progress": "☐", "completed": "☑", "cancelled": "☒"}
+        return icons.get(status, "☐")
+
+
+class ReadFileApprovalWidget(ToolApprovalWidget[ReadFileArgs]):
+    def compose(self) -> ComposeResult:
+        yield NoMarkupStatic(f"path: {self.args.path}", classes="approval-description")
+        if self.args.offset > 0:
+            yield NoMarkupStatic(
+                f"offset: {self.args.offset}", classes="approval-description"
+            )
+        if self.args.limit is not None:
+            yield NoMarkupStatic(
+                f"limit: {self.args.limit}", classes="approval-description"
+            )
+
+
+class ReadFileResultWidget(ToolResultWidget[ReadFileResult]):
+    def compose(self) -> ComposeResult:
+        if self.collapsed:
+            yield from self._footer()
+            return
+        if self.result:
+            yield NoMarkupStatic(
+                f"Path: {self.result.path}", classes="tool-result-detail"
+            )
+        for warning in self.warnings:
+            yield NoMarkupStatic(f"⚠ {warning}", classes="tool-result-warning")
+        truncation_info = None
+        if self.result and self.result.content:
+            yield NoMarkupStatic("")
+            ext = Path(self.result.path).suffix.lstrip(".") or "text"
+            content, truncation_info = _truncate_lines(self.result.content, 10)
+            yield Markdown(f"```{ext}\n{content}\n```")
+        yield from self._footer(truncation_info)
+
+
+class GrepApprovalWidget(ToolApprovalWidget[GrepArgs]):
+    def compose(self) -> ComposeResult:
+        yield NoMarkupStatic(
+            f"pattern: {self.args.pattern}", classes="approval-description"
+        )
+        yield NoMarkupStatic(f"path: {self.args.path}", classes="approval-description")
+        if self.args.max_matches is not None:
+            yield NoMarkupStatic(
+                f"max_matches: {self.args.max_matches}", classes="approval-description"
+            )
+
+
+class GrepResultWidget(ToolResultWidget[GrepResult]):
+    def compose(self) -> ComposeResult:
+        for warning in self.warnings:
+            yield NoMarkupStatic(f"⚠ {warning}", classes="tool-result-warning")
+        if not self.result or not self.result.matches:
+            yield from self._footer()
+            return
+        max_lines = 10 if self.collapsed else None
+        if max_lines:
+            content, truncation_info = _truncate_lines(self.result.matches, max_lines)
+        else:
+            content, truncation_info = self.result.matches, None
+        yield NoMarkupStatic(content, classes="tool-result-detail")
+        yield from self._footer(truncation_info)
+
+
+class AskUserQuestionResultWidget(ToolResultWidget[AskUserQuestionResult]):
+    def compose(self) -> ComposeResult:
+        if self.collapsed or not self.result:
+            yield from self._footer()
+            return
+
+        for answer in self.result.answers:
+            if len(self.result.answers) > 1:
+                yield NoMarkupStatic(answer.question, classes="tool-result-detail")
+            prefix = "(Other) " if answer.is_other else ""
+            yield NoMarkupStatic(f"{prefix}{answer.answer}", classes="ask-user-answer")
+        yield from self._footer()
+
+
+APPROVAL_WIDGETS: dict[str, type[ToolApprovalWidget]] = {
+    "bash": BashApprovalWidget,
+    "read_file": ReadFileApprovalWidget,
+    "write_file": WriteFileApprovalWidget,
+    "search_replace": SearchReplaceApprovalWidget,
+    "grep": GrepApprovalWidget,
+    "todo": TodoApprovalWidget,
+}
+
+RESULT_WIDGETS: dict[str, type[ToolResultWidget]] = {
+    "bash": BashResultWidget,
+    "read_file": ReadFileResultWidget,
+    "write_file": WriteFileResultWidget,
+    "search_replace": SearchReplaceResultWidget,
+    "grep": GrepResultWidget,
+    "todo": TodoResultWidget,
+    "ask_user_question": AskUserQuestionResultWidget,
+}
+
+
+def get_approval_widget(tool_name: str, args: BaseModel) -> ToolApprovalWidget:
+    widget_class = APPROVAL_WIDGETS.get(tool_name, ToolApprovalWidget)
+    return widget_class(args)
+
+
+def get_result_widget(
+    tool_name: str,
+    result: BaseModel | None,
+    success: bool,
+    message: str,
+    collapsed: bool = True,
+    warnings: list[str] | None = None,
+) -> ToolResultWidget:
+    widget_class = RESULT_WIDGETS.get(tool_name, ToolResultWidget)
+    return widget_class(result, success, message, collapsed, warnings)

vibe/cli/textual_ui/widgets/tools.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Static
+
+from vibe.cli.textual_ui.widgets.messages import ExpandingBorder, NonSelectableStatic
+from vibe.cli.textual_ui.widgets.no_markup_static import NoMarkupStatic
+from vibe.cli.textual_ui.widgets.status_message import StatusMessage
+from vibe.cli.textual_ui.widgets.tool_widgets import get_result_widget
+from vibe.core.tools.ui import ToolUIDataAdapter
+from vibe.core.types import ToolCallEvent, ToolResultEvent
+
+
+class ToolCallMessage(StatusMessage):
+    def __init__(
+        self, event: ToolCallEvent | None = None, *, tool_name: str | None = None
+    ) -> None:
+        if event is None and tool_name is None:
+            raise ValueError("Either event or tool_name must be provided")
+
+        self._event = event
+        self._tool_name = tool_name or (event.tool_name if event else "unknown")
+        self._is_history = event is None
+        self._stream_widget: NoMarkupStatic | None = None
+
+        super().__init__()
+        self.add_class("tool-call")
+
+        if self._is_history:
+            self._is_spinning = False
+
+    def compose(self) -> ComposeResult:
+        with Vertical(classes="tool-call-container"):
+            with Horizontal():
+                self._indicator_widget = NonSelectableStatic(
+                    self._spinner.current_frame(), classes="status-indicator-icon"
+                )
+                yield self._indicator_widget
+                self._text_widget = NoMarkupStatic("", classes="status-indicator-text")
+                yield self._text_widget
+            self._stream_widget = NoMarkupStatic("", classes="tool-stream-message")
+            self._stream_widget.display = False
+            yield self._stream_widget
+
+    def on_mount(self) -> None:
+        siblings = list(self.parent.children) if self.parent else []
+        idx = siblings.index(self) if self in siblings else -1
+        if idx > 0 and isinstance(
+            siblings[idx - 1], (ToolCallMessage, ToolResultMessage)
+        ):
+            self.add_class("no-gap")
+
+    def get_content(self) -> str:
+        if self._event and self._event.tool_class:
+            adapter = ToolUIDataAdapter(self._event.tool_class)
+            display = adapter.get_call_display(self._event)
+            return display.summary
+        return self._tool_name
+
+    def set_stream_message(self, message: str) -> None:
+        """Update the stream message displayed below the tool call indicator."""
+        if self._stream_widget:
+            self._stream_widget.update(f"→ {message}")
+            self._stream_widget.display = True
+
+    def stop_spinning(self, success: bool = True) -> None:
+        """Stop the spinner and hide the stream widget."""
+        if self._stream_widget:
+            self._stream_widget.display = False
+        super().stop_spinning(success)
+
+    def set_result_text(self, text: str) -> None:
+        if self._text_widget:
+            self._text_widget.update(text)
+
+
+class ToolResultMessage(Static):
+    def __init__(
+        self,
+        event: ToolResultEvent | None = None,
+        call_widget: ToolCallMessage | None = None,
+        collapsed: bool = True,
+        *,
+        tool_name: str | None = None,
+        content: str | None = None,
+    ) -> None:
+        if event is None and tool_name is None:
+            raise ValueError("Either event or tool_name must be provided")
+
+        self._event = event
+        self._call_widget = call_widget
+        self._tool_name = tool_name or (event.tool_name if event else "unknown")
+        self._content = content
+        self.collapsed = collapsed
+        self._content_container: Vertical | None = None
+
+        super().__init__()
+        self.add_class("tool-result")
+
+    @property
+    def tool_name(self) -> str:
+        return self._tool_name
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(classes="tool-result-container"):
+            yield ExpandingBorder(classes="tool-result-border")
+            self._content_container = Vertical(classes="tool-result-content")
+            yield self._content_container
+
+    async def on_mount(self) -> None:
+        if self._call_widget:
+            success = self._determine_success()
+            self._call_widget.stop_spinning(success=success)
+            result_text = self._get_result_text()
+            self._call_widget.set_result_text(result_text)
+        await self._render_result()
+
+    def _determine_success(self) -> bool:
+        if self._event is None:
+            return True
+        if self._event.error or self._event.skipped:
+            return False
+        if self._event.tool_class:
+            adapter = ToolUIDataAdapter(self._event.tool_class)
+            display = adapter.get_result_display(self._event)
+            return display.success
+        return True
+
+    def _get_result_text(self) -> str:
+        if self._event is None:
+            return f"{self._tool_name} completed"
+
+        if self._event.error:
+            return f"{self._tool_name}: error"
+
+        if self._event.skipped:
+            return f"{self._tool_name}: skipped"
+
+        if self._event.tool_class:
+            adapter = ToolUIDataAdapter(self._event.tool_class)
+            display = adapter.get_result_display(self._event)
+            return display.message
+
+        return f"{self._tool_name} completed"
+
+    async def _render_result(self) -> None:
+        if self._content_container is None:
+            return
+
+        await self._content_container.remove_children()
+
+        if self._event is None:
+            self.display = False
+            return
+
+        if self._event.error:
+            self.add_class("error-text")
+            await self._content_container.mount(
+                NoMarkupStatic(f"Error: {self._event.error}")
+            )
+            self.display = True
+            return
+
+        if self._event.skipped:
+            self.add_class("warning-text")
+            reason = self._event.skip_reason or "User skipped"
+            await self._content_container.mount(NoMarkupStatic(f"Skipped: {reason}"))
+            self.display = True
+            return
+
+        self.remove_class("error-text")
+        self.remove_class("warning-text")
+
+        if self._event.tool_class is None:
+            self.display = False
+            return
+
+        adapter = ToolUIDataAdapter(self._event.tool_class)
+        display = adapter.get_result_display(self._event)
+
+        widget = get_result_widget(
+            self._event.tool_name,
+            self._event.result,
+            success=display.success,
+            message=display.message,
+            collapsed=self.collapsed,
+            warnings=display.warnings,
+        )
+        await self._content_container.mount(widget)
+        self.display = bool(widget.children)
+
+    async def set_collapsed(self, collapsed: bool) -> None:
+        if self.collapsed == collapsed:
+            return
+        self.collapsed = collapsed
+        await self._render_result()
+
+    async def toggle_collapsed(self) -> None:
+        self.collapsed = not self.collapsed
+        await self._render_result()