shotgun-sh 0.2.8.dev2__py3-none-any.whl → 0.3.3.dev1__py3-none-any.whl

shotgun/tui/screens/chat_screen/history/agent_response.py

@@ -0,0 +1,66 @@
+"""Agent response widget for chat history."""
+
+from pydantic_ai.messages import (
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
+    ModelResponse,
+    TextPart,
+    ThinkingPart,
+    ToolCallPart,
+)
+from textual.app import ComposeResult
+from textual.widget import Widget
+from textual.widgets import Markdown
+
+from .formatters import ToolFormatter
+
+
+class AgentResponseWidget(Widget):
+    """Widget that displays agent responses in the chat history."""
+
+    def __init__(self, item: ModelResponse | None) -> None:
+        super().__init__()
+        self.item = item
+
+    def compose(self) -> ComposeResult:
+        self.display = self.item is not None
+        if self.item is None:
+            yield Markdown(markdown="")
+        else:
+            yield Markdown(markdown=self.compute_output())
+
+    def compute_output(self) -> str:
+        """Compute the markdown output for the agent response."""
+        acc = ""
+        if self.item is None:
+            return ""
+
+        for idx, part in enumerate(self.item.parts):
+            if isinstance(part, TextPart):
+                # Only show the circle prefix if there's actual content
+                if part.content and part.content.strip():
+                    acc += f"**⏺** {part.content}\n\n"
+            elif isinstance(part, ToolCallPart):
+                parts_str = ToolFormatter.format_tool_call_part(part)
+                if parts_str:  # Only add if there's actual content
+                    acc += parts_str + "\n\n"
+            elif isinstance(part, BuiltinToolCallPart):
+                # Format builtin tool calls using registry
+                formatted = ToolFormatter.format_builtin_tool_call(part)
+                if formatted:  # Only add if not hidden
+                    acc += formatted + "\n\n"
+            elif isinstance(part, BuiltinToolReturnPart):
+                # Don't show tool return parts in the UI
+                pass
+            elif isinstance(part, ThinkingPart):
+                if (
+                    idx == len(self.item.parts) - 1
+                ):  # show the thinking part only if it's the last part
+                    acc += (
+                        f"thinking: {part.content}\n\n"
+                        if part.content
+                        else "Thinking..."
+                    )
+                else:
+                    continue
+        return acc.strip()

shotgun/tui/screens/chat_screen/history/chat_history.py

@@ -0,0 +1,115 @@
+"""Chat history widget - main container for message display."""
+
+from collections.abc import Generator, Sequence
+
+from pydantic_ai.messages import (
+    ModelMessage,
+    ModelRequest,
+    ModelResponse,
+    UserPromptPart,
+)
+from textual.app import ComposeResult
+from textual.reactive import reactive
+from textual.widget import Widget
+
+from shotgun.tui.components.vertical_tail import VerticalTail
+from shotgun.tui.screens.chat_screen.hint_message import HintMessage, HintMessageWidget
+
+from .agent_response import AgentResponseWidget
+from .partial_response import PartialResponseWidget
+from .user_question import UserQuestionWidget
+
+
+class ChatHistory(Widget):
+    """Main widget for displaying chat message history."""
+
+    DEFAULT_CSS = """
+        VerticalTail {
+            align: left bottom;
+
+        }
+        VerticalTail > * {
+            height: auto;
+        }
+
+        Horizontal {
+            height: auto;
+            background: $secondary-muted;
+        }
+
+        Markdown {
+            height: auto;
+        }
+    """
+    partial_response: reactive[ModelMessage | None] = reactive(None)
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.items: Sequence[ModelMessage | HintMessage] = []
+        self.vertical_tail: VerticalTail | None = None
+        self._rendered_count = 0  # Track how many messages have been mounted
+
+    def compose(self) -> ComposeResult:
+        """Compose the chat history widget."""
+        self.vertical_tail = VerticalTail()
+
+        filtered = list(self.filtered_items())
+        with self.vertical_tail:
+            for item in filtered:
+                if isinstance(item, ModelRequest):
+                    yield UserQuestionWidget(item)
+                elif isinstance(item, HintMessage):
+                    yield HintMessageWidget(item)
+                elif isinstance(item, ModelResponse):
+                    yield AgentResponseWidget(item)
+            yield PartialResponseWidget(None).data_bind(
+                item=ChatHistory.partial_response
+            )
+
+        # Track how many messages were rendered during initial compose
+        self._rendered_count = len(filtered)
+
+    def filtered_items(self) -> Generator[ModelMessage | HintMessage, None, None]:
+        """Filter and yield items for display."""
+        for item in self.items:
+            # Skip ModelRequest messages that only contain ToolReturnPart
+            # (these are internal tool results, not user prompts)
+            if isinstance(item, ModelRequest):
+                has_user_content = any(
+                    isinstance(part, UserPromptPart) for part in item.parts
+                )
+                if not has_user_content:
+                    # This is just a tool return, skip displaying it
+                    continue
+
+            yield item
+
+    def update_messages(self, messages: list[ModelMessage | HintMessage]) -> None:
+        """Update the displayed messages using incremental mounting."""
+        if not self.vertical_tail:
+            return
+
+        self.items = messages
+        filtered = list(self.filtered_items())
+
+        # Only mount new messages that haven't been rendered yet
+        if len(filtered) > self._rendered_count:
+            new_messages = filtered[self._rendered_count :]
+            for item in new_messages:
+                widget: Widget
+                if isinstance(item, ModelRequest):
+                    widget = UserQuestionWidget(item)
+                elif isinstance(item, HintMessage):
+                    widget = HintMessageWidget(item)
+                elif isinstance(item, ModelResponse):
+                    widget = AgentResponseWidget(item)
+                else:
+                    continue
+
+                # Mount before the PartialResponseWidget
+                self.vertical_tail.mount(widget, before=self.vertical_tail.children[-1])
+
+            self._rendered_count = len(filtered)
+
+            # Scroll to bottom to show newly added messages
+            self.vertical_tail.scroll_end(animate=False)

