shotgun-sh 0.2.11.dev2__py3-none-any.whl → 0.2.11.dev7__py3-none-any.whl

shotgun/logging_config.py

@@ -3,11 +3,15 @@
 import logging
 import logging.handlers
 import sys
+from datetime import datetime, timezone
 from pathlib import Path
 
 from shotgun.settings import settings
 from shotgun.utils.env_utils import is_truthy
 
+# Generate a single timestamp for this run to be used across all loggers
+_RUN_TIMESTAMP = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+
 
 def get_log_directory() -> Path:
     """Get the log directory path, creating it if necessary.
@@ -66,10 +70,7 @@ def setup_logger(
     logger = logging.getLogger(name)
 
     # Check if we already have a file handler
-    has_file_handler = any(
-        isinstance(h, logging.handlers.TimedRotatingFileHandler)
-        for h in logger.handlers
-    )
+    has_file_handler = any(isinstance(h, logging.FileHandler) for h in logger.handlers)
 
     # If we already have a file handler, just return the logger
     if has_file_handler:
@@ -120,21 +121,16 @@ def setup_logger(
 
     if file_logging_enabled:
         try:
-            # Create file handler with rotation
+            # Create file handler with ISO8601 timestamp for each run
             log_dir = get_log_directory()
-            log_file = log_dir / "shotgun.log"
+            log_file = log_dir / f"shotgun-{_RUN_TIMESTAMP}.log"
 
-            # Use TimedRotatingFileHandler - rotates daily and keeps 7 days of logs
-            file_handler = logging.handlers.TimedRotatingFileHandler(
+            # Use regular FileHandler - each run gets its own isolated log file
+            file_handler = logging.FileHandler(
                 filename=log_file,
-                when="midnight",  # Rotate at midnight
-                interval=1,  # Every 1 day
-                backupCount=7,  # Keep 7 days of logs
                 encoding="utf-8",
             )
 
-            # Also set max file size (10MB) using RotatingFileHandler as fallback
-            # Note: We'll use TimedRotatingFileHandler which handles both time and size
             file_handler.setLevel(getattr(logging, log_level))
 
             # Use standard formatter for file (no colors)
@@ -189,10 +185,7 @@ def get_logger(name: str) -> logging.Logger:
     logger = logging.getLogger(name)
 
     # Check if we have a file handler already
-    has_file_handler = any(
-        isinstance(h, logging.handlers.TimedRotatingFileHandler)
-        for h in logger.handlers
-    )
+    has_file_handler = any(isinstance(h, logging.FileHandler) for h in logger.handlers)
 
     # If no file handler, set up the logger (will add file handler)
     if not has_file_handler:

shotgun/main.py

@@ -56,8 +56,10 @@ logger.debug("Logfire observability enabled: %s", _logfire_enabled)
 
 # Initialize configuration
 try:
+    import asyncio
+
     config_manager = get_config_manager()
-    config_manager.load()  # Ensure config is loaded at startup
+    asyncio.run(config_manager.load())  # Ensure config is loaded at startup
 except Exception as e:
     logger.debug("Configuration initialization warning: %s", e)
 

shotgun/posthog_telemetry.py

@@ -59,8 +59,10 @@ def setup_posthog_observability() -> bool:
 
         # Set user context with anonymous shotgun instance ID from config
         try:
+            import asyncio
+
             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())
 
             # Identify the user in PostHog
             posthog.identify(  # type: ignore[attr-defined]
@@ -107,9 +109,11 @@ def track_event(event_name: str, properties: dict[str, Any] | None = None) -> No
         return
 
     try:
+        import asyncio
+
         # Get shotgun instance ID for tracking
         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())
 
         # Add version and environment to properties
         if properties is None:
@@ -168,10 +172,16 @@ def submit_feedback_survey(feedback: Feedback) -> None:
         logger.debug("PostHog not initialized, skipping feedback survey")
         return
 
+    import asyncio
+
     config_manager = get_config_manager()
-    config = config_manager.load()
+    config = asyncio.run(config_manager.load())
     conversation_manager = ConversationManager()
-    conversation = conversation_manager.load()
+    conversation = None
+    try:
+        conversation = asyncio.run(conversation_manager.load())
+    except Exception as e:
+        logger.debug(f"Failed to load conversation history: {e}")
     last_10_messages = []
     if conversation is not None:
         last_10_messages = conversation.get_agent_messages()[:10]

shotgun/sentry_telemetry.py

@@ -1,5 +1,7 @@
 """Sentry observability setup for Shotgun."""
 
+from typing import Any
+
 from shotgun import __version__
 from shotgun.logging_config import get_early_logger
 from shotgun.settings import settings
@@ -32,12 +34,27 @@ def setup_sentry_observability() -> bool:
         logger.debug("Using Sentry DSN from settings, proceeding with setup")
 
         # Determine environment based on version
-        # Dev versions contain "dev", "rc", "alpha", or "beta"
+        # Dev versions contain "dev", "rc", "alpha", "beta"
         if any(marker in __version__ for marker in ["dev", "rc", "alpha", "beta"]):
             environment = "development"
         else:
             environment = "production"
 
+        def before_send(event: Any, hint: dict[str, Any]) -> Any:
+            """Filter out user-actionable errors from Sentry.
+
+            User-actionable errors (like context size limits) are expected conditions
+            that users need to resolve, not bugs that need tracking.
+            """
+            if "exc_info" in hint:
+                exc_type, exc_value, tb = hint["exc_info"]
+                from shotgun.exceptions import ErrorNotPickedUpBySentry
+
+                if isinstance(exc_value, ErrorNotPickedUpBySentry):
+                    # Don't send to Sentry - this is user-actionable, not a bug
+                    return None
+            return event
+
         # Initialize Sentry
         sentry_sdk.init(
             dsn=dsn,
@@ -46,14 +63,17 @@ def setup_sentry_observability() -> bool:
             send_default_pii=False,  # Privacy-first: never send PII
             traces_sample_rate=0.1 if environment == "production" else 1.0,
             profiles_sample_rate=0.1 if environment == "production" else 1.0,
+            before_send=before_send,
         )
 
         # Set user context with anonymous shotgun instance ID from config
         try:
+            import asyncio
+
             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())
             sentry_sdk.set_user({"id": shotgun_instance_id})
             logger.debug("Sentry user context set with anonymous ID")
         except Exception as e:

shotgun/telemetry.py

@@ -50,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,6 +5,7 @@ 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
@@ -18,7 +19,7 @@ from shotgun.utils.update_checker import (
 
 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
@@ -34,7 +35,7 @@ class ShotgunApp(App[None]):
         "provider_config": ProviderConfigScreen,
         "model_picker": ModelPickerScreen,
         "directory_setup": DirectorySetupScreen,
-        "feedback": FeedbackScreen,
+        "github_issue": GitHubIssueScreen,
     }
     BINDINGS = [
         Binding("ctrl+c", "quit", "Quit the app"),
@@ -95,65 +96,75 @@ class ShotgunApp(App[None]):
                 )
                 return
 
-        # 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):
+        # 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
 
-            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
-
-        # 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
+            # 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)
+            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()
@@ -170,20 +181,15 @@ 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 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 action_new_issue(self) -> None:
+        """Open GitHub issue screen to guide users to create an issue."""
+        self.push_screen(GitHubIssueScreen())
 
 
 def run(

shotgun/tui/components/context_indicator.py

@@ -1,6 +1,7 @@
 """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
