shotgun-sh 0.1.0__py3-none-any.whl

shotgun/tui/app.py

@@ -0,0 +1,116 @@
+from collections.abc import Iterable
+from typing import Any
+
+from textual.app import App, SystemCommand
+from textual.binding import Binding
+from textual.screen import Screen
+
+from shotgun.agents.config import ConfigManager, get_config_manager
+from shotgun.logging_config import get_logger
+from shotgun.tui.screens.splash import SplashScreen
+from shotgun.utils.file_system_utils import get_shotgun_base_path
+from shotgun.utils.update_checker import check_for_updates_async
+
+from .screens.chat import ChatScreen
+from .screens.directory_setup import DirectorySetupScreen
+from .screens.provider_config import ProviderConfigScreen
+
+logger = get_logger(__name__)
+
+
+class ShotgunApp(App[None]):
+    SCREENS = {
+        "chat": ChatScreen,
+        "provider_config": ProviderConfigScreen,
+        "directory_setup": DirectorySetupScreen,
+    }
+    BINDINGS = [
+        Binding("ctrl+c", "quit", "Quit the app"),
+    ]
+    CSS_PATH = "styles.tcss"
+
+    def __init__(
+        self, no_update_check: bool = False, continue_session: bool = False
+    ) -> None:
+        super().__init__()
+        self.config_manager: ConfigManager = get_config_manager()
+        self.no_update_check = no_update_check
+        self.continue_session = continue_session
+        self.update_notification: str | None = None
+
+        # Start async update check
+        if not no_update_check:
+            check_for_updates_async(callback=self._update_callback)
+
+    def _update_callback(self, notification: str) -> None:
+        """Store update notification to show later."""
+        self.update_notification = notification
+        logger.debug(f"Update notification received: {notification}")
+
+    def on_mount(self) -> None:
+        self.theme = "gruvbox"
+        # Track TUI startup
+        from shotgun.posthog_telemetry import track_event
+
+        track_event("tui_started", {})
+
+        self.push_screen(
+            SplashScreen(), callback=lambda _arg: self.refresh_startup_screen()
+        )
+
+    def refresh_startup_screen(self) -> None:
+        """Push the appropriate screen based on configured providers."""
+        if not self.config_manager.has_any_provider_key():
+            if isinstance(self.screen, ProviderConfigScreen):
+                return
+
+            self.push_screen(
+                "provider_config", callback=lambda _arg: self.refresh_startup_screen()
+            )
+            return
+
+        if not self.check_local_shotgun_directory_exists():
+            if isinstance(self.screen, DirectorySetupScreen):
+                return
+
+            self.push_screen(
+                "directory_setup", callback=lambda _arg: self.refresh_startup_screen()
+            )
+            return
+
+        if isinstance(self.screen, ChatScreen):
+            return
+        # Pass continue_session flag to ChatScreen
+        self.push_screen(ChatScreen(continue_session=self.continue_session))
+
+    def check_local_shotgun_directory_exists(self) -> bool:
+        shotgun_dir = get_shotgun_base_path()
+        return shotgun_dir.exists() and shotgun_dir.is_dir()
+
+    async def action_quit(self) -> None:
+        """Override quit action to show update notification."""
+        if self.update_notification:
+            # Show notification before quitting
+            from rich.console import Console
+
+            console = Console()
+            console.print(f"\n[cyan]{self.update_notification}[/cyan]", style="bold")
+        self.exit()
+
+    def get_system_commands(self, screen: Screen[Any]) -> Iterable[SystemCommand]:
+        return []  # we don't want any system commands
+
+
+def run(no_update_check: bool = False, continue_session: bool = False) -> None:
+    """Run the TUI application.
+
+    Args:
+        no_update_check: If True, disable automatic update checks.
+        continue_session: If True, continue from previous conversation.
+    """
+    app = ShotgunApp(no_update_check=no_update_check, continue_session=continue_session)
+    app.run(inline_no_clear=True)
+
+
+if __name__ == "__main__":
+    run()

shotgun/tui/commands/__init__.py

