shotgun-sh 0.3.3.dev1__py3-none-any.whl → 0.6.2__py3-none-any.whl

shotgun/tui/app.py

@@ -1,5 +1,13 @@
+from __future__ import annotations
+
+import os
+import platform
+import sys
 from collections.abc import Iterable
-from typing import Any
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from shotgun.codebase.core.errors import DatabaseIssue
 
 from textual.app import App, SystemCommand
 from textual.binding import Binding
@@ -13,6 +21,7 @@ from shotgun.agents.config import (
 from shotgun.agents.models import AgentType
 from shotgun.logging_config import get_logger
 from shotgun.tui.containers import TUIContainer
+from shotgun.tui.dependencies import create_default_router_deps
 from shotgun.tui.screens.splash import SplashScreen
 from shotgun.utils.file_system_utils import (
     ensure_shotgun_directory_exists,
@@ -44,7 +53,10 @@ class ShotgunApp(App[None]):
         "github_issue": GitHubIssueScreen,
     }
     BINDINGS = [
-        Binding("ctrl+c", "quit", "Quit the app"),
+        # Use smart_quit to support ctrl+c for copying selected text
+        Binding("ctrl+c", "smart_quit", "Quit/Copy", show=False),
+        # Cancel quit confirmation with ESC
+        Binding("escape", "cancel_quit", "Cancel Quit", show=False),
     ]
 
     CSS_PATH = "styles.tcss"
@@ -56,6 +68,7 @@ class ShotgunApp(App[None]):
         force_reindex: bool = False,
         show_pull_hint: bool = False,
         pull_version_id: str | None = None,
+        pending_db_issues: list[DatabaseIssue] | None = None,
     ) -> None:
         super().__init__()
         self.config_manager: ConfigManager = get_config_manager()
@@ -64,6 +77,12 @@ class ShotgunApp(App[None]):
         self.force_reindex = force_reindex
         self.show_pull_hint = show_pull_hint
         self.pull_version_id = pull_version_id
+        # Database issues detected at startup (locked, corrupted, timeout)
+        # These will be shown to the user via dialogs when ChatScreen mounts
+        self.pending_db_issues = pending_db_issues or []
+
+        # Quit confirmation state for double Ctrl+C to quit
+        self._quit_pending = False
 
         # Initialize dependency injection container
         self.container = TUIContainer()
@@ -166,13 +185,11 @@ class ShotgunApp(App[None]):
                 return
 
             # Create ChatScreen with all dependencies injected from container
-            # Get the default agent mode (RESEARCH)
-            agent_mode = AgentType.RESEARCH
-
-            # Create AgentDeps asynchronously (get_provider_model is now async)
-            from shotgun.tui.dependencies import create_default_tui_deps
+            # Get the default agent mode (ROUTER)
+            agent_mode = AgentType.ROUTER
 
-            agent_deps = await create_default_tui_deps()
+            # Create RouterDeps asynchronously (get_provider_model is now async)
+            agent_deps = await create_default_router_deps()
 
             # Create AgentManager with async initialization
             agent_manager = AgentManager(deps=agent_deps, initial_type=agent_mode)
@@ -228,6 +245,63 @@ class ShotgunApp(App[None]):
         # Continue to ChatScreen
         self.refresh_startup_screen()
 
