contextzip 0.4.2__tar.gz → 0.4.3__tar.gz

{contextzip-0.4.2 → contextzip-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contextzip
-Version: 0.4.2
+Version: 0.4.3
 Summary: Intelligently package your codebase for AI tools
 Author-email: Deepesh <akadeepesh@gmail.com>
 License-Expression: MIT

{contextzip-0.4.2 → contextzip-0.4.3}/contextzip/__init__.py

@@ -1,6 +1,6 @@
 """contextzip — intelligent codebase packager for AI tools."""
 
-__version__ = "0.4.2"
+__version__ = "0.4.3"
 
 from contextzip.api import (
     FileCollection,

{contextzip-0.4.2 → contextzip-0.4.3}/contextzip/applier.py

@@ -446,8 +446,24 @@ def build_plan(
     strip_prefix: str | None = None
     wrapper_note: str | None = None
     candidate = _detect_common_wrapper(raw_names)
-    if candidate and not (project_dir / candidate).is_dir():
+    if candidate:
         if manifest_files:
+            # Decide using the manifest — actual ground truth about what
+            # paths this project has — rather than whether a directory of
+            # that name merely happens to exist on disk. That on-disk check
+            # used to gate this whole branch, which backfired on the most
+            # common real case: an AI tool wraps the whole project in a
+            # folder named after the project itself (e.g. "contextzip/"),
+            # and the project's own top-level package/dir happens to share
+            # that exact name — so the wrapper looked "legitimate" and was
+            # never stripped, dumping a nested copy of the project instead
+            # of updating the real files. Comparing manifest match-rates
+            # with vs without stripping gets both cases right: a genuine
+            # wrapper matches far better once stripped, while a zip whose
+            # top-level folder is an intentional part of the project (e.g.
+            # updates confined to an existing "docs/" folder) matches
+            # better *unstripped*, since those paths are already in the
+            # manifest as-is.
             unstripped_rate = _match_rate(raw_names, manifest_files)
             stripped_names = [n[len(candidate) + 1:] for n in raw_names]
             stripped_rate = _match_rate(stripped_names, manifest_files)
@@ -462,10 +478,12 @@ def build_plan(
                     f"project manifest after stripping vs {unstripped_rate:.0%} "
                     "before."
                 )
-        else:
+        elif not (project_dir / candidate).is_dir():
             # No manifest to confirm against, so this is a softer call —
             # still strip (matches how `tar` and GitHub's own zip downloads
-            # behave), but say so plainly since it's not manifest-verified.
+            # behave) as long as the project doesn't already have a real
+            # folder of that name, but say so plainly since it's not
+            # manifest-verified.
             strip_prefix = candidate
             wrapper_note = (
                 f"Removed wrapping folder '{candidate}/' present in every zip "

{contextzip-0.4.2 → contextzip-0.4.3}/contextzip/cli.py

@@ -74,6 +74,7 @@ from contextzip.cli_ai import (
 )
 from contextzip.cli_onboard import onboard_api_key
 from contextzip import cleanup as cleanup_mod
+from contextzip import updater as updater_mod
 
 console = Console()
 
@@ -688,6 +689,90 @@ def cmd_config(
     console.print()
 
 
+# ---------------------------------------------------------------------------
+# Subcommand: update
+# ---------------------------------------------------------------------------
+
+
+@main.command("update")
+@click.option(
+    "--check",
+    "check_only",
+    is_flag=True,
+    default=False,
+    help="Only check for a newer version — don't install anything.",
+)
+@click.option(
+    "--yes",
+    "-y",
+    is_flag=True,
+    default=False,
+    help="Skip the confirmation prompt and update immediately if available.",
+)
+def cmd_update(check_only: bool, yes: bool) -> None:
+    """
+    Check PyPI for a newer contextzip release and update in place.
+
+    \b
+    EXAMPLES
+      contextzip update              # check, then confirm before updating
+      contextzip update --yes        # update immediately if one is available
+      contextzip update --check      # only report the current/latest version
+      cz update                      # same command, short alias
+
+    \b
+    HOW IT WORKS
+      contextzip cuts frequent releases, so this beats remembering
+      `pip install --upgrade contextzip` by hand. It detects whether this
+      install came from pip, pipx, or uv tool and re-invokes the matching
+      one, upgrading the same interpreter that's currently running —
+      never a possibly-different "pip" found on PATH.
+    """
+    console.print()
+    with console.status("[cyan]Checking for updates…[/]", spinner="dots"):
+        check = updater_mod.check_latest_version()
+
+    if check.latest is None:
+        err(f"Could not check for updates: {check.error}")
+        info(f"You're on {check.current}. Try again later, or update manually:")
+        info("  pip install --upgrade contextzip")
+        console.print()
+        raise SystemExit(1)
+
+    if not check.update_available:
+        ok(f"You're up to date — contextzip {check.current}")
+        console.print()
+        return
+
+    info(f"Update available: {check.current} → {check.latest}")
+
+    if check_only:
+        info("Run contextzip update to install it.")
+        console.print()
+        return
+
+    if not yes:
+        proceed = click.confirm(f"  Update to {check.latest} now?", default=True)
+        if not proceed:
+            info("Not updating.")
+            console.print()
+            return
+
+    with console.status(f"[cyan]Updating to {check.latest}…[/]", spinner="dots"):
+        result = updater_mod.run_update()
+
+    console.print()
+    if result.ok:
+        ok(f"Updated to contextzip {check.latest}", f"via {result.method}")
+        info("Restart any running contextzip/watch sessions to pick it up.")
+    else:
+        err(f"Update via {result.method} failed")
+        if result.output:
+            console.print(f"[dim]{result.output}[/]")
+        info("You can also update manually: pip install --upgrade contextzip")
+    console.print()
+
+
 # Core execution logic (shared by main command + all subcommands)
 # ---------------------------------------------------------------------------
 

contextzip-0.4.3/contextzip/updater.py

@@ -0,0 +1,165 @@
+"""
+updater.py — Self-update support for `contextzip update` / `cz update`.
+
+contextzip cuts frequent releases, so re-running
+`pip install --upgrade contextzip` by hand every time gets old fast.
+This module:
+
+  1. Asks PyPI's JSON API for the latest published version.
+  2. Compares it against the version actually running (contextzip.__version__).
+  3. If newer, re-invokes pip (or pipx, if that's how contextzip was
+     installed) to upgrade in place.
+
+Never raises on network failure — a broken connection or PyPI hiccup
+should degrade to "couldn't check right now", not crash the CLI.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+
+from contextzip import __version__ as installed_version
+
+PYPI_URL = "https://pypi.org/pypi/contextzip/json"
+_TIMEOUT_SECS = 5
+
+
+# ---------------------------------------------------------------------------
+# Version comparison (no `packaging` dependency)
+# ---------------------------------------------------------------------------
+
+
+def _parse_version(v: str) -> tuple[int, ...]:
+    """
+    Turn "1.2.3" into (1, 2, 3) for comparison. Ignores any pre-release /
+    build suffix after the numeric core (e.g. "1.2.3rc1" -> (1, 2, 3)) —
+    good enough for "is there a newer release" without pulling in the
+    `packaging` library just for this.
+    """
+    core = v.strip().lstrip("v")
+    parts: list[int] = []
+    for chunk in core.split("."):
+        digits = ""
+        for ch in chunk:
+            if ch.isdigit():
+                digits += ch
+            else:
+                break
+        parts.append(int(digits) if digits else 0)
+    return tuple(parts) if parts else (0,)
+
+
+def is_newer(latest: str, current: str) -> bool:
+    """True if *latest* is a strictly newer version than *current*."""
+    a, b = _parse_version(latest), _parse_version(current)
+    length = max(len(a), len(b))
+    a = a + (0,) * (length - len(a))
+    b = b + (0,) * (length - len(b))
+    return a > b
+
+
+# ---------------------------------------------------------------------------
+# PyPI lookup
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class VersionCheck:
+    current: str
+    latest: str | None  # None if the lookup failed
+    error: str | None = None
+
+    @property
+    def update_available(self) -> bool:
+        return bool(self.latest) and is_newer(self.latest, self.current)
+
+
+def check_latest_version(timeout: float = _TIMEOUT_SECS) -> VersionCheck:
+    """
+    Query PyPI for the latest published contextzip version.
+
+    Uses httpx (already a hard dependency) but never lets a network
+    problem escape as an exception — callers always get a VersionCheck
+    back, with `.error` set on failure.
+    """
+    try:
+        import httpx
+
+        resp = httpx.get(PYPI_URL, timeout=timeout)
+        resp.raise_for_status()
+        data = resp.json()
+        latest = data.get("info", {}).get("version")
+        if not latest:
+            return VersionCheck(
+                current=installed_version, latest=None, error="Malformed PyPI response"
+            )
+        return VersionCheck(current=installed_version, latest=latest)
+    except Exception as exc:  # noqa: BLE001 — any network/parsing failure
+        return VersionCheck(
+            current=installed_version, latest=None, error=f"{type(exc).__name__}: {exc}"
+        )
+
+
+# ---------------------------------------------------------------------------
+# Install-method detection
+# ---------------------------------------------------------------------------
+
+
+def _installed_via_pipx() -> bool:
+    """
+    Best-effort guess at whether this contextzip was installed with pipx
+    rather than plain pip — pipx installs live under a `pipx/venvs/...`
+    path, which shows up in the interpreter's own executable path.
+    """
+    exe = sys.executable.replace("\\", "/").lower()
+    return "pipx" in exe
+
+
+def _installed_via_uv_tool() -> bool:
+    exe = sys.executable.replace("\\", "/").lower()
+    return "/uv/tools/" in exe or "\\uv\\tools\\" in sys.executable.lower()
+
+
+@dataclass
+class UpdateResult:
+    ok: bool
+    method: str
+    output: str
+
+
+def run_update(timeout: float = 120) -> UpdateResult:
+    """
+    Upgrade the installed contextzip package to the latest PyPI release.
+
+    Picks the tool that matches how contextzip was installed:
+      - pipx, if this interpreter lives inside a pipx venv and the pipx
+        executable is on PATH
+      - uv tool, if this interpreter lives inside a uv tool install
+      - otherwise `python -m pip install --upgrade contextzip`, using
+        the *currently running* interpreter's pip — never a bare "pip"
+        off PATH, which could silently target the wrong Python.
+    """
+    if _installed_via_pipx() and shutil.which("pipx"):
+        cmd = ["pipx", "upgrade", "contextzip"]
+        method = "pipx"
+    elif _installed_via_uv_tool() and shutil.which("uv"):
+        cmd = ["uv", "tool", "upgrade", "contextzip"]
+        method = "uv tool"
+    else:
+        cmd = [sys.executable, "-m", "pip", "install", "--upgrade", "contextzip"]
+        method = "pip"
+
+    try:
+        proc = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+        output = (proc.stdout or "") + (proc.stderr or "")
+        return UpdateResult(ok=proc.returncode == 0, method=method, output=output.strip())
+    except Exception as exc:  # noqa: BLE001
+        return UpdateResult(ok=False, method=method, output=f"{type(exc).__name__}: {exc}")

{contextzip-0.4.2 → contextzip-0.4.3}/contextzip/webui/assets.py

@@ -1148,6 +1148,17 @@ INDEX_HTML = r"""<!DOCTYPE html>
       document.getElementById("overlay").classList.add("show");
       setTimeout(function () {
         api("/api/shutdown", { method: "GET" }).catch(function () {});
+        // Try to close the tab automatically and hop back to the terminal.
+        // Browsers only allow script-initiated close on windows/tabs that
+        // were opened by a script, or ones whose entire session history is
+        // just this one page — which this config-UI tab always is, since
+        // it's a single page with no navigation. If the browser still
+        // blocks it (some do, regardless), window.close() is a silent
+        // no-op and the overlay's "you can close this tab" text — already
+        // on screen — is the fallback the user follows manually.
+        setTimeout(function () {
+          try { window.close(); } catch (e) { /* ignored — fallback is the overlay text */ }
+        }, 300);
       }, 900);
     }).catch(function () {
       btn.disabled = false;

{contextzip-0.4.2 → contextzip-0.4.3}/contextzip.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contextzip
-Version: 0.4.2
+Version: 0.4.3
 Summary: Intelligently package your codebase for AI tools
 Author-email: Deepesh <akadeepesh@gmail.com>
 License-Expression: MIT

{contextzip-0.4.2 → contextzip-0.4.3}/contextzip.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ contextzip/packager.py
 contextzip/project_config.py
 contextzip/redact.py
 contextzip/report.py
+contextzip/updater.py
 contextzip/watcher.py
 contextzip.egg-info/PKG-INFO
 contextzip.egg-info/SOURCES.txt

{contextzip-0.4.2 → contextzip-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "contextzip"
-version = "0.4.2"
+version = "0.4.3"
 description = "Intelligently package your codebase for AI tools"
 readme = "README.md"
 requires-python = ">=3.9"