shotgun/tui/screens/chat_screen/history/formatters.py

@@ -0,0 +1,115 @@
+"""Tool formatting utilities for chat history display."""
+
+import json
+
+from pydantic_ai.messages import BuiltinToolCallPart, ToolCallPart
+
+from shotgun.agents.tools.registry import get_tool_display_config
+
+
+class ToolFormatter:
+    """Formats tool calls for display in the TUI."""
+
+    @staticmethod
+    def truncate(text: str, max_length: int = 100) -> str:
+        """Truncate text to max_length characters, adding ellipsis if needed."""
+        if len(text) <= max_length:
+            return text
+        return text[: max_length - 3] + "..."
+
+    @staticmethod
+    def parse_args(args: dict[str, object] | str | None) -> dict[str, object]:
+        """Parse tool call arguments, handling both dict and JSON string formats."""
+        if args is None:
+            return {}
+        if isinstance(args, str):
+            try:
+                return json.loads(args) if args.strip() else {}
+            except json.JSONDecodeError:
+                return {}
+        return args if isinstance(args, dict) else {}
+
+    @classmethod
+    def format_tool_call_part(cls, part: ToolCallPart) -> str:
+        """Format a tool call part using the tool display registry."""
+        # Look up the display config for this tool
+        display_config = get_tool_display_config(part.tool_name)
+
+        if display_config:
+            # Tool is registered - use its display config
+            if display_config.hide:
+                return ""
+
+            # Parse args
+            args = cls.parse_args(part.args)
+
+            # Get the key argument value
+            if args and isinstance(args, dict) and display_config.key_arg in args:
+                # Special handling for codebase_shell which needs command + args
+                if part.tool_name == "codebase_shell" and "command" in args:
+                    command = args.get("command", "")
+                    cmd_args = args.get("args", [])
+                    if isinstance(cmd_args, list):
+                        args_str = " ".join(str(arg) for arg in cmd_args)
+                    else:
+                        args_str = ""
+                    key_value = f"{command} {args_str}".strip()
+                else:
+                    key_value = str(args[display_config.key_arg])
+
+                # Format: "display_text: key_value"
+                return f"{display_config.display_text}: {cls.truncate(key_value)}"
+            else:
+                # No key arg value available - show just display_text
+                return display_config.display_text
+
+        # Tool not registered - use fallback formatting
+        args = cls.parse_args(part.args)
+        if args and isinstance(args, dict):
+            # Try to extract common fields
+            if "query" in args:
+                return f"{part.tool_name}: {cls.truncate(str(args['query']))}"
+            elif "question" in args:
+                return f"{part.tool_name}: {cls.truncate(str(args['question']))}"
+            elif "filename" in args:
+                return f"{part.tool_name}: {args['filename']}"
+            else:
+                # Show tool name with truncated args
+                args_str = (
+                    str(part.args)[:50] + "..."
+                    if len(str(part.args)) > 50
+                    else str(part.args)
+                )
+                return f"{part.tool_name}({args_str})"
+        else:
+            return f"{part.tool_name}()"
+
+    @classmethod
+    def format_builtin_tool_call(cls, part: BuiltinToolCallPart) -> str:
+        """Format a builtin tool call part using the tool display registry."""
+        display_config = get_tool_display_config(part.tool_name or "")
+
+        if display_config:
+            if display_config.hide:
+                return ""
+
+            args = cls.parse_args(part.args)
+            # Get the key argument value
+            if args and isinstance(args, dict) and display_config.key_arg in args:
+                key_value = str(args[display_config.key_arg])
+                # Format: "display_text: key_value"
+                return f"{display_config.display_text}: {cls.truncate(key_value)}"
+            else:
+                # No key arg value available - show just display_text
+                return display_config.display_text
+        else:
+            # Fallback for unregistered builtin tools
+            if part.args:
+                args_str = (
+                    str(part.args)[:50] + "..."
+                    if len(str(part.args)) > 50
+                    else str(part.args)
+                )
+                return f"{part.tool_name}({args_str})"
+            else:
+                return f"{part.tool_name}()"

