shotgun-sh 0.2.8.dev2__py3-none-any.whl → 0.2.17__py3-none-any.whl

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

@@ -125,8 +125,8 @@ class FeedbackScreen(Screen[Feedback | None]):
             self.set_focus(self.query_one("#feedback-description", TextArea))
 
     @on(Button.Pressed, "#submit")
-    def _on_submit_pressed(self) -> None:
-        self._submit_feedback()
+    async def _on_submit_pressed(self) -> None:
+        await self._submit_feedback()
 
     @on(Button.Pressed, "#cancel")
     def _on_cancel_pressed(self) -> None:
@@ -171,7 +171,7 @@ class FeedbackScreen(Screen[Feedback | None]):
         }
         return placeholders.get(kind, "Enter your feedback...")
 
-    def _submit_feedback(self) -> None:
+    async def _submit_feedback(self) -> None:
         text_area = self.query_one("#feedback-description", TextArea)
         description = text_area.text.strip()
 
@@ -182,7 +182,7 @@ class FeedbackScreen(Screen[Feedback | None]):
             return
 
         app = cast("ShotgunApp", self.app)
-        shotgun_instance_id = app.config_manager.get_shotgun_instance_id()
+        shotgun_instance_id = await app.config_manager.get_shotgun_instance_id()
 
         feedback = Feedback(
             kind=self.selected_kind,

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()

shotgun/tui/screens/model_picker.py

@@ -11,8 +11,13 @@ from textual.reactive import reactive
 from textual.screen import Screen
 from textual.widgets import Button, Label, ListItem, ListView, Static
 
+from shotgun.agents.agent_manager import ModelConfigUpdated
 from shotgun.agents.config import ConfigManager
 from shotgun.agents.config.models import MODEL_SPECS, ModelName, ShotgunConfig
+from shotgun.agents.config.provider import (
+    get_default_model_for_provider,
+    get_provider_model,
+)
 from shotgun.logging_config import get_logger
 
 if TYPE_CHECKING:
@@ -30,8 +35,11 @@ def _sanitize_model_name_for_id(model_name: ModelName) -> str:
     return model_name.value.replace(".", "-")
 
 
-class ModelPickerScreen(Screen[None]):
-    """Select AI model to use."""
+class ModelPickerScreen(Screen[ModelConfigUpdated | None]):
+    """Select AI model to use.
+
+    Returns ModelConfigUpdated when a model is selected, None if cancelled.
+    """
 
     CSS = """
         ModelPicker {
@@ -90,7 +98,7 @@ class ModelPickerScreen(Screen[None]):
             yield Button("Select \\[ENTER]", variant="primary", id="select")
             yield Button("Done \\[ESC]", id="done")
 
-    def _rebuild_model_list(self) -> None:
+    async def _rebuild_model_list(self) -> None:
         """Rebuild the model list from current config.
 
         This method is called both on first show and when screen is resumed
@@ -100,7 +108,7 @@ class ModelPickerScreen(Screen[None]):
 
         # Load current config with force_reload to get latest API keys
         config_manager = self.config_manager
-        config = config_manager.load(force_reload=True)
+        config = await config_manager.load(force_reload=True)
 
         # Log provider key status
         logger.debug(
@@ -111,7 +119,7 @@ class ModelPickerScreen(Screen[None]):
             config_manager._provider_has_api_key(config.shotgun),
         )
 
-        current_model = config.selected_model or ModelName.CLAUDE_SONNET_4_5
+        current_model = config.selected_model or get_default_model_for_provider(config)
         self.selected_model = current_model
         logger.debug("Current selected model: %s", current_model)
 
@@ -125,7 +133,7 @@ class ModelPickerScreen(Screen[None]):
         logger.debug("Removed %d existing model items from list", old_count)
 
         # Add new items (labels already have correct text including current indicator)
-        new_items = self._build_model_items(config)
+        new_items = await self._build_model_items(config)
         for item in new_items:
             list_view.append(item)
         logger.debug("Added %d available model items to list", len(new_items))
@@ -145,7 +153,7 @@ class ModelPickerScreen(Screen[None]):
     def on_show(self) -> None:
         """Rebuild model list when screen is first shown."""
         logger.debug("ModelPickerScreen.on_show() called")
-        self._rebuild_model_list()
+        self.run_worker(self._rebuild_model_list(), exclusive=False)
 
     def on_screenresume(self) -> None:
         """Rebuild model list when screen is resumed (subsequent visits).
@@ -154,7 +162,7 @@ class ModelPickerScreen(Screen[None]):
         ensuring the model list reflects any config changes made while away.
         """
         logger.debug("ModelPickerScreen.on_screenresume() called")
-        self._rebuild_model_list()
+        self.run_worker(self._rebuild_model_list(), exclusive=False)
 
     def action_done(self) -> None:
         self.dismiss()
@@ -185,15 +193,15 @@ class ModelPickerScreen(Screen[None]):
         app = cast("ShotgunApp", self.app)
         return app.config_manager
 
-    def refresh_model_labels(self) -> None:
+    async def refresh_model_labels(self) -> None:
         """Update the list view entries to reflect current selection.
 
         Note: This method only updates labels for currently displayed models.
         To rebuild the entire list after provider changes, on_show() should be used.
         """
         # Load config once with force_reload
-        config = self.config_manager.load(force_reload=True)
-        current_model = config.selected_model or ModelName.CLAUDE_SONNET_4_5
+        config = await self.config_manager.load(force_reload=True)
+        current_model = config.selected_model or get_default_model_for_provider(config)
 
         # Update labels for available models only
         for model_name in AVAILABLE_MODELS:
@@ -207,9 +215,11 @@ class ModelPickerScreen(Screen[None]):
                 self._model_label(model_name, is_current=model_name == current_model)
             )
 
