shotgun-sh 0.1.8.dev1__py3-none-any.whl → 0.1.10.dev1__py3-none-any.whl

shotgun/agents/agent_manager.py

@@ -277,6 +277,8 @@ class AgentManager(Widget):
 
         # Clear file tracker before each run to track only this run's operations
         deps.file_tracker.clear()
+        # preprocess messages; maybe we need to include the user answer in the message history
+
         original_messages = self.ui_message_history.copy()
 
         if prompt:
@@ -477,11 +479,6 @@ class AgentManager(Widget):
                 elif isinstance(event, FunctionToolResultEvent):
                     request_message = ModelRequest(parts=[event.result])
                     state.messages.append(request_message)
-                    if (
-                        event.result.tool_name == "ask_user"
-                    ):  # special handling to ask_user, because deferred tool results mean we missed the user response
-                        self.ui_message_history.append(request_message)
-                        self._post_messages_updated()
                     ## this is what the user responded with
                     self._post_partial_message(is_last=False)
 

shotgun/main.py

@@ -22,7 +22,7 @@ from shotgun.posthog_telemetry import setup_posthog_observability
 from shotgun.sentry_telemetry import setup_sentry_observability
 from shotgun.telemetry import setup_logfire_observability
 from shotgun.tui import app as tui_app
-from shotgun.utils.update_checker import check_for_updates_async
+from shotgun.utils.update_checker import perform_auto_update_async
 
 # Load environment variables from .env file
 load_dotenv()
@@ -50,15 +50,6 @@ logger.debug("Sentry observability enabled: %s", _sentry_enabled)
 _posthog_enabled = setup_posthog_observability()
 logger.debug("PostHog analytics enabled: %s", _posthog_enabled)
 
