datex-studio-cli 0.3.4__tar.gz → 0.4.0__tar.gz

{datex_studio_cli-0.3.4 → datex_studio_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datex-studio-cli
-Version: 0.3.4
+Version: 0.4.0
 Summary: CLI for Datex Studio low-code platform, designed for LLM-based AI agents
 Project-URL: Homepage, https://github.com/datex/datex-studio-cli
 Project-URL: Documentation, https://github.com/datex/datex-studio-cli

{datex_studio_cli-0.3.4 → datex_studio_cli-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "datex-studio-cli"
-version = "0.3.4"
+version = "0.4.0"
 description = "CLI for Datex Studio low-code platform, designed for LLM-based AI agents"
 readme = "README.md"
 license = "MIT"

{datex_studio_cli-0.3.4 → datex_studio_cli-0.4.0}/src/dxs/__init__.py

@@ -1,4 +1,4 @@
 """Datex Studio CLI - Command-line interface for Datex Studio platform."""
 
-__version__ = "0.3.4"
+__version__ = "0.4.0"
 __app_name__ = "dxs"

{datex_studio_cli-0.3.4 → datex_studio_cli-0.4.0}/src/dxs/cli.py

@@ -162,6 +162,13 @@ class DxsGroup(click.Group):
     default=False,
     help="Show authentication environment variables for debugging",
 )
+@click.option(
+    "--no-update-check",
+    "no_update_check",
+    is_flag=True,
+    default=False,
+    help="Skip the PyPI update check for this invocation",
+)
 @click.pass_context
 def cli(
     ctx: click.Context,
@@ -177,6 +184,7 @@ def cli(
     save_path: str | None,
     force_overwrite: bool,
     diagnose_auth: bool,
+    no_update_check: bool,
 ) -> None:
     """Datex Studio CLI - Command-line interface for Datex Studio platform.
 
@@ -249,6 +257,9 @@ def cli(
     if diagnose_auth:
         _show_auth_diagnostics()
 
+    # Stash for the result_callback to honor --no-update-check
+    dxs_ctx.no_update_check = no_update_check
+
 
 def _mask_token(token: str | None, visible_chars: int = 8) -> str:
     """Mask a token for display, showing only first/last few characters.
@@ -366,6 +377,59 @@ def register_commands() -> None:
     cli.add_command(schema.schema)
 
 
+@cli.result_callback()
+@click.pass_context
+def _after_command(ctx: click.Context, result: Any, **kwargs: Any) -> Any:
+    """Run post-command hooks (currently: PyPI update notice)."""
+    from dxs.utils.update_check import maybe_show_update_notice
+
+    dxs_ctx: DxsContext | None = ctx.find_object(DxsContext)
+    skip = bool(dxs_ctx and dxs_ctx.no_update_check)
+    try:
+        maybe_show_update_notice(skip=skip)
+    except Exception:  # noqa: BLE001 - never let the update check break the CLI
+        pass
+    return result
+
+
+@cli.command("update")
+@click.option(
+    "--check",
+    "check_only",
+    is_flag=True,
+    default=False,
+    help="Print whether an update is available without prompting to install",
+)
+def update_cmd(check_only: bool) -> None:
+    """Check PyPI for a newer release and optionally upgrade in place."""
+    from dxs.utils.update_check import (
+        _fetch_latest_version,
+        _run_upgrade,
+        detect_upgrade_command,
+        is_newer,
+    )
+
+    click.echo(f"Current version: {__version__}", err=True)
+    click.echo("Checking PyPI...", err=True)
+    latest = _fetch_latest_version()
+    if latest is None:
+        click.echo("Could not reach PyPI. Check your network and try again.", err=True)
+        sys.exit(1)
+    click.echo(f"Latest on PyPI: {latest}", err=True)
+
+    if not is_newer(latest, __version__):
+        click.echo("You are on the latest version.", err=True)
+        return
+
+    upgrade_cmd = detect_upgrade_command()
+    click.echo(f"Upgrade command: {upgrade_cmd}", err=True)
+    if check_only:
+        return
+
+    if click.confirm("Upgrade now?", default=True, err=True):
+        sys.exit(_run_upgrade(upgrade_cmd))
+
+
 # Register commands when module loads
 register_commands()
 

{datex_studio_cli-0.3.4 → datex_studio_cli-0.4.0}/src/dxs/context.py

@@ -29,6 +29,7 @@ class DxsContext:
         self.save_path: str | None = None
         self.force_overwrite: bool = False
         self.explicit_output_format: bool = False
+        self.no_update_check: bool = False
 
     def output(self, data: Any, include_metadata: bool = True) -> None:
         """Output data in the configured format.

datex_studio_cli-0.4.0/src/dxs/utils/update_check.py

@@ -0,0 +1,221 @@
+"""PyPI update check.
+
+On each invocation, reads a cached "latest version on PyPI" entry. If a newer
+version is available and we're attached to an interactive terminal, prints a
+banner and offers to upgrade in place. The PyPI fetch happens in a background
+daemon thread so the user's command is never delayed.
+
+Environment / flag controls:
+- ``DXS_NO_UPDATE_CHECK=1`` disables both the check and the banner.
+- ``--no-update-check`` (CLI flag) does the same per-invocation.
+- ``DXS_UPDATE_CHECK_DEBUG=1`` surfaces sender errors (development only).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import subprocess
+import sys
+import threading
+import time
+from pathlib import Path
+from typing import Any
+
+import click
+
+from dxs import __version__
+from dxs.utils.paths import get_datex_home
+
+PYPI_URL = "https://pypi.org/pypi/datex-studio-cli/json"
+PACKAGE_NAME = "datex-studio-cli"
+CACHE_TTL_SECONDS = 24 * 60 * 60
+PROMPT_DEDUPE_SECONDS = 60 * 60  # at most one prompt per hour per machine
+HTTP_TIMEOUT_SECONDS = 2.0
+
+_CI_ENV_VARS = ("CI", "CONTINUOUS_INTEGRATION", "GITHUB_ACTIONS", "BUILDKITE", "TF_BUILD")
+
+
+def _cache_path() -> Path:
+    return get_datex_home() / "update_check.json"
+
+
+def _debug(msg: str) -> None:
+    if os.environ.get("DXS_UPDATE_CHECK_DEBUG", "").lower() in ("1", "true", "yes"):
+        click.echo(f"[update-check] {msg}", err=True)
+
+
+def is_disabled() -> bool:
+    """Return True if the update check has been disabled via env var."""
+    return os.environ.get("DXS_NO_UPDATE_CHECK", "").lower() in ("1", "true", "yes")
+
+
+def _is_ci() -> bool:
+    return any(os.environ.get(v) for v in _CI_ENV_VARS)
+
+
+def _read_cache() -> dict[str, Any] | None:
+    path = _cache_path()
+    if not path.exists():
+        return None
+    try:
+        data = json.loads(path.read_text())
+        if isinstance(data, dict):
+            return data
+    except (json.JSONDecodeError, OSError) as e:
+        _debug(f"cache read failed: {e}")
+    return None
+
+
+def _write_cache(data: dict[str, Any]) -> None:
+    try:
+        _cache_path().write_text(json.dumps(data))
+    except OSError as e:
+        _debug(f"cache write failed: {e}")
+
+
+def _fetch_latest_version() -> str | None:
+    """Fetch the latest version from PyPI. Returns None on any failure."""
+    try:
+        import httpx
+
+        response = httpx.get(PYPI_URL, timeout=HTTP_TIMEOUT_SECONDS)
+        response.raise_for_status()
+        latest = response.json()["info"]["version"]
+        return str(latest) if latest else None
+    except Exception as e:  # noqa: BLE001 - never let telemetry break the CLI
+        _debug(f"fetch failed: {e}")
+        return None
+
+
+def _refresh_cache_worker() -> None:
+    latest = _fetch_latest_version()
+    if not latest:
+        return
+    cache = _read_cache() or {}
+    cache["latest"] = latest
+    cache["checked_at"] = time.time()
+    _write_cache(cache)
+
+
+def _maybe_refresh_async(cache: dict[str, Any] | None) -> None:
+    """Spawn a daemon thread to refresh the cache if it's missing or stale."""
+    needs_refresh = cache is None or (time.time() - float(cache.get("checked_at", 0))) > CACHE_TTL_SECONDS
+    if not needs_refresh:
+        return
+    thread = threading.Thread(target=_refresh_cache_worker, daemon=True, name="dxs-update-check")
+    thread.start()
+
+
+_VERSION_RE = re.compile(r"^(\d+)(?:\.(\d+))?(?:\.(\d+))?")
+
+
+def _parse_version(v: str) -> tuple[int, int, int]:
+    """Parse an X.Y.Z version into a tuple. Pre-release suffixes are ignored.
+
+    Returns (0, 0, 0) on unparseable input — treated as oldest possible.
+    """
+    m = _VERSION_RE.match(v.strip())
+    if not m:
+        return (0, 0, 0)
+    return (int(m.group(1) or 0), int(m.group(2) or 0), int(m.group(3) or 0))
+
+
+def is_newer(candidate: str, current: str) -> bool:
+    """Return True if `candidate` is a newer version than `current`."""
+    return _parse_version(candidate) > _parse_version(current)
+
+
+def detect_upgrade_command() -> str:
+    """Best-effort detection of how dxs was installed.
+
+    Returns the shell command the user should run to upgrade.
+    """
+    exe = sys.executable
+    # uv tool installs land under ~/.local/share/uv/tools/<pkg>/...
+    if "/uv/tools/" in exe or "\\uv\\tools\\" in exe:
+        return f"uv tool upgrade {PACKAGE_NAME}"
+    # pipx installs land under ~/.local/pipx/venvs/<pkg>/...
+    if "/pipx/" in exe or "\\pipx\\" in exe:
+        return f"pipx upgrade {PACKAGE_NAME}"
+    # Fallback: pip in whatever interpreter the user is on
+    return f"{exe} -m pip install --upgrade {PACKAGE_NAME}"
+
+
+def _run_upgrade(command: str) -> int:
+    """Run the upgrade command and stream its output to the user.
+
+    Returns the subprocess exit code.
+    """
+    click.echo(f"Running: {command}", err=True)
+    try:
+        completed = subprocess.run(command, shell=True, check=False)
+        return completed.returncode
+    except Exception as e:  # noqa: BLE001
+        click.echo(f"Upgrade failed to start: {e}", err=True)
+        return 1
+
+
+def _interactive() -> bool:
+    """True only when stdin, stderr, and stdout are all attached to a TTY.
+
+    We require stdout TTY too, because piping/redirecting stdout is the strongest
+    signal that the user is consuming structured output programmatically and
+    won't appreciate a banner mid-stream.
+    """
+    return all(s.isatty() for s in (sys.stdin, sys.stderr, sys.stdout))
+
+
+def maybe_show_update_notice(skip: bool = False) -> None:
+    """Check the cache and, if a newer version is available, prompt to upgrade.
+
+    Always returns quickly — the network fetch happens in a background thread.
+
+    Args:
+        skip: If True, skip both the check and any cache refresh. Used to honor
+            ``--no-update-check``.
+    """
+    if skip or is_disabled() or _is_ci():
+        return
+    if not _interactive():
+        return
+
+    cache = _read_cache()
+    _maybe_refresh_async(cache)
+
+    if not cache:
+        return
+
+    latest = cache.get("latest")
+    if not isinstance(latest, str) or not is_newer(latest, __version__):
+        return
+
+    last_prompted = float(cache.get("last_prompted_at", 0))
+    if time.time() - last_prompted < PROMPT_DEDUPE_SECONDS:
+        return
+
+    upgrade_cmd = detect_upgrade_command()
+    click.echo("", err=True)
+    click.echo(
+        f"  dxs {latest} is available (you have {__version__})",
+        err=True,
+    )
+    click.echo(f"  Upgrade command: {upgrade_cmd}", err=True)
+
+    cache["last_prompted_at"] = time.time()
+    _write_cache(cache)
+
+    try:
+        if click.confirm("  Upgrade now?", default=False, err=True):
+            exit_code = _run_upgrade(upgrade_cmd)
+            if exit_code == 0:
+                click.echo(
+                    "  Upgrade complete. Re-run your command to use the new version.",
+                    err=True,
+                )
+            else:
+                click.echo(f"  Upgrade exited with code {exit_code}.", err=True)
+    except (click.Abort, EOFError):
+        click.echo("", err=True)
+        return