-    def _build_model_items(self, config: ShotgunConfig | None = None) -> list[ListItem]:
+    async def _build_model_items(
+        self, config: ShotgunConfig | None = None
+    ) -> list[ListItem]:
         if config is None:
-            config = self.config_manager.load(force_reload=True)
+            config = await self.config_manager.load(force_reload=True)
 
         items: list[ListItem] = []
         current_model = self.selected_model
@@ -238,9 +248,7 @@ class ModelPickerScreen(Screen[None]):
                 return model_name
         return None
 
-    def _is_model_available(
-        self, model_name: ModelName, config: ShotgunConfig | None = None
-    ) -> bool:
+    def _is_model_available(self, model_name: ModelName, config: ShotgunConfig) -> bool:
         """Check if a model is available based on provider key configuration.
 
         A model is available if:
@@ -249,14 +257,11 @@ class ModelPickerScreen(Screen[None]):
 
         Args:
             model_name: The model to check availability for
-            config: Optional pre-loaded config to avoid multiple reloads
+            config: Pre-loaded config (must be provided)
 
         Returns:
             True if the model can be used, False otherwise
         """
-        if config is None:
-            config = self.config_manager.load(force_reload=True)
-
         # If Shotgun Account is configured, all models are available
         if self.config_manager._provider_has_api_key(config.shotgun):
             logger.debug("Model %s available (Shotgun Account configured)", model_name)
@@ -317,11 +322,31 @@ class ModelPickerScreen(Screen[None]):
 
     def _select_model(self) -> None:
         """Save the selected model."""
+        self.run_worker(self._do_select_model(), exclusive=True)
+
+    async def _do_select_model(self) -> None:
+        """Async implementation of model selection."""
         try:
-            self.config_manager.update_selected_model(self.selected_model)
-            self.refresh_model_labels()
-            self.notify(
-                f"Selected model: {self._model_display_name(self.selected_model)}"
+            # Get old model before updating
+            config = await self.config_manager.load()
+            old_model = config.selected_model
+
+            # Update the selected model in config
+            await self.config_manager.update_selected_model(self.selected_model)
+            await self.refresh_model_labels()
+
+            # Get the full model config with provider information
+            model_config = await get_provider_model(self.selected_model)
+
+            # Dismiss the screen and return the model config update to the caller
+            self.dismiss(
+                ModelConfigUpdated(
+                    old_model=old_model,
+                    new_model=self.selected_model,
+                    provider=model_config.provider,
+                    key_provider=model_config.key_provider,
+                    model_config=model_config,
+                )
             )
         except Exception as exc:  # pragma: no cover - defensive; textual path
             self.notify(f"Failed to select model: {exc}", severity="error")