shotgun-sh 0.3.3.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

@@ -3,7 +3,6 @@ from typing import TYPE_CHECKING, cast
 
 from textual.command import DiscoveryHit, Hit, Provider
 
-from shotgun.agents.models import AgentType
 from shotgun.codebase.models import CodebaseGraph
 from shotgun.tui.screens.chat_screen.hint_message import HintMessage
 from shotgun.tui.screens.model_picker import ModelPickerScreen
@@ -13,92 +12,6 @@ if TYPE_CHECKING:
     from shotgun.tui.screens.chat import ChatScreen
 
 
-class AgentModeProvider(Provider):
-    """Command provider for agent mode switching."""
-
-    @property
-    def chat_screen(self) -> "ChatScreen":
-        from shotgun.tui.screens.chat import ChatScreen
-
-        return cast(ChatScreen, self.screen)
-
-    def set_mode(self, mode: AgentType) -> None:
-        """Switch to research mode."""
-        self.chat_screen.mode = mode
-
-    async def discover(self) -> AsyncGenerator[DiscoveryHit, None]:
-        """Provide default mode switching commands when palette opens."""
-        yield DiscoveryHit(
-            "Switch to Research Mode",
-            lambda: self.set_mode(AgentType.RESEARCH),
-            help="🔬 Research topics with web search and synthesize findings",
-        )
-        yield DiscoveryHit(
-            "Switch to Specify Mode",
-            lambda: self.set_mode(AgentType.SPECIFY),
-            help="📝 Create detailed specifications and requirements documents",
-        )
-        yield DiscoveryHit(
-            "Switch to Plan Mode",
-            lambda: self.set_mode(AgentType.PLAN),
-            help="📋 Create comprehensive, actionable plans with milestones",
-        )
-        yield DiscoveryHit(
-            "Switch to Tasks Mode",
-            lambda: self.set_mode(AgentType.TASKS),
-            help="✅ Generate specific, actionable tasks from research and plans",
-        )
-        yield DiscoveryHit(
-            "Switch to Export Mode",
-            lambda: self.set_mode(AgentType.EXPORT),
-            help="📤 Export artifacts and findings to various formats",
-        )
-
-    async def search(self, query: str) -> AsyncGenerator[Hit, None]:
-        """Search for mode commands."""
-        matcher = self.matcher(query)
-
-        commands = [
-            (
-                "Switch to Research Mode",
-                "🔬 Research topics with web search and synthesize findings",
-                lambda: self.set_mode(AgentType.RESEARCH),
-                AgentType.RESEARCH,
-            ),
-            (
-                "Switch to Specify Mode",
-                "📝 Create detailed specifications and requirements documents",
-                lambda: self.set_mode(AgentType.SPECIFY),
-                AgentType.SPECIFY,
-            ),
-            (
-                "Switch to Plan Mode",
-                "📋 Create comprehensive, actionable plans with milestones",
-                lambda: self.set_mode(AgentType.PLAN),
-                AgentType.PLAN,
-            ),
-            (
-                "Switch to Tasks Mode",
-                "✅ Generate specific, actionable tasks from research and plans",
-                lambda: self.set_mode(AgentType.TASKS),
-                AgentType.TASKS,
-            ),
-            (
-                "Switch to Export Mode",
-                "📤 Export artifacts and findings to various formats",
-                lambda: self.set_mode(AgentType.EXPORT),
-                AgentType.EXPORT,
-            ),
-        ]
-
-        for title, help_text, callback, mode in commands:
-            if self.chat_screen.mode == mode:
-                continue
-            score = matcher.match(title)
-            if score > 0:
-                yield Hit(score, matcher.highlight(title), callback, help=help_text)
-
-
 class UsageProvider(Provider):
     """Command provider for agent mode switching."""
 
