shotgun-sh 0.1.7__tar.gz → 0.1.8__tar.gz

{shotgun_sh-0.1.7 → shotgun_sh-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.1.7
+Version: 0.1.8
 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.7 → shotgun_sh-0.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shotgun-sh"
-version = "0.1.7"
+version = "0.1.8"
 description = "AI-powered research, planning, and task management CLI tool"
 readme = "README.md"
 license = { text = "MIT" }

{shotgun_sh-0.1.7 → shotgun_sh-0.1.8}/src/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_and_install_updates_async
+from shotgun.utils.update_checker import perform_auto_update_async
 
 # Load environment variables from .env file
 load_dotenv()
@@ -50,23 +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
-_update_progress: str | None = None
-
-
-def _update_callback(notification: str) -> None:
-    """Callback to store update notification."""
-    global _update_notification
-    _update_notification = notification
-
-
-def _update_progress_callback(progress: str) -> None:
-    """Callback to store update progress."""
-    global _update_progress
-    _update_progress = progress
-    logger.debug(f"Update progress: {progress}")
-
 
 app = typer.Typer(
     name="shotgun",
@@ -131,39 +114,17 @@ def main(
 
     # Start async update check and install (non-blocking)
     if not ctx.resilient_parsing:
-        check_and_install_updates_async(
-            callback=_update_callback,
-            no_update_check=no_update_check,
-            progress_callback=_update_progress_callback,
-        )
+        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_sh-0.1.7 → shotgun_sh-0.1.8}/src/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_and_install_updates_async
+from shotgun.utils.update_checker import perform_auto_update_async
 
 from .screens.chat import ChatScreen
 from .screens.directory_setup import DirectorySetupScreen
@@ -36,26 +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
-        self.update_progress: str | None = None
 
         # Start async update check and install
         if not no_update_check:
-            check_and_install_updates_async(
-                callback=self._update_callback,
-                no_update_check=no_update_check,
-                progress_callback=self._update_progress_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}")
-
-    def _update_progress_callback(self, progress: str) -> None:
-        """Store update progress."""
-        self.update_progress = progress
-        logger.debug(f"Update progress: {progress}")
+            perform_auto_update_async(no_update_check=no_update_check)
 
     def on_mount(self) -> None:
         self.theme = "gruvbox"
@@ -98,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_sh-0.1.8/src/shotgun/utils/update_checker.py

@@ -0,0 +1,247 @@
+"""Simple auto-update functionality for shotgun-sh CLI."""
+
+import subprocess
+import sys
+import threading
+from pathlib import Path
+
+from shotgun.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+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=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"
+
+    # 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 perform_auto_update(no_update_check: bool = False) -> None:
+    """Perform automatic update if installed via pipx.
+
+    Args:
+        no_update_check: If True, skip the update.
+    """
+    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
+
+        # 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,
+        )
+
+        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}")
+
+    except subprocess.TimeoutExpired:
+        logger.debug("Auto-update timed out")
+    except Exception as e:
+        logger.debug(f"Auto-update error: {e}")
+
+
+def perform_auto_update_async(no_update_check: bool = False) -> threading.Thread:
+    """Run auto-update in a background thread.
+
+    Args:
+        no_update_check: If True, skip the update.
+
+    Returns:
+        The thread object that was started.
+    """
+
+    def _run_update() -> None:
+        perform_auto_update(no_update_check)
+
+    thread = threading.Thread(target=_run_update, daemon=True)
+    thread.start()
+    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.
+
+    Args:
+        version_str: Version string to check. If None, uses current version.
+
+    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:
+    """Fetch the latest version from PyPI.
+
+    Returns:
+        Latest version string if successful, None otherwise.
+    """
+    try:
+        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) as e:
+        logger.debug(f"Failed to fetch latest version: {e}")
+    return None
+
+
+def compare_versions(current: str, latest: str) -> bool:
+    """Compare version strings to determine if update is available.
+
+    Args:
+        current: Current version string.
+        latest: Latest available version string.
+
+    Returns:
+        True if latest version is newer than current, False otherwise.
+    """
+    try:
+        current_v = version.parse(current)
+        latest_v = version.parse(latest)
+        return latest_v > current_v
+    except Exception as e:
+        logger.debug(f"Error comparing versions: {e}")
+        return False
+
+
+def get_update_command(method: str) -> list[str]:
+    """Get the appropriate update command based on installation method.
+
+    Args:
+        method: Installation method ('pipx', 'pip', 'venv', or 'unknown').
+
+    Returns:
+        Command list to execute for updating.
+    """
+    commands = {
+        "pipx": ["pipx", "upgrade", "shotgun-sh"],
+        "pip": [sys.executable, "-m", "pip", "install", "--upgrade", "shotgun-sh"],
+        "venv": [sys.executable, "-m", "pip", "install", "--upgrade", "shotgun-sh"],
+        "unknown": [sys.executable, "-m", "pip", "install", "--upgrade", "shotgun-sh"],
+    }
+    return commands.get(method, commands["unknown"])
+
+
+def perform_update(force: bool = False) -> tuple[bool, str]:
+    """Perform manual update of shotgun-sh (for CLI command).
+
+    Args:
+        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 update development version. Use --force to override."
+
+    # Get latest version
+    latest = get_latest_version()
+    if not latest:
+        return False, "Failed to fetch latest version from PyPI"
+
+    # Check if update is needed
+    if not compare_versions(__version__, latest):
+        return False, f"Already at latest version ({__version__})"
+
+    # Detect installation method
+    method = detect_installation_method()
+    command = get_update_command(method)
+
+    # Perform update
+    try:
+        logger.info(f"Updating shotgun-sh using {method}...")
+        logger.debug(f"Running command: {' '.join(command)}")
+
+        result = subprocess.run(command, capture_output=True, text=True, timeout=60)  # noqa: S603
+
+        if result.returncode == 0:
+            message = f"Successfully updated from {__version__} to {latest}"
+            logger.info(message)
+            return True, message
+        else:
+            error_msg = f"Update failed: {result.stderr or result.stdout}"
+            logger.error(error_msg)
+            return False, error_msg
+
+    except subprocess.TimeoutExpired:
+        return False, "Update command timed out"
+    except Exception as e:
+        return False, f"Update failed: {e}"
+
+
+__all__ = [
+    "detect_installation_method",
+    "perform_auto_update",
+    "perform_auto_update_async",
+    "is_dev_version",
+    "get_latest_version",
+    "compare_versions",
+    "get_update_command",
+    "perform_update",
+]