shotgun-sh 0.1.14__py3-none-any.whl → 0.2.11__py3-none-any.whl

shotgun/tui/app.py

@@ -5,37 +5,58 @@ from textual.app import App, SystemCommand
 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.models import AgentType
 from shotgun.logging_config import get_logger
+from shotgun.tui.containers import TUIContainer
 from shotgun.tui.screens.splash import SplashScreen
 from shotgun.utils.file_system_utils import get_shotgun_base_path
-from shotgun.utils.update_checker import perform_auto_update_async
+from shotgun.utils.update_checker import (
+    detect_installation_method,
+    perform_auto_update_async,
+)
 
 from .screens.chat import ChatScreen
 from .screens.directory_setup import DirectorySetupScreen
+from .screens.github_issue import GitHubIssueScreen
+from .screens.model_picker import ModelPickerScreen
+from .screens.pipx_migration import PipxMigrationScreen
 from .screens.provider_config import ProviderConfigScreen
+from .screens.welcome import WelcomeScreen
 
 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()
     SCREENS = {
-        "chat": ChatScreen,
         "provider_config": ProviderConfigScreen,
+        "model_picker": ModelPickerScreen,
         "directory_setup": DirectorySetupScreen,
+        "github_issue": GitHubIssueScreen,
     }
     BINDINGS = [
         Binding("ctrl+c", "quit", "Quit the app"),
     ]
+
     CSS_PATH = "styles.tcss"
 
     def __init__(
-        self, no_update_check: bool = False, continue_session: bool = False
+        self,
+        no_update_check: bool = False,
+        continue_session: bool = False,
+        force_reindex: 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.force_reindex = force_reindex
+
+        # Initialize dependency injection container
+        self.container = TUIContainer()
 
         # Start async update check and install
         if not no_update_check:
@@ -46,36 +67,104 @@ class ShotgunApp(App[None]):
         # Track TUI startup
         from shotgun.posthog_telemetry import track_event
 
-        track_event("tui_started", {})
+        track_event(
+            "tui_started",
+            {
+                "installation_method": detect_installation_method(),
+            },
+        )
 
         self.push_screen(
             SplashScreen(), callback=lambda _arg: self.refresh_startup_screen()
         )
 
-    def refresh_startup_screen(self) -> None:
+    def refresh_startup_screen(self, skip_pipx_check: bool = False) -> None:
         """Push the appropriate screen based on configured providers."""
-        if not self.config_manager.has_any_provider_key():
-            if isinstance(self.screen, ProviderConfigScreen):
+        # Check for pipx installation and show migration modal first
+        if not skip_pipx_check:
+            installation_method = detect_installation_method()
+            if installation_method == "pipx":
+                if isinstance(self.screen, PipxMigrationScreen):
+                    return
+
+                # Show pipx migration modal as a blocking modal screen
+                self.push_screen(
+                    PipxMigrationScreen(),
+                    callback=lambda _arg: self.refresh_startup_screen(
+                        skip_pipx_check=True
+                    ),
+                )
                 return
 
-            self.push_screen(
-                "provider_config", callback=lambda _arg: self.refresh_startup_screen()
-            )
-            return
+        # 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
+            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):
+                    return
+
+                self.push_screen(
+                    WelcomeScreen(),
+                    callback=lambda _arg: self.refresh_startup_screen(),
+                )
+                return
+
+            if not self.check_local_shotgun_directory_exists():
+                if isinstance(self.screen, DirectorySetupScreen):
+                    return
 
-        if not self.check_local_shotgun_directory_exists():
-            if isinstance(self.screen, DirectorySetupScreen):
+                self.push_screen(
+                    DirectorySetupScreen(),
+                    callback=lambda _arg: self.refresh_startup_screen(),
+                )
                 return
 
