shotgun-sh 0.2.10.dev2__tar.gz → 0.2.10.dev4__tar.gz

{shotgun_sh-0.2.10.dev2 → shotgun_sh-0.2.10.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.2.10.dev2
+Version: 0.2.10.dev4
 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
@@ -84,13 +84,30 @@ Every research finding, every architectural decision, every "here's why we didn'
 
 ## Installation
 
-### Using pipx (Recommended)
+### Using uvx (Recommended)
+
+**Quick start (ephemeral):**
+```bash
+uvx shotgun-sh
+```
+
+**Install permanently:**
+```bash
+uv tool install shotgun-sh
+```
+
+**Why uvx?** It's 10-100x faster than pipx and handles binary wheels more reliably. If you don't have `uv` installed, get it at [astral.sh/uv](https://astral.sh/uv) or `curl -LsSf https://astral.sh/uv/install.sh | sh`
+
+### Using pipx
 
 ```bash
 pipx install shotgun-sh
 ```
 
-**Why pipx?** It installs Shotgun in an isolated environment, preventing dependency conflicts with your other Python projects.
+If you encounter build errors with kuzu on macOS:
+```bash
+pipx install --pip-args="--only-binary kuzu" shotgun-sh
+```
 
 ### Using pip
 

{shotgun_sh-0.2.10.dev2 → shotgun_sh-0.2.10.dev4}/README.md

@@ -10,7 +10,35 @@ A Python CLI tool for research, planning, and task management powered by AI agen
 
 ## Installation
 
-### From PyPI (Recommended)
+### Using uvx (Recommended)
+
+**Quick start (ephemeral):**
+```bash
+uvx shotgun-sh
+```
+
+**Install permanently:**
+```bash
+uv tool install shotgun-sh
+```
+
+**Why uvx?** It's 10-100x faster than pipx and handles binary wheels more reliably. If you don't have `uv` installed, get it at [astral.sh/uv](https://astral.sh/uv) or:
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+### Using pipx
+
+```bash
+pipx install shotgun-sh
+```
+
+If you encounter build errors with kuzu on macOS:
+```bash
+pipx install --pip-args="--only-binary kuzu" shotgun-sh
+```
+
+### Using pip
 
 ```bash
 pip install shotgun-sh
@@ -115,6 +143,8 @@ shotgun --no-update-check research "topic"
 ### Installation Methods
 
 The update command automatically detects and uses the appropriate method:
+- **uvx**: Run `uvx shotgun-sh` again or use `uv tool install shotgun-sh` for permanent installation
+- **uv tool**: `uv tool upgrade shotgun-sh`
 - **pipx**: `pipx upgrade shotgun-sh`
 - **pip**: `pip install --upgrade shotgun-sh`
 - **venv**: Updates within the virtual environment

{shotgun_sh-0.2.10.dev2 → shotgun_sh-0.2.10.dev4}/README_PYPI.md

@@ -28,13 +28,30 @@ Every research finding, every architectural decision, every "here's why we didn'
 
 ## Installation
 
-### Using pipx (Recommended)
+### Using uvx (Recommended)
+
+**Quick start (ephemeral):**
+```bash
+uvx shotgun-sh
+```
+
+**Install permanently:**
+```bash
+uv tool install shotgun-sh
+```
+
+**Why uvx?** It's 10-100x faster than pipx and handles binary wheels more reliably. If you don't have `uv` installed, get it at [astral.sh/uv](https://astral.sh/uv) or `curl -LsSf https://astral.sh/uv/install.sh | sh`
+
+### Using pipx
 
 ```bash
 pipx install shotgun-sh
 ```
 
-**Why pipx?** It installs Shotgun in an isolated environment, preventing dependency conflicts with your other Python projects.
+If you encounter build errors with kuzu on macOS:
+```bash
+pipx install --pip-args="--only-binary kuzu" shotgun-sh
+```
 
 ### Using pip
 

{shotgun_sh-0.2.10.dev2 → shotgun_sh-0.2.10.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shotgun-sh"
-version = "0.2.10.dev2"
+version = "0.2.10.dev4"
 description = "AI-powered research, planning, and task management CLI tool"
 readme = "README_PYPI.md"
 license = { text = "MIT" }
@@ -163,3 +163,6 @@ exclude_lines = [
 precision = 2
 skip_covered = false
 show_missing = true
+
+[tool.uv.pip]
+only-binary = ["kuzu"]

{shotgun_sh-0.2.10.dev2 → shotgun_sh-0.2.10.dev4}/src/shotgun/cli/update.py

@@ -45,7 +45,7 @@ def update(
 
     This command will:
     - Check PyPI for the latest version
-    - Detect your installation method (pipx, pip, or venv)
+    - Detect your installation method (uvx, uv-tool, pipx, pip, or venv)
     - Perform the appropriate upgrade command
 
     Examples:
@@ -93,6 +93,8 @@ def update(
         )
         console.print(
             "Use --force to update anyway, or install the stable version with:\n"
+            "  uv tool install shotgun-sh\n"
+            "  or\n"
             "  pipx install shotgun-sh\n"
             "  or\n"
             "  pip install shotgun-sh",
@@ -134,7 +136,19 @@ def update(
             console.print(f"\n[red]✗[/red] {message}", style="bold red")
 
             # Provide manual update instructions
-            if method == "pipx":
+            if method == "uvx":
+                console.print(
+                    "\n[yellow]Run uvx again to use the latest version:[/yellow]\n"
+                    "  uvx shotgun-sh\n"
+                    "\n[yellow]Or install permanently:[/yellow]\n"
+                    "  uv tool install shotgun-sh"
+                )
+            elif method == "uv-tool":
+                console.print(
+                    "\n[yellow]Try updating manually:[/yellow]\n"
+                    "  uv tool upgrade shotgun-sh"
+                )
+            elif method == "pipx":
                 console.print(
                     "\n[yellow]Try updating manually:[/yellow]\n"
                     "  pipx upgrade shotgun-sh"

{shotgun_sh-0.2.10.dev2 → shotgun_sh-0.2.10.dev4}/src/shotgun/utils/update_checker.py

@@ -18,8 +18,29 @@ 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 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 +80,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 +89,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 +204,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 +250,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}...")