shotgun-sh 0.2.8.dev2__py3-none-any.whl → 0.2.17__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,263 @@
+# 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)
+            # Set the reactive attribute to trigger the PartialResponseWidget update
+            chat_history.partial_response = message
+            # Also update the full message list
+            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/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/update_checker.py

@@ -10,6 +10,7 @@ from packaging import version
 
 from shotgun import __version__
 from shotgun.logging_config import get_logger
+from shotgun.settings import settings
 
 logger = get_logger(__name__)
 
@@ -18,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(
@@ -59,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.
@@ -68,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
@@ -166,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"],
@@ -210,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}...")