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

shotgun/tui/utils/mode_progress.py

@@ -3,6 +3,8 @@
 import random
 from pathlib import Path
 
+import aiofiles
+
 from shotgun.agents.models import AgentType
 from shotgun.utils.file_system_utils import get_shotgun_base_path
 
@@ -30,7 +32,7 @@ class ModeProgressChecker:
         """
         self.base_path = base_path or get_shotgun_base_path()
 
-    def has_mode_content(self, mode: AgentType) -> bool:
+    async def has_mode_content(self, mode: AgentType) -> bool:
         """Check if a mode has meaningful content.
 
         Args:
@@ -52,7 +54,8 @@ class ModeProgressChecker:
                 for item in export_path.glob("*"):
                     if item.is_file() and not item.name.startswith("."):
                         try:
-                            content = item.read_text(encoding="utf-8")
+                            async with aiofiles.open(item, encoding="utf-8") as f:
+                                content = await f.read()
                             if len(content.strip()) > self.MIN_CONTENT_SIZE:
                                 return True
                         except (OSError, UnicodeDecodeError):
@@ -65,13 +68,16 @@ class ModeProgressChecker:
             return False
 
         try:
-            content = file_path.read_text(encoding="utf-8")
+            async with aiofiles.open(file_path, encoding="utf-8") as f:
+                content = await f.read()
             # Check if file has meaningful content
             return len(content.strip()) > self.MIN_CONTENT_SIZE
         except (OSError, UnicodeDecodeError):
             return False
 
