shotgun-sh 0.1.6__py3-none-any.whl → 0.1.8.dev1__py3-none-any.whl

shotgun/build_constants.py

@@ -12,8 +12,8 @@ POSTHOG_API_KEY = ''
 POSTHOG_PROJECT_ID = '191396'
 
 # Logfire configuration embedded at build time (only for dev builds)
-LOGFIRE_ENABLED = ''
-LOGFIRE_TOKEN = ''
+LOGFIRE_ENABLED = 'true'
+LOGFIRE_TOKEN = 'pylf_v1_us_KZ5NM1pP3NwgJkbBJt6Ftdzk8mMhmrXcGJHQQgDJ1LfK'
 
 # Build metadata
 BUILD_TIME_ENV = "production" if SENTRY_DSN else "development"

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 check_for_updates_async
 
 # Load environment variables from .env file
 load_dotenv()
@@ -52,7 +52,6 @@ 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:
@@ -61,13 +60,6 @@ def _update_callback(notification: str) -> None:
     _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",
     help="Shotgun - AI-powered CLI tool for research, planning, and task management",
@@ -129,12 +121,10 @@ def main(
     """Shotgun - AI-powered CLI tool."""
     logger.debug("Starting shotgun CLI application")
 
-    # Start async update check and install (non-blocking)
+    # Start async update check (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,
+        check_for_updates_async(
+            callback=_update_callback, no_update_check=no_update_check
         )
 
     if ctx.invoked_subcommand is None and not ctx.resilient_parsing:

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 check_for_updates_async
 
 from .screens.chat import ChatScreen
 from .screens.directory_setup import DirectorySetupScreen
@@ -37,26 +37,16 @@ class ShotgunApp(App[None]):
         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
+        # Start async update check
         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,
-            )
+            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}")
 
-    def _update_progress_callback(self, progress: str) -> None:
-        """Store update progress."""
-        self.update_progress = progress
-        logger.debug(f"Update progress: {progress}")
-
     def on_mount(self) -> None:
         self.theme = "gruvbox"
         # Track TUI startup

shotgun/utils/update_checker.py

@@ -249,9 +249,6 @@ def perform_update(force: bool = False) -> tuple[bool, str]:
     if not compare_versions(__version__, latest):
         return False, f"Already at latest version ({__version__})"
 
-    # Store current version for comparison
-    current_version = __version__
-
     # Detect installation method
     method = detect_installation_method()
     command = get_update_command(method)
@@ -263,114 +260,8 @@ def perform_update(force: bool = False) -> tuple[bool, str]:
 
         result = subprocess.run(command, capture_output=True, text=True, timeout=60)  # noqa: S603
 