@@ -0,0 +1,76 @@
+"""Command handling for the TUI chat interface."""
+
+from collections.abc import Callable
+
+
+class CommandHandler:
+    """Handles slash commands in the TUI chat interface."""
+
+    def __init__(self) -> None:
+        """Initialize the command handler with available commands."""
+        self.commands: dict[str, Callable[[], str]] = {
+            "help": self.get_help_text,
+        }
+
+    def is_command(self, text: str) -> bool:
+        """Check if the text is a command (starts with /)."""
+        return text.strip().startswith("/")
+
+    def parse_command(self, text: str) -> str:
+        """Extract the command name from the text."""
+        text = text.strip()
+        if not text.startswith("/"):
+            return ""
+
+        # Split on whitespace and get the command part
+        parts = text[1:].split()
+        return parts[0] if parts else ""
+
+    def handle_command(self, text: str) -> tuple[bool, str]:
+        """
+        Handle a command and return success status and response text.
+
+        Args:
+            text: The full command text including the leading /
+
+        Returns:
+            Tuple of (success, response_text)
+        """
+        if not self.is_command(text):
+            return False, ""
+
+        command = self.parse_command(text)
+
+        if command in self.commands:
+            response = self.commands[command]()
+            return True, response
+        else:
+            return False, self.get_error_message(command)
+
+    def get_help_text(self) -> str:
+        """Return the help text for the /help command."""
+        return """📚 **Shotgun Help**
+
+**Commands:**
+• `/help` - Show this help message
+
+**Keyboard Shortcuts:**
+
+* `Enter` - Send message
+* `Ctrl+P` - Open command palette
+* `Shift+Tab` - Cycle agent modes
+* `Ctrl+C` - Quit application
+
+**Agent Modes:**
+* **Research** - Research topics with web search and synthesize findings
+* **Specify** - Create detailed specifications and requirements documents
+* **Planning** - Create comprehensive, actionable plans with milestones
+* **Tasks** - Generate specific, actionable tasks from research and plans
+* **Export** - Export artifacts and findings to various formats
+
+**Usage:**
+Type your message and press Enter to chat with the AI. The AI will respond based on the current mode."""
+
+    def get_error_message(self, command: str) -> str:
+        """Return a polite error message for unknown commands."""
+        return f"⚠️ Sorry, `/{command}` is not a recognized command. Type `/help` to see available commands."

shotgun/tui/components/prompt_input.py

@@ -0,0 +1,69 @@
+from textual import events
+from textual.message import Message
+from textual.widgets import TextArea
+
+
+class PromptInput(TextArea):
+    """A TextArea with a submit binding."""
+
+    DEFAULT_CSS = """
+        PromptInput {
+            outline: round $primary;
+            background: transparent;
+        }
+    """
+
+    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool:
+        if action != "copy":
+            return True
+        # run copy action if there is selected text
+        # otherwise, do nothing, so global ctrl+c still works.
+        return bool(self.selected_text)
+
+    class Submitted(Message):
+        """A message to indicate that the text has been submitted."""
+
+        def __init__(self, text: str) -> None:
+            super().__init__()
+            self.text = text
+
+    def action_submit(self) -> None:
+        """An action to submit the text."""
+        self.post_message(self.Submitted(self.text))
+
+    async def _on_key(self, event: events.Key) -> None:
+        """Handle key presses which correspond to document inserts."""
+
+        # Don't handle Enter key here - let the binding handle it
+        if event.key == "enter":
+            self.action_submit()
+
+        self._restart_blink()
+
+        if self.read_only:
+            return
+
+        key = event.key
+        insert_values = {
+            "ctrl+j": "\n",
+        }
+        if self.tab_behavior == "indent":
+            if key == "escape":
+                event.stop()
+                event.prevent_default()
+                self.screen.focus_next()
+                return
+            if self.indent_type == "tabs":
+                insert_values["tab"] = "\t"
+            else:
+                insert_values["tab"] = " " * self._find_columns_to_next_tab_stop()
+
+        if event.is_printable or key in insert_values:
+            event.stop()
+            event.prevent_default()
+            insert = insert_values.get(key, event.character)
+            # `insert` is not None because event.character cannot be
+            # None because we've checked that it's printable.
+            assert insert is not None  # noqa: S101
+            start, end = self.selection
+            self._replace_via_keyboard(insert, start, end)

