shotgun-sh 0.2.3.dev2__py3-none-any.whl → 0.2.11.dev1__py3-none-any.whl

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/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 {
@@ -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)
 
@@ -193,7 +201,7 @@ class ModelPickerScreen(Screen[None]):
         """
         # 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
+        current_model = config.selected_model or get_default_model_for_provider(config)
 
         # Update labels for available models only
         for model_name in AVAILABLE_MODELS:
@@ -318,10 +326,26 @@ class ModelPickerScreen(Screen[None]):
     def _select_model(self) -> None:
         """Save the selected model."""
         try:
+            # Get old model before updating
+            config = self.config_manager.load()
+            old_model = config.selected_model
+
+            # Update the selected model in config
             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 the full model config with provider information
+            model_config = 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")

shotgun/tui/screens/pipx_migration.py

@@ -0,0 +1,153 @@
+"""Migration notice screen for pipx users."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Button, Markdown
+
+if TYPE_CHECKING:
+    pass
+
+
+class PipxMigrationScreen(ModalScreen[None]):
+    """Modal screen warning pipx users about migration to uvx."""
+
+    CSS = """
+        PipxMigrationScreen {
+            align: center middle;
+        }
+
+        #migration-container {
+            width: 90;
+            height: auto;
+            max-height: 90%;
+            border: thick $error;
+            background: $surface;
+            padding: 2;
+        }
+
+        #migration-content {
+            height: 1fr;
+            padding: 1 0;
+        }
+
+        #buttons-container {
+            height: auto;
+            padding: 2 0 1 0;
+        }
+
+        #action-buttons {
+            width: 100%;
+            height: auto;
+            align: center middle;
+        }
+
+        .action-button {
+            margin: 0 1;
+            min-width: 20;
+        }
+    """
+
+    BINDINGS = [
+        ("escape", "dismiss", "Continue Anyway"),
+        ("ctrl+c", "app.quit", "Quit"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        """Compose the migration notice modal."""
+        with Container(id="migration-container"):
+            with VerticalScroll(id="migration-content"):
+                yield Markdown(
+                    """
+## We've Switched to uvx
+
+We've switched from `pipx` to `uvx` as the primary installation method due to critical build issues with our `kuzu` dependency.
+
+### The Problem
+Users with pipx encounter cmake build errors during installation because pip falls back to building from source instead of using pre-built binary wheels.
+
+### The Solution: uvx
+- ✅ **No build tools required** - Binary wheels enforced
+- ✅ **10-100x faster** - Much faster than pipx
+- ✅ **Better reliability** - No cmake/build errors
+
+### How to Migrate
+
+**1. Uninstall shotgun-sh from pipx:**
+```bash
+pipx uninstall shotgun-sh
+```
+
+**2. Install uv:**
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+Or with Homebrew: `brew install uv`
+
+**3. Run shotgun-sh with uvx:**
+```bash
+uvx shotgun-sh
+```
+Or install permanently: `uv tool install shotgun-sh`
+
+---
+
+### Need Help?
+
+**Discord:** https://discord.gg/5RmY6J2N7s
+
+**Full Migration Guide:** https://github.com/shotgun-sh/shotgun/blob/main/docs/PIPX_MIGRATION.md
+"""
+                )
+
+                with Container(id="buttons-container"):
+                    with Horizontal(id="action-buttons"):
+                        yield Button(
+                            "Copy Instructions to Clipboard",
+                            variant="default",
+                            id="copy-instructions",
+                            classes="action-button",
+                        )
+                        yield Button(
+                            "Continue Anyway",
+                            variant="primary",
+                            id="continue",
+                            classes="action-button",
+                        )
+
+    def on_mount(self) -> None:
+        """Focus the continue button and ensure scroll starts at top."""
+        self.query_one("#continue", Button).focus()
+        self.query_one("#migration-content", VerticalScroll).scroll_home(animate=False)
+
+    @on(Button.Pressed, "#copy-instructions")
+    def _copy_instructions(self) -> None:
+        """Copy all migration instructions to clipboard."""
+        instructions = """# Step 1: Uninstall from pipx
+pipx uninstall shotgun-sh
+
+# Step 2: Install uv
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# Step 3: Run shotgun with uvx
+uvx shotgun-sh"""
+        try:
+            import pyperclip  # type: ignore[import-untyped]  # noqa: PGH003
+
+            pyperclip.copy(instructions)
+            self.notify("Copied migration instructions to clipboard!")
+        except ImportError:
+            self.notify(
+                "Clipboard not available. See instructions above.",
+                severity="warning",
+            )
+
+    @on(Button.Pressed, "#continue")
+    def _continue(self) -> None:
+        """Dismiss the modal and continue."""
+        self.dismiss()

shotgun/tui/screens/welcome.py

@@ -136,6 +136,12 @@ class WelcomeScreen(Screen[None]):
 
     def on_mount(self) -> None:
         """Focus the first button on mount."""
+        # Update BYOK button text based on whether user has existing providers
+        byok_button = self.query_one("#byok-button", Button)
+        app = cast("ShotgunApp", self.app)
+        if app.config_manager.has_any_provider_key():
+            byok_button.label = "I'll stick with my BYOK setup"
+
         self.query_one("#shotgun-button", Button).focus()
 
     @on(Button.Pressed, "#shotgun-button")
@@ -146,14 +152,27 @@ class WelcomeScreen(Screen[None]):
     @on(Button.Pressed, "#byok-button")
     def _on_byok_pressed(self) -> None:
         """Handle BYOK button press."""
+        self.run_worker(self._start_byok_config(), exclusive=True)
+
+    async def _start_byok_config(self) -> None:
+        """Launch BYOK provider configuration flow."""
         self._mark_welcome_shown()
-        # Push provider config screen before dismissing
+
+        app = cast("ShotgunApp", self.app)
+
+        # If user already has providers, just dismiss and continue to chat
+        if app.config_manager.has_any_provider_key():
+            self.dismiss()
+            return
+
+        # Otherwise, push provider config screen and wait for result
         from .provider_config import ProviderConfigScreen
 
-        self.app.push_screen(
-            ProviderConfigScreen(),
-            callback=lambda _arg: self.dismiss(),
-        )
+        await self.app.push_screen_wait(ProviderConfigScreen())
+
+        # Dismiss welcome screen after config if providers are now configured
+        if app.config_manager.has_any_provider_key():
+            self.dismiss()
 
     async def _start_shotgun_auth(self) -> None:
         """Launch Shotgun Account authentication flow."""

shotgun/tui/services/__init__.py

@@ -0,0 +1,5 @@
+"""Services for TUI business logic."""
+
+from shotgun.tui.services.conversation_service import ConversationService
+
+__all__ = ["ConversationService"]

shotgun/tui/services/conversation_service.py

@@ -0,0 +1,182 @@
+"""Service for managing conversation persistence and restoration.
+
+This service extracts conversation save/load/restore logic from ChatScreen,
+making it testable and reusable.
+"""
+
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from shotgun.agents.conversation_history import ConversationHistory, ConversationState
+from shotgun.agents.conversation_manager import ConversationManager
+from shotgun.agents.models import AgentType
+
+if TYPE_CHECKING:
+    from shotgun.agents.agent_manager import AgentManager
+    from shotgun.agents.usage_manager import SessionUsageManager
+
+logger = logging.getLogger(__name__)
+
+
+class ConversationService:
+    """Handles conversation persistence and restoration.
+
+    This service provides:
+    - Save current conversation to disk
+    - Load conversation from disk
+    - Restore conversation state to agent manager
+    - Handle corrupted conversations gracefully
+    """
+
+    def __init__(
+        self,
+        conversation_manager: ConversationManager | None = None,
+        conversation_path: Path | None = None,
+    ):
+        """Initialize the conversation service.
+
+        Args:
+            conversation_manager: Optional conversation manager. If not provided,
+                                creates a default one.
+            conversation_path: Optional custom path for conversation storage.
+        """
+        if conversation_manager:
+            self.conversation_manager = conversation_manager
+        elif conversation_path:
+            self.conversation_manager = ConversationManager(conversation_path)
+        else:
+            self.conversation_manager = ConversationManager()
+
+    def save_conversation(self, agent_manager: "AgentManager") -> bool:
+        """Save the current conversation to persistent storage.
+
+        Args:
+            agent_manager: The agent manager containing conversation state.
+
+        Returns:
+            True if save was successful, False otherwise.
+        """
+        try:
+            # Get conversation state from agent manager
+            state = agent_manager.get_conversation_state()
+
+            # Create conversation history object
+            conversation = ConversationHistory(
+                last_agent_model=state.agent_type,
+            )
+            conversation.set_agent_messages(state.agent_messages)
+            conversation.set_ui_messages(state.ui_messages)
+
+            # Save to file
+            self.conversation_manager.save(conversation)
+            logger.debug("Conversation saved successfully")
+            return True
+        except Exception as e:
+            logger.exception(f"Failed to save conversation: {e}")
+            return False
+
+    def load_conversation(self) -> ConversationHistory | None:
+        """Load conversation from persistent storage.
+
+        Returns:
+            The loaded conversation history, or None if no conversation exists
+            or if loading failed.
+        """
+        try:
+            conversation = self.conversation_manager.load()
+            if conversation is None:
+                logger.debug("No conversation file found")
+                return None
+
+            logger.debug("Conversation loaded successfully")
+            return conversation
+        except Exception as e:
+            logger.exception(f"Failed to load conversation: {e}")
+            return None
+
+    def check_for_corrupted_conversation(self) -> bool:
+        """Check if a conversation backup exists (indicating corruption).
+
+        Returns:
+            True if a backup exists (conversation was corrupted), False otherwise.
+        """
+        backup_path = self.conversation_manager.conversation_path.with_suffix(
+            ".json.backup"
+        )
+        return backup_path.exists()
+
+    def restore_conversation(
+        self,
+        agent_manager: "AgentManager",
+        usage_manager: "SessionUsageManager | None" = None,
+    ) -> tuple[bool, str | None, AgentType | None]:
+        """Restore conversation state from disk.
+
+        Args:
+            agent_manager: The agent manager to restore state to.
+            usage_manager: Optional usage manager to restore usage state.
+
+        Returns:
+            Tuple of (success, error_message, restored_agent_type)
+            - success: True if restoration succeeded
+            - error_message: Error message if restoration failed, None otherwise
+            - restored_agent_type: The agent type from restored conversation
+        """
+        conversation = self.load_conversation()
+
+        if conversation is None:
+            # Check for corruption
+            if self.check_for_corrupted_conversation():
+                return (
+                    False,
+                    "⚠️ Previous session was corrupted and has been backed up. Starting fresh conversation.",
+                    None,
+                )
+            return True, None, None  # No conversation to restore is not an error
+
+        try:
+            # Restore agent state
+            agent_messages = conversation.get_agent_messages()
+            ui_messages = conversation.get_ui_messages()
+
+            # Create ConversationState for restoration
+            state = ConversationState(
+                agent_messages=agent_messages,
+                ui_messages=ui_messages,
+                agent_type=conversation.last_agent_model,
+            )
+
+            agent_manager.restore_conversation_state(state)
+
+            # Restore usage state if manager provided
+            if usage_manager:
+                usage_manager.restore_usage_state()
+
+            restored_type = AgentType(conversation.last_agent_model)
+            logger.info(f"Conversation restored successfully (mode: {restored_type})")
+            return True, None, restored_type
+
+        except Exception as e:
+            logger.exception(f"Failed to restore conversation state: {e}")
+            return (
+                False,
+                "⚠️ Could not restore previous session. Starting fresh conversation.",
+                None,
+            )
+
+    def clear_conversation(self) -> bool:
+        """Clear the saved conversation file.
+
+        Returns:
+            True if clearing succeeded, False otherwise.
+        """
+        try:
+            conversation_path = self.conversation_manager.conversation_path
+            if conversation_path.exists():
+                conversation_path.unlink()
+                logger.info("Conversation file cleared")
+            return True
+        except Exception as e:
+            logger.exception(f"Failed to clear conversation: {e}")
+            return False

shotgun/tui/state/__init__.py

@@ -0,0 +1,7 @@
+"""State management utilities for TUI."""
+
+from .processing_state import ProcessingStateManager
+
+__all__ = [
+    "ProcessingStateManager",
+]