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

shotgun/tui/screens/chat/codebase_index_prompt_screen.py

@@ -0,0 +1,64 @@
+"""Modal dialog for codebase indexing prompts."""
+
+from pathlib import Path
+
+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
+
+
+class CodebaseIndexPromptScreen(ModalScreen[bool]):
+    """Modal dialog asking whether to index the detected codebase."""
+
+    DEFAULT_CSS = """
+        CodebaseIndexPromptScreen {
+            align: center middle;
+            background: rgba(0, 0, 0, 0.0);
+        }
+
+        CodebaseIndexPromptScreen > #index-prompt-dialog {
+            width: 60%;
+            max-width: 60;
+            height: auto;
+            border: wide $primary;
+            padding: 1 2;
+            layout: vertical;
+            background: $surface;
+            height: auto;
+        }
+
+        #index-prompt-buttons {
+            layout: horizontal;
+            align-horizontal: right;
+            height: auto;
+        }
+    """
+
+    def compose(self) -> ComposeResult:
+        with Container(id="index-prompt-dialog"):
+            yield Label("Index this codebase?", id="index-prompt-title")
+            yield Static(
+                f"Would you like to index the codebase at:\n{Path.cwd()}\n\n"
+                "This is required for the agent to understand your code and answer "
+                "questions about it. Without indexing, the agent cannot analyze "
+                "your codebase."
+            )
+            with Container(id="index-prompt-buttons"):
+                yield Button(
+                    "Index now",
+                    id="index-prompt-confirm",
+                    variant="primary",
+                )
+                yield Button("Not now", id="index-prompt-cancel")
+
+    @on(Button.Pressed, "#index-prompt-cancel")
+    def handle_cancel(self, event: Button.Pressed) -> None:
+        event.stop()
+        self.dismiss(False)
+
+    @on(Button.Pressed, "#index-prompt-confirm")
+    def handle_confirm(self, event: Button.Pressed) -> None:
+        event.stop()
+        self.dismiss(True)

shotgun/tui/screens/chat/codebase_index_selection.py

@@ -0,0 +1,12 @@
+"""Codebase indexing selection models."""
+
+from pathlib import Path
+
+from pydantic import BaseModel
+
+
+class CodebaseIndexSelection(BaseModel):
+    """User-selected repository path and name for indexing."""
+
+    repo_path: Path
+    name: str

shotgun/tui/screens/chat/help_text.py

@@ -0,0 +1,40 @@
+"""Helper functions for chat screen help text."""
+
+
+def help_text_with_codebase(already_indexed: bool = False) -> str:
+    """Generate help text for when a codebase is available.
+
+    Args:
+        already_indexed: Whether the codebase is already indexed.
+
+    Returns:
+        Formatted help text string.
+    """
+    return (
+        "Howdy! Welcome to Shotgun - Spec Driven Development for Developers and AI Agents.\n\n"
+        "Shotgun writes codebase-aware specs for your AI coding agents so they don't derail.\n\n"
+        f"{'It' if already_indexed else 'Once your codebase is indexed, it'} can help you:\n"
+        "- Research your codebase and spec out new features\n"
+        "- Create implementation plans that fit your architecture\n"
+        "- Generate AGENTS.md files for AI coding agents\n"
+        "- Onboard to existing projects or plan refactors\n\n"
+        "Ready to build something? Let's go.\n"
+    )
+
+
+def help_text_empty_dir() -> str:
+    """Generate help text for empty directory.
+
+    Returns:
+        Formatted help text string.
+    """
+    return (
+        "Howdy! Welcome to Shotgun - Spec Driven Development for Developers and AI Agents.\n\n"
+        "Shotgun writes codebase-aware specs for your AI coding agents so they don't derail.\n\n"
+        "It can help you:\n"
+        "- Research your codebase and spec out new features\n"
+        "- Create implementation plans that fit your architecture\n"
+        "- Generate AGENTS.md files for AI coding agents\n"
+        "- Onboard to existing projects or plan refactors\n\n"
+        "Ready to build something? Let's go.\n"
+    )

shotgun/tui/screens/chat/prompt_history.py

