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

shotgun/tui/screens/chat/codebase_index_prompt_screen.py

@@ -1,12 +1,35 @@
 """Modal dialog for codebase indexing prompts."""
 
+import os
+import webbrowser
 from pathlib import Path
 
 from textual import on
 from textual.app import ComposeResult
-from textual.containers import Container
+from textual.containers import Container, VerticalScroll
+from textual.events import Resize
 from textual.screen import ModalScreen
-from textual.widgets import Button, Label, Static
+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
+
+
+def _is_home_directory() -> bool:
+    """Check if cwd is user's home directory.
+
+    Can be simulated with HOME_DIRECTORY_SIMULATE=true env var for testing.
+    """
+    if os.environ.get("HOME_DIRECTORY_SIMULATE", "").lower() == "true":
+        return True
+    return Path.cwd() == Path.home()
+
+
+def _track_event(event_name: str) -> None:
+    """Track an event to PostHog."""
+    from shotgun.posthog_telemetry import track_event
+
+    track_event(event_name)
 
 
 class CodebaseIndexPromptScreen(ModalScreen[bool]):
@@ -19,39 +42,182 @@ class CodebaseIndexPromptScreen(ModalScreen[bool]):
         }
 
         CodebaseIndexPromptScreen > #index-prompt-dialog {
-            width: 60%;
-            max-width: 60;
+            width: 80%;
+            max-width: 90;
             height: auto;
+            max-height: 85%;
             border: wide $primary;
             padding: 1 2;
             layout: vertical;
             background: $surface;
+        }
+
+        #index-prompt-title {
+            text-style: bold;
+            color: $text-accent;
+            text-align: center;
+            padding-bottom: 1;
+        }
+
+        #index-prompt-content {
             height: auto;
+            max-height: 1fr;
+        }
+
+        #index-prompt-info {
+            padding: 0 1;
         }
 
         #index-prompt-buttons {
             layout: horizontal;
             align-horizontal: right;
             height: auto;
