shotgun-sh 0.1.14__py3-none-any.whl → 0.2.11__py3-none-any.whl

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,151 @@
+"""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.screen import ModalScreen
+from textual.widgets import Button, Label, Static
+
+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;
+        }
+    """
+
+    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()
+
+    @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)

shotgun/tui/screens/feedback.py

@@ -0,0 +1,193 @@
+"""Screen for submitting user feedback."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.reactive import reactive
+from textual.screen import Screen
+from textual.widgets import Button, Label, ListItem, ListView, Static, TextArea
+
+from shotgun.posthog_telemetry import Feedback, FeedbackKind
+
+if TYPE_CHECKING:
+    from ..app import ShotgunApp
+
+
+class FeedbackScreen(Screen[Feedback | None]):
+    """Collect feedback from users."""
+
+    CSS = """
+        FeedbackScreen {
+            layout: vertical;
+        }
+
+        FeedbackScreen > * {
+            height: auto;
+        }
+
+        Label {
+            padding: 0 1;
+        }
+
+        #titlebox {
+            height: auto;
+            margin: 2 0;
+            padding: 1;
+            border: hkey $border;
+            content-align: center middle;
+
+            & > * {
+                text-align: center;
+            }
+        }
+
+        #feedback-title {
+            padding: 1 0;
+            margin-bottom: 2;
+            text-style: bold;
+            color: $text-accent;
+        }
+
+        #feedback-type-list {
+            height: auto;
+            & > * {
+                padding: 1 0;
+            }
+        }
+
+        #feedback-description {
+            margin: 1 0;
+            height: 10;
+            border: solid $border;
+        }
+
+        #feedback-actions {
+            padding: 1;
+        }
+
+        #feedback-actions > * {
+            margin-right: 2;
+        }
+
+        #feedback-type-list {
+            padding: 1;
+        }
+    """
+
+    BINDINGS = [
+        ("escape", "cancel", "Cancel"),
+    ]
+
+    selected_kind: reactive[FeedbackKind] = reactive(FeedbackKind.BUG)
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="titlebox"):
+            yield Static("Send us feedback", id="feedback-title")
+            yield Static(
+                "Select the type of feedback and provide details below.",
+                id="feedback-summary",
+            )
+        yield ListView(*self._build_feedback_type_items(), id="feedback-type-list")
+        yield TextArea(
+            "",
+            id="feedback-description",
+        )
+        with Horizontal(id="feedback-actions"):
+            yield Button("Submit", variant="primary", id="submit")
+            yield Button("Cancel \\[ESC]", id="cancel")
+
+    def on_mount(self) -> None:
+        list_view = self.query_one(ListView)
+        if list_view.children:
+            list_view.index = 0
+        self.selected_kind = FeedbackKind.BUG
+        text_area = self.query_one("#feedback-description", TextArea)
+        text_area.focus()
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+    @on(ListView.Highlighted)
+    def _on_kind_highlighted(self, event: ListView.Highlighted) -> None:
+        kind = self._kind_from_item(event.item)
+        if kind:
+            self.selected_kind = kind
+
+    @on(ListView.Selected)
+    def _on_kind_selected(self, event: ListView.Selected) -> None:
+        kind = self._kind_from_item(event.item)
+        if kind:
+            self.selected_kind = kind
+            self.set_focus(self.query_one("#feedback-description", TextArea))
+
+    @on(Button.Pressed, "#submit")
+    async def _on_submit_pressed(self) -> None:
+        await self._submit_feedback()
+
+    @on(Button.Pressed, "#cancel")
+    def _on_cancel_pressed(self) -> None:
+        self.action_cancel()
+
+    def watch_selected_kind(self, kind: FeedbackKind) -> None:
+        if not self.is_mounted:
+            return
+        # Update the placeholder in text area based on selected kind
+        text_area = self.query_one("#feedback-description", TextArea)
+        text_area.placeholder = self._placeholder_for_kind(kind)
+
+    def _build_feedback_type_items(self) -> list[ListItem]:
+        items: list[ListItem] = []
+        for kind in FeedbackKind:
+            label = Label(self._kind_label(kind), id=f"label-{kind.value}")
+            items.append(ListItem(label, id=f"kind-{kind.value}"))
+        return items
+
+    def _kind_from_item(self, item: ListItem | None) -> FeedbackKind | None:
+        if item is None or item.id is None:
+            return None
+        kind_id = item.id.removeprefix("kind-")
+        try:
+            return FeedbackKind(kind_id)
+        except ValueError:
+            return None
+
+    def _kind_label(self, kind: FeedbackKind) -> str:
+        display_names = {
+            FeedbackKind.BUG: "Bug Report",
+            FeedbackKind.FEATURE: "Feature Request",
+            FeedbackKind.OTHER: "Other",
+        }
+        return display_names.get(kind, kind.value.title())
+
+    def _placeholder_for_kind(self, kind: FeedbackKind) -> str:
+        placeholders = {
+            FeedbackKind.BUG: "Describe the bug you encountered...",
+            FeedbackKind.FEATURE: "Describe the feature you'd like to see...",
+            FeedbackKind.OTHER: "Tell us what's on your mind...",
+        }
+        return placeholders.get(kind, "Enter your feedback...")
+
+    async def _submit_feedback(self) -> None:
+        text_area = self.query_one("#feedback-description", TextArea)
+        description = text_area.text.strip()
+
+        if not description:
+            self.notify(
+                "Please enter a description before submitting.", severity="error"
+            )
+            return
+
+        app = cast("ShotgunApp", self.app)
+        shotgun_instance_id = await app.config_manager.get_shotgun_instance_id()
+
+        feedback = Feedback(
+            kind=self.selected_kind,
+            description=description,
+            shotgun_instance_id=shotgun_instance_id,
+        )
+
+        self.dismiss(feedback)

shotgun/tui/screens/github_issue.py

@@ -0,0 +1,102 @@
+"""Screen for guiding users to create GitHub issues."""
+
+import webbrowser
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Container, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Markdown, Static
+
+
+class GitHubIssueScreen(ModalScreen[None]):
+    """Guide users to create issues on GitHub."""
+
+    CSS = """
+        GitHubIssueScreen {
+            align: center middle;
+        }
+
+        #issue-container {
+            width: 70;
+            max-width: 100;
+            height: auto;
+            border: thick $primary;
+            background: $surface;
+            padding: 2;
+        }
+
+        #issue-header {
+            text-style: bold;
+            color: $text-accent;
+            padding-bottom: 1;
+            text-align: center;
+        }
+
+        #issue-content {
+            padding: 1 0;
+        }
+
+        #issue-buttons {
+            height: auto;
+            padding: 2 0 0 0;
+            align: center middle;
+        }
+
+        #issue-buttons Button {
+            margin: 1 1;
+            min-width: 20;
+        }
+    """
+
+    BINDINGS = [
+        ("escape", "dismiss", "Close"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        """Compose the GitHub issue screen."""
+        with Container(id="issue-container"):
+            yield Static("Create a GitHub Issue", id="issue-header")
+            with Vertical(id="issue-content"):
+                yield Markdown(
+                    """
+## Report Bugs or Request Features
+
+We track all bugs, feature requests, and improvements on GitHub Issues.
+
+### How to Create an Issue:
+
+1. Click the button below to open our GitHub Issues page
+2. Click **"New Issue"**
+3. Choose a template:
+   - **Bug Report** - Report a bug or unexpected behavior
+   - **Feature Request** - Suggest new functionality
+   - **Documentation** - Report docs issues or improvements
+4. Fill in the details and submit
+
+We review all issues and will respond as soon as possible!
+
+### Before Creating an Issue:
+
+- Search existing issues to avoid duplicates
+- Include steps to reproduce for bugs
+- Be specific about what you'd like for feature requests
+                    """,
+                    id="issue-markdown",
+                )
+            with Vertical(id="issue-buttons"):
+                yield Button(
+                    "🐙 Open GitHub Issues", id="github-button", variant="primary"
+                )
+                yield Button("Close", id="close-button")
+
+    @on(Button.Pressed, "#github-button")
+    def handle_github(self) -> None:
+        """Open GitHub issues page in browser."""
+        webbrowser.open("https://github.com/shotgun-sh/shotgun/issues")
+        self.notify("Opening GitHub Issues in your browser...")
+
+    @on(Button.Pressed, "#close-button")
+    def handle_close(self) -> None:
+        """Handle close button press."""
+        self.dismiss()