shotgun-sh 0.2.3.dev2__py3-none-any.whl → 0.2.11.dev5__py3-none-any.whl

shotgun/settings.py

@@ -0,0 +1,238 @@
+"""Centralized application settings using Pydantic Settings.
+
+All environment variables use the SHOTGUN_ prefix to avoid conflicts with other tools.
+Settings are loaded with the following priority:
+1. Environment variables (highest priority)
+2. Build constants (embedded at build time)
+3. Default values (lowest priority)
+
+Example usage:
+    from shotgun.settings import settings
+
+    # Access telemetry settings
+    if settings.telemetry.sentry_dsn:
+        sentry_sdk.init(dsn=settings.telemetry.sentry_dsn)
+
+    # Access logging settings
+    logger.setLevel(settings.logging.log_level)
+
+    # Access API settings
+    response = httpx.get(settings.api.web_base_url)
+"""
+
+from typing import Any
+
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+def _get_build_constant(name: str, default: Any = None) -> Any:
+    """Get a value from build_constants.py, falling back to default.
+
+    Args:
+        name: The constant name to retrieve (e.g., "SENTRY_DSN")
+        default: Default value if constant not found
+
+    Returns:
+        The constant value, or default if not found/import fails
+    """
+    try:
+        from shotgun import build_constants
+
+        return getattr(build_constants, name, default)
+    except ImportError:
+        return default
+
+
+class TelemetrySettings(BaseSettings):
+    """Telemetry and observability settings.
+
+    These settings control error tracking (Sentry), analytics (PostHog),
+    and observability (Logfire) integrations.
+    """
+
+    sentry_dsn: str = Field(
+        default_factory=lambda: _get_build_constant("SENTRY_DSN", ""),
+        description="Sentry DSN for error tracking",
+    )
+    posthog_api_key: str = Field(
+        default_factory=lambda: _get_build_constant("POSTHOG_API_KEY", ""),
+        description="PostHog API key for analytics",
+    )
+    posthog_project_id: str = Field(
+        default_factory=lambda: _get_build_constant("POSTHOG_PROJECT_ID", ""),
+        description="PostHog project ID",
+    )
+    logfire_enabled: bool = Field(
+        default_factory=lambda: _get_build_constant("LOGFIRE_ENABLED", False),
+        description="Enable Logfire observability (dev builds only)",
+    )
+    logfire_token: str = Field(
+        default_factory=lambda: _get_build_constant("LOGFIRE_TOKEN", ""),
+        description="Logfire authentication token",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    @field_validator("logfire_enabled", mode="before")
+    @classmethod
+    def parse_bool(cls, v: Any) -> bool:
+        """Parse boolean values from strings (matches is_truthy behavior)."""
+        if isinstance(v, bool):
+            return v
+        if isinstance(v, str):
+            return v.lower() in ("true", "1", "yes")
+        return bool(v)
+
+
+class LoggingSettings(BaseSettings):
+    """Logging configuration settings.
+
+    Controls log level, console output, and file logging behavior.
+    """
+
+    log_level: str = Field(
+        default="INFO",
+        description="Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
+    )
+    logging_to_console: bool = Field(
+        default=False,
+        description="Enable console logging output",
+    )
+    logging_to_file: bool = Field(
+        default=True,
+        description="Enable file logging output",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    @field_validator("log_level")
+    @classmethod
+    def validate_log_level(cls, v: str) -> str:
+        """Validate log level is one of the allowed values."""
+        v = v.upper()
+        valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+        if v not in valid_levels:
+            return "INFO"  # Default to INFO if invalid
+        return v
+
+    @field_validator("logging_to_console", "logging_to_file", mode="before")
+    @classmethod
+    def parse_bool(cls, v: Any) -> bool:
+        """Parse boolean values from strings (matches is_truthy behavior)."""
+        if isinstance(v, bool):
+            return v
+        if isinstance(v, str):
+            return v.lower() in ("true", "1", "yes")
+        return bool(v)
+
+
+class ApiSettings(BaseSettings):
+    """API endpoint settings.
+
+    Configuration for Shotgun backend services.
+    """
+
+    web_base_url: str = Field(
+        default="https://api-219702594231.us-east4.run.app",
+        description="Shotgun Web API base URL (authentication/subscription)",
+    )
+    account_llm_base_url: str = Field(
+        default="https://litellm-219702594231.us-east4.run.app",
+        description="Shotgun's LiteLLM proxy base URL (AI model requests)",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+
+class DevelopmentSettings(BaseSettings):
+    """Development and testing settings.
+
+    These settings are primarily used for testing and development purposes.
+    """
+
+    home: str | None = Field(
+        default=None,
+        description="Override Shotgun home directory (for testing)",
+    )
+    pipx_simulate: bool = Field(
+        default=False,
+        description="Simulate pipx installation (for testing)",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    @field_validator("pipx_simulate", mode="before")
+    @classmethod
+    def parse_bool(cls, v: Any) -> bool:
+        """Parse boolean values from strings (matches is_truthy behavior)."""
+        if isinstance(v, bool):
+            return v
+        if isinstance(v, str):
+            return v.lower() in ("true", "1", "yes")
+        return bool(v)
+
+
+class Settings(BaseSettings):
+    """Main application settings with SHOTGUN_ prefix.
+
+    This is the main settings class that composes all other settings groups.
+    Access settings via the global `settings` singleton instance.
+
+    Example:
+        from shotgun.settings import settings
+
+        # Telemetry settings
+        settings.telemetry.sentry_dsn
+        settings.telemetry.posthog_api_key
+        settings.telemetry.logfire_enabled
+
+        # Logging settings
+        settings.logging.log_level
+        settings.logging.logging_to_console
+
+        # API settings
+        settings.api.web_base_url
+        settings.api.account_llm_base_url
+
+        # Development settings
+        settings.dev.home
+        settings.dev.pipx_simulate
+    """
+
+    telemetry: TelemetrySettings = Field(default_factory=TelemetrySettings)
+    logging: LoggingSettings = Field(default_factory=LoggingSettings)
+    api: ApiSettings = Field(default_factory=ApiSettings)
+    dev: DevelopmentSettings = Field(default_factory=DevelopmentSettings)
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+
+# Global settings singleton
+# Import this in your modules: from shotgun.settings import settings
+settings = Settings()

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
@@ -65,14 +40,24 @@ def setup_logfire_observability() -> bool:
         # Instrument Pydantic AI for better observability
         logfire.instrument_pydantic_ai()
 
+        # Add LogfireLoggingHandler to root logger so logfire logs also go to file
+        import logging
+
+        root_logger = logging.getLogger()
+        logfire_handler = logfire.LogfireLoggingHandler()
+        root_logger.addHandler(logfire_handler)
+        logger.debug("Added LogfireLoggingHandler to root logger for file integration")
+
         # 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,23 @@ 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.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 +29,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()
     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 +44,19 @@ 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,
     ) -> 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:
@@ -52,43 +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."""
-        # 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
+            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
+
+                self.push_screen(
+                    DirectorySetupScreen(),
+                    callback=lambda _arg: self.refresh_startup_screen(),
+                )
+                return
 
-        if not self.check_local_shotgun_directory_exists():
-            if isinstance(self.screen, DirectorySetupScreen):
+            if isinstance(self.screen, ChatScreen):
                 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,
             )
-            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()
@@ -105,28 +181,28 @@ 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,
+) -> 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
@@ -148,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()