-        # Log output for debugging
-        if result.stdout:
-            logger.debug(f"Update stdout: {result.stdout}")
-        if result.stderr:
-            logger.debug(f"Update stderr: {result.stderr}")
-        logger.debug(f"Update return code: {result.returncode}")
-
-        # Check for success patterns in output (pipx specific)
-        output_combined = (result.stdout or "") + (result.stderr or "")
-
-        # For pipx, check if it mentions successful upgrade or already at latest
-        pipx_success_patterns = [
-            "successfully upgraded",
-            "is already at latest version",
-            f"installed package shotgun-sh {latest}",
-            "upgrading shotgun-sh...",
-        ]
-
-        pipx_success = method == "pipx" and any(
-            pattern.lower() in output_combined.lower()
-            for pattern in pipx_success_patterns
-        )
-
-        # Verify actual installation by checking version
-        update_successful = False
-
-        # For pipx with return code 0, trust it succeeded
-        if method == "pipx" and result.returncode == 0:
-            update_successful = True
-            logger.debug("Pipx returned 0, trusting update succeeded")
-        elif result.returncode == 0 or pipx_success:
-            # Give the system a moment to update the package metadata
-            import time
-
-            time.sleep(1)
-
-            # Try to verify the installed version
-            try:
-                # For pipx, we need to check differently
-                if method == "pipx":
-                    # Use pipx list to verify the installed version
-                    verify_result = subprocess.run(
-                        ["pipx", "list", "--json"],  # noqa: S607
-                        capture_output=True,
-                        text=True,
-                        timeout=5,  # noqa: S603
-                    )
-                    if verify_result.returncode == 0:
-                        try:
-                            pipx_data = json.loads(verify_result.stdout)
-                            venvs = pipx_data.get("venvs", {})
-                            shotgun_info = venvs.get("shotgun-sh", {})
-                            metadata = shotgun_info.get("metadata", {})
-                            main_package = metadata.get("main_package", {})
-                            installed_version = main_package.get("package_version", "")
-                            if installed_version == latest:
-                                update_successful = True
-                                logger.debug(
-                                    f"Pipx verification successful: version {installed_version}"
-                                )
-                        except (json.JSONDecodeError, KeyError) as e:
-                            logger.debug(
-                                f"Pipx JSON parsing failed: {e}, trusting patterns"
-                            )
-                            update_successful = pipx_success
-                    else:
-                        # Fallback to checking with command
-                        import shutil
-
-                        shotgun_path = shutil.which("shotgun")
-                        if shotgun_path:
-                            verify_result = subprocess.run(  # noqa: S603
-                                [shotgun_path, "--version"],
-                                capture_output=True,
-                                text=True,
-                                timeout=5,
-                            )
-                            if (
-                                verify_result.returncode == 0
-                                and latest in verify_result.stdout
-                            ):
-                                update_successful = True
-                                logger.debug(
-                                    f"Version verification successful: {verify_result.stdout.strip()}"
-                                )
-                        else:
-                            update_successful = pipx_success
-                else:
-                    # For pip/venv, check with python module
-                    verify_result = subprocess.run(  # noqa: S603
-                        [sys.executable, "-m", "shotgun", "--version"],
-                        capture_output=True,
-                        text=True,
-                        timeout=5,
-                    )
-                    if verify_result.returncode == 0 and latest in verify_result.stdout:
-                        update_successful = True
-                        logger.debug(
-                            f"Version verification successful: {verify_result.stdout.strip()}"
-                        )
-            except Exception as e:
-                logger.debug(f"Version verification failed: {e}")
-                # If verification fails but initial command succeeded, trust it
-                if not update_successful:
-                    update_successful = result.returncode == 0 or pipx_success
-
-        if update_successful:
-            message = f"Successfully updated from {current_version} to {latest}"
+        if result.returncode == 0:
+            message = f"Successfully updated from {__version__} to {latest}"
             logger.info(message)
 
             # Clear cache to trigger fresh check next time
@@ -380,13 +271,7 @@ def perform_update(force: bool = False) -> tuple[bool, str]:
 
             return True, message
         else:
-            # Only use stderr for error message, stdout often contains normal progress
-            if result.stderr:
-                error_msg = f"Update failed: {result.stderr}"
-            elif result.returncode != 0:
-                error_msg = f"Update failed with exit code {result.returncode}: {result.stdout or 'No output'}"
-            else:
-                error_msg = "Update verification failed but command may have succeeded"
+            error_msg = f"Update failed: {result.stderr or result.stdout}"
             logger.error(error_msg)
             return False, error_msg
 
@@ -409,31 +294,6 @@ def format_update_notification(current: str, latest: str) -> str:
     return f"Update available: {current} → {latest}. Run 'shotgun update' to upgrade."
 
 
