ggcode 1.1.1__tar.gz → 1.1.3__tar.gz

{ggcode-1.1.1 → ggcode-1.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ggcode
-Version: 1.1.1
+Version: 1.1.3
 Summary: Thin Python wrapper that installs the ggcode GitHub Release binary
 Author: topcheer
 License: MIT
@@ -12,10 +12,16 @@ Description-Content-Type: text/markdown
 
 # ggcode Python wrapper
 
-`ggcode` on PyPI is a thin Python wrapper for the `ggcode` terminal agent.
+`ggcode` on PyPI bootstraps the native `ggcode` terminal agent from GitHub Releases.
 
-It does not ship the platform binary inside the wheel. Instead, the wrapper downloads the latest
-matching `ggcode` GitHub Release on first run, caches it locally, and then launches it.
+When the bootstrap runs, it installs the real binary into a stable CLI location instead of keeping
+it in a wrapper-managed cache:
+
+- macOS / Linux: prefers `/usr/local/bin`, falls back to `~/.local/bin`
+- Windows: prefers `%USERPROFILE%\\AppData\\Local\\Programs\\ggcode\\bin`, falls back to `%USERPROFILE%\\.local\\bin`
+
+If that directory is not already on `PATH`, the bootstrap updates your PATH configuration and asks
+you to reopen the terminal so future `ggcode` launches resolve directly to the native binary.
 
 ## Install
 
@@ -29,12 +35,19 @@ Then run:
 ggcode
 ```
 
+If you ever need to rerun the bootstrap flow explicitly, you can also use:
+
+```bash
+ggcode-bootstrap
+```
+
 ## What it does
 
 - Detects your operating system and CPU architecture
 - Downloads the latest matching `ggcode` archive from GitHub Releases
 - Verifies the archive against `checksums.txt`
-- Extracts and caches the binary for future runs
+- Installs the real binary into a stable PATH location
+- Updates PATH so future `ggcode` launches bypass the Python wrapper
 
 ## Pin a specific ggcode release
 

ggcode-1.1.3/README.md

@@ -0,0 +1,70 @@
+# ggcode Python wrapper
+
+`ggcode` on PyPI bootstraps the native `ggcode` terminal agent from GitHub Releases.
+
+When the bootstrap runs, it installs the real binary into a stable CLI location instead of keeping
+it in a wrapper-managed cache:
+
+- macOS / Linux: prefers `/usr/local/bin`, falls back to `~/.local/bin`
+- Windows: prefers `%USERPROFILE%\\AppData\\Local\\Programs\\ggcode\\bin`, falls back to `%USERPROFILE%\\.local\\bin`
+
+If that directory is not already on `PATH`, the bootstrap updates your PATH configuration and asks
+you to reopen the terminal so future `ggcode` launches resolve directly to the native binary.
+
+## Install
+
+```bash
+pip install ggcode
+```
+
+Then run:
+
+```bash
+ggcode
+```
+
+If you ever need to rerun the bootstrap flow explicitly, you can also use:
+
+```bash
+ggcode-bootstrap
+```
+
+## What it does
+
+- Detects your operating system and CPU architecture
+- Downloads the latest matching `ggcode` archive from GitHub Releases
+- Verifies the archive against `checksums.txt`
+- Installs the real binary into a stable PATH location
+- Updates PATH so future `ggcode` launches bypass the Python wrapper
+
+## Pin a specific ggcode release
+
+By default, the wrapper always resolves the latest `ggcode` release.
+
+To force a specific release, set `GGCODE_INSTALL_VERSION`:
+
+```bash
+GGCODE_INSTALL_VERSION=vX.Y.Z ggcode
+```
+
+or:
+
+```bash
+GGCODE_INSTALL_VERSION=X.Y.Z ggcode
+```
+
+## Supported platforms
+
+- macOS
+- Linux
+- Windows
+
+Supported architectures:
+
+- x86_64 / amd64
+- arm64
+
+## Project links
+
+- Repository: https://github.com/topcheer/ggcode
+- Issues: https://github.com/topcheer/ggcode/issues

{ggcode-1.1.1 → ggcode-1.1.3}/ggcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ggcode
-Version: 1.1.1
+Version: 1.1.3
 Summary: Thin Python wrapper that installs the ggcode GitHub Release binary
 Author: topcheer
 License: MIT
@@ -12,10 +12,16 @@ Description-Content-Type: text/markdown
 
 # ggcode Python wrapper
 
-`ggcode` on PyPI is a thin Python wrapper for the `ggcode` terminal agent.
+`ggcode` on PyPI bootstraps the native `ggcode` terminal agent from GitHub Releases.
 
-It does not ship the platform binary inside the wheel. Instead, the wrapper downloads the latest
-matching `ggcode` GitHub Release on first run, caches it locally, and then launches it.
+When the bootstrap runs, it installs the real binary into a stable CLI location instead of keeping
+it in a wrapper-managed cache:
+
+- macOS / Linux: prefers `/usr/local/bin`, falls back to `~/.local/bin`
+- Windows: prefers `%USERPROFILE%\\AppData\\Local\\Programs\\ggcode\\bin`, falls back to `%USERPROFILE%\\.local\\bin`
+
+If that directory is not already on `PATH`, the bootstrap updates your PATH configuration and asks
+you to reopen the terminal so future `ggcode` launches resolve directly to the native binary.
 
 ## Install
 
@@ -29,12 +35,19 @@ Then run:
 ggcode
 ```
 
+If you ever need to rerun the bootstrap flow explicitly, you can also use:
+
+```bash
+ggcode-bootstrap
+```
+
 ## What it does
 
 - Detects your operating system and CPU architecture
 - Downloads the latest matching `ggcode` archive from GitHub Releases
 - Verifies the archive against `checksums.txt`
-- Extracts and caches the binary for future runs
+- Installs the real binary into a stable PATH location
+- Updates PATH so future `ggcode` launches bypass the Python wrapper
 
 ## Pin a specific ggcode release
 

ggcode-1.1.3/ggcode.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+ggcode = ggcode_release_installer.cli:main
+ggcode-bootstrap = ggcode_release_installer.cli:bootstrap_main

ggcode-1.1.3/ggcode_release_installer/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.1.3"

ggcode-1.1.3/ggcode_release_installer/cli.py

@@ -0,0 +1,344 @@
+from __future__ import annotations
+
+import errno
+import hashlib
+import json
+import os
+import platform
+import re
+import shutil
+import stat
+import subprocess
+import sys
+import tarfile
+import tempfile
+import urllib.parse
+import urllib.request
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path
+
+OWNER = "topcheer"
+REPO = "ggcode"
+MARKER_START = "# >>> ggcode PATH >>>"
+MARKER_END = "# <<< ggcode PATH <<<"
+METADATA = ".ggcode-wrapper.json"
+
+
+@dataclass
+class InstallResult:
+    binary_path: Path
+    install_dir: Path
+    version: str
+    path_updated: bool
+    installed_now: bool
+    needs_restart: bool
+    used_fallback: bool
+
+
+def normalize_version() -> str:
+    selected = os.environ.get("GGCODE_INSTALL_VERSION", "").strip()
+    if not selected or selected == "latest":
+        return "latest"
+    if selected.startswith("v"):
+        return selected
+    return f"v{selected}"
+
+
+def resolve_target() -> tuple[str, str]:
+    system = sys.platform
+    if system.startswith("linux"):
+        goos = "linux"
+    elif system == "darwin":
+        goos = "darwin"
+    elif system in ("win32", "cygwin"):
+        goos = "windows"
+    else:
+        raise RuntimeError(f"Unsupported platform: {system}")
+
+    machine = platform.machine().lower() or os.environ.get("PROCESSOR_ARCHITECTURE", "").lower()
+    if machine in ("x86_64", "amd64"):
+        arch = "x86_64"
+    elif machine in ("arm64", "aarch64"):
+        arch = "arm64"
+    else:
+        raise RuntimeError(f"Unsupported architecture: {machine or 'unknown'}")
+    return goos, arch
+
+
+def release_base(version: str) -> str:
+    if version == "latest":
+        return f"https://github.com/{OWNER}/{REPO}/releases/latest/download"
+    return f"https://github.com/{OWNER}/{REPO}/releases/download/{version}"
+
+
+def preferred_install_dirs() -> list[Path]:
+    home = Path.home()
+    if os.name == "nt":
+        return [
+            home / "AppData" / "Local" / "Programs" / "ggcode" / "bin",
+            home / ".local" / "bin",
+        ]
+    return [Path("/usr/local/bin"), home / ".local" / "bin"]
+
+
+def metadata_path(directory: Path) -> Path:
+    return directory / METADATA
+
+
+def download(url: str) -> bytes:
+    with urllib.request.urlopen(url) as response:
+        return response.read()
+
+
+def resolve_release_version(version: str) -> str:
+    if version != "latest":
+        return version
+
+    with urllib.request.urlopen(f"https://github.com/{OWNER}/{REPO}/releases/latest") as response:
+        final_url = response.geturl()
+
+    parsed = urllib.parse.urlparse(final_url)
+    parts = [part for part in parsed.path.split("/") if part]
+    if len(parts) < 4 or parts[-2] != "tag":
+        raise RuntimeError(f"Could not resolve latest ggcode release from {final_url}")
+    return urllib.parse.unquote(parts[-1])
+
+
+def parse_checksums(body: str) -> dict[str, str]:
+    checksums: dict[str, str] = {}
+    for raw_line in body.splitlines():
+        parts = raw_line.strip().split()
+        if len(parts) >= 2:
+            checksums[parts[-1]] = parts[0]
+    return checksums
+
+
+def read_metadata(directory: Path) -> dict[str, str] | None:
+    try:
+        return json.loads(metadata_path(directory).read_text(encoding="utf-8"))
+    except (FileNotFoundError, json.JSONDecodeError):
+        return None
+
+
+def write_metadata(directory: Path, version: str) -> None:
+    metadata_path(directory).write_text(json.dumps({"version": version}, indent=2) + "\n", encoding="utf-8")
+
+
+def existing_install(requested_version: str, binary_name: str) -> InstallResult | None:
+    for directory in preferred_install_dirs():
+        binary_path = directory / binary_name
+        if not binary_path.exists():
+            continue
+        metadata = read_metadata(directory) or {}
+        if requested_version != "latest" and metadata.get("version") != requested_version:
+            continue
+        path_updated = ensure_installed_path(directory)
+        return InstallResult(
+            binary_path=binary_path,
+            install_dir=directory,
+            version=metadata.get("version", "unknown"),
+            path_updated=path_updated,
+            installed_now=False,
+            needs_restart=path_updated,
+            used_fallback=directory != preferred_install_dirs()[0],
+        )
+    return None
+
+
+def ensure_installed() -> InstallResult:
+    requested_version = normalize_version()
+    goos, arch = resolve_target()
+    archive_ext = ".zip" if goos == "windows" else ".tar.gz"
+    archive_name = f"ggcode_{goos}_{arch}{archive_ext}"
+    binary_name = "ggcode.exe" if goos == "windows" else "ggcode"
+
+    existing = existing_install(requested_version, binary_name)
+    if existing is not None:
+        return existing
+
+    version = resolve_release_version(requested_version)
+    base = release_base(version)
+    archive = download(f"{base}/{archive_name}")
+    checksums = parse_checksums(download(f"{base}/checksums.txt").decode("utf-8"))
+    expected = checksums.get(archive_name)
+    if not expected:
+        raise RuntimeError(f"Checksum for {archive_name} not found")
+    actual = hashlib.sha256(archive).hexdigest()
+    if actual.lower() != expected.lower():
+        raise RuntimeError(f"Checksum mismatch for {archive_name}")
+
+    with tempfile.TemporaryDirectory(prefix="ggcode-py-") as temp_dir:
+        temp_root = Path(temp_dir)
+        archive_path = temp_root / archive_name
+        archive_path.write_bytes(archive)
+        extract_dir = temp_root / "extract"
+        extract_dir.mkdir(parents=True, exist_ok=True)
+
+        if archive_ext == ".zip":
+            with zipfile.ZipFile(archive_path) as zf:
+                zf.extractall(extract_dir)
+        else:
+            with tarfile.open(archive_path, "r:gz") as tf:
+                tf.extractall(extract_dir)
+
+        extracted = next((p for p in extract_dir.rglob(binary_name) if p.is_file()), None)
+        if extracted is None:
+            raise RuntimeError(f"Could not find {binary_name} in {archive_name}")
+
+        last_error: Exception | None = None
+        preferred = preferred_install_dirs()
+        for index, install_dir in enumerate(preferred):
+            try:
+                binary_path = install_binary(extracted, install_dir / binary_name, version)
+                path_updated = ensure_installed_path(install_dir)
+                return InstallResult(
+                    binary_path=binary_path,
+                    install_dir=install_dir,
+                    version=version,
+                    path_updated=path_updated,
+                    installed_now=True,
+                    needs_restart=path_updated,
+                    used_fallback=index > 0,
+                )
+            except OSError as exc:
+                last_error = exc
+                if not is_permission_error(exc) or index == len(preferred) - 1:
+                    break
+
+        if last_error is not None:
+            raise RuntimeError(f"Failed to install ggcode: {last_error}") from last_error
+
+    raise RuntimeError("Failed to install ggcode")
+
+
+def install_binary(source: Path, destination: Path, version: str) -> Path:
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    temp_path = destination.with_name(f"{destination.name}.tmp-{os.getpid()}")
+    shutil.copy2(source, temp_path)
+    if os.name != "nt":
+        current_mode = temp_path.stat().st_mode
+        temp_path.chmod(current_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+    os.replace(temp_path, destination)
+    write_metadata(destination.parent, version)
+    return destination
+
+
+def is_permission_error(exc: OSError) -> bool:
+    return exc.errno in {errno.EACCES, errno.EPERM}
+
+
+def ensure_installed_path(directory: Path) -> bool:
+    entries = path_entries(os.environ.get("PATH", ""))
+    if any(same_path(entry, directory) for entry in entries):
+        return False
+    if os.name == "nt":
+        changed = ensure_windows_user_path(directory)
+    else:
+        changed = ensure_unix_path(directory)
+    os.environ["PATH"] = os.pathsep.join([str(directory), *entries])
+    return changed
+
+
+def path_entries(value: str) -> list[str]:
+    return [entry.strip() for entry in value.split(os.pathsep) if entry.strip()]
+
+
+def same_path(left: str | Path, right: str | Path) -> bool:
+    left_path = os.path.abspath(os.fspath(left))
+    right_path = os.path.abspath(os.fspath(right))
+    if os.name == "nt":
+        left_path = left_path.rstrip("\\/").lower()
+        right_path = right_path.rstrip("\\/").lower()
+    return left_path == right_path
+
+
+def ensure_windows_user_path(directory: Path) -> bool:
+    escaped_dir = str(directory).replace("'", "''")
+    script = (
+        f"$dir = '{escaped_dir}'; "
+        "$current = [Environment]::GetEnvironmentVariable('Path', 'User'); "
+        "$parts = @(); "
+        "if ($current) { $parts = $current -split ';' | Where-Object { $_ -and $_.Trim() -ne '' } }; "
+        "$exists = $parts | Where-Object { $_.TrimEnd('\\\\') -ieq $dir.TrimEnd('\\\\') }; "
+        "if (-not $exists) { "
+        "  $new = @($dir) + $parts; "
+        "  [Environment]::SetEnvironmentVariable('Path', ($new -join ';'), 'User'); "
+        "  Write-Output 'updated' "
+        "} else { "
+        "  Write-Output 'unchanged' "
+        "}"
+    )
+    result = subprocess.run(
+        ["powershell", "-NoProfile", "-Command", script],
+        check=True,
+        text=True,
+        capture_output=True,
+    )
+    return result.stdout.strip() == "updated"
+
+
+def ensure_unix_path(directory: Path) -> bool:
+    changed = False
+    for target in profile_targets():
+        before = target.read_text(encoding="utf-8") if target.exists() else ""
+        after = upsert_path_block(before, directory)
+        if after != before:
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_text(after, encoding="utf-8")
+            changed = True
+    return changed
+
+
+def profile_targets() -> list[Path]:
+    home = Path.home()
+    shell = Path(os.environ.get("SHELL", "")).name
+    preferred: list[str] = []
+    if shell == "zsh":
+        preferred.extend([".zshrc", ".zprofile"])
+    elif shell == "bash":
+        preferred.extend([".bashrc", ".bash_profile"])
+    preferred.append(".profile")
+
+    existing = [".zshrc", ".zprofile", ".bashrc", ".bash_profile", ".profile"]
+    targets: list[Path] = []
+    for name in preferred + [name for name in existing if (home / name).exists()]:
+        path = home / name
+        if path not in targets:
+            targets.append(path)
+    return targets
+
+
+def upsert_path_block(content: str, directory: Path) -> str:
+    block = f'{MARKER_START}\nexport PATH="{directory}:$PATH"\n{MARKER_END}\n'
+    pattern = re.compile(re.escape(MARKER_START) + r"[\s\S]*?" + re.escape(MARKER_END) + r"\n?", re.MULTILINE)
+    if pattern.search(content):
+        return pattern.sub(block, content)
+    suffix = "\n" if content and not content.endswith("\n") else ""
+    return f"{content}{suffix}{block}"
+
+
+def print_install_message(result: InstallResult) -> None:
+    action = "installed" if result.installed_now else "already available"
+    print(f"ggcode {result.version} {action} at {result.binary_path}", file=sys.stderr)
+    if result.needs_restart:
+        print("Reopen your terminal, then run `ggcode` directly.", file=sys.stderr)
+    print("If you ever need to rerun the bootstrap flow, use `ggcode-bootstrap`.", file=sys.stderr)
+
+
+def main() -> int:
+    result = ensure_installed()
+    if result.installed_now or result.needs_restart:
+        print_install_message(result)
+    env = dict(os.environ)
+    env["GGCODE_WRAPPER_KIND"] = "python"
+    completed = subprocess.run([str(result.binary_path), *sys.argv[1:]], env=env)
+    return completed.returncode
+
+
+def bootstrap_main() -> int:
+    return main()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{ggcode-1.1.1 → ggcode-1.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ggcode"
-version = "1.1.1"
+version = "1.1.3"
 description = "Thin Python wrapper that installs the ggcode GitHub Release binary"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -18,6 +18,7 @@ Issues = "https://github.com/topcheer/ggcode/issues"
 
 [project.scripts]
 ggcode = "ggcode_release_installer.cli:main"
+ggcode-bootstrap = "ggcode_release_installer.cli:bootstrap_main"
 
 [tool.setuptools]
 packages = ["ggcode_release_installer"]

ggcode-1.1.3/tests/test_cli.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from ggcode_release_installer import cli
+
+
+class ResolveTargetTests(unittest.TestCase):
+    def test_normalize_version_defaults_to_latest(self) -> None:
+        with patch.dict(os.environ, {}, clear=True):
+            self.assertEqual(cli.normalize_version(), "latest")
+
+    def test_normalize_version_uses_explicit_override(self) -> None:
+        with patch.dict(os.environ, {"GGCODE_INSTALL_VERSION": "1.2.3"}, clear=True):
+            self.assertEqual(cli.normalize_version(), "v1.2.3")
+
+    def test_resolve_target_uses_platform_module_for_machine(self) -> None:
+        with patch.object(cli.sys, "platform", "darwin"):
+            with patch.object(cli.platform, "machine", return_value="arm64"):
+                self.assertEqual(cli.resolve_target(), ("darwin", "arm64"))
+
+    def test_resolve_target_falls_back_to_processor_architecture(self) -> None:
+        env = dict(os.environ, PROCESSOR_ARCHITECTURE="AMD64")
+        with patch.dict(os.environ, env, clear=True):
+            with patch.object(cli.sys, "platform", "win32"):
+                with patch.object(cli.platform, "machine", return_value=""):
+                    self.assertEqual(cli.resolve_target(), ("windows", "x86_64"))
+
+    def test_resolve_release_version_follows_latest_redirect(self) -> None:
+        response = unittest.mock.Mock()
+        response.geturl.return_value = "https://github.com/topcheer/ggcode/releases/tag/v9.9.9"
+        response.__enter__ = unittest.mock.Mock(return_value=response)
+        response.__exit__ = unittest.mock.Mock(return_value=False)
+        with patch.object(cli.urllib.request, "urlopen", return_value=response):
+            self.assertEqual(cli.resolve_release_version("latest"), "v9.9.9")
+
+
+class PathHandlingTests(unittest.TestCase):
+    def test_preferred_install_dirs_unix(self) -> None:
+        with patch.object(cli, "os") as fake_os:
+            fake_os.name = "posix"
+            with patch.object(cli.Path, "home", return_value=Path("/home/tester")):
+                dirs = cli.preferred_install_dirs()
+        self.assertEqual(dirs, [Path("/usr/local/bin"), Path("/home/tester/.local/bin")])
+
+    def test_upsert_path_block_appends_marker(self) -> None:
+        updated = cli.upsert_path_block("export FOO=bar\n", Path("/tmp/ggcode-bin"))
+        self.assertIn(cli.MARKER_START, updated)
+        self.assertIn('export PATH="/tmp/ggcode-bin:$PATH"', updated)
+
+    def test_upsert_path_block_replaces_existing_marker(self) -> None:
+        original = (
+            f"{cli.MARKER_START}\n"
+            'export PATH="/old/bin:$PATH"\n'
+            f"{cli.MARKER_END}\n"
+        )
+        updated = cli.upsert_path_block(original, Path("/new/bin"))
+        self.assertNotIn("/old/bin", updated)
+        self.assertIn('export PATH="/new/bin:$PATH"', updated)
+
+    def test_existing_install_uses_binary_without_resolving_latest(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            install_dir = Path(temp_dir)
+            binary_path = install_dir / "ggcode"
+            binary_path.write_text("stub", encoding="utf-8")
+            cli.write_metadata(install_dir, "v1.0.21")
+
+            with patch.object(cli, "preferred_install_dirs", return_value=[install_dir]):
+                with patch.object(cli, "ensure_installed_path", return_value=False):
+                    result = cli.existing_install("latest", "ggcode")
+
+        self.assertIsNotNone(result)
+        assert result is not None
+        self.assertEqual(result.binary_path, binary_path)
+        self.assertEqual(result.version, "v1.0.21")
+
+    def test_install_binary_writes_metadata(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_root = Path(temp_dir)
+            source = temp_root / "source"
+            source.write_text("ggcode", encoding="utf-8")
+            destination = temp_root / "bin" / "ggcode"
+
+            installed = cli.install_binary(source, destination, "v9.9.9")
+
+            self.assertEqual(installed, destination)
+            self.assertEqual(destination.read_text(encoding="utf-8"), "ggcode")
+            self.assertEqual(cli.read_metadata(destination.parent), {"version": "v9.9.9"})
+
+
+if __name__ == "__main__":
+    unittest.main()

ggcode-1.1.1/README.md

@@ -1,57 +0,0 @@
-# ggcode Python wrapper
-
-`ggcode` on PyPI is a thin Python wrapper for the `ggcode` terminal agent.
-
-It does not ship the platform binary inside the wheel. Instead, the wrapper downloads the latest
-matching `ggcode` GitHub Release on first run, caches it locally, and then launches it.
-
-## Install
-
-```bash
-pip install ggcode
-```
-
-Then run:
-
-```bash
-ggcode
-```
-
-## What it does
-
-- Detects your operating system and CPU architecture
-- Downloads the latest matching `ggcode` archive from GitHub Releases
-- Verifies the archive against `checksums.txt`
-- Extracts and caches the binary for future runs
-
-## Pin a specific ggcode release
-
-By default, the wrapper always resolves the latest `ggcode` release.
-
-To force a specific release, set `GGCODE_INSTALL_VERSION`:
-
-```bash
-GGCODE_INSTALL_VERSION=vX.Y.Z ggcode
-```
-
-or:
-
-```bash
-GGCODE_INSTALL_VERSION=X.Y.Z ggcode
-```
-
-## Supported platforms
-
-- macOS
-- Linux
-- Windows
-
-Supported architectures:
-
-- x86_64 / amd64
-- arm64
-
-## Project links
-
-- Repository: https://github.com/topcheer/ggcode
-- Issues: https://github.com/topcheer/ggcode/issues

ggcode-1.1.1/ggcode.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-ggcode = ggcode_release_installer.cli:main

ggcode-1.1.1/ggcode_release_installer/__init__.py

@@ -1 +0,0 @@
-__version__ = "1.1.1"

ggcode-1.1.1/ggcode_release_installer/cli.py

@@ -1,147 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import os
-import platform
-import shutil
-import stat
-import subprocess
-import sys
-import tarfile
-import tempfile
-import urllib.parse
-import urllib.request
-import zipfile
-from pathlib import Path
-
-OWNER = "topcheer"
-REPO = "ggcode"
-
-
-def normalize_version() -> str:
-    selected = os.environ.get("GGCODE_INSTALL_VERSION", "").strip()
-    if not selected or selected == "latest":
-        return "latest"
-    if selected.startswith("v"):
-        return selected
-    return f"v{selected}"
-
-
-def resolve_target() -> tuple[str, str]:
-    system = sys.platform
-    if system.startswith("linux"):
-        goos = "linux"
-    elif system == "darwin":
-        goos = "darwin"
-    elif system in ("win32", "cygwin"):
-        goos = "windows"
-    else:
-        raise RuntimeError(f"Unsupported platform: {system}")
-
-    machine = platform.machine().lower() or os.environ.get("PROCESSOR_ARCHITECTURE", "").lower()
-    if machine in ("x86_64", "amd64"):
-        arch = "x86_64"
-    elif machine in ("arm64", "aarch64"):
-        arch = "arm64"
-    else:
-        raise RuntimeError(f"Unsupported architecture: {machine or 'unknown'}")
-    return goos, arch
-
-
-def release_base(version: str) -> str:
-    if version == "latest":
-        return f"https://github.com/{OWNER}/{REPO}/releases/latest/download"
-    return f"https://github.com/{OWNER}/{REPO}/releases/download/{version}"
-
-
-def cache_root() -> Path:
-    if os.name == "nt":
-        base = Path(os.environ.get("LOCALAPPDATA", tempfile.gettempdir()))
-        return base / "ggcode" / "python"
-    return Path.home() / ".cache" / "ggcode" / "python"
-
-
-def download(url: str) -> bytes:
-    with urllib.request.urlopen(url) as response:
-        return response.read()
-
-
-def resolve_release_version(version: str) -> str:
-    if version != "latest":
-        return version
-
-    with urllib.request.urlopen(f"https://github.com/{OWNER}/{REPO}/releases/latest") as response:
-        final_url = response.geturl()
-
-    parsed = urllib.parse.urlparse(final_url)
-    parts = [part for part in parsed.path.split("/") if part]
-    if len(parts) < 4 or parts[-2] != "tag":
-        raise RuntimeError(f"Could not resolve latest ggcode release from {final_url}")
-    return urllib.parse.unquote(parts[-1])
-
-
-def parse_checksums(body: str) -> dict[str, str]:
-    checksums: dict[str, str] = {}
-    for raw_line in body.splitlines():
-        parts = raw_line.strip().split()
-        if len(parts) >= 2:
-            checksums[parts[-1]] = parts[0]
-    return checksums
-
-
-def ensure_installed() -> Path:
-    version = resolve_release_version(normalize_version())
-    goos, arch = resolve_target()
-    archive_ext = ".zip" if goos == "windows" else ".tar.gz"
-    archive_name = f"ggcode_{goos}_{arch}{archive_ext}"
-    binary_name = "ggcode.exe" if goos == "windows" else "ggcode"
-    install_dir = cache_root() / version / f"{goos}-{arch}"
-    binary_path = install_dir / binary_name
-    if binary_path.exists():
-        return binary_path
-
-    base = release_base(version)
-    archive = download(f"{base}/{archive_name}")
-    checksums = parse_checksums(download(f"{base}/checksums.txt").decode("utf-8"))
-    expected = checksums.get(archive_name)
-    if not expected:
-        raise RuntimeError(f"Checksum for {archive_name} not found")
-    actual = hashlib.sha256(archive).hexdigest()
-    if actual.lower() != expected.lower():
-        raise RuntimeError(f"Checksum mismatch for {archive_name}")
-
-    with tempfile.TemporaryDirectory(prefix="ggcode-py-") as temp_dir:
-        temp_root = Path(temp_dir)
-        archive_path = temp_root / archive_name
-        archive_path.write_bytes(archive)
-        extract_dir = temp_root / "extract"
-        extract_dir.mkdir(parents=True, exist_ok=True)
-
-        if archive_ext == ".zip":
-            with zipfile.ZipFile(archive_path) as zf:
-                zf.extractall(extract_dir)
-        else:
-            with tarfile.open(archive_path, "r:gz") as tf:
-                tf.extractall(extract_dir)
-
-        extracted = next((p for p in extract_dir.rglob(binary_name) if p.is_file()), None)
-        if extracted is None:
-            raise RuntimeError(f"Could not find {binary_name} in {archive_name}")
-
-        install_dir.mkdir(parents=True, exist_ok=True)
-        shutil.copy2(extracted, binary_path)
-        if os.name != "nt":
-            current_mode = binary_path.stat().st_mode
-            binary_path.chmod(current_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
-
-    return binary_path
-
-
-def main() -> int:
-    binary = ensure_installed()
-    result = subprocess.run([str(binary), *sys.argv[1:]])
-    return result.returncode
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

ggcode-1.1.1/tests/test_cli.py

@@ -1,41 +0,0 @@
-from __future__ import annotations
-
-import os
-import unittest
-from unittest.mock import patch
-
-from ggcode_release_installer import cli
-
-
-class ResolveTargetTests(unittest.TestCase):
-    def test_normalize_version_defaults_to_latest(self) -> None:
-        with patch.dict(os.environ, {}, clear=True):
-            self.assertEqual(cli.normalize_version(), "latest")
-
-    def test_normalize_version_uses_explicit_override(self) -> None:
-        with patch.dict(os.environ, {"GGCODE_INSTALL_VERSION": "1.2.3"}, clear=True):
-            self.assertEqual(cli.normalize_version(), "v1.2.3")
-
-    def test_resolve_target_uses_platform_module_for_machine(self) -> None:
-        with patch.object(cli.sys, "platform", "darwin"):
-            with patch.object(cli.platform, "machine", return_value="arm64"):
-                self.assertEqual(cli.resolve_target(), ("darwin", "arm64"))
-
-    def test_resolve_target_falls_back_to_processor_architecture(self) -> None:
-        env = dict(os.environ, PROCESSOR_ARCHITECTURE="AMD64")
-        with patch.dict(os.environ, env, clear=True):
-            with patch.object(cli.sys, "platform", "win32"):
-                with patch.object(cli.platform, "machine", return_value=""):
-                    self.assertEqual(cli.resolve_target(), ("windows", "x86_64"))
-
-    def test_resolve_release_version_follows_latest_redirect(self) -> None:
-        response = unittest.mock.Mock()
-        response.geturl.return_value = "https://github.com/topcheer/ggcode/releases/tag/v9.9.9"
-        response.__enter__ = unittest.mock.Mock(return_value=response)
-        response.__exit__ = unittest.mock.Mock(return_value=False)
-        with patch.object(cli.urllib.request, "urlopen", return_value=response):
-            self.assertEqual(cli.resolve_release_version("latest"), "v9.9.9")
-
-
-if __name__ == "__main__":
-    unittest.main()