-            self.push_screen(
-                "directory_setup", callback=lambda _arg: self.refresh_startup_screen()
+            if isinstance(self.screen, ChatScreen):
+                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
+
+            agent_deps = await create_default_tui_deps()
+
+            # Create AgentManager with async initialization
+            agent_manager = AgentManager(deps=agent_deps, initial_type=agent_mode)
+
+            # Create ProcessingStateManager - we'll pass the screen after creation
+            # For now, create with None and the ChatScreen will set itself
+            chat_screen = ChatScreen(
+                agent_manager=agent_manager,
+                conversation_manager=self.container.conversation_manager(),
+                conversation_service=self.container.conversation_service(),
+                widget_coordinator=self.container.widget_coordinator_factory(
+                    screen=None
+                ),
+                processing_state=self.container.processing_state_factory(
+                    screen=None,  # Will be set after ChatScreen is created
+                    telemetry_context={"agent_mode": agent_mode.value},
+                ),
+                command_handler=self.container.command_handler(),
+                placeholder_hints=self.container.placeholder_hints(),
+                codebase_sdk=self.container.codebase_sdk(),
+                deps=agent_deps,
+                continue_session=self.continue_session,
+                force_reindex=self.force_reindex,
             )
-            return
 
-        if isinstance(self.screen, ChatScreen):
-            return
-        # Pass continue_session flag to ChatScreen
-        self.push_screen(ChatScreen(continue_session=self.continue_session))
+            # Update the ProcessingStateManager and WidgetCoordinator with the actual ChatScreen instance
+            chat_screen.processing_state.screen = chat_screen
+            chat_screen.widget_coordinator.screen = chat_screen
+
+            self.push_screen(chat_screen)
+
+        # Run the async config check in a worker
+        self.run_worker(_check_config(), exclusive=False)
 
     def check_local_shotgun_directory_exists(self) -> bool:
         shotgun_dir = get_shotgun_base_path()
@@ -90,15 +179,30 @@ class ShotgunApp(App[None]):
         self.exit()
 
     def get_system_commands(self, screen: Screen[Any]) -> Iterable[SystemCommand]:
-        return []  # we don't want any system commands
+        return [
+            SystemCommand(
+                "New Issue",
+                "Report a bug or request a feature on GitHub",
+                self.action_new_issue,
+            )
+        ]
+
+    def action_new_issue(self) -> None:
+        """Open GitHub issue screen to guide users to create an issue."""
+        self.push_screen(GitHubIssueScreen())
 
 
-def run(no_update_check: bool = False, continue_session: bool = False) -> None:
+def run(
+    no_update_check: bool = False,
+    continue_session: bool = False,
+    force_reindex: 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.
+        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
@@ -120,9 +224,133 @@ def run(no_update_check: bool = False, continue_session: bool = False) -> None:
         logger.error(f"Failed to cleanup corrupted databases: {e}")
         # Continue anyway - the TUI can still function
 
-    app = ShotgunApp(no_update_check=no_update_check, continue_session=continue_session)
+    app = ShotgunApp(
+        no_update_check=no_update_check,
+        continue_session=continue_session,
+        force_reindex=force_reindex,
+    )
     app.run(inline_no_clear=True)
 
 
+def serve(
+    host: str = "localhost",
+    port: int = 8000,
+    public_url: str | None = None,
+    no_update_check: bool = False,
+    continue_session: bool = False,
+    force_reindex: bool = False,
+) -> None:
+    """Serve the TUI application as a web application.
+
+    Args:
+        host: Host address for the web server.
+        port: Port number for the web server.
+        public_url: Public URL if behind a proxy.
+        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).
+    """
+    # Clean up any corrupted databases BEFORE starting the TUI
+    # This prevents crashes from corrupted databases during initialization
+    import asyncio
+
+    from textual_serve.server import Server
+
+    from shotgun.codebase.core.manager import CodebaseGraphManager
+    from shotgun.utils import get_shotgun_home
+
+    storage_dir = get_shotgun_home() / "codebases"
+    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"
+            )
+    except Exception as e:
+        logger.error(f"Failed to cleanup corrupted databases: {e}")
+        # Continue anyway - the TUI can still function
+
+    # Create a new event loop after asyncio.run() closes the previous one
+    # This is needed for the Server.serve() method
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    # Build the command string based on flags
+    command = "shotgun"
+    if no_update_check:
+        command += " --no-update-check"
+    if continue_session:
+        command += " --continue"
+    if force_reindex:
+        command += " --force-reindex"
+
+    # Create and start the server with hardcoded title and debug=False
+    server = Server(
+        command=command,
+        host=host,
+        port=port,
+        title="The Shotgun",
+        public_url=public_url,
+    )
+
+    # Set up graceful shutdown on SIGTERM/SIGINT
+    import signal
+    import sys
+
+    def signal_handler(_signum: int, _frame: Any) -> None:
+        """Handle shutdown signals gracefully."""
+        from shotgun.posthog_telemetry import shutdown
+
+        logger.info("Received shutdown signal, cleaning up...")
+        # Restore stdout/stderr before shutting down
+        sys.stdout = original_stdout
+        sys.stderr = original_stderr
+        shutdown()
+        sys.exit(0)
+
+    signal.signal(signal.SIGTERM, signal_handler)
+    signal.signal(signal.SIGINT, signal_handler)
+
+    # Suppress the textual-serve banner by redirecting stdout/stderr
+    import io
+
+    # Capture and suppress the banner, but show the actual serving URL
+    original_stdout = sys.stdout
+    original_stderr = sys.stderr
+
+    captured_output = io.StringIO()
+    sys.stdout = captured_output
+    sys.stderr = captured_output
+
+    try:
+        # This will print the banner to our captured output
+        import logging
+
+        # Temporarily set logging to ERROR level to suppress INFO messages
+        textual_serve_logger = logging.getLogger("textual_serve")
+        original_level = textual_serve_logger.level
+        textual_serve_logger.setLevel(logging.ERROR)
+
+        # Print our own message to the original stdout
+        sys.stdout = original_stdout
+        sys.stderr = original_stderr
+        print(f"Serving Shotgun TUI at http://{host}:{port}")
+        print("Press Ctrl+C to quit")
+
+        # Now suppress output again for the serve call
+        sys.stdout = captured_output
+        sys.stderr = captured_output
+
+        server.serve(debug=False)
+    finally:
+        # Restore original stdout/stderr
+        sys.stdout = original_stdout
+        sys.stderr = original_stderr
+        if "textual_serve_logger" in locals():
+            textual_serve_logger.setLevel(original_level)
+
+
 if __name__ == "__main__":
     run()

shotgun/tui/commands/__init__.py

@@ -57,7 +57,7 @@ class CommandHandler:
 **Keyboard Shortcuts:**
 
 * `Enter` - Send message
-* `Ctrl+P` - Open command palette
+* `Ctrl+P` - Open command palette (for usage, context, and other commands)
 * `Shift+Tab` - Cycle agent modes
 * `Ctrl+C` - Quit application
 

shotgun/tui/components/context_indicator.py

@@ -0,0 +1,179 @@
+"""Context window indicator component for showing model usage."""
+
+from textual.reactive import reactive
+from textual.timer import Timer
+from textual.widgets import Static
+
+from shotgun.agents.config.models import MODEL_SPECS, ModelName
+from shotgun.agents.context_analyzer.models import ContextAnalysis
+
+
+class ContextIndicator(Static):
+    """Display context window usage and current model name."""
+
+    DEFAULT_CSS = """
+    ContextIndicator {
+        width: auto;
+        height: 1;
+        text-align: right;
+    }
+    """
+
+    context_analysis: reactive[ContextAnalysis | None] = reactive(None)
+    model_name: reactive[ModelName | None] = reactive(None)
+    is_streaming: reactive[bool] = reactive(False)
+
+    _animation_frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    _animation_index = 0
+
+    def __init__(
+        self,
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        super().__init__(name=name, id=id, classes=classes)
+        self._animation_timer: Timer | None = None
+
+    def update_context(
+        self, analysis: ContextAnalysis | None, model: ModelName | None
+    ) -> None:
+        """Update the context indicator with new analysis and model data.
+
+        Args:
+            analysis: Context analysis with token usage data
+            model: Current model name
+        """
+        self.context_analysis = analysis
+        self.model_name = model
+        self._refresh_display()
+
+    def set_streaming(self, streaming: bool) -> None:
+        """Enable or disable streaming animation.
+
+        Args:
+            streaming: Whether to show streaming animation
+        """
+        self.is_streaming = streaming
+        if streaming:
+            self._start_animation()
+        else:
+            self._stop_animation()
+
+    def _start_animation(self) -> None:
+        """Start the pulsing animation."""
+        if self._animation_timer is None:
+            self._animation_timer = self.set_interval(0.1, self._animate_frame)
+
+    def _stop_animation(self) -> None:
+        """Stop the pulsing animation."""
+        if self._animation_timer is not None:
+            self._animation_timer.stop()
+            self._animation_timer = None
+        self._animation_index = 0
+        self._refresh_display()
+
+    def _animate_frame(self) -> None:
+        """Advance the animation frame."""
+        self._animation_index = (self._animation_index + 1) % len(
+            self._animation_frames
+        )
+        self._refresh_display()
+
+    def _get_percentage_color(self, percentage: float) -> str:
+        """Get color for percentage based on threshold.
+
+        Args:
+            percentage: Usage percentage (0-100)
+
+        Returns:
+            Color name for Textual markup
+        """
+        if percentage < 60:
+            return "#00ff00"  # Green
+        elif percentage < 85:
+            return "#ffff00"  # Yellow
+        else:
+            return "#ff0000"  # Red
+
+    def _format_token_count(self, tokens: int) -> str:
+        """Format token count for display (e.g., 115000 -> "115K").
+
+        Args:
+            tokens: Token count
+
+        Returns:
+            Formatted string
+        """
+        if tokens >= 1_000_000:
+            return f"{tokens / 1_000_000:.1f}M"
+        elif tokens >= 1_000:
+            return f"{tokens / 1_000:.0f}K"
+        else:
+            return str(tokens)
+
+    def _refresh_display(self) -> None:
+        """Refresh the display with current context data."""
+        # If no analysis yet, show placeholder with model name or empty
+        if self.context_analysis is None:
+            if self.model_name:
+                model_spec = MODEL_SPECS.get(self.model_name)
+                model_display = (
+                    model_spec.short_name if model_spec else str(self.model_name)
+                )
+                self.update(f"[bold]{model_display}[/bold]")
+            else:
+                self.update("")
+            return
+
+        analysis = self.context_analysis
+
+        # Calculate percentage
+        if analysis.max_usable_tokens > 0:
+            percentage = round(
+                (analysis.agent_context_tokens / analysis.max_usable_tokens) * 100, 1
+            )
+        else:
+            percentage = 0.0
+
+        # Format token counts
+        current_tokens = self._format_token_count(analysis.agent_context_tokens)
+        max_tokens = self._format_token_count(analysis.max_usable_tokens)
+
+        # Get color based on percentage
+        color = self._get_percentage_color(percentage)
+
+        # Build the display string - always show full context info
+        parts = [
+            "[$foreground-muted]Context window:[/]",
+            f"[{color}]{percentage}% ({current_tokens}/{max_tokens})[/]",
+        ]
+
+        # Add streaming animation indicator if streaming
+        if self.is_streaming:
+            animation_char = self._animation_frames[self._animation_index]
+            parts.append(f"[bold cyan]{animation_char}[/]")
+
+        # Add model name if available
+        if self.model_name:
+            model_spec = MODEL_SPECS.get(self.model_name)
+            model_display = (
+                model_spec.short_name if model_spec else str(self.model_name)
+            )
+            parts.extend(
+                [
+                    "[$foreground-muted]|[/]",
+                    f"[bold]{model_display}[/bold]",
+                ]
+            )
+
+        self.update(" ".join(parts))
+
+    def watch_context_analysis(self, analysis: ContextAnalysis | None) -> None:
+        """React to context analysis changes."""
+        self._refresh_display()
+
+    def watch_model_name(self, model: ModelName | None) -> None:
+        """React to model name changes."""
+        self._refresh_display()

shotgun/tui/components/mode_indicator.py

@@ -0,0 +1,70 @@
+"""Widget to display the current agent mode."""
+
+from textual.widget import Widget
+
+from shotgun.agents.models import AgentType
+from shotgun.tui.protocols import QAStateProvider
+from shotgun.tui.utils.mode_progress import PlaceholderHints
+
+
+class ModeIndicator(Widget):
+    """Widget to display the current agent mode."""
+
+    DEFAULT_CSS = """
+        ModeIndicator {
+            text-wrap: wrap;
+            padding-left: 1;
+        }
+    """
+
+    def __init__(self, mode: AgentType) -> None:
+        """Initialize the mode indicator.
+
+        Args:
+            mode: The current agent type/mode.
+        """
+        super().__init__()
+        self.mode = mode
+        self.progress_checker = PlaceholderHints().progress_checker
+
+    def render(self) -> str:
+        """Render the mode indicator."""
+        # Check if in Q&A mode first
+        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",
+        }
+
+        mode_title = mode_display.get(self.mode, self.mode.value.title())
+        description = mode_description.get(self.mode, "")
+
+        # Check if mode has content
+        has_content = self.progress_checker.has_mode_content(self.mode)
+        status_icon = " ✓" if has_content else ""
+
+        return (
+            f"[bold $text-accent]{mode_title}{status_icon} mode[/]"
+            f"[$foreground-muted] ({description})[/]"
+        )

shotgun/tui/components/status_bar.py

@@ -0,0 +1,48 @@
+"""Widget to display the status bar with contextual help text."""
+
+from textual.widget import Widget
+
+from shotgun.tui.protocols import QAStateProvider
+
+
+class StatusBar(Widget):
+    """Widget to display the status bar with contextual help text."""
+
+    DEFAULT_CSS = """
+        StatusBar {
+            text-wrap: wrap;
+            padding-left: 1;
+        }
+    """
+
+    def __init__(self, working: bool = False) -> None:
+        """Initialize the status bar.
+
+        Args:
+            working: Whether an agent is currently working.
+        """
+        super().__init__()
+        self.working = working
+
+    def render(self) -> str:
+        """Render the status bar with contextual help text."""
+        # Check if in Q&A mode first (highest priority)
+        if isinstance(self.screen, QAStateProvider) and self.screen.qa_mode:
+            return (
+                "[$foreground-muted][bold $text]esc[/] to exit Q&A mode • "
+                "[bold $text]enter[/] to send answer • [bold $text]ctrl+j[/] for newline[/]"
+            )
+
+        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[/]"
+            )
+        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[/]"
+            )