-def format_update_status(
-    status: str, current: str | None = None, latest: str | None = None
-) -> str:
-    """Format update status messages.
-
-    Args:
-        status: Status type ('installing', 'success', 'failed', 'checking').
-        current: Current version (optional).
-        latest: Latest version (optional).
-
-    Returns:
-        Formatted status message.
-    """
-    if status == "checking":
-        return "Checking for updates..."
-    elif status == "installing" and current and latest:
-        return f"Installing update: {current} → {latest}..."
-    elif status == "success" and latest:
-        return f"✓ Successfully updated to version {latest}. Restart your terminal to use the new version."
-    elif status == "failed":
-        return "Update failed. Run 'shotgun update' to try manually."
-    else:
-        return ""
-
-
 def check_for_updates_sync(no_update_check: bool = False) -> str | None:
     """Synchronously check for updates and return notification if available.
 
@@ -476,69 +336,6 @@ def check_for_updates_sync(no_update_check: bool = False) -> str | None:
     return None
 
 
-def check_and_install_updates_sync(no_update_check: bool = False) -> tuple[str, bool]:
-    """Synchronously check for updates and install if available.
-
-    Args:
-        no_update_check: If True, skip update checks and installation.
-
-    Returns:
-        Tuple of (status message, success boolean).
-    """
-    if no_update_check:
-        return "", False
-
-    if not should_check_for_updates(no_update_check):
-        return "", False
-
-    # Skip auto-install for development versions
-    if is_dev_version():
-        logger.debug("Skipping auto-install for development version")
-        return "", False
-
-    latest_version = get_latest_version()
-    if not latest_version:
-        return "", False
-    latest = latest_version  # Type narrowing
-
-    # Check if update is needed
-    if not compare_versions(__version__, latest):
-        # Already up to date, update cache
-        now = datetime.now(timezone.utc)
-        cache_data = UpdateCache(
-            last_check=now,
-            latest_version=latest,
-            current_version=__version__,
-            update_available=False,
-        )
-        save_cache(cache_data)
-        return "", False
-
-    # Perform the update
-    logger.info(f"Auto-installing update: {__version__} → {latest}")
-    success, message = perform_update(force=False)
-
-    if success:
-        # Clear cache on successful update
-        cache_file = get_cache_file()
-        if cache_file.exists():
-            cache_file.unlink()
-        return format_update_status("success", latest=latest), True
-    else:
-        # Update cache to mark that we tried and failed
-        # This prevents repeated attempts within the check interval
-        now = datetime.now(timezone.utc)
-        cache_data = UpdateCache(
-            last_check=now,
-            latest_version=latest,
-            current_version=__version__,
-            update_available=True,  # Still available, but we failed to install
-        )
-        save_cache(cache_data)
-        logger.warning(f"Auto-update failed: {message}")
-        return format_update_status("failed"), False
-
-
 def check_for_updates_async(
     callback: Callable[[str], None] | None = None, no_update_check: bool = False
 ) -> threading.Thread:
@@ -565,117 +362,6 @@ def check_for_updates_async(
     return thread
 
 
-def check_and_install_updates_async(
-    callback: Callable[[str], None] | None = None,
-    no_update_check: bool = False,
-    progress_callback: Callable[[str], None] | None = None,
-) -> threading.Thread:
-    """Asynchronously check for updates and install in a background thread.
-
-    Args:
-        callback: Optional callback function to call with final status message.
-        no_update_check: If True, skip update checks and installation.
-        progress_callback: Optional callback for progress updates.
-
-    Returns:
-        The thread object that was started.
-    """
-
-    def _check_and_install() -> None:
-        try:
-            # Send checking status if progress callback provided
-            if progress_callback:
-                progress_callback(format_update_status("checking"))
-
-            # Skip if disabled
-            if no_update_check:
-                return
-
-            # Skip for dev versions
-            if is_dev_version():
-                logger.debug("Skipping auto-install for development version")
-                return
-
-            # Check if we should check for updates
-            if not should_check_for_updates(no_update_check):
-                # Check cache to see if update is still pending
-                cache = load_cache()
-                if cache and cache.update_available:
-                    # We have a pending update from a previous check
-                    # Don't retry installation automatically to avoid repeated failures
-                    if callback:
-                        callback(
-                            format_update_notification(
-                                cache.current_version, cache.latest_version
-                            )
-                        )
-                return
-
-            # Get latest version
-            latest_version = get_latest_version()
-            if not latest_version:
-                return
-            latest = latest_version  # Type narrowing
-
-            # Check if update is needed
-            if not compare_versions(__version__, latest):
-                # Already up to date, update cache
-                now = datetime.now(timezone.utc)
-                cache_data = UpdateCache(
-                    last_check=now,
-                    latest_version=latest,
-                    current_version=__version__,
-                    update_available=False,
-                )
-                save_cache(cache_data)
-                logger.debug(f"Already at latest version ({__version__})")
-                return
-
-            # Send installing status
-            if progress_callback:
-                progress_callback(
-                    format_update_status(
-                        "installing", current=__version__, latest=latest
-                    )
-                )
-
-            # Perform the update
-            logger.info(f"Auto-installing update: {__version__} → {latest}")
-            success, message = perform_update(force=False)
-
-            if success:
-                # Clear cache on successful update
-                cache_file = get_cache_file()
-                if cache_file.exists():
-                    cache_file.unlink()
-
-                if callback:
-                    callback(format_update_status("success", latest=latest))
-            else:
-                # Update cache to mark that we tried and failed
-                now = datetime.now(timezone.utc)
-                cache_data = UpdateCache(
-                    last_check=now,
-                    latest_version=latest,
-                    current_version=__version__,
-                    update_available=True,
-                )
-                save_cache(cache_data)
-                logger.warning(f"Auto-update failed: {message}")
-
-                if callback:
-                    callback(format_update_status("failed"))
-
-        except Exception as e:
-            logger.debug(f"Error in async update check and install: {e}")
-            if callback:
-                callback(format_update_status("failed"))
-
-    thread = threading.Thread(target=_check_and_install, daemon=True)
-    thread.start()
-    return thread
-
-
 __all__ = [
     "UpdateCache",
     "is_dev_version",
@@ -685,8 +371,5 @@ __all__ = [
     "perform_update",
     "check_for_updates_async",
     "check_for_updates_sync",
-    "check_and_install_updates_async",
-    "check_and_install_updates_sync",
     "format_update_notification",
-    "format_update_status",
 ]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.1.6
+Version: 0.1.8.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.6.dist-info → shotgun_sh-0.1.8.dev1.dist-info}/RECORD

@@ -1,7 +1,7 @@
 shotgun/__init__.py,sha256=P40K0fnIsb7SKcQrFnXZ4aREjpWchVDhvM1HxI4cyIQ,104
-shotgun/build_constants.py,sha256=hDFr6eO0lwN0iCqHQ1A5s0D68txR8sYrTJLGa7tSi0o,654
+shotgun/build_constants.py,sha256=RXNxMz46HaB5jucgMVpw8a2yCJqjbhTOh0PddyEVMN8,713
 shotgun/logging_config.py,sha256=UKenihvgH8OA3W0b8ZFcItYaFJVe9MlsMYlcevyW1HY,7440
-shotgun/main.py,sha256=lFx8IsLIfMvOw6lMJGnzg8o9HKcuj59VxhjNgetMZP0,5854
+shotgun/main.py,sha256=5WEtPs5kwD1tdeWCnM-jIAwarcwQNc4dhaqdPKCyxug,5510
 shotgun/posthog_telemetry.py,sha256=usfaJ8VyqckLIbLgoj2yhuNyDh0VWA5EJPRr7a0dyVs,5054
 shotgun/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shotgun/sentry_telemetry.py,sha256=0W0o810ewFpIcdPsi_q4uKLiaP6zDYRRE5MHpIbQIPo,2954
@@ -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=AAoFQYw6A9_kVxB0c0p7g-BNdplexfZIQbrGDQ1m4KI,4407
+shotgun/tui/app.py,sha256=t0IAQbGr0lKKEoBVnp85DcmZ-V92bi79SjyEE2uKpuw,3990
 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
@@ -123,9 +123,9 @@ shotgun/tui/utils/mode_progress.py,sha256=lseRRo7kMWLkBzI3cU5vqJmS2ZcCjyRYf9Zwtv
 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=7zdNV1GbEKrUrduibDZ6OeUcuyz87Pihr3GKayL5Kxk,23944
-shotgun_sh-0.1.6.dist-info/METADATA,sha256=-PbbQuJfK6Wfn-eC2LKft13vdiEpFcT1QMtHPGv0m1w,11191
-shotgun_sh-0.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-shotgun_sh-0.1.6.dist-info/entry_points.txt,sha256=asZxLU4QILneq0MWW10saVCZc4VWhZfb0wFZvERnzfA,45
-shotgun_sh-0.1.6.dist-info/licenses/LICENSE,sha256=YebsZl590zCHrF_acCU5pmNt0pnAfD2DmAnevJPB1tY,1065
-shotgun_sh-0.1.6.dist-info/RECORD,,
+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,,