shotgun/tui/components/spinner.py

@@ -0,0 +1,86 @@
+"""Spinner component for showing loading/working state."""
+
+from textual.app import ComposeResult
+from textual.containers import Container
+from textual.css.query import NoMatches
+from textual.reactive import reactive
+from textual.timer import Timer
+from textual.widget import Widget
+from textual.widgets import Static
+
+
+class Spinner(Widget):
+    """A spinner widget that shows a rotating animation when working."""
+
+    DEFAULT_CSS = """
+    Spinner {
+        width: auto;
+        height: 1;
+    }
+
+    Spinner > Container {
+        width: auto;
+        height: 1;
+        layout: horizontal;
+    }
+
+    Spinner .spinner-icon {
+        width: 1;
+        margin-right: 1;
+    }
+
+    Spinner .spinner-text {
+        width: auto;
+    }
+    """
+
+    # Animation frames for the spinner
+    FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+    text = reactive("Working...")
+    _frame_index = reactive(0)
+
+    def __init__(
+        self,
+        text: str = "Working...",
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        super().__init__(name=name, id=id, classes=classes)
+        self.text = text
+        self._timer: Timer | None = None
+
+    def compose(self) -> ComposeResult:
+        """Compose the spinner widget."""
+        with Container():
+            yield Static("", classes="spinner-icon")
+            yield Static(self.text, classes="spinner-text")
+
+    def on_mount(self) -> None:
+        """Set up the animation timer when mounted."""
+        self._timer = self.set_interval(0.1, self._advance_frame)
+
+    def _advance_frame(self) -> None:
+        """Advance to the next animation frame."""
+        self._frame_index = (self._frame_index + 1) % len(self.FRAMES)
+        self._update_display()
+
+    def _update_display(self) -> None:
+        """Update the spinner display."""
+        try:
+            icon_widget = self.query_one(".spinner-icon", Static)
+            icon_widget.update(self.FRAMES[self._frame_index])
+        except NoMatches:
+            # Widget not mounted yet, ignore
+            pass
+
+    def watch_text(self, text: str) -> None:
+        """React to changes in the text."""
+        try:
+            text_widget = self.query_one(".spinner-text", Static)
+            text_widget.update(text)
+        except NoMatches:
+            # Widget not mounted yet, ignore
+            return

shotgun/tui/components/splash.py

@@ -0,0 +1,25 @@
+from textual.app import RenderResult
+from textual.widgets import Static
+
+ART = """
+
+███████╗██╗  ██╗ ██████╗ ████████╗ ██████╗ ██╗   ██╗███╗   ██╗
+██╔════╝██║  ██║██╔═══██╗╚══██╔══╝██╔════╝ ██║   ██║████╗  ██║
+███████╗███████║██║   ██║   ██║   ██║  ███╗██║   ██║██╔██╗ ██║
+╚════██║██╔══██║██║   ██║   ██║   ██║   ██║██║   ██║██║╚██╗██║
+███████║██║  ██║╚██████╔╝   ██║   ╚██████╔╝╚██████╔╝██║ ╚████║
+╚══════╝╚═╝  ╚═╝ ╚═════╝    ╚═╝    ╚═════╝  ╚═════╝ ╚═╝  ╚═══╝
+
+"""
+
+
+class SplashWidget(Static):
+    DEFAULT_CSS = """
+        SplashWidget {
+            text-align: center;
+            width: 64;
+        }
+    """
+
+    def render(self) -> RenderResult:
+        return ART

shotgun/tui/components/vertical_tail.py

@@ -0,0 +1,13 @@
+from textual.containers import VerticalScroll
+from textual.reactive import reactive
+
+
+class VerticalTail(VerticalScroll):
+    """A vertical scroll container that automatically scrolls to the bottom when content is added."""
+
+    auto_scroll = reactive(True, layout=False)
+
+    def watch_auto_scroll(self, value: bool) -> None:
+        """Handle auto_scroll property changes."""
+        if value:
+            self.scroll_end(animate=False)