@@ -20,6 +21,10 @@ class ContextIndicator(Static):
 
     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,
@@ -29,6 +34,7 @@ class ContextIndicator(Static):
         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
@@ -43,6 +49,38 @@ class ContextIndicator(Static):
         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.
 
@@ -112,6 +150,11 @@ class ContextIndicator(Static):
             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)

shotgun/tui/containers.py

@@ -5,10 +5,8 @@ from typing import TYPE_CHECKING
 from dependency_injector import containers, providers
 from pydantic_ai import RunContext
 
-from shotgun.agents.agent_manager import AgentManager
-from shotgun.agents.config import get_provider_model
 from shotgun.agents.conversation_manager import ConversationManager
-from shotgun.agents.models import AgentDeps, AgentType
+from shotgun.agents.models import AgentDeps
 from shotgun.sdk.codebase import CodebaseSDK
 from shotgun.tui.commands import CommandHandler
 from shotgun.tui.filtered_codebase_service import FilteredCodebaseService
@@ -35,13 +33,19 @@ class TUIContainer(containers.DeclarativeContainer):
 
     This container manages the lifecycle and dependencies of all TUI components,
     ensuring consistent configuration and facilitating testing.
+
+    Note: model_config and agent_deps are created lazily via async factory methods
+    since get_provider_model() is now async.
     """
 
     # Configuration
     config = providers.Configuration()
 
     # Core dependencies
-    model_config = providers.Singleton(get_provider_model)
+    # TODO: Figure out a better solution for async dependency injection
+    # model_config is now loaded lazily via create_default_tui_deps()
+    # because get_provider_model() is async. This breaks the DI pattern
+    # and should be refactored to support async factories properly.
 
     storage_dir = providers.Singleton(lambda: get_shotgun_home() / "codebases")
 
@@ -51,15 +55,10 @@ class TUIContainer(containers.DeclarativeContainer):
 
     system_prompt_fn = providers.Object(_placeholder_system_prompt)
 
-    # AgentDeps singleton
-    agent_deps = providers.Singleton(
-        AgentDeps,
-        interactive_mode=True,
-        is_tui_context=True,
-        llm_model=model_config,
-        codebase_service=codebase_service,
-        system_prompt_fn=system_prompt_fn,
-    )
+    # TODO: Figure out a better solution for async dependency injection
+    # AgentDeps is now created via async create_default_tui_deps()
+    # instead of using DI container's Singleton provider because it requires
+    # async model_config initialization
 
     # Service singletons
     codebase_sdk = providers.Singleton(CodebaseSDK)
@@ -74,10 +73,9 @@ class TUIContainer(containers.DeclarativeContainer):
         ConversationService, conversation_manager=conversation_manager
     )
 
-    # Factory for AgentManager (needs agent_type parameter)
-    agent_manager_factory = providers.Factory(
-        AgentManager, deps=agent_deps, initial_type=providers.Object(AgentType.RESEARCH)
-    )
+    # TODO: Figure out a better solution for async dependency injection
+    # AgentManager factory removed - create via async initialization
+    # since it requires async agent creation
 
     # Factory for ProcessingStateManager (needs ChatScreen reference)
     processing_state_factory = providers.Factory(

shotgun/tui/dependencies.py

@@ -8,7 +8,7 @@ from shotgun.tui.filtered_codebase_service import FilteredCodebaseService
 from shotgun.utils import get_shotgun_home
 
 
-def create_default_tui_deps() -> AgentDeps:
+async def create_default_tui_deps() -> AgentDeps:
     """Create default AgentDeps for TUI components.
 
     This creates a standard AgentDeps configuration suitable for interactive
@@ -21,7 +21,7 @@ def create_default_tui_deps() -> AgentDeps:
     Returns:
         Configured AgentDeps instance ready for TUI use.
     """
-    model_config = get_provider_model()
+    model_config = await get_provider_model()
     storage_dir = get_shotgun_home() / "codebases"
     codebase_service = FilteredCodebaseService(storage_dir)