@@ -0,0 +1,48 @@
+"""Prompt history management for chat screen."""
+
+from pydantic import BaseModel, Field
+
+
+class PromptHistory(BaseModel):
+    """Manages prompt history for navigation in chat input."""
+
+    prompts: list[str] = Field(default_factory=lambda: ["Hello there!"])
+    curr: int | None = None
+
+    def next(self) -> str:
+        """Navigate to next prompt in history.
+
+        Returns:
+            The next prompt in history.
+        """
+        if self.curr is None:
+            self.curr = -1
+        else:
+            self.curr = -1
+        return self.prompts[self.curr]
+
+    def prev(self) -> str:
+        """Navigate to previous prompt in history.
+
+        Returns:
+            The previous prompt in history.
+
+        Raises:
+            Exception: If current entry is None.
+        """
+        if self.curr is None:
+            raise Exception("current entry is none")
+        if self.curr == -1:
+            self.curr = None
+            return ""
+        self.curr += 1
+        return ""
+
+    def append(self, text: str) -> None:
+        """Add a new prompt to history.
+
+        Args:
+            text: The prompt text to add.
+        """
+        self.prompts.append(text)
+        self.curr = None

shotgun/tui/screens/chat.tcss

@@ -38,6 +38,17 @@ ModeIndicator {
 }
 
 
+#right-footer-indicators {
+  width: auto;
+  height: auto;
+  layout: vertical;
+}
+
+#context-indicator {
+  text-align: end;
+  height: 1;
+}
+
 #indexing-job-display {
   text-align: end;
 }

shotgun/tui/screens/chat_screen/command_providers.py

@@ -5,6 +5,8 @@ from textual.command import DiscoveryHit, Hit, Provider
 
 from shotgun.agents.models import AgentType
 from shotgun.codebase.models import CodebaseGraph
+from shotgun.tui.screens.model_picker import ModelPickerScreen
+from shotgun.tui.screens.provider_config import ProviderConfigScreen
 
 if TYPE_CHECKING:
     from shotgun.tui.screens.chat import ChatScreen
@@ -96,6 +98,70 @@ class AgentModeProvider(Provider):
                 yield Hit(score, matcher.highlight(title), callback, help=help_text)
 
 
+class UsageProvider(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)
+
+    async def discover(self) -> AsyncGenerator[DiscoveryHit, None]:
+        """Provide default mode switching commands when palette opens."""
+        yield DiscoveryHit(
+            "Show usage",
+            self.chat_screen.action_show_usage,
+            help="Display usage information for the current session",
+        )
+
+    async def search(self, query: str) -> AsyncGenerator[Hit, None]:
+        """Search for mode commands."""
+        matcher = self.matcher(query)
+
+        async for discovery_hit in self.discover():
+            score = matcher.match(discovery_hit.text or "")
+            if score > 0:
+                yield Hit(
+                    score,
+                    matcher.highlight(discovery_hit.text or ""),
+                    discovery_hit.command,
+                    help=discovery_hit.help,
+                )
+
+
+class ContextProvider(Provider):
+    """Command provider for showing conversation context analysis."""
+
+    @property
+    def chat_screen(self) -> "ChatScreen":
+        from shotgun.tui.screens.chat import ChatScreen
+
+        return cast(ChatScreen, self.screen)
+
+    async def discover(self) -> AsyncGenerator[DiscoveryHit, None]:
+        """Provide context command when palette opens."""
+        yield DiscoveryHit(
+            "Show context",
+            self.chat_screen.action_show_context,
+            help="Display conversation context composition and statistics",
+        )
+
+    async def search(self, query: str) -> AsyncGenerator[Hit, None]:
+        """Search for context command."""
+        matcher = self.matcher(query)
+
+        async for discovery_hit in self.discover():
+            score = matcher.match(discovery_hit.text or "")
+            if score > 0:
+                yield Hit(
+                    score,
+                    matcher.highlight(discovery_hit.text or ""),
+                    discovery_hit.command,
+                    help=discovery_hit.help,
+                )
+
+
 class ProviderSetupProvider(Provider):
     """Command palette entries for provider configuration."""
 
