shotgun-sh 0.2.3.dev2__py3-none-any.whl → 0.2.11.dev5__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

@@ -130,6 +130,38 @@ class UsageProvider(Provider):
                 )
 
 
+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."""
 
@@ -145,7 +177,9 @@ class ProviderSetupProvider(Provider):
 
     def open_model_picker(self) -> None:
         """Show the model picker screen."""
-        self.chat_screen.app.push_screen(ModelPickerScreen())
+        self.chat_screen.app.push_screen(
+            ModelPickerScreen(), callback=self.chat_screen.handle_model_selected
+        )
 
     async def discover(self) -> AsyncGenerator[DiscoveryHit, None]:
         yield DiscoveryHit(
@@ -288,11 +322,18 @@ class UnifiedCommandProvider(Provider):
 
     def open_model_picker(self) -> None:
         """Show the model picker screen."""
-        self.chat_screen.app.push_screen(ModelPickerScreen())
+        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,
@@ -303,6 +344,11 @@ class UnifiedCommandProvider(Provider):
             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,
@@ -313,11 +359,21 @@ class UnifiedCommandProvider(Provider):
             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."""
@@ -325,6 +381,11 @@ class UnifiedCommandProvider(Provider):
 
         # 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,
@@ -335,6 +396,11 @@ class UnifiedCommandProvider(Provider):
                 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,
@@ -345,11 +411,21 @@ class UnifiedCommandProvider(Provider):
                 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:

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)

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

@@ -0,0 +1,115 @@
+"""Tool formatting utilities for chat history display."""
+
+import json
+
+from pydantic_ai.messages import BuiltinToolCallPart, ToolCallPart
+
+from shotgun.agents.tools.registry import get_tool_display_config
+
+
+class ToolFormatter:
+    """Formats tool calls for display in the TUI."""
+
+    @staticmethod
+    def truncate(text: str, max_length: int = 100) -> str:
+        """Truncate text to max_length characters, adding ellipsis if needed."""
+        if len(text) <= max_length:
+            return text
+        return text[: max_length - 3] + "..."
+
+    @staticmethod
+    def parse_args(args: dict[str, object] | str | None) -> dict[str, object]:
+        """Parse tool call arguments, handling both dict and JSON string formats."""
+        if args is None:
+            return {}
+        if isinstance(args, str):
+            try:
+                return json.loads(args) if args.strip() else {}
+            except json.JSONDecodeError:
+                return {}
+        return args if isinstance(args, dict) else {}
+
+    @classmethod
+    def format_tool_call_part(cls, part: ToolCallPart) -> str:
+        """Format a tool call part using the tool display registry."""
+        # Look up the display config for this tool
+        display_config = get_tool_display_config(part.tool_name)
+
+        if display_config:
+            # Tool is registered - use its display config
+            if display_config.hide:
+                return ""
+
+            # Parse args
+            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])
+
+                # Format: "display_text: key_value"
+                return f"{display_config.display_text}: {cls.truncate(key_value)}"
+            else:
+                # No key arg value available - show just display_text
+                return display_config.display_text
+
+        # Tool not registered - use fallback formatting
+        args = cls.parse_args(part.args)
+        if args and isinstance(args, dict):
+            # Try to extract common fields
+            if "query" in args:
+                return f"{part.tool_name}: {cls.truncate(str(args['query']))}"
+            elif "question" in args:
+                return f"{part.tool_name}: {cls.truncate(str(args['question']))}"
+            elif "filename" in args:
+                return f"{part.tool_name}: {args['filename']}"
+            else:
+                # Show tool name with truncated args
+                args_str = (
+                    str(part.args)[:50] + "..."
+                    if len(str(part.args)) > 50
+                    else str(part.args)
+                )
+                return f"{part.tool_name}({args_str})"
+        else:
+            return f"{part.tool_name}()"
+
+    @classmethod
+    def format_builtin_tool_call(cls, part: BuiltinToolCallPart) -> str:
+        """Format a builtin tool call part using the tool display registry."""
+        display_config = get_tool_display_config(part.tool_name or "")
+
+        if display_config:
+            if display_config.hide:
+                return ""
+
+            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])
+                # Format: "display_text: key_value"
+                return f"{display_config.display_text}: {cls.truncate(key_value)}"
+            else:
+                # No key arg value available - show just display_text
+                return display_config.display_text
+        else:
+            # Fallback for unregistered builtin tools
+            if part.args:
+                args_str = (
+                    str(part.args)[:50] + "..."
+                    if len(str(part.args)) > 50
+                    else str(part.args)
+                )
+                return f"{part.tool_name}({args_str})"
+            else:
+                return f"{part.tool_name}()"