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

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,6 +40,14 @@ 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:
             from opentelemetry import baggage, context

shotgun/tui/app.py

@@ -6,15 +6,21 @@ from textual.binding import Binding
 from textual.screen import Screen
 
 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.model_picker import ModelPickerScreen
+from .screens.pipx_migration import PipxMigrationScreen
 from .screens.provider_config import ProviderConfigScreen
 from .screens.welcome import WelcomeScreen
 
@@ -22,8 +28,9 @@ 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,
@@ -36,12 +43,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,14 +66,35 @@ 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."""
+        # 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
+
         # Show welcome screen if no providers are configured OR if user hasn't seen it yet
         config = self.config_manager.load()
         if (
@@ -87,8 +122,38 @@ class ShotgunApp(App[None]):
 
         if isinstance(self.screen, ChatScreen):
             return
-        # Pass continue_session flag to ChatScreen
-        self.push_screen(ChatScreen(continue_session=self.continue_session))
+
+        # Create ChatScreen with all dependencies injected from container
+        # Get the default agent mode (RESEARCH)
+        agent_mode = AgentType.RESEARCH
+
+        # Create AgentManager with the correct mode
+        agent_manager = self.container.agent_manager_factory(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=self.container.agent_deps(),
+            continue_session=self.continue_session,
+            force_reindex=self.force_reindex,
+        )
+
+        # 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)
 
     def check_local_shotgun_directory_exists(self) -> bool:
         shotgun_dir = get_shotgun_base_path()
@@ -121,12 +186,17 @@ class ShotgunApp(App[None]):
         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 +218,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,136 @@
+"""Context window indicator component for showing model usage."""
+
+from textual.reactive import reactive
+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)
+
+    def __init__(
+        self,
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        super().__init__(name=name, id=id, classes=classes)
+
+    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 _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 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[/]"
+            )