shotgun/tui/screens/chat_screen/history/partial_response.py

@@ -0,0 +1,43 @@
+"""Partial response widget for streaming chat messages."""
+
+from pydantic_ai.messages import ModelMessage
+from textual.app import ComposeResult
+from textual.reactive import reactive
+from textual.widget import Widget
+
+from .agent_response import AgentResponseWidget
+from .user_question import UserQuestionWidget
+
+
+class PartialResponseWidget(Widget):  # TODO: doesn't work lol
+    """Widget that displays a streaming/partial response in the chat history."""
+
+    DEFAULT_CSS = """
+        PartialResponseWidget {
+            height: auto;
+        }
+        Markdown, AgentResponseWidget, UserQuestionWidget {
+            height: auto;
+        }
+    """
+
+    item: reactive[ModelMessage | None] = reactive(None, recompose=True)
+
+    def __init__(self, item: ModelMessage | None) -> None:
+        super().__init__()
+        self.item = item
+
+    def compose(self) -> ComposeResult:
+        if self.item is None:
+            pass
+        elif self.item.kind == "response":
+            yield AgentResponseWidget(self.item)
+        elif self.item.kind == "request":
+            yield UserQuestionWidget(self.item)
+
+    def watch_item(self, item: ModelMessage | None) -> None:
+        """React to changes in the item."""
+        if item is None:
+            self.display = False
+        else:
+            self.display = True

shotgun/tui/screens/chat_screen/history/user_question.py

@@ -0,0 +1,42 @@
+"""User question widget for chat history."""
+
+from collections.abc import Sequence
+
+from pydantic_ai.messages import (
+    ModelRequest,
+    ModelRequestPart,
+    ToolReturnPart,
+    UserPromptPart,
+)
+from textual.app import ComposeResult
+from textual.widget import Widget
+from textual.widgets import Markdown
+
+
+class UserQuestionWidget(Widget):
+    """Widget that displays user prompts in the chat history."""
+
+    def __init__(self, item: ModelRequest | None) -> None:
+        super().__init__()
+        self.item = item
+
+    def compose(self) -> ComposeResult:
+        self.display = self.item is not None
+        if self.item is None:
+            yield Markdown(markdown="")
+        else:
+            prompt = self.format_prompt_parts(self.item.parts)
+            yield Markdown(markdown=prompt)
+
+    def format_prompt_parts(self, parts: Sequence[ModelRequestPart]) -> str:
+        """Format user prompt parts into markdown."""
+        acc = ""
+        for part in parts:
+            if isinstance(part, UserPromptPart):
+                acc += (
+                    f"**>** {part.content if isinstance(part.content, str) else ''}\n\n"
+                )
+            elif isinstance(part, ToolReturnPart):
+                # Don't show tool return parts in the UI
+                pass
+        return acc

shotgun/tui/screens/confirmation_dialog.py

