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

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/env_utils.py

@@ -1,6 +1,19 @@
 """Utilities for working with environment variables."""
 
 
+def is_shotgun_account_enabled() -> bool:
+    """Check if Shotgun Account feature is enabled via environment variable.
+
+    Returns:
+        True always (Shotgun Account is now live for all users)
+
+    Note:
+        This function is deprecated and always returns True.
+        Shotgun Account is now available to all users by default.
+    """
+    return True
+
+
 def is_truthy(value: str | None) -> bool:
     """Check if a string value represents true.
 

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)

shotgun/utils/source_detection.py

@@ -0,0 +1,16 @@
+"""Utility for detecting the source of function calls (CLI vs TUI)."""
+
+import inspect
+
+
+def detect_source() -> str:
+    """Detect if the call originated from CLI or TUI by inspecting the call stack.
+
+    Returns:
+        "tui" if any frame in the call stack contains "tui" in the filename,
+        "cli" otherwise.
+    """
+    for frame_info in inspect.stack():
+        if "tui" in frame_info.filename.lower():
+            return "tui"
+    return "cli"

shotgun/utils/update_checker.py

@@ -5,7 +5,12 @@ import sys
 import threading
 from pathlib import Path
 
+import httpx
+from packaging import version
+
+from shotgun import __version__
 from shotgun.logging_config import get_logger
+from shotgun.settings import settings
 
 logger = get_logger(__name__)
 
@@ -14,8 +19,34 @@ def detect_installation_method() -> str:
     """Detect how shotgun-sh was installed.
 
     Returns:
-        Installation method: 'pipx', 'pip', 'venv', or 'unknown'.
+        Installation method: 'uvx', 'uv-tool', 'pipx', 'pip', 'venv', or 'unknown'.
     """
+    # Check for simulation environment variable (for testing)
+    if settings.dev.pipx_simulate:
+        logger.debug("SHOTGUN_PIPX_SIMULATE enabled, simulating pipx installation")
+        return "pipx"
+
+    # Check for uvx (ephemeral execution) by looking at executable path
+    # uvx runs from a temporary cache directory
+    executable = Path(sys.executable)
+    if ".cache/uv" in str(executable) or "uv/cache" in str(executable):
+        logger.debug("Detected uvx (ephemeral) execution")
+        return "uvx"
+
+    # Check for uv tool installation
+    try:
+        result = subprocess.run(
+            ["uv", "tool", "list"],  # noqa: S607, S603
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0 and "shotgun-sh" in result.stdout:
+            logger.debug("Detected uv tool installation")
+            return "uv-tool"
+    except (subprocess.SubprocessError, FileNotFoundError):
+        pass
+
     # Check for pipx installation
     try:
         result = subprocess.run(
@@ -55,7 +86,7 @@ def detect_installation_method() -> str:
 
 
 def perform_auto_update(no_update_check: bool = False) -> None:
-    """Perform automatic update if installed via pipx.
+    """Perform automatic update if installed via pipx or uv tool.
 
     Args:
         no_update_check: If True, skip the update.
@@ -64,23 +95,40 @@ def perform_auto_update(no_update_check: bool = False) -> None:
         return
 
     try:
-        # Only auto-update for pipx installations
-        if detect_installation_method() != "pipx":
-            logger.debug("Not a pipx installation, skipping auto-update")
+        method = detect_installation_method()
+
+        # Skip auto-update for ephemeral uvx executions
+        if method == "uvx":
+            logger.debug("uvx (ephemeral) execution, skipping auto-update")
             return
 
-        # Run pipx upgrade quietly
-        logger.debug("Running pipx upgrade shotgun-sh --quiet")
-        result = subprocess.run(
-            ["pipx", "upgrade", "shotgun-sh", "--quiet"],  # noqa: S607, S603
+        # Only auto-update for pipx and uv-tool installations
+        if method not in ["pipx", "uv-tool"]:
+            logger.debug(f"Installation method '{method}', skipping auto-update")
+            return
+
+        # Determine the appropriate upgrade command
+        if method == "pipx":
+            command = ["pipx", "upgrade", "shotgun-sh", "--quiet"]
+            logger.debug("Running pipx upgrade shotgun-sh --quiet")
+        elif method == "uv-tool":
+            command = ["uv", "tool", "upgrade", "shotgun-sh"]
+            logger.debug("Running uv tool upgrade shotgun-sh")
+        else:
+            return
+
+        # Run upgrade command
+        result = subprocess.run(  # noqa: S603, S607
+            command,
             capture_output=True,
             text=True,
             timeout=30,
         )
 
         if result.returncode == 0:
-            # Check if there was an actual update (pipx shows output even with --quiet for actual updates)
-            if result.stdout and "upgraded" in result.stdout.lower():
+            # Check if there was an actual update
+            output = result.stdout.lower()
+            if "upgraded" in output or "updated" in output:
                 logger.info("Shotgun-sh has been updated to the latest version")
         else:
             # Only log errors at debug level to not annoy users
@@ -110,13 +158,6 @@ def perform_auto_update_async(no_update_check: bool = False) -> threading.Thread
     return thread
 
 
-# Keep these for backward compatibility with the update CLI command
-import httpx  # noqa: E402
-from packaging import version  # noqa: E402
-
-from shotgun import __version__  # noqa: E402
-
-
 def is_dev_version(version_str: str | None = None) -> bool:
     """Check if the current or given version is a development version.
 
@@ -169,16 +210,18 @@ def compare_versions(current: str, latest: str) -> bool:
         return False
 
 
-def get_update_command(method: str) -> list[str]:
+def get_update_command(method: str) -> list[str] | None:
     """Get the appropriate update command based on installation method.
 
     Args:
-        method: Installation method ('pipx', 'pip', 'venv', or 'unknown').
+        method: Installation method ('uvx', 'uv-tool', 'pipx', 'pip', 'venv', or 'unknown').
 
     Returns:
-        Command list to execute for updating.
+        Command list to execute for updating, or None for uvx (ephemeral).
     """
     commands = {
+        "uvx": None,  # uvx is ephemeral, no update command
+        "uv-tool": ["uv", "tool", "upgrade", "shotgun-sh"],
         "pipx": ["pipx", "upgrade", "shotgun-sh"],
         "pip": [sys.executable, "-m", "pip", "install", "--upgrade", "shotgun-sh"],
         "venv": [sys.executable, "-m", "pip", "install", "--upgrade", "shotgun-sh"],
@@ -213,6 +256,15 @@ def perform_update(force: bool = False) -> tuple[bool, str]:
     method = detect_installation_method()
     command = get_update_command(method)
 
+    # Handle uvx (ephemeral) installations
+    if method == "uvx" or command is None:
+        return (
+            False,
+            "You're running shotgun-sh via uvx (ephemeral mode). "
+            "To get the latest version, simply run 'uvx shotgun-sh' again, "
+            "or install permanently with 'uv tool install shotgun-sh'.",
+        )
+
     # Perform update
     try:
         logger.info(f"Updating shotgun-sh using {method}...")