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

shotgun/logging_config.py

@@ -3,15 +3,11 @@
 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.
@@ -70,7 +66,10 @@ def setup_logger(
     logger = logging.getLogger(name)
 
     # Check if we already have a file handler
-    has_file_handler = any(isinstance(h, logging.FileHandler) for h in logger.handlers)
+    has_file_handler = any(
+        isinstance(h, logging.handlers.TimedRotatingFileHandler)
+        for h in logger.handlers
+    )
 
     # If we already have a file handler, just return the logger
     if has_file_handler:
@@ -121,16 +120,21 @@ def setup_logger(
 
     if file_logging_enabled:
         try:
-            # Create file handler with ISO8601 timestamp for each run
+            # Create file handler with rotation
             log_dir = get_log_directory()
-            log_file = log_dir / f"shotgun-{_RUN_TIMESTAMP}.log"
+            log_file = log_dir / "shotgun.log"
 
-            # Use regular FileHandler - each run gets its own isolated log file
-            file_handler = logging.FileHandler(
+            # Use TimedRotatingFileHandler - rotates daily and keeps 7 days of logs
+            file_handler = logging.handlers.TimedRotatingFileHandler(
                 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)
@@ -185,7 +189,10 @@ 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.FileHandler) for h in logger.handlers)
+    has_file_handler = any(
+        isinstance(h, logging.handlers.TimedRotatingFileHandler)
+        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,10 +56,8 @@ logger.debug("Logfire observability enabled: %s", _logfire_enabled)
 
 # Initialize configuration
 try:
-    import asyncio
-
     config_manager = get_config_manager()
-    asyncio.run(config_manager.load())  # Ensure config is loaded at startup
+    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,10 +59,8 @@ 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 = asyncio.run(config_manager.get_shotgun_instance_id())
+            shotgun_instance_id = config_manager.get_shotgun_instance_id()
 
             # Identify the user in PostHog
             posthog.identify(  # type: ignore[attr-defined]
@@ -109,11 +107,9 @@ 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 = asyncio.run(config_manager.get_shotgun_instance_id())
+        shotgun_instance_id = config_manager.get_shotgun_instance_id()
 
         # Add version and environment to properties
         if properties is None:
@@ -172,16 +168,10 @@ def submit_feedback_survey(feedback: Feedback) -> None:
         logger.debug("PostHog not initialized, skipping feedback survey")
         return
 
-    import asyncio
-
     config_manager = get_config_manager()
-    config = asyncio.run(config_manager.load())
+    config = config_manager.load()
     conversation_manager = ConversationManager()
-    conversation = None
-    try:
-        conversation = asyncio.run(conversation_manager.load())
-    except Exception as e:
-        logger.debug(f"Failed to load conversation history: {e}")
+    conversation = conversation_manager.load()
     last_10_messages = []
     if conversation is not None:
         last_10_messages = conversation.get_agent_messages()[:10]

shotgun/sentry_telemetry.py

@@ -1,7 +1,5 @@
 """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
@@ -34,27 +32,12 @@ 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", "beta"
+        # Dev versions contain "dev", "rc", "alpha", or "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,
@@ -63,17 +46,14 @@ 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 = asyncio.run(config_manager.get_shotgun_instance_id())
+            shotgun_instance_id = 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,14 +50,12 @@ 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 = asyncio.run(config_manager.get_shotgun_instance_id())
+            shotgun_instance_id = 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,7 +5,6 @@ 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
@@ -19,7 +18,7 @@ from shotgun.utils.update_checker import (
 
 from .screens.chat import ChatScreen
 from .screens.directory_setup import DirectorySetupScreen
-from .screens.github_issue import GitHubIssueScreen
+from .screens.feedback import FeedbackScreen
 from .screens.model_picker import ModelPickerScreen
 from .screens.pipx_migration import PipxMigrationScreen
 from .screens.provider_config import ProviderConfigScreen
@@ -35,7 +34,7 @@ class ShotgunApp(App[None]):
         "provider_config": ProviderConfigScreen,
         "model_picker": ModelPickerScreen,
         "directory_setup": DirectorySetupScreen,
-        "github_issue": GitHubIssueScreen,
+        "feedback": FeedbackScreen,
     }
     BINDINGS = [
         Binding("ctrl+c", "quit", "Quit the app"),
@@ -96,75 +95,65 @@ class ShotgunApp(App[None]):
                 )
                 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(),
-                )
+        # 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):
                 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
+            self.push_screen(
+                WelcomeScreen(),
+                callback=lambda _arg: self.refresh_startup_screen(),
+            )
+            return
 
-            if isinstance(self.screen, ChatScreen):
+        if not self.check_local_shotgun_directory_exists():
+            if isinstance(self.screen, DirectorySetupScreen):
                 return
 
-            # Create ChatScreen with all dependencies injected from container
-            # Get the default agent mode (RESEARCH)
-            agent_mode = AgentType.RESEARCH
-
-            # Create AgentDeps asynchronously (get_provider_model is now async)
-            from shotgun.tui.dependencies import create_default_tui_deps
-
-            agent_deps = await create_default_tui_deps()
-
-            # Create AgentManager with async initialization
-            agent_manager = AgentManager(deps=agent_deps, initial_type=agent_mode)
-
-            # Create ProcessingStateManager - we'll pass the screen after creation
-            # For now, create with None and the ChatScreen will set itself
-            chat_screen = ChatScreen(
-                agent_manager=agent_manager,
-                conversation_manager=self.container.conversation_manager(),
-                conversation_service=self.container.conversation_service(),
-                widget_coordinator=self.container.widget_coordinator_factory(
-                    screen=None
-                ),
-                processing_state=self.container.processing_state_factory(
-                    screen=None,  # Will be set after ChatScreen is created
-                    telemetry_context={"agent_mode": agent_mode.value},
-                ),
-                command_handler=self.container.command_handler(),
-                placeholder_hints=self.container.placeholder_hints(),
-                codebase_sdk=self.container.codebase_sdk(),
-                deps=agent_deps,
-                continue_session=self.continue_session,
-                force_reindex=self.force_reindex,
+            self.push_screen(
+                DirectorySetupScreen(),
+                callback=lambda _arg: self.refresh_startup_screen(),
             )
+            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
-
-            self.push_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
 
-        # Run the async config check in a worker
-        self.run_worker(_check_config(), exclusive=False)
+        self.push_screen(chat_screen)
 
     def check_local_shotgun_directory_exists(self) -> bool:
         shotgun_dir = get_shotgun_base_path()
@@ -181,15 +170,20 @@ class ShotgunApp(App[None]):
     def get_system_commands(self, screen: Screen[Any]) -> Iterable[SystemCommand]:
         return [
             SystemCommand(
-                "New Issue",
-                "Report a bug or request a feature on GitHub",
-                self.action_new_issue,
+                "Feedback", "Send us feedback or report a bug", self.action_feedback
             )
-        ]
+        ]  # 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!")
 
-    def action_new_issue(self) -> None:
-        """Open GitHub issue screen to guide users to create an issue."""
-        self.push_screen(GitHubIssueScreen())
+        self.push_screen(FeedbackScreen(), callback=handle_feedback)
 
 
 def run(

shotgun/tui/components/context_indicator.py

@@ -1,7 +1,6 @@
 """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
@@ -21,10 +20,6 @@ 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,
@@ -34,7 +29,6 @@ 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
@@ -49,38 +43,6 @@ 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.
 
@@ -150,11 +112,6 @@ 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,8 +5,10 @@ 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
+from shotgun.agents.models import AgentDeps, AgentType
 from shotgun.sdk.codebase import CodebaseSDK
 from shotgun.tui.commands import CommandHandler
 from shotgun.tui.filtered_codebase_service import FilteredCodebaseService
@@ -33,19 +35,13 @@ 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
-    # 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.
+    model_config = providers.Singleton(get_provider_model)
 
     storage_dir = providers.Singleton(lambda: get_shotgun_home() / "codebases")
 
@@ -55,10 +51,15 @@ class TUIContainer(containers.DeclarativeContainer):
 
     system_prompt_fn = providers.Object(_placeholder_system_prompt)
 
-    # 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
+    # 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,
+    )
 
     # Service singletons
     codebase_sdk = providers.Singleton(CodebaseSDK)
@@ -73,9 +74,10 @@ class TUIContainer(containers.DeclarativeContainer):
         ConversationService, conversation_manager=conversation_manager
     )
 
-    # 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 AgentManager (needs agent_type parameter)
+    agent_manager_factory = providers.Factory(
+        AgentManager, deps=agent_deps, initial_type=providers.Object(AgentType.RESEARCH)
+    )
 
     # 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
 
 
-async def create_default_tui_deps() -> AgentDeps:
+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 @@ async def create_default_tui_deps() -> AgentDeps:
     Returns:
         Configured AgentDeps instance ready for TUI use.
     """
-    model_config = await get_provider_model()
+    model_config = get_provider_model()
     storage_dir = get_shotgun_home() / "codebases"
     codebase_service = FilteredCodebaseService(storage_dir)