@@ -107,7 +173,13 @@ class ProviderSetupProvider(Provider):
 
     def open_provider_config(self) -> None:
         """Show the provider configuration screen."""
-        self.chat_screen.app.push_screen("provider_config")
+        self.chat_screen.app.push_screen(ProviderConfigScreen())
+
+    def open_model_picker(self) -> None:
+        """Show the model picker screen."""
+        self.chat_screen.app.push_screen(
+            ModelPickerScreen(), callback=self.chat_screen.handle_model_selected
+        )
 
     async def discover(self) -> AsyncGenerator[DiscoveryHit, None]:
         yield DiscoveryHit(
@@ -115,9 +187,15 @@ class ProviderSetupProvider(Provider):
             self.open_provider_config,
             help="⚙️ Manage API keys for available providers",
         )
+        yield DiscoveryHit(
+            "Select AI Model",
+            self.open_model_picker,
+            help="🤖 Choose which AI model to use",
+        )
 
     async def search(self, query: str) -> AsyncGenerator[Hit, None]:
         matcher = self.matcher(query)
+
         title = "Open Provider Setup"
         score = matcher.match(title)
         if score > 0:
@@ -128,6 +206,16 @@ class ProviderSetupProvider(Provider):
                 help="⚙️ Manage API keys for available providers",
             )
 
+        title = "Select AI Model"
+        score = matcher.match(title)
+        if score > 0:
+            yield Hit(
+                score,
+                matcher.highlight(title),
+                self.open_model_picker,
+                help="🤖 Choose which AI model to use",
+            )
+
 
 class CodebaseCommandProvider(Provider):
     """Command palette entries for codebase management."""
@@ -139,30 +227,30 @@ class CodebaseCommandProvider(Provider):
         return cast(ChatScreen, self.screen)
 
     async def discover(self) -> AsyncGenerator[DiscoveryHit, None]:
-        yield DiscoveryHit(
-            "Codebase: Index Codebase",
-            self.chat_screen.index_codebase_command,
-            help="Index a repository into the codebase graph",
-        )
         yield DiscoveryHit(
             "Codebase: Delete Codebase Index",
             self.chat_screen.delete_codebase_command,
             help="Delete an existing codebase index",
         )
+        yield DiscoveryHit(
+            "Codebase: Index Codebase",
+            self.chat_screen.index_codebase_command,
+            help="Index a repository into the codebase graph",
+        )
 
     async def search(self, query: str) -> AsyncGenerator[Hit, None]:
         matcher = self.matcher(query)
         commands = [
-            (
-                "Codebase: Index Codebase",
-                self.chat_screen.index_codebase_command,
-                "Index a repository into the codebase graph",
-            ),
             (
                 "Codebase: Delete Codebase Index",
                 self.chat_screen.delete_codebase_command,
                 "Delete an existing codebase index",
             ),
+            (
+                "Codebase: Index Codebase",
+                self.chat_screen.index_codebase_command,
+                "Index a repository into the codebase graph",
+            ),
         ]
         for title, callback, help_text in commands:
             score = matcher.match(title)
@@ -217,3 +305,130 @@ class DeleteCodebasePaletteProvider(Provider):
                     ),
                     help=graph.repo_path,
                 )
