shotgun-sh 0.2.29.dev2__py3-none-any.whl → 0.6.1.dev1__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,
@@ -56,6 +65,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 +74,9 @@ 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 []
 
         # Initialize dependency injection container
         self.container = TUIContainer()
@@ -166,13 +179,11 @@ class ShotgunApp(App[None]):
                 return
 
             # Create ChatScreen with all dependencies injected from container
-            # Get the default agent mode (RESEARCH)
-            agent_mode = AgentType.RESEARCH
+            # Get the default agent mode (ROUTER)
+            agent_mode = AgentType.ROUTER
 
-            # Create AgentDeps asynchronously (get_provider_model is now async)
-            from shotgun.tui.dependencies import create_default_tui_deps
-
-            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)
@@ -250,6 +261,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 +293,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 +349,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 +372,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 +387,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,38 @@ 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 for newline (since enter is for submit)
+        if event.key == "ctrl+j":
             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

@@ -37,12 +37,13 @@ class StatusBar(Widget):
             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]/[/] command palette • "
+                "[bold $text]shift+tab[/] toggle mode[/]"
             )
         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[/] for newline • "
+                "[bold $text]/[/] command palette • "
+                "[bold $text]shift+tab[/] toggle mode[/]"
             )

shotgun/tui/dependencies.py

@@ -1,13 +1,44 @@
 """Dependency creation utilities for TUI components."""
 
+from typing import Any
+
 from pydantic_ai import RunContext
 
 from shotgun.agents.config import get_provider_model
+from shotgun.agents.config.models import ModelConfig
 from shotgun.agents.models import AgentDeps
+from shotgun.agents.router.models import RouterDeps, RouterMode
+from shotgun.codebase.service import CodebaseService
 from shotgun.tui.filtered_codebase_service import FilteredCodebaseService
 from shotgun.utils import get_shotgun_home
 
 
+async def _get_tui_config() -> tuple[ModelConfig, CodebaseService]:
+    """Get common TUI configuration components.
+
+    Returns:
+        Tuple of (model_config, codebase_service) for TUI deps.
+    """
+    model_config = await get_provider_model()
+    storage_dir = get_shotgun_home() / "codebases"
+    codebase_service = FilteredCodebaseService(storage_dir)
+    return model_config, codebase_service
+
+
+def _placeholder_system_prompt_fn(ctx: RunContext[Any]) -> str:
+    """Placeholder system prompt that should never be called.
+
+    Agents provide their own system_prompt_fn via their create functions.
+    This placeholder exists only to satisfy the AgentDeps requirement.
+
+    Raises:
+        RuntimeError: Always, as this should never be invoked.
+    """
+    raise RuntimeError(
+        "This should not be called - agents provide their own system_prompt_fn"
+    )
+
+
 async def create_default_tui_deps() -> AgentDeps:
     """Create default AgentDeps for TUI components.
 
@@ -21,14 +52,7 @@ async def create_default_tui_deps() -> AgentDeps:
     Returns:
         Configured AgentDeps instance ready for TUI use.
     """
-    model_config = await get_provider_model()
-    storage_dir = get_shotgun_home() / "codebases"
-    codebase_service = FilteredCodebaseService(storage_dir)
-
-    def _placeholder_system_prompt_fn(ctx: RunContext[AgentDeps]) -> str:
-        raise RuntimeError(
-            "This should not be called - agents provide their own system_prompt_fn"
-        )
+    model_config, codebase_service = await _get_tui_config()
 
     return AgentDeps(
         interactive_mode=True,
@@ -37,3 +61,29 @@ async def create_default_tui_deps() -> AgentDeps:
         codebase_service=codebase_service,
         system_prompt_fn=_placeholder_system_prompt_fn,
     )
+
+
+async def create_default_router_deps() -> RouterDeps:
+    """Create default RouterDeps for TUI components with router mode.
+
+    This creates a RouterDeps configuration suitable for interactive
+    TUI usage with:
+    - Router mode always starts in PLANNING (not persisted)
+    - Interactive mode enabled
+    - TUI context flag set
+    - Filtered codebase service (restricted to CWD)
+    - Placeholder system prompt (router provides its own)
+
+    Returns:
+        Configured RouterDeps instance ready for TUI use.
+    """
+    model_config, codebase_service = await _get_tui_config()
+
+    return RouterDeps(
+        interactive_mode=True,
+        is_tui_context=True,
+        llm_model=model_config,
+        codebase_service=codebase_service,
+        system_prompt_fn=_placeholder_system_prompt_fn,
+        router_mode=RouterMode.PLANNING,
+    )