@@ -0,0 +1,191 @@
+"""Reusable confirmation dialog for destructive actions in the TUI."""
+
+from typing import Literal
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Container
+from textual.events import Resize
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label, Static
+
+from shotgun.tui.layout import COMPACT_HEIGHT_THRESHOLD
+
+ButtonVariant = Literal["default", "primary", "success", "warning", "error"]
+
+
+class ConfirmationDialog(ModalScreen[bool]):
+    """Reusable confirmation dialog for destructive actions.
+
+    This modal dialog presents a confirmation prompt with a title, explanatory
+    message, and customizable confirm/cancel buttons. Useful for preventing
+    accidental destructive actions like clearing data or deleting resources.
+
+    Args:
+        title: Dialog title text (e.g., "Clear conversation?")
+        message: Detailed explanation of what will happen
+        confirm_label: Label for the confirm button (default: "Confirm")
+        cancel_label: Label for the cancel button (default: "Cancel")
+        confirm_variant: Button variant for confirm button (default: "warning")
+        danger: Whether this is a dangerous/destructive action (default: False)
+
+    Returns:
+        True if user confirms, False if user cancels
+
+    Example:
+        ```python
+        should_delete = await self.app.push_screen_wait(
+            ConfirmationDialog(
+                title="Delete item?",
+                message="This will permanently delete the item. This cannot be undone.",
+                confirm_label="Delete",
+                cancel_label="Keep",
+                confirm_variant="warning",
+                danger=True,
+            )
+        )
+        if should_delete:
+            # Proceed with deletion
+            ...
+        ```
+    """
+
+    DEFAULT_CSS = """
+        ConfirmationDialog {
+            align: center middle;
+            background: rgba(0, 0, 0, 0.0);
+        }
+
+        ConfirmationDialog > #dialog-container {
+            width: 60%;
+            max-width: 70;
+            height: auto;
+            border: wide $warning;
+            padding: 1 2;
+            layout: vertical;
+            background: $surface;
+        }
+
+        ConfirmationDialog.danger > #dialog-container {
+            border: wide $error;
+        }
+
+        #dialog-title {
+            text-style: bold;
+            color: $text;
+            padding-bottom: 1;
+        }
+
+        #dialog-message {
+            padding-bottom: 1;
+            color: $text-muted;
+        }
+
+        #dialog-buttons {
+            layout: horizontal;
+            align-horizontal: right;
+            height: auto;
+        }
+
+        #dialog-buttons Button {
+            margin-left: 1;
+        }
+
+        /* Compact styles for short terminals */
+        #dialog-container.compact {
+            padding: 0 2;
+            max-height: 98%;
+        }
+
+        #dialog-title.compact {
+            padding-bottom: 0;
+        }
+
+        #dialog-message.compact {
+            padding-bottom: 0;
+        }
+    """
+
+    def __init__(
+        self,
+        title: str,
+        message: str,
+        confirm_label: str = "Confirm",
+        cancel_label: str = "Cancel",
+        confirm_variant: ButtonVariant = "warning",
+        danger: bool = False,
+    ) -> None:
+        """Initialize the confirmation dialog.
+
+        Args:
+            title: Dialog title text
+            message: Detailed explanation of what will happen
+            confirm_label: Label for the confirm button
+            cancel_label: Label for the cancel button
+            confirm_variant: Button variant for confirm button
+            danger: Whether this is a dangerous/destructive action
+        """
+        super().__init__()
+        self.title_text = title
+        self.message_text = message
+        self.confirm_label = confirm_label
+        self.cancel_label = cancel_label
+        self.confirm_variant = confirm_variant
+        self.is_danger = danger
+
+    def compose(self) -> ComposeResult:
+        """Compose the dialog widgets."""
+        with Container(id="dialog-container"):
+            yield Label(self.title_text, id="dialog-title")
+            yield Static(self.message_text, id="dialog-message")
+            with Container(id="dialog-buttons"):
+                yield Button(
+                    self.confirm_label,
+                    id="confirm",
+                    variant=self.confirm_variant,
+                )
+                yield Button(self.cancel_label, id="cancel")
+
+    def on_mount(self) -> None:
+        """Set up the dialog after mounting."""
+        # Apply danger class if needed
+        if self.is_danger:
+            self.add_class("danger")
+
+        # Focus cancel button by default for safety
+        self.query_one("#cancel", Button).focus()
+
+        # Apply compact layout if starting in a short terminal
+        self._apply_compact_layout(self.app.size.height < COMPACT_HEIGHT_THRESHOLD)
+
+    @on(Resize)
+    def handle_resize(self, event: Resize) -> None:
+        """Adjust layout based on terminal height."""
+        self._apply_compact_layout(event.size.height < COMPACT_HEIGHT_THRESHOLD)
+
+    def _apply_compact_layout(self, compact: bool) -> None:
+        """Apply or remove compact layout classes for short terminals."""
+        container = self.query_one("#dialog-container")
+        title = self.query_one("#dialog-title")
+        message = self.query_one("#dialog-message")
+
+        if compact:
+            container.add_class("compact")
+            title.add_class("compact")
+            message.add_class("compact")
+        else:
+            container.remove_class("compact")
+            title.remove_class("compact")
+            message.remove_class("compact")
+
+    @on(Button.Pressed, "#cancel")
+    def handle_cancel(self, event: Button.Pressed) -> None:
+        """Handle cancel button press."""
+        event.stop()
+        self.dismiss(False)
+
+    @on(Button.Pressed, "#confirm")
+    def handle_confirm(self, event: Button.Pressed) -> None:
+        """Handle confirm button press."""
+        event.stop()
+        self.dismiss(True)