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

shotgun/shotgun_web/supabase_client.py

@@ -0,0 +1,31 @@
+"""Supabase Storage download utilities."""
+
+import httpx
+
+from shotgun.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+async def download_file_from_url(download_url: str) -> bytes:
+    """Download a file from a presigned Supabase Storage URL.
+
+    The API returns presigned URLs with embedded tokens that don't require
+    any authentication headers.
+
+    Args:
+        download_url: Presigned Supabase Storage URL
+                     (e.g., "https://...supabase.co/storage/v1/object/sign/...?token=...")
+
+    Returns:
+        File contents as bytes
+
+    Raises:
+        httpx.HTTPStatusError: If download fails
+    """
+    logger.debug("Downloading file from: %s", download_url)
+
+    async with httpx.AsyncClient(timeout=60.0) as client:
+        response = await client.get(download_url)
+        response.raise_for_status()
+        return response.content

shotgun/tui/app.py

@@ -6,12 +6,19 @@ from textual.binding import Binding
 from textual.screen import Screen
 
 from shotgun.agents.agent_manager import AgentManager
-from shotgun.agents.config import ConfigManager, get_config_manager
+from shotgun.agents.config import (
+    ConfigManager,
+    get_config_manager,
+)
 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 get_shotgun_base_path
+from shotgun.utils.file_system_utils import (
+    ensure_shotgun_directory_exists,
+    get_shotgun_base_path,
+)
 from shotgun.utils.update_checker import (
     detect_installation_method,
     perform_auto_update_async,
@@ -31,10 +38,10 @@ logger = get_logger(__name__)
 class ShotgunApp(App[None]):
     # ChatScreen removed from SCREENS dict since it requires dependency injection
     # and is instantiated manually in refresh_startup_screen()
+    # DirectorySetupScreen also removed since it requires error_message parameter
     SCREENS = {
         "provider_config": ProviderConfigScreen,
         "model_picker": ModelPickerScreen,
-        "directory_setup": DirectorySetupScreen,
         "github_issue": GitHubIssueScreen,
     }
     BINDINGS = [
@@ -48,12 +55,16 @@ class ShotgunApp(App[None]):
         no_update_check: bool = False,
         continue_session: bool = False,
         force_reindex: bool = False,
+        show_pull_hint: bool = False,
+        pull_version_id: str | None = None,
     ) -> None:
         super().__init__()
         self.config_manager: ConfigManager = get_config_manager()
         self.no_update_check = no_update_check
         self.continue_session = continue_session
         self.force_reindex = force_reindex
+        self.show_pull_hint = show_pull_hint
+        self.pull_version_id = pull_version_id
 
         # Initialize dependency injection container
         self.container = TUIContainer()
@@ -71,6 +82,8 @@ class ShotgunApp(App[None]):
             "tui_started",
             {
                 "installation_method": detect_installation_method(),
+                "terminal_width": self.size.width,
+                "terminal_height": self.size.height,
             },
         )
 
@@ -99,7 +112,10 @@ class ShotgunApp(App[None]):
         # Run async config loading in worker
         async def _check_config() -> None:
             # Show welcome screen if no providers are configured OR if user hasn't seen it yet
+            # Note: If config migration fails, ConfigManager will auto-create fresh config
+            # and set migration_failed flag, which WelcomeScreen will display
             config = await self.config_manager.load()
+
             has_any_key = await self.config_manager.has_any_provider_key()
             if not has_any_key or not config.shown_welcome_screen:
                 if isinstance(self.screen, WelcomeScreen):
@@ -111,27 +127,51 @@ class ShotgunApp(App[None]):
                 )
                 return
 
+            # Try to create .shotgun directory if it doesn't exist
             if not self.check_local_shotgun_directory_exists():
-                if isinstance(self.screen, DirectorySetupScreen):
+                try:
+                    path = ensure_shotgun_directory_exists()
+                    # Verify directory was created successfully
+                    if not path.is_dir():
+                        # Show error screen if creation failed
+                        if isinstance(self.screen, DirectorySetupScreen):
+                            return
+                        self.push_screen(
+                            DirectorySetupScreen(
+                                error_message="Unable to create .shotgun directory due to filesystem conflict."
+                            ),
+                            callback=lambda _arg: self.refresh_startup_screen(),
+                        )
+                        return
+                except Exception as exc:
+                    # Show error screen if creation failed with exception
+                    if isinstance(self.screen, DirectorySetupScreen):
+                        return
+                    self.push_screen(
+                        DirectorySetupScreen(error_message=str(exc)),
+                        callback=lambda _arg: self.refresh_startup_screen(),
+                    )
                     return
 
-                self.push_screen(
-                    DirectorySetupScreen(),
-                    callback=lambda _arg: self.refresh_startup_screen(),
-                )
+            if isinstance(self.screen, ChatScreen):
                 return
 
-            if isinstance(self.screen, ChatScreen):
+            # If we have a version to pull, show pull screen first
+            if self.pull_version_id:
+                from .screens.spec_pull import SpecPullScreen
+
+                self.push_screen(
+                    SpecPullScreen(self.pull_version_id),
+                    callback=self._handle_pull_complete,
+                )
                 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)