-    def get_next_suggested_mode(self, current_mode: AgentType) -> AgentType | None:
+    async def get_next_suggested_mode(
+        self, current_mode: AgentType
+    ) -> AgentType | None:
         """Get the next suggested mode based on current progress.
 
         Args:
@@ -94,7 +100,7 @@ class ModeProgressChecker:
             return None
 
         # Check if current mode has content
-        if not self.has_mode_content(current_mode):
+        if not await self.has_mode_content(current_mode):
             # Current mode is empty, no suggestion for next mode
             return None
 
@@ -222,8 +228,9 @@ class PlaceholderHints:
         if current_mode not in self.HINTS:
             return f"Enter your {current_mode.value} mode prompt (SHIFT+TAB to switch modes)"
 
-        # Determine if mode has content
-        has_content = self.progress_checker.has_mode_content(current_mode)
+        # For placeholder text, we default to "no content" state (initial hints)
+        # This avoids async file system checks in the UI rendering path
+        has_content = False
 
         # Get hint variations for this mode and state
         hints_list = self.HINTS[current_mode][has_content]

shotgun/tui/widgets/__init__.py

@@ -0,0 +1,5 @@
+"""Widget utilities and coordinators for TUI."""
+
+from shotgun.tui.widgets.widget_coordinator import WidgetCoordinator
+
+__all__ = ["WidgetCoordinator"]

shotgun/tui/widgets/widget_coordinator.py

@@ -0,0 +1,262 @@
+# mypy: disable-error-code="import-not-found"
+"""Widget coordinator to centralize widget queries and updates.
+
+This module eliminates scattered `query_one()` calls throughout ChatScreen
+by providing a single place for all widget updates. This improves:
+- Testability (can test update logic in isolation)
+- Maintainability (clear update contracts)
+- Performance (can batch updates if needed)
+"""
+
+import logging
+from typing import TYPE_CHECKING
+
+from pydantic_ai.messages import ModelMessage
+
+from shotgun.agents.config.models import ModelName
+from shotgun.agents.models import AgentType
+from shotgun.tui.components.context_indicator import ContextIndicator
+from shotgun.tui.components.mode_indicator import ModeIndicator
+from shotgun.tui.components.prompt_input import PromptInput
+from shotgun.tui.components.spinner import Spinner
+from shotgun.tui.components.status_bar import StatusBar
+from shotgun.tui.screens.chat_screen.history.chat_history import ChatHistory
+
+if TYPE_CHECKING:
+    from shotgun.agents.context_analyzer.models import ContextAnalysis
+    from shotgun.agents.conversation_history import HintMessage
+    from shotgun.tui.screens.chat import ChatScreen
+
+logger = logging.getLogger(__name__)
+
+
+class WidgetCoordinator:
+    """Coordinates updates to all widgets in ChatScreen.
+
+    This class centralizes all `query_one()` calls and widget manipulations,
+    providing clear update methods instead of scattered direct queries.
+
+    Benefits:
+    - Single place for all widget updates
+    - Testable without full TUI
+    - Clear update contracts
+    - Can add batching/debouncing easily
+    """
+
+    def __init__(self, screen: "ChatScreen"):
+        """Initialize the coordinator with a reference to the screen.
+
+        Args:
+            screen: The ChatScreen instance containing the widgets.
+        """
+        self.screen = screen
+
+    def update_for_mode_change(
+        self, new_mode: AgentType, placeholder: str | None = None
+    ) -> None:
+        """Update all widgets when agent mode changes.
+
+        Args:
+            new_mode: The new agent mode.
+            placeholder: Optional placeholder text for input. If not provided,
+                        will use the screen's _placeholder_for_mode method.
+        """
+        if not self.screen.is_mounted:
+            return
+
+        # Update mode indicator
+        try:
+            mode_indicator = self.screen.query_one(ModeIndicator)
+            mode_indicator.mode = new_mode
+            mode_indicator.refresh()
+        except Exception as e:
+            logger.exception(f"Failed to update mode indicator: {e}")
+
+        # Update prompt input placeholder
+        try:
+            prompt_input = self.screen.query_one(PromptInput)
+            if placeholder is None:
+                placeholder = self.screen._placeholder_for_mode(
+                    new_mode, force_new=True
+                )
+            prompt_input.placeholder = placeholder
+            prompt_input.refresh()
+        except Exception as e:
+            logger.exception(f"Failed to update prompt input: {e}")
+
+    def update_for_processing_state(
+        self, is_processing: bool, spinner_text: str | None = None
+    ) -> None:
+        """Update widgets when processing state changes.
+
+        Args:
+            is_processing: Whether processing is active.
+            spinner_text: Optional text to display in spinner.
+        """
+        if not self.screen.is_mounted:
+            return
+
+        # Update spinner visibility
+        try:
+            spinner = self.screen.query_one("#spinner", Spinner)
+            spinner.set_classes("" if is_processing else "hidden")
+            spinner.display = is_processing
+            if spinner_text and is_processing:
+                spinner.text = spinner_text
+        except Exception as e:
+            logger.exception(f"Failed to update spinner: {e}")
+
+        # Update status bar
+        try:
+            status_bar = self.screen.query_one(StatusBar)
+            status_bar.working = is_processing
+            status_bar.refresh()
+        except Exception as e:
+            logger.exception(f"Failed to update status bar: {e}")
+
+    def update_for_qa_mode(self, qa_mode_active: bool) -> None:
+        """Update widgets when Q&A mode changes.
+
+        Args:
+            qa_mode_active: Whether Q&A mode is active.
+        """
+        if not self.screen.is_mounted:
+            return
+
+        # Update status bar
+        try:
+            status_bar = self.screen.query_one(StatusBar)
+            status_bar.refresh()
+        except Exception as e:
+            logger.exception(f"Failed to update status bar for Q&A: {e}")
+
+        # Update mode indicator
+        try:
+            mode_indicator = self.screen.query_one(ModeIndicator)
+            mode_indicator.refresh()
+        except Exception as e:
+            logger.exception(f"Failed to update mode indicator for Q&A: {e}")
+
+    def update_messages(self, messages: list[ModelMessage | "HintMessage"]) -> None:
+        """Update chat history with new messages.
+
+        Args:
+            messages: The messages to display.
+        """
+        if not self.screen.is_mounted:
+            return
+
+        try:
+            chat_history = self.screen.query_one(ChatHistory)
+            chat_history.update_messages(messages)
+        except Exception as e:
+            logger.exception(f"Failed to update messages: {e}")
+
+    def set_partial_response(
+        self, message: ModelMessage | None, messages: list[ModelMessage | "HintMessage"]
+    ) -> None:
+        """Update chat history with partial streaming response.
+
+        Args:
+            message: The partial message being streamed.
+            messages: The full message history.
+        """
+        if not self.screen.is_mounted:
+            return
+
+        try:
+            chat_history = self.screen.query_one(ChatHistory)
+            if message:
+                chat_history.partial_response = message
+            chat_history.update_messages(messages)
+        except Exception as e:
+            logger.exception(f"Failed to set partial response: {e}")
+
+    def update_context_indicator(
+        self, analysis: "ContextAnalysis | None", model_name: str
+    ) -> None:
+        """Update context indicator with new analysis.
+
+        Args:
+            analysis: The context analysis results.
+            model_name: The current model name.
+        """
+        if not self.screen.is_mounted:
+            return
+
+        try:
+            context_indicator = self.screen.query_one(ContextIndicator)
+            # Cast the string model name to ModelName type
+            model = ModelName(model_name) if model_name else None
+            context_indicator.update_context(analysis, model)
+        except Exception as e:
+            logger.exception(f"Failed to update context indicator: {e}")
+
+    def update_prompt_input(
+        self,
+        placeholder: str | None = None,
+        clear: bool = False,
+        focus: bool = False,
+    ) -> None:
+        """Update prompt input widget.
+
+        Args:
+            placeholder: New placeholder text.
+            clear: Whether to clear the input.
+            focus: Whether to focus the input.
+        """
+        if not self.screen.is_mounted:
+            return
+
+        try:
+            prompt_input = self.screen.query_one(PromptInput)
+            if placeholder is not None:
+                prompt_input.placeholder = placeholder
+            if clear:
+                prompt_input.clear()
+            if focus:
+                prompt_input.focus()
+        except Exception as e:
+            logger.exception(f"Failed to update prompt input: {e}")
+
+    def refresh_mode_indicator(self) -> None:
+        """Refresh mode indicator without changing mode."""
+        if not self.screen.is_mounted:
+            return
+
+        try:
+            mode_indicator = self.screen.query_one(ModeIndicator)
+            mode_indicator.refresh()
+        except Exception as e:
+            logger.exception(f"Failed to refresh mode indicator: {e}")
+
+    def update_spinner_text(self, text: str) -> None:
+        """Update spinner text without changing visibility.
+
+        Args:
+            text: The new spinner text.
+        """
+        if not self.screen.is_mounted:
+            return
+
+        try:
+            spinner = self.screen.query_one("#spinner", Spinner)
+            if spinner.display:  # Only update if visible
+                spinner.text = text
+        except Exception as e:
+            logger.exception(f"Failed to update spinner text: {e}")
+
+    def set_context_streaming(self, streaming: bool) -> None:
+        """Enable or disable context indicator streaming animation.
+
+        Args:
+            streaming: Whether to show streaming animation.
+        """
+        if not self.screen.is_mounted:
+            return
+
+        try:
+            context_indicator = self.screen.query_one(ContextIndicator)
+            context_indicator.set_streaming(streaming)
+        except Exception as e:
+            logger.exception(f"Failed to set context streaming: {e}")

shotgun/utils/datetime_utils.py

@@ -0,0 +1,77 @@
+"""Datetime utilities for consistent datetime formatting across the application."""
+
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+
+class DateTimeContext(BaseModel):
+    """Structured datetime context with timezone information.
+
+    This model provides consistently formatted datetime information
+    for use in prompts, templates, and UI display.
+
+    Attributes:
+        datetime_formatted: Human-readable datetime string
+        timezone_name: Short timezone name (e.g., "PST", "UTC")
+        utc_offset: UTC offset formatted with colon (e.g., "UTC-08:00")
+
+    Example:
+        >>> dt_context = get_datetime_context()
+        >>> print(dt_context.datetime_formatted)
+        'Monday, January 13, 2025 at 3:45:30 PM'
+        >>> print(dt_context.timezone_name)
+        'PST'
+        >>> print(dt_context.utc_offset)
+        'UTC-08:00'
+    """
+
+    datetime_formatted: str = Field(
+        description="Human-readable datetime string in format: 'Day, Month DD, YYYY at HH:MM:SS AM/PM'"
+    )
+    timezone_name: str = Field(description="Short timezone name (e.g., PST, EST, UTC)")
+    utc_offset: str = Field(
+        description="UTC offset formatted with colon (e.g., UTC-08:00, UTC+05:30)"
+    )
+
+
+def get_datetime_context() -> DateTimeContext:
+    """Get formatted datetime context with timezone information.
+
+    Returns a Pydantic model containing consistently formatted datetime
+    information suitable for use in prompts and templates.
+
+    Returns:
+        DateTimeContext: Structured datetime context with formatted strings
+
+    Example:
+        >>> dt_context = get_datetime_context()
+        >>> dt_context.datetime_formatted
+        'Monday, January 13, 2025 at 3:45:30 PM'
+        >>> dt_context.timezone_name
+        'PST'
+        >>> dt_context.utc_offset
+        'UTC-08:00'
+    """
+    # Get current datetime with timezone information
+    now = datetime.now().astimezone()
+
+    # Format datetime in plain English
+    # Example: "Monday, January 13, 2025 at 3:45:30 PM"
+    datetime_formatted = now.strftime("%A, %B %d, %Y at %I:%M:%S %p")
+
+    # Get timezone name and UTC offset
+    # Example: "PST" and "UTC-08:00"
+    timezone_name = now.strftime("%Z")
+    utc_offset = now.strftime("%z")  # Format: +0800 or -0500
+
+    # Reformat UTC offset to include colon: +08:00 or -05:00
+    utc_offset_formatted = (
+        f"UTC{utc_offset[:3]}:{utc_offset[3:]}" if utc_offset else "UTC"
+    )
+
+    return DateTimeContext(
+        datetime_formatted=datetime_formatted,
+        timezone_name=timezone_name,
+        utc_offset=utc_offset_formatted,
+    )

shotgun/utils/file_system_utils.py

@@ -1,8 +1,11 @@
 """File system utility functions."""
 
-import os
 from pathlib import Path
 
+import aiofiles
+
+from shotgun.settings import settings
+
 
 def get_shotgun_base_path() -> Path:
     """Get the absolute path to the .shotgun directory."""
@@ -18,7 +21,7 @@ def get_shotgun_home() -> Path:
         Path to shotgun home directory (default: ~/.shotgun-sh/)
     """
     # Allow override via environment variable (useful for testing)
