shotgun-sh 0.2.8.dev2__py3-none-any.whl → 0.3.3.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/telemetry.py

@@ -1,9 +1,7 @@
 """Observability setup for Logfire."""
 
-import os
-
 from shotgun.logging_config import get_early_logger
-from shotgun.utils.env_utils import is_falsy, is_truthy
+from shotgun.settings import settings
 
 # Use early logger to prevent automatic StreamHandler creation
 logger = get_early_logger(__name__)
@@ -15,36 +13,13 @@ def setup_logfire_observability() -> bool:
     Returns:
         True if Logfire was successfully set up, False otherwise
     """
-    # Try to get Logfire configuration from build constants first, fall back to env vars
-    logfire_enabled = None
-    logfire_token = None
-
-    try:
-        from shotgun.build_constants import LOGFIRE_ENABLED, LOGFIRE_TOKEN
-
-        # Use build constants if they're not empty
-        if LOGFIRE_ENABLED:
-            logfire_enabled = LOGFIRE_ENABLED
-        if LOGFIRE_TOKEN:
-            logfire_token = LOGFIRE_TOKEN
-    except ImportError:
-        # No build constants available
-        pass
-
-    # Fall back to environment variables if not set from build constants
-    if not logfire_enabled:
-        logfire_enabled = os.getenv("LOGFIRE_ENABLED", "false")
-    if not logfire_token:
-        logfire_token = os.getenv("LOGFIRE_TOKEN")
-
-    # Allow environment variable to override and disable Logfire
-    env_override = os.getenv("LOGFIRE_ENABLED")
-    if env_override and is_falsy(env_override):
-        logfire_enabled = env_override
+    # Get Logfire configuration from settings (handles build constants + env vars)
+    logfire_enabled = settings.telemetry.logfire_enabled
+    logfire_token = settings.telemetry.logfire_token
 
     # Check if Logfire observability is enabled
-    if not is_truthy(logfire_enabled):
-        logger.debug("Logfire observability disabled via LOGFIRE_ENABLED")
+    if not logfire_enabled:
+        logger.debug("Logfire observability disabled")
         return False
 
     try:
@@ -52,7 +27,7 @@ def setup_logfire_observability() -> bool:
 
         # Check for Logfire token
         if not logfire_token:
-            logger.warning("LOGFIRE_TOKEN not set, Logfire observability disabled")
+            logger.warning("Logfire token not set, Logfire observability disabled")
             return False
 
         # Configure Logfire
@@ -75,12 +50,14 @@ def setup_logfire_observability() -> bool:
 
         # Set user context using baggage for all logs and spans
         try:
+            import asyncio
+
             from opentelemetry import baggage, context
 
             from shotgun.agents.config import get_config_manager
 
             config_manager = get_config_manager()
-            shotgun_instance_id = config_manager.get_shotgun_instance_id()
+            shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
 
             # Set shotgun_instance_id as baggage in global context - this will be included in all logs/spans
             ctx = baggage.set_baggage("shotgun_instance_id", shotgun_instance_id)

shotgun/tui/app.py

@@ -5,16 +5,29 @@ from textual.app import App, SystemCommand
 from textual.binding import Binding
 from textual.screen import Screen
 
-from shotgun.agents.config import ConfigManager, get_config_manager
+from shotgun.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.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,
+)
 
 from .screens.chat import ChatScreen
 from .screens.directory_setup import DirectorySetupScreen
-from .screens.feedback import FeedbackScreen
+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
 
@@ -22,12 +35,13 @@ 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 = {
-        "chat": ChatScreen,
         "provider_config": ProviderConfigScreen,
         "model_picker": ModelPickerScreen,
-        "directory_setup": DirectorySetupScreen,
-        "feedback": FeedbackScreen,
+        "github_issue": GitHubIssueScreen,
     }
     BINDINGS = [
         Binding("ctrl+c", "quit", "Quit the app"),
@@ -36,12 +50,23 @@ class ShotgunApp(App[None]):
     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,
+        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()
 
         # Start async update check and install
         if not no_update_check:
@@ -52,48 +77,157 @@ 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(),
+                "terminal_width": self.size.width,
+                "terminal_height": self.size.height,
+            },
+        )
 
         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."""
-        # Show welcome screen if no providers are configured OR if user hasn't seen it yet
-        config = self.config_manager.load()
-        if (
-            not self.config_manager.has_any_provider_key()
-            or not config.shown_welcome_screen
-        ):
-            if isinstance(self.screen, WelcomeScreen):
+        # 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(
-                WelcomeScreen(),
-                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
+            # 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):
+                    return
+
+                self.push_screen(
+                    WelcomeScreen(),
+                    callback=lambda _arg: self.refresh_startup_screen(),
+                )
+                return
+
+            # Try to create .shotgun directory if it doesn't exist
+            if not self.check_local_shotgun_directory_exists():
+                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
+
+            if isinstance(self.screen, ChatScreen):
+                return
+
+            # If we have a version to pull, show pull screen first
+            if self.pull_version_id:
+                from .screens.spec_pull import SpecPullScreen
 
-        if not self.check_local_shotgun_directory_exists():
-            if isinstance(self.screen, DirectorySetupScreen):
+                self.push_screen(
+                    SpecPullScreen(self.pull_version_id),
+                    callback=self._handle_pull_complete,
+                )
                 return
 
-            self.push_screen(
-                DirectorySetupScreen(),
-                callback=lambda _arg: self.refresh_startup_screen(),
+            # 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,
+                show_pull_hint=self.show_pull_hint,
             )
-            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()
         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
@@ -105,28 +239,32 @@ class ShotgunApp(App[None]):
     def get_system_commands(self, screen: Screen[Any]) -> Iterable[SystemCommand]:
         return [
             SystemCommand(
-                "Feedback", "Send us feedback or report a bug", self.action_feedback
+                "New Issue",
+                "Report a bug or request a feature on GitHub",
+                self.action_new_issue,
             )
-        ]  # we don't want any system commands
+        ]
 
-    def action_feedback(self) -> None:
-        """Open feedback screen and submit feedback."""
-        from shotgun.posthog_telemetry import Feedback, submit_feedback_survey
+    def action_new_issue(self) -> None:
+        """Open GitHub issue screen to guide users to create an issue."""
+        self.push_screen(GitHubIssueScreen())
 
-        def handle_feedback(feedback: Feedback | None) -> None:
-            if feedback is not None:
-                submit_feedback_survey(feedback)
-                self.notify("Feedback sent. Thank you!")
 
-        self.push_screen(FeedbackScreen(), callback=handle_feedback)
-
-
-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,
+    show_pull_hint: bool = False,
+    pull_version_id: str | None = None,
+) -> 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).
+        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
@@ -148,9 +286,135 @@ 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,
+        show_pull_hint=show_pull_hint,
+        pull_version_id=pull_version_id,
+    )
     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