shotgun-sh 0.4.0.dev1__py3-none-any.whl → 0.6.2__py3-none-any.whl

shotgun/tui/screens/chat/codebase_index_prompt_screen.py

@@ -11,9 +11,11 @@ from textual.events import Resize
 from textual.screen import ModalScreen
 from textual.widgets import Button, Label, Markdown, Static
 
-from shotgun.tui.layout import COMPACT_HEIGHT_THRESHOLD
 from shotgun.utils.file_system_utils import get_shotgun_home
 
+# Use a higher threshold than the global default since this dialog has more content
+INDEX_PROMPT_COMPACT_THRESHOLD = 45
+
 
 def _is_home_directory() -> bool:
     """Check if cwd is user's home directory.
@@ -46,7 +48,7 @@ class CodebaseIndexPromptScreen(ModalScreen[bool]):
             max-width: 90;
             height: auto;
             max-height: 85%;
-            border: wide $primary;
+            border: none;
             padding: 1 2;
             layout: vertical;
             background: $surface;
@@ -200,12 +202,14 @@ We take your privacy seriously. You can read our full [privacy policy](https://a
         if _is_home_directory():
             _track_event("home_directory_warning_shown")
         # Apply compact layout if starting in a short terminal
-        self._apply_compact_layout(self.app.size.height < COMPACT_HEIGHT_THRESHOLD)
+        self._apply_compact_layout(
+            self.app.size.height < INDEX_PROMPT_COMPACT_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)
+        self._apply_compact_layout(event.size.height < INDEX_PROMPT_COMPACT_THRESHOLD)
 
     def _apply_compact_layout(self, compact: bool) -> None:
         """Apply or remove compact layout classes for short terminals."""

shotgun/tui/screens/chat_screen/attachment_hint.py

@@ -0,0 +1,40 @@
+"""Attachment hint widget for displaying attachments in chat history."""
+
+from textual.app import ComposeResult
+from textual.widget import Widget
+from textual.widgets import Static
+
+from shotgun.attachments import AttachmentHint, get_attachment_icon
+
+
+class AttachmentHintWidget(Widget):
+    """Widget that displays attachment indicator in chat history.
+
+    Display format: "icon Attached: filename (size)"
+    """
+
+    DEFAULT_CSS = """
+    AttachmentHintWidget {
+        height: auto;
+        padding: 0 1;
+        margin: 0 1;
+        color: $text-muted;
+    }
+    """
+
+    def __init__(self, hint: AttachmentHint) -> None:
+        """Initialize with attachment hint data.
+
+        Args:
+            hint: AttachmentHint model containing display info.
+        """
+        super().__init__()
+        self.hint = hint
+
+    def compose(self) -> ComposeResult:
+        """Compose the attachment hint widget."""
+        icon = get_attachment_icon(self.hint.file_type)
+        display_text = (
+            f"{icon} Attached: {self.hint.filename} ({self.hint.file_size_display})"
+        )
+        yield Static(display_text)

shotgun/tui/screens/chat_screen/command_providers.py

@@ -288,11 +288,6 @@ class UnifiedCommandProvider(Provider):
             self.chat_screen.action_show_usage,
             help="Display usage information for the current session",
         )
-        yield DiscoveryHit(
-            "View Onboarding",
-            self.chat_screen.action_view_onboarding,
-            help="View the onboarding tutorial and helpful resources",
-        )
 
     async def search(self, query: str) -> AsyncGenerator[Hit, None]:
         """Search for commands in alphabetical order."""
@@ -345,11 +340,6 @@ class UnifiedCommandProvider(Provider):
                 self.chat_screen.action_show_usage,
                 "Display usage information for the current session",
             ),
-            (
-                "View Onboarding",
-                self.chat_screen.action_view_onboarding,
-                "View the onboarding tutorial and helpful resources",
-            ),
         ]
 
         for title, callback, help_text in commands:

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

@@ -1,5 +1,6 @@
 """Chat history widget - main container for message display."""
 
+import logging
 from collections.abc import Generator, Sequence
 
 from pydantic_ai.messages import (
@@ -13,6 +14,7 @@ from textual.app import ComposeResult
 from textual.reactive import reactive
 from textual.widget import Widget
 
+from shotgun.agents.messages import InternalPromptPart
 from shotgun.tui.components.prompt_input import PromptInput
 from shotgun.tui.components.vertical_tail import VerticalTail
 from shotgun.tui.screens.chat_screen.hint_message import HintMessage, HintMessageWidget
@@ -21,6 +23,8 @@ from .agent_response import AgentResponseWidget
 from .partial_response import PartialResponseWidget
 from .user_question import UserQuestionWidget
 
+logger = logging.getLogger(__name__)
+
 
 class ChatHistory(Widget):
     """Main widget for displaying chat message history."""
@@ -74,14 +78,16 @@ class ChatHistory(Widget):
     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)
+            # Skip ModelRequest messages without visible user content
             if isinstance(item, ModelRequest):
-                has_user_content = any(
-                    isinstance(part, UserPromptPart) for part in item.parts
+                # Check for visible user content (UserPromptPart but NOT InternalPromptPart)
+                has_visible_user_content = any(
+                    isinstance(part, UserPromptPart)
+                    and not isinstance(part, InternalPromptPart)
+                    for part in item.parts
                 )
-                if not has_user_content:
-                    # This is just a tool return, skip displaying it
+                if not has_visible_user_content:
+                    # Skip: either just tool returns or internal system prompts
                     continue
 
             yield item
@@ -89,14 +95,35 @@ class ChatHistory(Widget):
     def update_messages(self, messages: list[ModelMessage | HintMessage]) -> None:
         """Update the displayed messages using incremental mounting."""
         if not self.vertical_tail:
+            logger.debug(
+                "[CHAT_HISTORY] update_messages called but vertical_tail is None"
+            )
             return
 
         self.items = messages
         filtered = list(self.filtered_items())
 
+        # If rendered count is higher than filtered count, the message list was
+        # modified (not just appended). Reset rendered count to allow new messages
+        # to be mounted. This can happen when messages are compacted or filtered.
+        if self._rendered_count > len(filtered):
+            logger.debug(
+                "[CHAT_HISTORY] Rendered count (%d) > filtered count (%d), "
+                "resetting to allow new messages to be mounted",
+                self._rendered_count,
+                len(filtered),
+            )
+            self._rendered_count = len(filtered)
+
         # Only mount new messages that haven't been rendered yet
         if len(filtered) > self._rendered_count:
             new_messages = filtered[self._rendered_count :]
+            logger.debug(
+                "[CHAT_HISTORY] Mounting %d new messages (total=%d, filtered=%d)",
+                len(new_messages),
+                len(messages),
+                len(filtered),
+            )
             for item in new_messages:
                 widget: Widget
                 if isinstance(item, ModelRequest):
@@ -106,6 +133,10 @@ class ChatHistory(Widget):
                 elif isinstance(item, ModelResponse):
                     widget = AgentResponseWidget(item)
                 else:
+                    logger.debug(
+                        "[CHAT_HISTORY] Skipping unknown message type: %s",
+                        type(item).__name__,
+                    )
                     continue
 
                 # Mount before the PartialResponseWidget
@@ -117,11 +148,20 @@ class ChatHistory(Widget):
             self.vertical_tail.scroll_end(animate=False)
 
     def on_click(self, event: events.Click) -> None:
-        """Focus the prompt input when clicking on the history area."""
-        # Only handle clicks that weren't already handled by a child widget
-        if event.button == 1:  # Left click
-            results = self.screen.query(PromptInput)
-            if results:
-                prompt_input = results.first()
-                if prompt_input.display:
-                    prompt_input.focus()
+        """Focus the prompt input when clicking on the history area.
+
+        Skip focusing if text is selected (to allow copy operations).
+        """
+        # Only handle left clicks
+        if event.button != 1:
+            return
+
+        # Don't focus input if user has selected text (they might want to copy it)
+        if self.screen.get_selected_text():
+            return
+
+        results = self.screen.query(PromptInput)
+        if results:
+            prompt_input = results.first()
+            if prompt_input.display:
+                prompt_input.focus()

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

@@ -95,6 +95,17 @@ class ToolFormatter:
                 args, display_config.key_arg, part.tool_name
             )
             if key_value:
+                # Check for secondary key arg
+                if display_config.secondary_key_arg:
+                    secondary_value = cls._extract_key_arg(
+                        args, display_config.secondary_key_arg, part.tool_name
+                    )
+                    if secondary_value:
+                        # Format: "display_text: key_value → secondary_value"
+                        return (
+                            f"{display_config.display_text}: "
+                            f"{cls.truncate(key_value)} → {cls.truncate(secondary_value)}"
+                        )
                 # Format: "display_text: key_value"
                 return f"{display_config.display_text}: {cls.truncate(key_value)}"
             else:
@@ -135,6 +146,17 @@ class ToolFormatter:
             # Get the key argument value
             key_value = cls._extract_key_arg(args, display_config.key_arg)
             if key_value:
+                # Check for secondary key arg
+                if display_config.secondary_key_arg:
+                    secondary_value = cls._extract_key_arg(
+                        args, display_config.secondary_key_arg
+                    )
+                    if secondary_value:
+                        # Format: "display_text: key_value → secondary_value"
+                        return (
+                            f"{display_config.display_text}: "
+                            f"{cls.truncate(key_value)} → {cls.truncate(secondary_value)}"
+                        )
                 # Format: "display_text: key_value"
                 return f"{display_config.display_text}: {cls.truncate(key_value)}"
             else:

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

@@ -12,6 +12,8 @@ from textual.app import ComposeResult
 from textual.widget import Widget
 from textual.widgets import Markdown
 
+from shotgun.agents.messages import InternalPromptPart
+
 
 class UserQuestionWidget(Widget):
     """Widget that displays user prompts in the chat history."""
@@ -33,10 +35,30 @@ class UserQuestionWidget(Widget):
         acc = ""
         for part in parts:
             if isinstance(part, UserPromptPart):
-                acc += (
-                    f"**>** {part.content if isinstance(part.content, str) else ''}\n\n"
-                )
+                # Skip internal prompts (system-generated, not user input)
+                if isinstance(part, InternalPromptPart):
+                    continue
+                content = self._extract_text_content(part.content)
+                if content:
+                    acc += f"**>** {content}\n\n"
+                # Skip if no displayable text (e.g., only binary files)
             elif isinstance(part, ToolReturnPart):
                 # Don't show tool return parts in the UI
                 pass
         return acc
+
+    def _extract_text_content(self, content: object) -> str:
+        """Extract displayable text from UserPromptPart content.
+
+        Content can be:
+        - str: Return directly
+        - list: Extract text strings, skip binary content (BinaryContent, ImageUrl, etc.)
+        - other: Return empty string
+        """
+        if isinstance(content, str):
+            return content
+        if isinstance(content, list):
+            # Multimodal content - extract only text strings
+            text_parts = [item for item in content if isinstance(item, str)]
+            return " ".join(text_parts) if text_parts else ""
+        return ""

shotgun/tui/screens/database_locked_dialog.py

@@ -0,0 +1,219 @@
+"""Dialog shown when the database is locked by another process."""
+
+import webbrowser
+
+import pyperclip  # type: ignore[import-untyped]
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal
+from textual.events import Resize
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label, Static
+
+from shotgun.exceptions import SHOTGUN_CONTACT_EMAIL
+from shotgun.posthog_telemetry import track_event
+from shotgun.tui.layout import COMPACT_HEIGHT_THRESHOLD
+from shotgun.tui.screens.confirmation_dialog import ConfirmationDialog
+from shotgun.tui.screens.models import LockedDialogAction
+
+# Discord invite link for support
+DISCORD_LINK = "https://discord.gg/5RmY6J2N7s"
+
+
+class DatabaseLockedDialog(ModalScreen[LockedDialogAction]):
+    """Dialog shown when the database is locked by another process.
+
+    This modal informs the user that the database is locked, which could mean
+    another instance is running OR a previous instance shut down unsafely
+    without releasing the lock.
+
+    Returns:
+        LockedDialogAction.RETRY if user wants to retry after closing other instances
+        LockedDialogAction.DELETE if user wants to delete the locked database
+        LockedDialogAction.QUIT if user wants to quit the application
+    """
+
+    DEFAULT_CSS = """
+        DatabaseLockedDialog {
+            align: center middle;
+            background: rgba(0, 0, 0, 0.0);
+        }
+
+        DatabaseLockedDialog > #dialog-container {
+            width: 70%;
+            max-width: 80;
+            height: auto;
+            border: wide $warning;
+            padding: 1 2;
+            layout: vertical;
+            background: $surface;
+        }
+
+        #dialog-title {
+            text-style: bold;
+            color: $warning;
+            padding-bottom: 1;
+        }
+
+        #dialog-message {
+            padding-bottom: 1;
+            color: $text-muted;
+        }
+
+        #support-buttons {
+            layout: horizontal;
+            height: auto;
+            padding-bottom: 1;
+        }
+
+        #support-buttons Button {
+            margin-right: 1;
+        }
+
+        #dialog-buttons {
+            layout: horizontal;
+            align-horizontal: right;
+            height: auto;
+        }
+
+        #dialog-buttons Button {
+            margin-left: 1;
+        }
+
+        #delete-section {
+            layout: horizontal;
+            height: auto;
+            padding-top: 1;
+            border-top: solid $warning-darken-2;
+        }
+
+        #delete-section Static {
+            width: 1fr;
+            color: $text-muted;
+        }
+
+        #delete-section 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 compose(self) -> ComposeResult:
+        """Compose the dialog widgets."""
+        with Container(id="dialog-container"):
+            yield Label("Codebase Index Unavailable", id="dialog-title")
+            message = (
+                "Unable to access the codebase index because it is locked.\n\n"
+                "We can't determine if another shotgun instance is currently running "
+                "or if a previous instance shut down unsafely without releasing the lock.\n\n"
+                "To resolve this:\n"
+                "1. Close any other shotgun instances and click Retry\n"
+                "2. If no other instance is running, you can delete the index\n\n"
+                "Need help? Contact support:"
+            )
+            yield Static(message, id="dialog-message")
+            with Horizontal(id="support-buttons"):
+                yield Button(
+                    f"Copy Support Email [{SHOTGUN_CONTACT_EMAIL}]", id="copy-email"
+                )
+                yield Button("Open Support Discord", id="open-discord")
+            with Container(id="dialog-buttons"):
+                yield Button("Retry", id="retry", variant="primary")
+                yield Button("Quit", id="cancel")
+            with Horizontal(id="delete-section"):
+                yield Static("Caution: Only delete if no other instance is running.")
+                yield Button("Delete Index", id="delete", variant="error")
+
+    def on_mount(self) -> None:
+        """Set up the dialog after mounting."""
+        # Track this event in PostHog
+        track_event("database_locked_dialog_shown", {})
+
+        # Focus retry button - user likely wants to retry after closing other instance
+        self.query_one("#retry", 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(LockedDialogAction.QUIT)
+
+    @on(Button.Pressed, "#retry")
+    def handle_retry(self, event: Button.Pressed) -> None:
+        """Handle retry button press."""
+        event.stop()
+        self.dismiss(LockedDialogAction.RETRY)
+
+    @on(Button.Pressed, "#delete")
+    async def handle_delete(self, event: Button.Pressed) -> None:
+        """Handle delete button press with confirmation."""
+        event.stop()
+        # Show confirmation dialog before proceeding
+        confirmed = await self.app.push_screen_wait(
+            ConfirmationDialog(
+                title="Delete Codebase Index?",
+                message=(
+                    "Have you checked that no other shotgun instance is running?\n\n"
+                    "Deleting while another instance is open could cause data loss. "
+                    "You will need to re-index the codebase after deletion."
+                ),
+                confirm_label="Delete Index",
+                cancel_label="Cancel",
+                confirm_variant="error",
+                danger=True,
+            )
+        )
+        if confirmed:
+            track_event("database_locked_dialog_delete", {})
+            self.dismiss(LockedDialogAction.DELETE)
+
+    @on(Button.Pressed, "#copy-email")
+    def handle_copy_email(self, event: Button.Pressed) -> None:
+        """Copy support email to clipboard."""
+        event.stop()
+        pyperclip.copy(SHOTGUN_CONTACT_EMAIL)
+        track_event("database_locked_dialog_copy_email", {})
+        self.notify("Email copied to clipboard", severity="information")
+
+    @on(Button.Pressed, "#open-discord")
+    def handle_open_discord(self, event: Button.Pressed) -> None:
+        """Open Discord link in browser."""
+        event.stop()
+        webbrowser.open(DISCORD_LINK)
+        track_event("database_locked_dialog_open_discord", {})

shotgun/tui/screens/database_timeout_dialog.py

@@ -0,0 +1,158 @@
+"""Dialog shown when database operation times out."""
+
+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
+
+TimeoutAction = Literal["retry", "skip", "cancel"]
+
+
+class DatabaseTimeoutDialog(ModalScreen[TimeoutAction]):
+    """Dialog shown when database operation takes longer than expected.
+
+    This modal informs the user that the database operation is taking longer
+    than expected (can happen with large codebases) and offers options to
+    wait longer, skip, or cancel.
+
+    Args:
+        codebase_name: Name of the codebase that timed out
+        timeout_seconds: The timeout that was exceeded
+
+    Returns:
+        "retry" - Wait longer (90s timeout)
+        "skip" - Skip this database and continue
+        "cancel" - Cancel the operation
+    """
+
+    DEFAULT_CSS = """
+        DatabaseTimeoutDialog {
+            align: center middle;
+            background: rgba(0, 0, 0, 0.0);
+        }
+
+        DatabaseTimeoutDialog > #dialog-container {
+            width: 60%;
+            max-width: 70;
+            height: auto;
+            border: wide $warning;
+            padding: 1 2;
+            layout: vertical;
+            background: $surface;
+        }
+
+        #dialog-title {
+            text-style: bold;
+            color: $warning;
+            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, codebase_name: str = "", timeout_seconds: float = 10.0) -> None:
+        """Initialize the dialog.
+
+        Args:
+            codebase_name: Name of the codebase that timed out
+            timeout_seconds: The timeout that was exceeded
+        """
+        super().__init__()
+        self.codebase_name = codebase_name
+        self.timeout_seconds = timeout_seconds
+
+    def compose(self) -> ComposeResult:
+        """Compose the dialog widgets."""
+        with Container(id="dialog-container"):
+            yield Label("Database Taking Longer Than Expected", id="dialog-title")
+            message = (
+                f"The database operation exceeded {self.timeout_seconds:.0f} seconds.\n\n"
+                "This can happen with large codebases. "
+                "Would you like to wait longer (90 seconds)?"
+            )
+            if self.codebase_name:
+                message = f"Codebase: {self.codebase_name}\n\n" + message
+            yield Static(message, id="dialog-message")
+            with Container(id="dialog-buttons"):
+                yield Button("Wait Longer", id="retry", variant="primary")
+                yield Button("Skip", id="skip")
+                yield Button("Cancel", id="cancel")
+
+    def on_mount(self) -> None:
+        """Set up the dialog after mounting."""
+        # Focus "Wait Longer" button - most likely what user wants
+        self.query_one("#retry", 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("cancel")
+
+    @on(Button.Pressed, "#skip")
+    def handle_skip(self, event: Button.Pressed) -> None:
+        """Handle skip button press."""
+        event.stop()
+        self.dismiss("skip")
+
+    @on(Button.Pressed, "#retry")
+    def handle_retry(self, event: Button.Pressed) -> None:
+        """Handle retry button press."""
+        event.stop()
+        self.dismiss("retry")