+    @property
+    def quit_pending(self) -> bool:
+        """Whether a quit confirmation is pending.
+
+        Returns True if user pressed Ctrl+C and needs to press again or ESC to cancel.
+        """
+        return self._quit_pending
+
+    def _reset_quit_pending(self) -> None:
+        """Reset the quit confirmation state and refresh the status bar."""
+        self._quit_pending = False
+        self._refresh_status_bar()
+
+    def _refresh_status_bar(self) -> None:
+        """Refresh the StatusBar widget to reflect current state."""
+        from textual.css.query import NoMatches
+
+        from shotgun.tui.components.status_bar import StatusBar
+
+        try:
+            status_bar = self.screen.query_one(StatusBar)
+            status_bar.refresh()
+        except NoMatches:
+            # StatusBar might not exist on all screens
+            pass
+
+    def action_cancel_quit(self) -> None:
+        """Cancel the quit confirmation when ESC is pressed."""
+        if self._quit_pending:
+            self._reset_quit_pending()
+
+    async def action_smart_quit(self) -> None:
+        """Handle ctrl+c: copy selected text if any, otherwise quit.
+
+        This allows users to select text in the TUI and copy it with ctrl+c,
+        while still supporting ctrl+c to quit when no text is selected.
+        Requires pressing Ctrl+C twice to quit, or ESC to cancel.
+        """
+        # Check if there's selected text on the current screen
+        selected_text = self.screen.get_selected_text()
+        if selected_text:
+            # Copy selected text to clipboard
+            self.copy_to_clipboard(selected_text)
+            # Clear the selection after copying
+            self.screen.clear_selection()
+            self.notify("Copied to clipboard", timeout=2)
+            return
+
+        # No selection - check if quit is already pending
+        if self._quit_pending:
+            await self.action_quit()
+            return
+
+        # Start quit confirmation
+        self._quit_pending = True
+        self._refresh_status_bar()
+
     async def action_quit(self) -> None:
         """Quit the application."""
         # Shut down PostHog client to prevent threading errors
@@ -250,6 +324,22 @@ class ShotgunApp(App[None]):
         self.push_screen(GitHubIssueScreen())
 
 