@@ -375,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."""
@@ -432,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/agent_response.py

@@ -18,9 +18,10 @@ from .formatters import ToolFormatter
 class AgentResponseWidget(Widget):
     """Widget that displays agent responses in the chat history."""
 
-    def __init__(self, item: ModelResponse | None) -> None:
+    def __init__(self, item: ModelResponse | None, is_sub_agent: bool = False) -> None:
         super().__init__()
         self.item = item
+        self.is_sub_agent = is_sub_agent
 
     def compose(self) -> ComposeResult:
         self.display = self.item is not None
@@ -35,11 +36,14 @@ class AgentResponseWidget(Widget):
         if self.item is None:
             return ""
 
+        # Use different prefix for sub-agent responses
+        prefix = "**⏺** " if not self.is_sub_agent else "  **↳** "
+
         for idx, part in enumerate(self.item.parts):
             if isinstance(part, TextPart):
-                # Only show the circle prefix if there's actual content
+                # Only show the prefix if there's actual content
                 if part.content and part.content.strip():
-                    acc += f"**⏺** {part.content}\n\n"
+                    acc += f"{prefix}{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

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 (
@@ -8,10 +9,13 @@ from pydantic_ai.messages import (
     ModelResponse,
     UserPromptPart,
 )
+from textual import events
 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
 
@@ -19,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."""
@@ -72,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
@@ -87,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):
@@ -104,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
@@ -113,3 +146,22 @@ class ChatHistory(Widget):
 
             # Scroll to bottom to show newly added messages
             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.
+
+        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

@@ -29,6 +29,53 @@ class ToolFormatter:
                 return {}
         return args if isinstance(args, dict) else {}
 
+    @classmethod
+    def _extract_key_arg(
+        cls,
+        args: dict[str, object],
+        key_arg: str,
+        tool_name: str | None = None,
+    ) -> str | None:
+        """Extract key argument value, handling nested args and special cases.
+
+        Supports:
+        - Direct key access: key_arg="query" -> args["query"]
+        - Nested access: key_arg="task" -> args["input"]["task"] (for Pydantic model inputs)
+        - Special handling for codebase_shell
+
+        Args:
+            args: Parsed tool arguments dict
+            key_arg: The key argument to extract
+            tool_name: Optional tool name for special handling
+
+        Returns:
+            The extracted value as a string, or None if not found
+        """
+        if not args or not isinstance(args, dict):
+            return None
+
+        # Special handling for codebase_shell which needs command + args
+        if 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 = ""
+            return f"{command} {args_str}".strip()
+
+        # Direct key access
+        if key_arg in args:
+            return str(args[key_arg])
+
+        # Try nested access through "input" (for Pydantic model inputs)
+        if "input" in args and isinstance(args["input"], dict):
+            input_dict = args["input"]
+            if key_arg in input_dict:
+                return str(input_dict[key_arg])
+
+        return None
+
     @classmethod
     def format_tool_call_part(cls, part: ToolCallPart) -> str:
         """Format a tool call part using the tool display registry."""
@@ -44,19 +91,21 @@ class ToolFormatter:
             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])
-
+            key_value = cls._extract_key_arg(
+                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:
@@ -95,8 +144,19 @@ class ToolFormatter:
 
             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])
+            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/partial_response.py

@@ -5,6 +5,8 @@ from textual.app import ComposeResult
 from textual.reactive import reactive
 from textual.widget import Widget
 
+from shotgun.tui.protocols import ActiveSubAgentProvider
+
 from .agent_response import AgentResponseWidget
 from .user_question import UserQuestionWidget
 
@@ -27,11 +29,19 @@ class PartialResponseWidget(Widget):  # TODO: doesn't work lol
         super().__init__()
         self.item = item
 
+    def _is_sub_agent_active(self) -> bool:
+        """Check if a sub-agent is currently active."""
+        if isinstance(self.screen, ActiveSubAgentProvider):
+            return self.screen.active_sub_agent is not None
+        return False
+
     def compose(self) -> ComposeResult:
         if self.item is None:
             pass
         elif self.item.kind == "response":
-            yield AgentResponseWidget(self.item)
+            yield AgentResponseWidget(
+                self.item, is_sub_agent=self._is_sub_agent_active()
+            )
         elif self.item.kind == "request":
             yield UserQuestionWidget(self.item)
 

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 ""