-# Global variable to store update notification
-_update_notification: str | None = None
-
-
-def _update_callback(notification: str) -> None:
-    """Callback to store update notification."""
-    global _update_notification
-    _update_notification = notification
-
 
 app = typer.Typer(
     name="shotgun",
@@ -121,39 +112,19 @@ def main(
     """Shotgun - AI-powered CLI tool."""
     logger.debug("Starting shotgun CLI application")
 
-    # Start async update check (non-blocking)
+    # Start async update check and install (non-blocking)
     if not ctx.resilient_parsing:
-        check_for_updates_async(
-            callback=_update_callback, no_update_check=no_update_check
-        )
+        perform_auto_update_async(no_update_check=no_update_check)
 
     if ctx.invoked_subcommand is None and not ctx.resilient_parsing:
         logger.debug("Launching shotgun TUI application")
         tui_app.run(no_update_check=no_update_check, continue_session=continue_session)
-
-        # Show update notification after TUI exits
-        if _update_notification:
-            from rich.console import Console
-
-            console = Console()
-            console.print(f"\n[cyan]{_update_notification}[/cyan]", style="bold")
-
         raise typer.Exit()
 
-    # For CLI commands, we'll show notification at the end
-    # This is handled by registering an atexit handler
+    # For CLI commands, register PostHog shutdown handler
     if not ctx.resilient_parsing and ctx.invoked_subcommand is not None:
         import atexit
 
-        def show_update_notification() -> None:
-            if _update_notification:
-                from rich.console import Console
-
-                console = Console()
-                console.print(f"\n[cyan]{_update_notification}[/cyan]", style="bold")
-
-        atexit.register(show_update_notification)
-
         # Register PostHog shutdown handler
         def shutdown_posthog() -> None:
             from shotgun.posthog_telemetry import shutdown

shotgun/tui/app.py

@@ -9,7 +9,7 @@ from shotgun.agents.config import ConfigManager, get_config_manager
 from shotgun.logging_config import get_logger
 from shotgun.tui.screens.splash import SplashScreen
 from shotgun.utils.file_system_utils import get_shotgun_base_path
-from shotgun.utils.update_checker import check_for_updates_async
+from shotgun.utils.update_checker import perform_auto_update_async
 
 from .screens.chat import ChatScreen
 from .screens.directory_setup import DirectorySetupScreen
@@ -36,16 +36,10 @@ class ShotgunApp(App[None]):
         self.config_manager: ConfigManager = get_config_manager()
         self.no_update_check = no_update_check
         self.continue_session = continue_session
-        self.update_notification: str | None = None
 
-        # Start async update check
+        # Start async update check and install
         if not no_update_check:
-            check_for_updates_async(callback=self._update_callback)
-
-    def _update_callback(self, notification: str) -> None:
-        """Store update notification to show later."""
-        self.update_notification = notification
-        logger.debug(f"Update notification received: {notification}")
+            perform_auto_update_async(no_update_check=no_update_check)
 
     def on_mount(self) -> None:
         self.theme = "gruvbox"
@@ -88,13 +82,7 @@ class ShotgunApp(App[None]):
         return shotgun_dir.exists() and shotgun_dir.is_dir()
 
     async def action_quit(self) -> None:
-        """Override quit action to show update notification."""
-        if self.update_notification:
-            # Show notification before quitting
-            from rich.console import Console
-
-            console = Console()
-            console.print(f"\n[cyan]{self.update_notification}[/cyan]", style="bold")
+        """Quit the application."""
         self.exit()
 
     def get_system_commands(self, screen: Screen[Any]) -> Iterable[SystemCommand]:

shotgun/tui/screens/chat_screen/history.py

@@ -1,5 +1,5 @@
 import json
-from collections.abc import Sequence
+from collections.abc import Generator, Sequence
 
 from pydantic_ai.messages import (
     BuiltinToolCallPart,
@@ -19,6 +19,7 @@ from textual.reactive import reactive
 from textual.widget import Widget
 from textual.widgets import Markdown
 
+from shotgun.agents.models import UserAnswer
 from shotgun.tui.components.vertical_tail import VerticalTail
 from shotgun.tui.screens.chat_screen.hint_message import HintMessage, HintMessageWidget
 
@@ -86,7 +87,7 @@ class ChatHistory(Widget):
         self.vertical_tail = VerticalTail()
 
         with self.vertical_tail:
-            for item in self.items:
+            for item in self.filtered_items():
                 if isinstance(item, ModelRequest):
                     yield UserQuestionWidget(item)
                 elif isinstance(item, HintMessage):
@@ -98,6 +99,44 @@ class ChatHistory(Widget):
             )
         self.call_later(self.autoscroll)
 
+    def filtered_items(self) -> Generator[ModelMessage | HintMessage, None, None]:
+        for idx, next_item in enumerate(self.items):
+            prev_item = self.items[idx - 1] if idx > 0 else None
+
+            if isinstance(prev_item, ModelRequest) and isinstance(
+                next_item, ModelResponse
+            ):
+                ask_user_tool_response_part = next(
+                    (
+                        part
+                        for part in prev_item.parts
+                        if isinstance(part, ToolReturnPart)
+                        and part.tool_name == "ask_user"
+                    ),
+                    None,
+                )
+
+                ask_user_part = next(
+                    (
+                        part
+                        for part in next_item.parts
+                        if isinstance(part, ToolCallPart)
+                        and part.tool_name == "ask_user"
+                    ),
+                    None,
+                )
+
+                if not ask_user_part or not ask_user_tool_response_part:
+                    yield next_item
+                    continue
+                if (
+                    ask_user_tool_response_part.tool_call_id
+                    == ask_user_part.tool_call_id
+                ):
+                    continue  # don't emit tool call that happens after tool response
+
+            yield next_item
+
     def update_messages(self, messages: list[ModelMessage | HintMessage]) -> None:
         """Update the displayed messages without recomposing."""
         if not self.vertical_tail:
@@ -133,8 +172,8 @@ class UserQuestionWidget(Widget):
                     f"**>** {part.content if isinstance(part.content, str) else ''}\n\n"
                 )
             elif isinstance(part, ToolReturnPart):
-                if part.tool_name == "ask_user" and isinstance(part.content, dict):
-                    acc += f"**>** {part.content['answer']}\n\n"
+                if part.tool_name == "ask_user":
+                    acc += f"**>** {part.content.answer if isinstance(part.content, UserAnswer) else part.content['answer']}\n\n"
                 else:
                     # acc += "  ∟ finished\n\n"  # let's not show anything yet
                     pass

shotgun/utils/update_checker.py

@@ -1,125 +1,133 @@
-"""Auto-update functionality for shotgun-sh CLI."""
+"""Simple auto-update functionality for shotgun-sh CLI."""
 
-import json
 import subprocess
 import sys
 import threading
-from collections.abc import Callable
-from datetime import datetime, timedelta, timezone
 from pathlib import Path
 
-import httpx
-from packaging import version
-from pydantic import BaseModel, Field, ValidationError
-
-from shotgun import __version__
 from shotgun.logging_config import get_logger
-from shotgun.utils.file_system_utils import get_shotgun_home
 
 logger = get_logger(__name__)
 
-# Configuration constants
-UPDATE_CHECK_INTERVAL = timedelta(hours=24)
-PYPI_API_URL = "https://pypi.org/pypi/shotgun-sh/json"
-REQUEST_TIMEOUT = 5.0  # seconds
-
 
-def get_cache_file() -> Path:
-    """Get the path to the update cache file.
+def detect_installation_method() -> str:
+    """Detect how shotgun-sh was installed.
 
     Returns:
-        Path to the cache file in the shotgun home directory.
+        Installation method: 'pipx', 'pip', 'venv', or 'unknown'.
     """
-    return get_shotgun_home() / "check-update.json"
+    # Check for pipx installation
+    try:
+        result = subprocess.run(
+            ["pipx", "list", "--short"],  # noqa: S607
+            capture_output=True,
+            text=True,
+            timeout=5,  # noqa: S603
+        )
+        if "shotgun-sh" in result.stdout:
+            logger.debug("Detected pipx installation")
+            return "pipx"
+    except (subprocess.SubprocessError, FileNotFoundError):
+        pass
 
+    # Check if we're in a virtual environment
+    if hasattr(sys, "real_prefix") or (
+        hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix
+    ):
+        logger.debug("Detected virtual environment installation")
+        return "venv"
 
-class UpdateCache(BaseModel):
-    """Model for update check cache data."""
+    # Check for user installation
+    import site
 
-    last_check: datetime = Field(description="Last time update check was performed")
-    latest_version: str = Field(description="Latest version available on PyPI")
-    current_version: str = Field(description="Current installed version at check time")
-    update_available: bool = Field(
-        default=False, description="Whether an update is available"
-    )
+    user_site = site.getusersitepackages()
+    if user_site and Path(user_site).exists():
+        shotgun_path = Path(user_site) / "shotgun"
+        if shotgun_path.exists() or any(
+            p.exists() for p in Path(user_site).glob("shotgun_sh*")
+        ):
+            logger.debug("Detected pip --user installation")
+            return "pip"
 
+    # Default to pip if we can't determine
+    logger.debug("Could not detect installation method, defaulting to pip")
+    return "pip"
 
-def is_dev_version(version_str: str | None = None) -> bool:
-    """Check if the current or given version is a development version.
 
-    Args:
-        version_str: Version string to check. If None, uses current version.
+def perform_auto_update(no_update_check: bool = False) -> None:
+    """Perform automatic update if installed via pipx.
 
-    Returns:
-        True if version contains 'dev', False otherwise.
+    Args:
+        no_update_check: If True, skip the update.
     """
-    check_version = version_str or __version__
-    return "dev" in check_version.lower()
+    if no_update_check:
+        return
 
+    try:
+        # Only auto-update for pipx installations
+        if detect_installation_method() != "pipx":
+            logger.debug("Not a pipx installation, skipping auto-update")
+            return
 
-def load_cache() -> UpdateCache | None:
-    """Load the update check cache from disk.
+        # Run pipx upgrade quietly
+        logger.debug("Running pipx upgrade shotgun-sh --quiet")
+        result = subprocess.run(
+            ["pipx", "upgrade", "shotgun-sh", "--quiet"],  # noqa: S607, S603
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
 
-    Returns:
-        UpdateCache model if cache exists and is valid, None otherwise.
-    """
-    cache_file = get_cache_file()
-    if not cache_file.exists():
-        return None
+        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():
+                logger.info("Shotgun-sh has been updated to the latest version")
+        else:
+            # Only log errors at debug level to not annoy users
+            logger.debug(f"Auto-update check failed: {result.stderr or result.stdout}")
 
-    try:
-        with open(cache_file) as f:
-            data = json.load(f)
-            return UpdateCache.model_validate(data)
-    except (json.JSONDecodeError, OSError, PermissionError, ValidationError) as e:
-        logger.debug(f"Failed to load cache: {e}")
-        return None
+    except subprocess.TimeoutExpired:
+        logger.debug("Auto-update timed out")
+    except Exception as e:
+        logger.debug(f"Auto-update error: {e}")
 
 
-def save_cache(cache_data: UpdateCache) -> None:
-    """Save update check cache to disk.
+def perform_auto_update_async(no_update_check: bool = False) -> threading.Thread:
+    """Run auto-update in a background thread.
 
     Args:
-        cache_data: UpdateCache model containing cache data to save.
+        no_update_check: If True, skip the update.
+
+    Returns:
+        The thread object that was started.
     """
-    cache_file = get_cache_file()
 
-    try:
-        # Ensure the parent directory exists
-        cache_file.parent.mkdir(parents=True, exist_ok=True)
+    def _run_update() -> None:
+        perform_auto_update(no_update_check)
 
-        with open(cache_file, "w") as f:
-            json.dump(cache_data.model_dump(mode="json"), f, indent=2, default=str)
-    except (OSError, PermissionError) as e:
-        logger.debug(f"Failed to save cache: {e}")
+    thread = threading.Thread(target=_run_update, daemon=True)
+    thread.start()
+    return thread
 
 
-def should_check_for_updates(no_update_check: bool = False) -> bool:
-    """Determine if we should check for updates.
+# Keep these for backward compatibility with the update CLI command
+import httpx  # noqa: E402
+from packaging import version  # noqa: E402
 
-    Args:
-        no_update_check: If True, skip update checks.
+from shotgun import __version__  # noqa: E402
 
-    Returns:
-        True if update check should be performed, False otherwise.
-    """
-    # Skip if explicitly disabled
-    if no_update_check:
-        return False
 
-    # Skip if development version
-    if is_dev_version():
-        logger.debug("Skipping update check for development version")
-        return False
+def is_dev_version(version_str: str | None = None) -> bool:
+    """Check if the current or given version is a development version.
 
-    # Check cache to see if enough time has passed
-    cache = load_cache()
-    if not cache:
-        return True
+    Args:
+        version_str: Version string to check. If None, uses current version.
 
-    now = datetime.now(timezone.utc)
-    time_since_check = now - cache.last_check
-    return time_since_check >= UPDATE_CHECK_INTERVAL
+    Returns:
+        True if version contains 'dev', False otherwise.
+    """
+    check_version = version_str or __version__
+    return "dev" in check_version.lower()
 
 
 def get_latest_version() -> str | None:
@@ -129,20 +137,16 @@ def get_latest_version() -> str | None:
         Latest version string if successful, None otherwise.
     """
     try:
-        with httpx.Client(timeout=REQUEST_TIMEOUT) as client:
-            response = client.get(PYPI_API_URL)
+        with httpx.Client(timeout=5.0) as client:
+            response = client.get("https://pypi.org/pypi/shotgun-sh/json")
             response.raise_for_status()
-
             data = response.json()
             latest = data.get("info", {}).get("version")
-
             if latest:
                 logger.debug(f"Latest version from PyPI: {latest}")
                 return str(latest)
-
-    except (httpx.RequestError, httpx.HTTPStatusError, json.JSONDecodeError) as e:
+    except (httpx.RequestError, httpx.HTTPStatusError) as e:
         logger.debug(f"Failed to fetch latest version: {e}")
-
     return None
 
 
@@ -165,50 +169,6 @@ def compare_versions(current: str, latest: str) -> bool:
         return False
 
 
-def detect_installation_method() -> str:
-    """Detect how shotgun-sh was installed.
-
-    Returns:
-        Installation method: 'pipx', 'pip', 'venv', or 'unknown'.
-    """
-    # Check for pipx installation
-    try:
-        result = subprocess.run(
-            ["pipx", "list", "--short"],  # noqa: S607
-            capture_output=True,
-            text=True,
-            timeout=30,  # noqa: S603
-        )
-        if "shotgun-sh" in result.stdout:
-            logger.debug("Detected pipx installation")
-            return "pipx"
-    except (subprocess.SubprocessError, FileNotFoundError):
-        pass
-
-    # Check if we're in a virtual environment
-    if hasattr(sys, "real_prefix") or (
-        hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix
-    ):
-        logger.debug("Detected virtual environment installation")
-        return "venv"
-
-    # Check for user installation
-    import site
-
-    user_site = site.getusersitepackages()
-    if user_site and Path(user_site).exists():
-        shotgun_path = Path(user_site) / "shotgun"
-        if shotgun_path.exists() or any(
-            p.exists() for p in Path(user_site).glob("shotgun_sh*")
-        ):
-            logger.debug("Detected pip --user installation")
-            return "pip"
-
-    # Default to pip if we can't determine
-    logger.debug("Could not detect installation method, defaulting to pip")
-    return "pip"
-
-
 def get_update_command(method: str) -> list[str]:
     """Get the appropriate update command based on installation method.
 
@@ -228,17 +188,17 @@ def get_update_command(method: str) -> list[str]:
 
 
 def perform_update(force: bool = False) -> tuple[bool, str]:
-    """Perform the actual update of shotgun-sh.
+    """Perform manual update of shotgun-sh (for CLI command).
 
     Args:
-        force: If True, update even if it's a dev version (with confirmation).
+        force: If True, update even if it's a dev version.
 
     Returns:
         Tuple of (success, message).
     """
     # Check if dev version and not forced
     if is_dev_version() and not force:
-        return False, "Cannot auto-update development version. Use --force to override."
+        return False, "Cannot update development version. Use --force to override."
 
     # Get latest version
     latest = get_latest_version()
@@ -263,12 +223,6 @@ def perform_update(force: bool = False) -> tuple[bool, str]:
         if result.returncode == 0:
             message = f"Successfully updated from {__version__} to {latest}"
             logger.info(message)
-
-            # Clear cache to trigger fresh check next time
-            cache_file = get_cache_file()
-            if cache_file.exists():
-                cache_file.unlink()
-
             return True, message
         else:
             error_msg = f"Update failed: {result.stderr or result.stdout}"
@@ -281,95 +235,13 @@ def perform_update(force: bool = False) -> tuple[bool, str]:
         return False, f"Update failed: {e}"
 
 
-def format_update_notification(current: str, latest: str) -> str:
-    """Format a user-friendly update notification message.
-
-    Args:
-        current: Current version.
-        latest: Latest available version.
-
-    Returns:
-        Formatted notification string.
-    """
-    return f"Update available: {current} → {latest}. Run 'shotgun update' to upgrade."
-
-
-def check_for_updates_sync(no_update_check: bool = False) -> str | None:
-    """Synchronously check for updates and return notification if available.
-
-    Args:
-        no_update_check: If True, skip update checks.
-
-    Returns:
-        Update notification string if update available, None otherwise.
-    """
-    if not should_check_for_updates(no_update_check):
-        # Check cache for existing notification
-        cache = load_cache()
-        if cache and cache.update_available:
-            current = cache.current_version
-            latest = cache.latest_version
-            if compare_versions(current, latest):
-                return format_update_notification(current, latest)
-        return None
-
-    latest_version = get_latest_version()
-    if not latest_version:
-        return None
-    latest = latest_version  # Type narrowing - we know it's not None here
-
-    # Update cache
-    now = datetime.now(timezone.utc)
-    update_available = compare_versions(__version__, latest)
-
-    cache_data = UpdateCache(
-        last_check=now,
-        latest_version=latest,
-        current_version=__version__,
-        update_available=update_available,
-    )
-    save_cache(cache_data)
-
-    if update_available:
-        return format_update_notification(__version__, latest)
-
-    return None
-
-
-def check_for_updates_async(
-    callback: Callable[[str], None] | None = None, no_update_check: bool = False
-) -> threading.Thread:
-    """Asynchronously check for updates in a background thread.
-
-    Args:
-        callback: Optional callback function to call with notification string.
-        no_update_check: If True, skip update checks.
-
-    Returns:
-        The thread object that was started.
-    """
-
-    def _check_updates() -> None:
-        try:
-            notification = check_for_updates_sync(no_update_check)
-            if notification and callback:
-                callback(notification)
-        except Exception as e:
-            logger.debug(f"Error in async update check: {e}")
-
-    thread = threading.Thread(target=_check_updates, daemon=True)
-    thread.start()
-    return thread
-
-
 __all__ = [
-    "UpdateCache",
+    "detect_installation_method",
+    "perform_auto_update",
+    "perform_auto_update_async",
     "is_dev_version",
-    "should_check_for_updates",
     "get_latest_version",
-    "detect_installation_method",
+    "compare_versions",
+    "get_update_command",
     "perform_update",
-    "check_for_updates_async",
-    "check_for_updates_sync",
-    "format_update_notification",
 ]

{shotgun_sh-0.1.8.dev1.dist-info → shotgun_sh-0.1.10.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.1.8.dev1
+Version: 0.1.10.dev1
 Summary: AI-powered research, planning, and task management CLI tool
 Project-URL: Homepage, https://shotgun.sh/
 Project-URL: Repository, https://github.com/shotgun-sh/shotgun

{shotgun_sh-0.1.8.dev1.dist-info → shotgun_sh-0.1.10.dev1.dist-info}/RECORD

@@ -1,13 +1,13 @@
 shotgun/__init__.py,sha256=P40K0fnIsb7SKcQrFnXZ4aREjpWchVDhvM1HxI4cyIQ,104
 shotgun/build_constants.py,sha256=RXNxMz46HaB5jucgMVpw8a2yCJqjbhTOh0PddyEVMN8,713
 shotgun/logging_config.py,sha256=UKenihvgH8OA3W0b8ZFcItYaFJVe9MlsMYlcevyW1HY,7440
-shotgun/main.py,sha256=5WEtPs5kwD1tdeWCnM-jIAwarcwQNc4dhaqdPKCyxug,5510
+shotgun/main.py,sha256=qteehx2FyqPVvSRNawEMorybNiIrYfgVeqtMaASQcPw,4606
 shotgun/posthog_telemetry.py,sha256=usfaJ8VyqckLIbLgoj2yhuNyDh0VWA5EJPRr7a0dyVs,5054
 shotgun/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shotgun/sentry_telemetry.py,sha256=0W0o810ewFpIcdPsi_q4uKLiaP6zDYRRE5MHpIbQIPo,2954
 shotgun/telemetry.py,sha256=Ves6Ih3hshpKVNVAUUmwRdtW8NkTjFPg8hEqvFKZ0t0,3208
 shotgun/agents/__init__.py,sha256=8Jzv1YsDuLyNPFJyckSr_qI4ehTVeDyIMDW4omsfPGc,25
-shotgun/agents/agent_manager.py,sha256=xw9xNEwVU-P4NGqF8W6mzVw4HNqtSfegAN9atog7aEo,23813
+shotgun/agents/agent_manager.py,sha256=xSyra7R8s8RP2N0Oh1fYlwu46EB16npRNckzKGY-rGg,23578
 shotgun/agents/common.py,sha256=vt7ECq1rT6GR5Rt63t0whH0R0cydrk7Mty2KyPL8mEg,19045
 shotgun/agents/conversation_history.py,sha256=5J8_1yxdZiiWTq22aDio88DkBDZ4_Lh_p5Iy5_ENszc,3898
 shotgun/agents/conversation_manager.py,sha256=fxAvXbEl3Cl2ugJ4N9aWXaqZtkrnfj3QzwjWC4LFXwI,3514
@@ -102,7 +102,7 @@ shotgun/sdk/exceptions.py,sha256=qBcQv0v7ZTwP7CMcxZST4GqCsfOWtOUjSzGBo0-heqo,412
 shotgun/sdk/models.py,sha256=X9nOTUHH0cdkQW1NfnMEDu-QgK9oUsEISh1Jtwr5Am4,5496
 shotgun/sdk/services.py,sha256=J4PJFSxCQ6--u7rb3Ta-9eYtlYcxcbnzrMP6ThyCnw4,705
 shotgun/tui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-shotgun/tui/app.py,sha256=t0IAQbGr0lKKEoBVnp85DcmZ-V92bi79SjyEE2uKpuw,3990
+shotgun/tui/app.py,sha256=rNi1a2vIhu385-DylE1rYgVj3_cok65X_z1lEamrFqo,3445
 shotgun/tui/styles.tcss,sha256=ETyyw1bpMBOqTi5RLcAJUScdPWTvAWEqE9YcT0kVs_E,121
 shotgun/tui/commands/__init__.py,sha256=8D5lvtpqMW5-fF7Bg3oJtUzU75cKOv6aUaHYYszydU8,2518
 shotgun/tui/components/prompt_input.py,sha256=Ss-htqraHZAPaehGE4x86ij0veMjc4UgadMXpbdXr40,2229
@@ -117,15 +117,15 @@ shotgun/tui/screens/splash.py,sha256=E2MsJihi3c9NY1L28o_MstDxGwrCnnV7zdq00MrGAsw
 shotgun/tui/screens/chat_screen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shotgun/tui/screens/chat_screen/command_providers.py,sha256=55JIH9T8QnyHRsMoXhOi87FiVM-d6o7OKpCe82uDP9I,7840
 shotgun/tui/screens/chat_screen/hint_message.py,sha256=WOpbk8q7qt7eOHTyyHvh_IQIaublVDeJGaLpsxEk9FA,933
-shotgun/tui/screens/chat_screen/history.py,sha256=JjQOKjCZpLBcw9CMorkBjOt2U5Ikr81hEQRtQmhw_KM,7459
+shotgun/tui/screens/chat_screen/history.py,sha256=pmgtvPDcY4dyxLyMH0RrVmf8qBouW1hM99VSUn7XGPQ,8950
 shotgun/tui/utils/__init__.py,sha256=cFjDfoXTRBq29wgP7TGRWUu1eFfiIG-LLOzjIGfadgI,150
 shotgun/tui/utils/mode_progress.py,sha256=lseRRo7kMWLkBzI3cU5vqJmS2ZcCjyRYf9Zwtvc-v58,10931
 shotgun/utils/__init__.py,sha256=WinIEp9oL2iMrWaDkXz2QX4nYVPAm8C9aBSKTeEwLtE,198
 shotgun/utils/env_utils.py,sha256=8QK5aw_f_V2AVTleQQlcL0RnD4sPJWXlDG46fsHu0d8,1057
 shotgun/utils/file_system_utils.py,sha256=l-0p1bEHF34OU19MahnRFdClHufThfGAjQ431teAIp0,1004
-shotgun/utils/update_checker.py,sha256=Xf-7w3Pos3etzCoT771gJe2HLkA8_V2GrqWy7ni9UqA,11373
-shotgun_sh-0.1.8.dev1.dist-info/METADATA,sha256=Th2ky9U_hy_zxh_OP67Io7DJlWT9BjRAG61EAZb6OPE,11196
-shotgun_sh-0.1.8.dev1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-shotgun_sh-0.1.8.dev1.dist-info/entry_points.txt,sha256=asZxLU4QILneq0MWW10saVCZc4VWhZfb0wFZvERnzfA,45
-shotgun_sh-0.1.8.dev1.dist-info/licenses/LICENSE,sha256=YebsZl590zCHrF_acCU5pmNt0pnAfD2DmAnevJPB1tY,1065
-shotgun_sh-0.1.8.dev1.dist-info/RECORD,,
+shotgun/utils/update_checker.py,sha256=TorvPRLtTVVNrTdKFZCfhrz9CQfkJZa4Mi9vQgsppvM,7698
+shotgun_sh-0.1.10.dev1.dist-info/METADATA,sha256=lOgwJ67x2-dV2pZjAW8GpJsPaYhZia4C7b5Ta-XaYr8,11197
+shotgun_sh-0.1.10.dev1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+shotgun_sh-0.1.10.dev1.dist-info/entry_points.txt,sha256=asZxLU4QILneq0MWW10saVCZc4VWhZfb0wFZvERnzfA,45
+shotgun_sh-0.1.10.dev1.dist-info/licenses/LICENSE,sha256=YebsZl590zCHrF_acCU5pmNt0pnAfD2DmAnevJPB1tY,1065
+shotgun_sh-0.1.10.dev1.dist-info/RECORD,,