+def _log_startup_info() -> None:
+    """Log startup information for debugging purposes."""
+    # Import here to avoid circular import (shotgun.__init__ imports from submodules)
+    from shotgun import __version__
+
+    logger.info("=" * 60)
+    logger.info("Shotgun TUI Starting")
+    logger.info("=" * 60)
+    logger.info(f"  Version: {__version__}")
+    logger.info(f"  Python: {sys.version.split()[0]}")
+    logger.info(f"  Platform: {platform.system()} {platform.release()}")
+    logger.info(f"  Architecture: {platform.machine()}")
+    logger.info(f"  Working Directory: {os.getcwd()}")
+    logger.info("=" * 60)
+
+
 def run(
     no_update_check: bool = False,
     continue_session: bool = False,
@@ -266,24 +356,54 @@ def run(
         show_pull_hint: If True, show hint about recently pulled spec.
         pull_version_id: If provided, pull this spec version before showing ChatScreen.
     """
-    # Clean up any corrupted databases BEFORE starting the TUI
-    # This prevents crashes from corrupted databases during initialization
+    # Log startup information
+    _log_startup_info()
+
+    # Detect database issues BEFORE starting the TUI (but don't auto-delete)
+    # Issues will be presented to the user via dialogs once the TUI is running
     import asyncio
 
+    from shotgun.codebase.core.errors import KuzuErrorType
     from shotgun.codebase.core.manager import CodebaseGraphManager
     from shotgun.utils import get_shotgun_home
 
     storage_dir = get_shotgun_home() / "codebases"
     manager = CodebaseGraphManager(storage_dir)
 
+    pending_db_issues: list[DatabaseIssue] = []
     try:
-        removed = asyncio.run(manager.cleanup_corrupted_databases())
-        if removed:
-            logger.info(
-                f"Cleaned up {len(removed)} corrupted database(s) before TUI startup"
-            )
+        # First pass: 10-second timeout
+        issues = asyncio.run(manager.detect_database_issues(timeout_seconds=10.0))
+        if issues:
+            # Categorize issues for logging
+            for issue in issues:
+                logger.info(
+                    f"Detected database issue: {issue.graph_id} - "
+                    f"{issue.error_type.value}: {issue.message}"
+                )
+
+            # Only pass issues that require user interaction to the TUI
+            # Schema issues (incomplete builds) can be auto-cleaned silently
+            user_facing_issues = [
+                i
+                for i in issues
+                if i.error_type
+                in (
+                    KuzuErrorType.LOCKED,
+                    KuzuErrorType.CORRUPTION,
+                    KuzuErrorType.TIMEOUT,
+                )
+            ]
+
+            # Auto-delete schema issues (incomplete builds) - safe to remove
+            schema_issues = [i for i in issues if i.error_type == KuzuErrorType.SCHEMA]
+            for issue in schema_issues:
+                asyncio.run(manager.delete_database(issue.graph_id))
+                logger.info(f"Auto-removed incomplete database: {issue.graph_id}")
+
+            pending_db_issues = user_facing_issues
     except Exception as e:
-        logger.error(f"Failed to cleanup corrupted databases: {e}")
+        logger.error(f"Failed to detect database issues: {e}")
         # Continue anyway - the TUI can still function
 
     app = ShotgunApp(
@@ -292,6 +412,7 @@ def run(
         force_reindex=force_reindex,
         show_pull_hint=show_pull_hint,
         pull_version_id=pull_version_id,
+        pending_db_issues=pending_db_issues,
     )
     app.run(inline_no_clear=True)
 
@@ -314,12 +435,14 @@ def serve(
         continue_session: If True, continue from previous conversation.
         force_reindex: If True, force re-indexing of codebase (ignores existing index).
     """
-    # Clean up any corrupted databases BEFORE starting the TUI
-    # This prevents crashes from corrupted databases during initialization
+    # Detect database issues BEFORE starting the TUI
+    # Note: In serve mode, issues are logged but user interaction happens in
+    # the spawned process via run()
     import asyncio
 
     from textual_serve.server import Server
 
+    from shotgun.codebase.core.errors import KuzuErrorType
     from shotgun.codebase.core.manager import CodebaseGraphManager
     from shotgun.utils import get_shotgun_home
 
@@ -327,13 +450,20 @@ def serve(
     manager = CodebaseGraphManager(storage_dir)
 
     try:
-        removed = asyncio.run(manager.cleanup_corrupted_databases())
-        if removed:
-            logger.info(
-                f"Cleaned up {len(removed)} corrupted database(s) before TUI startup"
-            )
+        issues = asyncio.run(manager.detect_database_issues(timeout_seconds=10.0))
+        if issues:
+            for issue in issues:
+                logger.info(
+                    f"Detected database issue: {issue.graph_id} - "
+                    f"{issue.error_type.value}: {issue.message}"
+                )
+            # Auto-delete only schema issues (incomplete builds)
+            schema_issues = [i for i in issues if i.error_type == KuzuErrorType.SCHEMA]
+            for issue in schema_issues:
+                asyncio.run(manager.delete_database(issue.graph_id))
+                logger.info(f"Auto-removed incomplete database: {issue.graph_id}")
     except Exception as e:
-        logger.error(f"Failed to cleanup corrupted databases: {e}")
+        logger.error(f"Failed to detect database issues: {e}")
         # Continue anyway - the TUI can still function
 
     # Create a new event loop after asyncio.run() closes the previous one

shotgun/tui/commands/__init__.py

@@ -54,10 +54,18 @@ class CommandHandler:
 **Commands:**
 • `/help` - Show this help message
 
+**Shell Commands:**
+• `!<command>` - Execute shell commands directly (e.g., `!ls`, `!git status`)
+  - Commands run in your current working directory
+  - Output is displayed in the chat (not sent to AI)
+  - Commands are NOT added to conversation history
+  - Leading whitespace is allowed: `  !echo hi` works
+  - Note: `!!` is treated as `!` (no history expansion in this version)
+
 **Keyboard Shortcuts:**
 
 * `Enter` - Send message
-* `Ctrl+P` - Open command palette (for usage, context, and other commands)
+* `/` - Open command palette (for usage, context, and other commands)
 * `Shift+Tab` - Cycle agent modes
 * `Ctrl+C` - Quit application
 

shotgun/tui/components/attachment_bar.py

@@ -0,0 +1,87 @@
+"""Attachment bar widget for showing pending file attachment."""
+
+from textual.app import ComposeResult
+from textual.css.query import NoMatches
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Static
+
+from shotgun.attachments import (
+    AttachmentBarState,
+    FileAttachment,
+    format_file_size,
+    get_attachment_icon,
+)
+
+
+class AttachmentBar(Widget):
+    """Widget showing pending attachment above input.
+
+    Displays format: [icon filename.ext (size)]
+    Hidden when no attachment is pending.
+
+    Styles defined in chat.tcss.
+    """
+
+    state: reactive[AttachmentBarState] = reactive(AttachmentBarState, init=False)
+
+    def __init__(
+        self,
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        """Initialize the attachment bar.
+
+        Args:
+            name: Optional widget name.
+            id: Optional widget ID.
+            classes: Optional CSS classes.
+        """
+        super().__init__(name=name, id=id, classes=classes)
+        self.state = AttachmentBarState(attachment=None)
+        self.add_class("hidden")
+
+    def compose(self) -> ComposeResult:
+        """Compose the attachment bar widget."""
+        yield Static("", id="attachment-display")
+
+    def update_attachment(self, attachment: FileAttachment | None) -> None:
+        """Update the displayed attachment.
+
+        Args:
+            attachment: FileAttachment to display, or None to hide bar.
+        """
+        self.state = AttachmentBarState(attachment=attachment)
+
+        if attachment is None:
+            self.add_class("hidden")
+        else:
+            self.remove_class("hidden")
+            self._refresh_display()
+
+    def _refresh_display(self) -> None:
+        """Refresh the attachment display text."""
+        attachment = self.state.attachment
+        if attachment is None:
+            return
+
+        icon = get_attachment_icon(attachment.file_type)
+        size_str = format_file_size(attachment.file_size_bytes)
+        display_text = f"[{icon} {attachment.file_name} ({size_str})]"
+
+        try:
+            display_widget = self.query_one("#attachment-display", Static)
+            display_widget.update(display_text)
+        except NoMatches:
+            pass  # Widget not mounted yet
+
+    def watch_state(self, new_state: AttachmentBarState) -> None:
+        """React to state changes.
+
+        Args:
+            new_state: The new attachment bar state.
+        """
+        if new_state.attachment is not None:
+            self._refresh_display()

shotgun/tui/components/mode_indicator.py

@@ -1,20 +1,68 @@
 """Widget to display the current agent mode."""
 
+from enum import StrEnum
+
 from textual.widget import Widget
 
 from shotgun.agents.models import AgentType
-from shotgun.tui.protocols import QAStateProvider
+from shotgun.agents.router.models import RouterMode
+from shotgun.tui.protocols import (
+    ActiveSubAgentProvider,
+    QAStateProvider,
+    RouterModeProvider,
+)
 from shotgun.tui.utils.mode_progress import PlaceholderHints
 
 
+class RouterModeCssClass(StrEnum):
+    """CSS class names for router mode styling."""
+
+    PLANNING = "mode-planning"
+    DRAFTING = "mode-drafting"
+
+
+# Shared display name mapping for agent types
+AGENT_DISPLAY_NAMES: dict[AgentType, str] = {
+    AgentType.RESEARCH: "Research",
+    AgentType.SPECIFY: "Specify",
+    AgentType.PLAN: "Planning",
+    AgentType.TASKS: "Tasks",
+    AgentType.EXPORT: "Export",
+}
+
+# Mode descriptions for legacy agent display
+AGENT_DESCRIPTIONS: dict[AgentType, str] = {
+    AgentType.RESEARCH: "Research topics with web search and synthesize findings",
+    AgentType.PLAN: "Create comprehensive, actionable plans with milestones",
+    AgentType.TASKS: "Generate specific, actionable tasks from research and plans",
+    AgentType.SPECIFY: "Create detailed specifications and requirements documents",
+    AgentType.EXPORT: "Export artifacts and findings to various formats",
+}
+
+
 class ModeIndicator(Widget):
-    """Widget to display the current agent mode."""
+    """Widget to display the current agent mode.
+
+    For router mode, displays:
+    - Idle: "📋 Planning mode" or "✍️ Drafting mode"
+    - During execution: "📋 Planning → Research" format
+
+    For legacy agents, displays the agent name and description.
+    """
 
     DEFAULT_CSS = """
         ModeIndicator {
             text-wrap: wrap;
             padding-left: 1;
         }
+
+        ModeIndicator.mode-planning {
+            /* Planning mode styling - blue/cyan accent */
+        }
+
+        ModeIndicator.mode-drafting {
+            /* Drafting mode styling - green accent */
+        }
     """
 
     def __init__(self, mode: AgentType) -> None:
@@ -29,41 +77,88 @@ class ModeIndicator(Widget):
 
     def render(self) -> str:
         """Render the mode indicator."""
-        # Check if in Q&A mode first
+        # Check if in Q&A mode first - takes priority
         if isinstance(self.screen, QAStateProvider) and self.screen.qa_mode:
             return (
                 "[bold $text-accent]Q&A mode[/]"
                 "[$foreground-muted] (Answer the clarifying questions or ESC to cancel)[/]"
             )
 
-        mode_display = {
-            AgentType.RESEARCH: "Research",
-            AgentType.PLAN: "Planning",
-            AgentType.TASKS: "Tasks",
-            AgentType.SPECIFY: "Specify",
-            AgentType.EXPORT: "Export",
-        }
-        mode_description = {
-            AgentType.RESEARCH: (
-                "Research topics with web search and synthesize findings"
-            ),
-            AgentType.PLAN: "Create comprehensive, actionable plans with milestones",
-            AgentType.TASKS: (
-                "Generate specific, actionable tasks from research and plans"
-            ),
-            AgentType.SPECIFY: (
-                "Create detailed specifications and requirements documents"
-            ),
-            AgentType.EXPORT: "Export artifacts and findings to various formats",
-        }
+        # Router mode display
+        if self.mode == AgentType.ROUTER:
+            return self._render_router_mode()
 
-        mode_title = mode_display.get(self.mode, self.mode.value.title())
-        description = mode_description.get(self.mode, "")
+        # Legacy agent mode display
+        return self._render_legacy_mode()
+
+    def _render_router_mode(self) -> str:
+        """Render the router mode indicator.
+
+        Shows:
+        - "📋 Planning mode" or "✍️ Drafting mode" when idle
+        - "📋 Planning → Research" format when sub-agent is executing
+        """
+        # Get router mode from screen
+        router_mode: str | None = None
+        if isinstance(self.screen, RouterModeProvider):
+            router_mode = self.screen.router_mode
+
+        # Get active sub-agent from screen
+        active_sub_agent: AgentType | None = None
+        if isinstance(self.screen, ActiveSubAgentProvider):
+            sub_agent_str = self.screen.active_sub_agent
+            if sub_agent_str:
+                # Convert string back to AgentType enum
+                try:
+                    active_sub_agent = AgentType(sub_agent_str)
+                except ValueError:
+                    pass
+
+        # Determine mode display using RouterMode enum
+        if router_mode == RouterMode.DRAFTING.value:
+            icon = "✍️"
+            mode_name = "Drafting"
+            description = "Auto-execute without confirmation"
+            css_class = RouterModeCssClass.DRAFTING
+        else:
+            # Default to planning mode
+            icon = "📋"
+            mode_name = "Planning"
+            description = "Review plans before execution"
+            css_class = RouterModeCssClass.PLANNING
+
+        # Update CSS class for styling
+        self.set_classes(css_class)
+
+        # Add sub-agent suffix if executing
+        if active_sub_agent:
+            # Use shared display name mapping
+            sub_agent_name = AGENT_DISPLAY_NAMES.get(
+                active_sub_agent, active_sub_agent.value.title()
+            )
+            return f"[bold $text-accent]{icon} {mode_name} → {sub_agent_name}[/]"
+
+        return (
+            f"[bold $text-accent]{icon} {mode_name} mode[/]"
+            f"[$foreground-muted] ({description})[/]"
+        )
+
+    def _render_legacy_mode(self) -> str:
+        """Render the legacy agent mode indicator.
+
+        Shows the agent name with description and content status.
+        """
+        mode_title = AGENT_DISPLAY_NAMES.get(self.mode, self.mode.value.title())
+        description = AGENT_DESCRIPTIONS.get(self.mode, "")
 
         # Check if mode has content
         has_content = self.progress_checker.has_mode_content(self.mode)
         status_icon = " ✓" if has_content else ""
 
+        # Clear any router mode CSS classes
+        self.remove_class(RouterModeCssClass.PLANNING)
+        self.remove_class(RouterModeCssClass.DRAFTING)
+
         return (
             f"[bold $text-accent]{mode_title}{status_icon} mode[/]"
             f"[$foreground-muted] ({description})[/]"

shotgun/tui/components/prompt_input.py

@@ -27,43 +27,40 @@ class PromptInput(TextArea):
             super().__init__()
             self.text = text
 
+    class OpenCommandPalette(Message):
+        """Request to open the command palette."""
+
     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
+    def on_key(self, event: events.Key) -> None:
+        """Handle key presses for special actions."""
+        # Submit on Enter
         if event.key == "enter":
+            event.stop()
+            event.prevent_default()
             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()
+        # Detect "/" as first character to trigger command palette
+        if event.character == "/" and not self.text.strip():
+            event.stop()
+            event.prevent_default()
+            self.post_message(self.OpenCommandPalette())
+            return
 
-        if event.is_printable or key in insert_values:
+        # Handle ctrl+j or shift+enter for newline (since enter is for submit)
+        # Note: shift+enter only works if terminal is configured to send escape sequence
+        # Common terminals: iTerm2, VS Code, WezTerm can be configured for this
+        if event.key in ("ctrl+j", "shift+enter"):
             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)
+            self.replace(
+                "\n",
+                start,
+                end,
+                maintain_selection_offset=False,
+            )
+            return

shotgun/tui/components/status_bar.py

@@ -2,7 +2,7 @@
 
 from textual.widget import Widget
 
-from shotgun.tui.protocols import QAStateProvider
+from shotgun.tui.protocols import QAStateProvider, QuitConfirmationProvider
 
 
 class StatusBar(Widget):
@@ -26,7 +26,11 @@ class StatusBar(Widget):
 
     def render(self) -> str:
         """Render the status bar with contextual help text."""
-        # Check if in Q&A mode first (highest priority)
+        # Check if quit confirmation is pending (highest priority)
+        if isinstance(self.app, QuitConfirmationProvider) and self.app.quit_pending:
+            return "[$foreground-muted][bold $warning]Press Ctrl+C again to quit[/] • [bold $text]esc[/] to cancel[/]"
+
+        # Check if in Q&A mode
         if isinstance(self.screen, QAStateProvider) and self.screen.qa_mode:
             return (
                 "[$foreground-muted][bold $text]esc[/] to exit Q&A mode • "
@@ -36,13 +40,16 @@ class StatusBar(Widget):
         if self.working:
             return (
                 "[$foreground-muted][bold $text]esc[/] to stop • "
-                "[bold $text]enter[/] to send • [bold $text]ctrl+j[/] for newline • "
-                "[bold $text]ctrl+p[/] command palette • [bold $text]shift+tab[/] cycle modes • "
-                "/help for commands[/]"
+                "[bold $text]enter[/] to send • [bold $text]ctrl+j[/] newline • "
+                "[bold $text]/[/] command palette • "
+                "[bold $text]shift+tab[/] toggle mode • "
+                "[bold $text]ctrl+c[/] copy • [bold $text]ctrl+v[/] paste[/]"
             )
         else:
             return (
                 "[$foreground-muted][bold $text]enter[/] to send • "
-                "[bold $text]ctrl+j[/] for newline • [bold $text]ctrl+p[/] command palette • "
-                "[bold $text]shift+tab[/] cycle modes • /help for commands[/]"
+                "[bold $text]ctrl+j[/] newline • "
+                "[bold $text]/[/] command palette • "
+                "[bold $text]shift+tab[/] toggle mode • "
+                "[bold $text]ctrl+c[/] copy • [bold $text]ctrl+v[/] paste[/]"
             )