+            padding-top: 1;
+        }
+
+        #index-prompt-buttons Button {
+            margin: 0 1;
+            min-width: 12;
+        }
+
+        #index-prompt-warning {
+            background: $surface-lighten-1;
+            color: $text;
+            padding: 1 2;
+            margin-bottom: 1;
+            text-align: center;
+        }
+
+        #compact-link {
+            text-align: center;
+            padding: 1 0;
+            display: none;
+        }
+
+        /* Compact styles for short terminals */
+        #index-prompt-dialog.compact {
+            padding: 0 1;
+            border: none;
+            max-height: 100%;
+        }
+
+        #index-prompt-dialog.compact #index-prompt-content {
+            display: none;
+        }
+
+        #index-prompt-dialog.compact #compact-link {
+            display: block;
+        }
+
+        #index-prompt-dialog.compact #index-prompt-warning {
+            padding: 0;
+            margin-bottom: 0;
+            background: transparent;
+        }
+
+        #index-prompt-dialog.compact #index-prompt-title {
+            padding-bottom: 0;
+        }
+
+        #index-prompt-dialog.compact #index-prompt-buttons {
+            padding-top: 0;
         }
     """
 
     def compose(self) -> ComposeResult:
+        storage_path = get_shotgun_home() / "codebases"
+        cwd = Path.cwd()
+        is_home = _is_home_directory()
+
         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",
+            if is_home:
+                # Show warning for home directory
+                yield Label(
+                    "Home directory detected",
+                    id="index-prompt-title",
+                )
+                yield Static(
+                    "Running from home directory isn't recommended.",
+                    id="index-prompt-warning",
+                )
+                with Container(id="index-prompt-buttons"):
+                    yield Button(
+                        "Quit",
+                        id="index-prompt-quit",
+                    )
+                    yield Button(
+                        "Continue without indexing",
+                        id="index-prompt-continue",
+                    )
+            else:
+                # Normal indexing prompt
+                content = f"""
+## 🔒 Your code never leaves your computer
+
+Shotgun will index the codebase at:
+**`{cwd}`**
+_(This is the current working directory where you started Shotgun)_
+
+### What happens during indexing:
+
+- **Stays on your computer**: Index is stored locally at `{storage_path}` - it will not be stored on a server
+- **Zero cost**: Indexing runs entirely on your machine
+- **Runs in the background**: Usually takes 1-3 minutes, and you can continue using Shotgun while it indexes
+- **Enable code understanding**: Allows Shotgun to answer questions about your codebase
+
+---
+
+If you're curious, you can review how Shotgun indexes/queries code by taking a look at the [source code](https://github.com/shotgun-sh/shotgun).
+
+We take your privacy seriously. You can read our full [privacy policy](https://app.shotgun.sh/privacy) for more details.
+"""
+                yield Label(
+                    "Want to index your codebase?",
+                    id="index-prompt-title",
+                )
+                # Compact mode: show only a link
+                yield Static(
+                    "[@click=screen.open_faq]Learn more about indexing[/]",
+                    id="compact-link",
+                    markup=True,
                 )
-                yield Button("Not now", id="index-prompt-cancel")
+                # Full mode: show detailed content
+                with VerticalScroll(id="index-prompt-content"):
+                    yield Markdown(content, id="index-prompt-info")
+                with Container(id="index-prompt-buttons"):
+                    yield Button(
+                        "Not now",
+                        id="index-prompt-cancel",
+                    )
+                    yield Button(
+                        "Index now",
+                        id="index-prompt-confirm",
+                        variant="primary",
+                    )
+
+    def on_mount(self) -> None:
+        """Track when the home directory warning screen is shown and apply compact layout."""
+        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)
+
+    @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."""
+        dialog = self.query_one("#index-prompt-dialog")
+        if compact:
+            dialog.add_class("compact")
+        else:
+            dialog.remove_class("compact")
+
+    def action_open_faq(self) -> None:
+        """Open the FAQ page in a browser."""
+        webbrowser.open("https://github.com/shotgun-sh/shotgun?tab=readme-ov-file#faq")
 
     @on(Button.Pressed, "#index-prompt-cancel")
     def handle_cancel(self, event: Button.Pressed) -> None:
@@ -62,3 +228,16 @@ class CodebaseIndexPromptScreen(ModalScreen[bool]):
     def handle_confirm(self, event: Button.Pressed) -> None:
         event.stop()
         self.dismiss(True)
+
+    @on(Button.Pressed, "#index-prompt-continue")
+    def handle_continue(self, event: Button.Pressed) -> None:
+        """Continue without indexing when in home directory."""
+        event.stop()
+        _track_event("home_directory_warning_continue")
+        self.dismiss(False)
+
+    @on(Button.Pressed, "#index-prompt-quit")
+    def handle_quit(self, event: Button.Pressed) -> None:
+        event.stop()
+        _track_event("home_directory_warning_quit")
+        self.app.exit()

shotgun/tui/screens/chat_screen/command_providers.py

@@ -3,8 +3,8 @@ 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
 from shotgun.tui.screens.provider_config import ProviderConfigScreen
 
@@ -12,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."""
 
@@ -271,8 +185,8 @@ class DeleteCodebasePaletteProvider(Provider):
         try:
             result = await self.chat_screen.codebase_sdk.list_codebases()
         except Exception as exc:  # pragma: no cover - defensive UI path
-            self.chat_screen.notify(
-                f"Unable to load codebases: {exc}", severity="error"
+            self.chat_screen.agent_manager.add_hint_message(
+                HintMessage(message=f"❌ Unable to load codebases: {exc}")
             )
             return []
         return result.graphs
@@ -359,6 +273,11 @@ class UnifiedCommandProvider(Provider):
             self.open_model_picker,
             help="🤖 Choose which AI model to use",
         )
+        yield DiscoveryHit(
+            "Share specs to workspace",
+            self.chat_screen.share_specs_command,
+            help="📤 Upload .shotgun/ files to share with your team",
+        )
         yield DiscoveryHit(
             "Show context",
             self.chat_screen.action_show_context,
@@ -411,6 +330,11 @@ class UnifiedCommandProvider(Provider):
                 self.open_model_picker,
                 "🤖 Choose which AI model to use",
             ),
+            (
+                "Share specs to workspace",
+                self.chat_screen.share_specs_command,
+                "📤 Upload .shotgun/ files to share with your team",
+            ),
             (
                 "Show context",
                 self.chat_screen.action_show_context,

shotgun/tui/screens/chat_screen/hint_message.py

@@ -1,14 +1,23 @@
 from typing import Literal
 
 from pydantic import BaseModel
+from textual import on
 from textual.app import ComposeResult
+from textual.containers import Horizontal
 from textual.widget import Widget
-from textual.widgets import Markdown
+from textual.widgets import Button, Label, Markdown, Static
+
+from shotgun.logging_config import get_logger
+
+logger = get_logger(__name__)
 
 
 class HintMessage(BaseModel):
     message: str
     kind: Literal["hint"] = "hint"
+    # Optional email copy functionality
+    email: str | None = None
+    markdown_after: str | None = None
 
 
 class HintMessageWidget(Widget):
@@ -30,6 +39,30 @@ class HintMessageWidget(Widget):
           }
         }
 
+        HintMessageWidget .email-copy-row {
+            width: auto;
+            height: auto;
+            margin: 1 0;
+        }
+
+        HintMessageWidget .email-text {
+            width: auto;
+            margin-right: 1;
+            content-align: left middle;
+        }
+
+        HintMessageWidget .copy-btn {
+            width: auto;
+            min-width: 12;
+        }
+
+        HintMessageWidget #copy-status {
+            height: 1;
+            width: 100%;
+            margin-top: 1;
+            content-align: left middle;
+        }
+
     """
 
     def __init__(self, message: HintMessage) -> None:
@@ -37,4 +70,46 @@ class HintMessageWidget(Widget):
         self.message = message
 
     def compose(self) -> ComposeResult:
+        # Main message markdown
         yield Markdown(markdown=f"{self.message.message}")
+
+        # Optional email copy section
+        if self.message.email:
+            # Email + copy button on same line
+            with Horizontal(classes="email-copy-row"):
+                yield Static(f"Contact: {self.message.email}", classes="email-text")
+                yield Button("Copy email", id="copy-email-btn", classes="copy-btn")
+
+            # Status feedback label
+            yield Label("", id="copy-status")
+
+            # Optional markdown after email
+            if self.message.markdown_after:
+                yield Markdown(self.message.markdown_after)
+
+    @on(Button.Pressed, "#copy-email-btn")
+    def _copy_email(self) -> None:
+        """Copy email address to clipboard when button is pressed."""
+        if not self.message.email:
+            return
+
+        status_label = self.query_one("#copy-status", Label)
+
+        try:
+            import pyperclip  # type: ignore[import-untyped]  # noqa: PGH003
+
+            pyperclip.copy(self.message.email)
+            status_label.update("✓ Copied to clipboard!")
+            logger.debug(
+                f"Successfully copied email to clipboard: {self.message.email}"
+            )
+
+        except ImportError:
+            status_label.update(
+                f"⚠️ Clipboard unavailable. Please manually copy: {self.message.email}"
+            )
+            logger.warning("pyperclip not available for clipboard operations")
+
+        except Exception as e:
+            status_label.update(f"⚠️ Copy failed: {e}")
+            logger.error(f"Failed to copy email to clipboard: {e}", exc_info=True)

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

@@ -8,10 +8,12 @@ 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.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
 
@@ -113,3 +115,13 @@ 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."""
+        # 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()

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,10 @@ 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:
                 # Format: "display_text: key_value"
                 return f"{display_config.display_text}: {cls.truncate(key_value)}"
             else:
@@ -95,8 +133,8 @@ 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:
                 # 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)