+
+
+class UnifiedCommandProvider(Provider):
+    """Unified command provider with all commands in alphabetical order."""
+
+    @property
+    def chat_screen(self) -> "ChatScreen":
+        from shotgun.tui.screens.chat import ChatScreen
+
+        return cast(ChatScreen, self.screen)
+
+    def open_provider_config(self) -> None:
+        """Show the provider configuration screen."""
+        self.chat_screen.app.push_screen(ProviderConfigScreen())
+
+    def open_model_picker(self) -> None:
+        """Show the model picker screen."""
+        self.chat_screen.app.push_screen(
+            ModelPickerScreen(), callback=self.chat_screen.handle_model_selected
+        )
+
+    async def discover(self) -> AsyncGenerator[DiscoveryHit, None]:
+        """Provide commands in alphabetical order when palette opens."""
+        # Alphabetically ordered commands
+        yield DiscoveryHit(
+            "Clear Conversation",
+            self.chat_screen.action_clear_conversation,
+            help="Clear the entire conversation history",
+        )
+        yield DiscoveryHit(
+            "Codebase: Delete Codebase Index",
+            self.chat_screen.delete_codebase_command,
+            help="Delete an existing codebase index",
+        )
+        yield DiscoveryHit(
+            "Codebase: Index Codebase",
+            self.chat_screen.index_codebase_command,
+            help="Index a repository into the codebase graph",
+        )
+        yield DiscoveryHit(
+            "Compact Conversation",
+            self.chat_screen.action_compact_conversation,
+            help="Reduce conversation size by compacting message history",
+        )
+        yield DiscoveryHit(
+            "Open Provider Setup",
+            self.open_provider_config,
+            help="⚙️ Manage API keys for available providers",
+        )
+        yield DiscoveryHit(
+            "Select AI Model",
+            self.open_model_picker,
+            help="🤖 Choose which AI model to use",
+        )
+        yield DiscoveryHit(
+            "Show context",
+            self.chat_screen.action_show_context,
+            help="Display conversation context composition and statistics",
+        )
+        yield DiscoveryHit(
+            "Show usage",
+            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."""
+        matcher = self.matcher(query)
+
+        # Define all commands in alphabetical order
+        commands = [
+            (
+                "Clear Conversation",
+                self.chat_screen.action_clear_conversation,
+                "Clear the entire conversation history",
+            ),
+            (
+                "Codebase: Delete Codebase Index",
+                self.chat_screen.delete_codebase_command,
+                "Delete an existing codebase index",
+            ),
+            (
+                "Codebase: Index Codebase",
+                self.chat_screen.index_codebase_command,
+                "Index a repository into the codebase graph",
+            ),
+            (
+                "Compact Conversation",
+                self.chat_screen.action_compact_conversation,
+                "Reduce conversation size by compacting message history",
+            ),
+            (
+                "Open Provider Setup",
+                self.open_provider_config,
+                "⚙️ Manage API keys for available providers",
+            ),
+            (
+                "Select AI Model",
+                self.open_model_picker,
+                "🤖 Choose which AI model to use",
+            ),
+            (
+                "Show context",
+                self.chat_screen.action_show_context,
+                "Display conversation context composition and statistics",
+            ),
+            (
+                "Show usage",
+                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:
+            score = matcher.match(title)
+            if score > 0:
+                yield Hit(score, matcher.highlight(title), callback, help=help_text)

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

@@ -0,0 +1,22 @@
+"""Chat history package - displays conversation messages in the TUI.
+
+This package provides widgets for displaying chat history including:
+- User questions
+- Agent responses
+- Tool calls
+- Streaming/partial responses
+"""
+
+from .agent_response import AgentResponseWidget
+from .chat_history import ChatHistory
+from .formatters import ToolFormatter
+from .partial_response import PartialResponseWidget
+from .user_question import UserQuestionWidget
+
+__all__ = [
+    "ChatHistory",
+    "PartialResponseWidget",
+    "AgentResponseWidget",
+    "UserQuestionWidget",
+    "ToolFormatter",
+]

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

@@ -0,0 +1,66 @@
+"""Agent response widget for chat history."""
+
+from pydantic_ai.messages import (
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
+    ModelResponse,
+    TextPart,
+    ThinkingPart,
+    ToolCallPart,
+)
+from textual.app import ComposeResult
+from textual.widget import Widget
+from textual.widgets import Markdown
+
+from .formatters import ToolFormatter
+
+
+class AgentResponseWidget(Widget):
+    """Widget that displays agent responses in the chat history."""
+
+    def __init__(self, item: ModelResponse | 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:
+            yield Markdown(markdown=self.compute_output())
+
+    def compute_output(self) -> str:
+        """Compute the markdown output for the agent response."""
+        acc = ""
+        if self.item is None:
+            return ""
+
+        for idx, part in enumerate(self.item.parts):
+            if isinstance(part, TextPart):
+                # Only show the circle prefix if there's actual content
+                if part.content and part.content.strip():
+                    acc += f"**⏺** {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
+                    acc += parts_str + "\n\n"
+            elif isinstance(part, BuiltinToolCallPart):
+                # Format builtin tool calls using registry
+                formatted = ToolFormatter.format_builtin_tool_call(part)
+                if formatted:  # Only add if not hidden
+                    acc += formatted + "\n\n"
+            elif isinstance(part, BuiltinToolReturnPart):
+                # Don't show tool return parts in the UI
+                pass
+            elif isinstance(part, ThinkingPart):
+                if (
+                    idx == len(self.item.parts) - 1
+                ):  # show the thinking part only if it's the last part
+                    acc += (
+                        f"thinking: {part.content}\n\n"
+                        if part.content
+                        else "Thinking..."
+                    )
+                else:
+                    continue
+        return acc.strip()

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

@@ -0,0 +1,116 @@
+"""Chat history widget - main container for message display."""
+
+from collections.abc import Generator, Sequence
+
+from pydantic_ai.messages import (
+    ModelMessage,
+    ModelRequest,
+    ModelResponse,
+    UserPromptPart,
+)
+from textual.app import ComposeResult
+from textual.reactive import reactive
+from textual.widget import Widget
+
+from shotgun.tui.components.vertical_tail import VerticalTail
+from shotgun.tui.screens.chat_screen.hint_message import HintMessage, HintMessageWidget
+
+from .agent_response import AgentResponseWidget
+from .partial_response import PartialResponseWidget
+from .user_question import UserQuestionWidget
+
+
+class ChatHistory(Widget):
+    """Main widget for displaying chat message history."""
+
+    DEFAULT_CSS = """
+        VerticalTail {
+            align: left bottom;
+
+        }
+        VerticalTail > * {
+            height: auto;
+        }
+
+        Horizontal {
+            height: auto;
+            background: $secondary-muted;
+        }
+
+        Markdown {
+            height: auto;
+        }
+    """
+    partial_response: reactive[ModelMessage | None] = reactive(None)
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.items: Sequence[ModelMessage | HintMessage] = []
+        self.vertical_tail: VerticalTail | None = None
+        self.partial_response = None
+        self._rendered_count = 0  # Track how many messages have been mounted
+
+    def compose(self) -> ComposeResult:
+        """Compose the chat history widget."""
+        self.vertical_tail = VerticalTail()
+
+        filtered = list(self.filtered_items())
+        with self.vertical_tail:
+            for item in filtered:
+                if isinstance(item, ModelRequest):
+                    yield UserQuestionWidget(item)
+                elif isinstance(item, HintMessage):
+                    yield HintMessageWidget(item)
+                elif isinstance(item, ModelResponse):
+                    yield AgentResponseWidget(item)
+            yield PartialResponseWidget(self.partial_response).data_bind(
+                item=ChatHistory.partial_response
+            )
+
+        # Track how many messages were rendered during initial compose
+        self._rendered_count = len(filtered)
+
+    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)
+            if isinstance(item, ModelRequest):
+                has_user_content = any(
+                    isinstance(part, UserPromptPart) for part in item.parts
+                )
+                if not has_user_content:
+                    # This is just a tool return, skip displaying it
+                    continue
+
+            yield item
+
+    def update_messages(self, messages: list[ModelMessage | HintMessage]) -> None:
+        """Update the displayed messages using incremental mounting."""
+        if not self.vertical_tail:
+            return
+
+        self.items = messages
+        filtered = list(self.filtered_items())
+
+        # Only mount new messages that haven't been rendered yet
+        if len(filtered) > self._rendered_count:
+            new_messages = filtered[self._rendered_count :]
+            for item in new_messages:
+                widget: Widget
+                if isinstance(item, ModelRequest):
+                    widget = UserQuestionWidget(item)
+                elif isinstance(item, HintMessage):
+                    widget = HintMessageWidget(item)
+                elif isinstance(item, ModelResponse):
+                    widget = AgentResponseWidget(item)
+                else:
+                    continue
+
+                # Mount before the PartialResponseWidget
+                self.vertical_tail.mount(widget, before=self.vertical_tail.children[-1])
+
+            self._rendered_count = len(filtered)
+
+            # Scroll to bottom to show newly added messages
+            self.vertical_tail.scroll_end(animate=False)