@@ -155,6 +195,7 @@ class ShotgunApp(App[None]):
                 deps=agent_deps,
                 continue_session=self.continue_session,
                 force_reindex=self.force_reindex,
+                show_pull_hint=self.show_pull_hint,
             )
 
             # Update the ProcessingStateManager and WidgetCoordinator with the actual ChatScreen instance
@@ -170,6 +211,22 @@ class ShotgunApp(App[None]):
         shotgun_dir = get_shotgun_base_path()
         return shotgun_dir.exists() and shotgun_dir.is_dir()
 
+    def _handle_pull_complete(self, success: bool | None) -> None:
+        """Handle completion of spec pull screen.
+
+        Args:
+            success: Whether the pull was successful, or None if dismissed.
+        """
+        # Clear version_id so we don't pull again on next refresh
+        self.pull_version_id = None
+
+        if success:
+            # Enable hint for ChatScreen
+            self.show_pull_hint = True
+
+        # Continue to ChatScreen
+        self.refresh_startup_screen()
+
     async def action_quit(self) -> None:
         """Quit the application."""
         # Shut down PostHog client to prevent threading errors
@@ -196,6 +253,8 @@ def run(
     no_update_check: bool = False,
     continue_session: bool = False,
     force_reindex: bool = False,
+    show_pull_hint: bool = False,
+    pull_version_id: str | None = None,
 ) -> None:
     """Run the TUI application.
 
@@ -203,6 +262,8 @@ def run(
         no_update_check: If True, disable automatic update checks.
         continue_session: If True, continue from previous conversation.
         force_reindex: If True, force re-indexing of codebase (ignores existing index).
+        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
@@ -228,6 +289,8 @@ def run(
         no_update_check=no_update_check,
         continue_session=continue_session,
         force_reindex=force_reindex,
+        show_pull_hint=show_pull_hint,
+        pull_version_id=pull_version_id,
     )
     app.run(inline_no_clear=True)
 

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/status_bar.py

@@ -37,12 +37,12 @@ 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 • "
+                "[bold $text]ctrl+p[/] command palette • [bold $text]shift+tab[/] toggle mode • "
                 "/help for commands[/]"
             )
         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]shift+tab[/] toggle mode • /help for commands[/]"
             )

shotgun/tui/containers.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 from dependency_injector import containers, providers
 from pydantic_ai import RunContext
 
-from shotgun.agents.conversation_manager import ConversationManager
+from shotgun.agents.conversation import ConversationManager
 from shotgun.agents.models import AgentDeps
 from shotgun.sdk.codebase import CodebaseSDK
 from shotgun.tui.commands import CommandHandler

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 import get_config_manager, 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,34 @@ 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 loaded from config (default: PLANNING)
+    - 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()
+
+    # Load router mode from config (default to PLANNING)
+    config_manager = get_config_manager()
+    config = await config_manager.load()
+    router_mode = RouterMode(config.router_mode)
+
+    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=router_mode,
+    )

shotgun/tui/layout.py

@@ -0,0 +1,5 @@
+"""Layout utilities for responsive terminal UI."""
+
+# Height thresholds for responsive layouts
+TINY_HEIGHT_THRESHOLD = 25  # Below this: minimal UI, hide most content
+COMPACT_HEIGHT_THRESHOLD = 35  # Below this: reduced padding, hide verbose text

shotgun/tui/protocols.py

@@ -43,3 +43,40 @@ class ProcessingStateProvider(Protocol):
             True if an agent is processing, False otherwise.
         """
         ...
+
+
+@runtime_checkable
+class RouterModeProvider(Protocol):
+    """Protocol for screens that provide router mode state.
+
+    This protocol allows components to check the current router mode
+    (Planning or Drafting) without importing the concrete ChatScreen class.
+    """
+
+    @property
+    def router_mode(self) -> str | None:
+        """The current router mode.
+
+        Returns:
+            'planning' or 'drafting' if in router mode, None otherwise.
+        """
+        ...
+
+
+@runtime_checkable
+class ActiveSubAgentProvider(Protocol):
+    """Protocol for screens that provide active sub-agent state.
+
+    This protocol allows components to check which sub-agent is currently
+    executing during router delegation without importing ChatScreen.
+    """
+
+    @property
+    def active_sub_agent(self) -> str | None:
+        """The currently executing sub-agent type.
+
+        Returns:
+            The sub-agent type string (e.g., 'research', 'specify') if
+            a sub-agent is executing, None if idle.
+        """
+        ...

shotgun/tui/screens/chat/chat.tcss

@@ -16,11 +16,19 @@ ModeIndicator {
   height: auto;
 }
 
+ModeIndicator.mode-planning {
+  /* Blue/cyan accent for planning mode */
+}
+
+ModeIndicator.mode-drafting {
+  /* Green accent for drafting mode */
+}
+
 #footer {
   dock: bottom;
   height: auto;
   padding: 1 1 1 2;
-  max-height: 14;
+  max-height: 24;
 }
 
 #window {