-    if custom_home := os.environ.get("SHOTGUN_HOME"):
+    if custom_home := settings.dev.home:
         return Path(custom_home)
 
     return Path.home() / ".shotgun-sh"
@@ -34,3 +37,20 @@ def ensure_shotgun_directory_exists() -> Path:
     shotgun_dir.mkdir(exist_ok=True)
     # Note: Removed logger to avoid circular dependency with logging_config
     return shotgun_dir
+
+
+async def async_copy_file(src: Path, dst: Path) -> None:
+    """Asynchronously copy a file from src to dst.
+
+    Args:
+        src: Source file path
+        dst: Destination file path
+
+    Raises:
+        FileNotFoundError: If source file doesn't exist
+        OSError: If copy operation fails
+    """
+    async with aiofiles.open(src, "rb") as src_file:
+        content = await src_file.read()
+    async with aiofiles.open(dst, "wb") as dst_file:
+        await dst_file.write(content)

shotgun/utils/marketing.py

@@ -0,0 +1,110 @@
+"""Marketing message management for Shotgun CLI."""
+
+from collections.abc import Callable
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from shotgun.agents.config.models import MarketingConfig, MarketingMessageRecord
+from shotgun.agents.models import FileOperation
+
+if TYPE_CHECKING:
+    from shotgun.agents.config.manager import ConfigManager
+
+# Marketing message IDs
+GITHUB_STAR_MESSAGE_ID = "github_star_v1"
+
+# Spec files that trigger the GitHub star message
+SPEC_FILES = {"research.md", "specification.md", "plan.md", "tasks.md"}
+
+
+class MarketingManager:
+    """Manages marketing messages shown to users."""
+
+    @staticmethod
+    def should_show_github_star_message(
+        marketing_config: MarketingConfig, file_operations: list[FileOperation]
+    ) -> bool:
+        """
+        Check if the GitHub star message should be shown.
+
+        Args:
+            marketing_config: Current marketing configuration
+            file_operations: List of file operations from the current agent run
+
+        Returns:
+            True if message should be shown, False otherwise
+        """
+        # Check if message has already been shown
+        if GITHUB_STAR_MESSAGE_ID in marketing_config.messages:
+            return False
+
+        # Check if any spec file was written
+        for operation in file_operations:
+            # operation.file_path is a string, so we convert to Path to get the filename
+            file_name = Path(operation.file_path).name
+            if file_name in SPEC_FILES:
+                return True
+
+        return False
+
+    @staticmethod
+    def mark_message_shown(
+        marketing_config: MarketingConfig, message_id: str
+    ) -> MarketingConfig:
+        """
+        Mark a marketing message as shown.
+
+        Args:
+            marketing_config: Current marketing configuration
+            message_id: ID of the message to mark as shown
+
+        Returns:
+            Updated marketing configuration
+        """
+        # Create a new record with current timestamp
+        record = MarketingMessageRecord(shown_at=datetime.now(timezone.utc))
+
+        # Update the messages dict
+        marketing_config.messages[message_id] = record
+
+        return marketing_config
+
+    @staticmethod
+    def get_github_star_message() -> str:
+        """Get the GitHub star marketing message text."""
+        return "⭐ Enjoying Shotgun? Star us on GitHub: https://github.com/shotgun-sh/shotgun"
+
+    @staticmethod
+    async def check_and_display_messages(
+        config_manager: "ConfigManager",
+        file_operations: list[FileOperation],
+        display_callback: Callable[[str], None],
+    ) -> None:
+        """
+        Check if any marketing messages should be shown and display them.
+
+        This is the main entry point for marketing message handling. It checks
+        all configured messages, displays them if appropriate, and updates the
+        config to mark them as shown.
+
+        Args:
+            config_manager: Config manager to load/save configuration
+            file_operations: List of file operations from the current agent run
+            display_callback: Callback function to display messages to the user
+        """
+        config = await config_manager.load()
+
+        # Check GitHub star message
+        if MarketingManager.should_show_github_star_message(
+            config.marketing, file_operations
+        ):
+            # Display the message
+            message = MarketingManager.get_github_star_message()
+            display_callback(message)
+
+            # Mark as shown and save
+            MarketingManager.mark_message_shown(
+                config.marketing, GITHUB_STAR_MESSAGE_ID
+            )
+            await config_manager.save(config)