rensoai-code-graph 1.0.19__py3-none-any.whl

rensoai_code_graph/__init__.py

@@ -0,0 +1,5 @@
+"""rensoai-code-graph — packaging shim for the prebuilt code_graph binaries."""
+
+from .__version__ import __version__
+
+__all__ = ["__version__"]

rensoai_code_graph/__version__.py

@@ -0,0 +1,3 @@
+"""Wheel version. Templated by build_wheels.py."""
+
+__version__ = "1.0.19"

rensoai_code_graph/_launcher.py

@@ -0,0 +1,146 @@
+"""Fetch the prebuilt binary on first run, then exec it.
+
+The wheel ships no binary (so it stays a tiny pure-Python package that fits
+under PyPI's per-file size limit). On the first invocation of ``code_graph``
+or ``code_graph-mcp`` this downloads the matching prebuilt archive from the
+public release, verifies its SHA256 against the templated manifest, caches the
+extracted binary, and execs it. Subsequent runs use the cached binary.
+
+Stdlib only — no third-party dependencies.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import platform
+import shutil
+import sys
+import tarfile
+import tempfile
+import urllib.request
+import zipfile
+from pathlib import Path
+
+from . import _manifest
+
+_DOWNLOAD_CHUNK = 1 << 20  # 1 MiB
+
+
+def _target() -> str:
+    """Map the host OS/arch to the Rust target triple of its release archive."""
+    machine = platform.machine().lower()
+    arm = machine in ("arm64", "aarch64")
+    intel = machine in ("x86_64", "amd64", "x64")
+    if sys.platform.startswith("linux"):
+        if intel:
+            return "x86_64-unknown-linux-gnu"
+        if arm:
+            return "aarch64-unknown-linux-gnu"
+    elif sys.platform == "darwin":
+        if intel:
+            return "x86_64-apple-darwin"
+        if arm:
+            return "aarch64-apple-darwin"
+    elif sys.platform == "win32":
+        if intel:
+            return "x86_64-pc-windows-msvc"
+    raise RuntimeError(
+        f"rensoai-code-graph has no prebuilt binary for {sys.platform}/{machine}. "
+        "Supported: linux/macOS/Windows on x86_64 and arm64."
+    )
+
+
+def _cache_dir() -> Path:
+    """Per-version cache root for the extracted binaries."""
+    override = os.environ.get("CODE_GRAPH_CACHE_DIR")
+    if override:
+        root = Path(override)
+    elif sys.platform == "win32":
+        root = Path(os.environ.get("LOCALAPPDATA") or (Path.home() / "AppData" / "Local"))
+    elif sys.platform == "darwin":
+        root = Path.home() / "Library" / "Caches"
+    else:
+        root = Path(os.environ.get("XDG_CACHE_HOME") or (Path.home() / ".cache"))
+    return root / "rensoai-code-graph" / _manifest.VERSION
+
+
+def _sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as fh:
+        for chunk in iter(lambda: fh.read(_DOWNLOAD_CHUNK), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def _download(url: str, dest: Path) -> None:
+    req = urllib.request.Request(url, headers={"User-Agent": "rensoai-code-graph"})
+    with urllib.request.urlopen(req) as resp, dest.open("wb") as out:  # noqa: S310 (trusted host)
+        shutil.copyfileobj(resp, out, _DOWNLOAD_CHUNK)
+
+
+def _ensure_binary(name: str) -> Path:
+    is_windows = sys.platform == "win32"
+    suffix = ".exe" if is_windows else ""
+    dest = _cache_dir() / f"{name}{suffix}"
+    if dest.exists():
+        return dest
+
+    target = _target()
+    expected = (_manifest.SHA256_BY_TARGET.get(target) or {}).get(name)
+    if not expected:
+        raise RuntimeError(
+            f"rensoai-code-graph manifest has no {name} entry for {target}; "
+            "the wheel may be a placeholder build."
+        )
+
+    ext = "zip" if is_windows else "tar.gz"
+    url = f"{_manifest.BASE_URL}/v{_manifest.VERSION}/{name}-{target}.{ext}"
+
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp_path = Path(tmp)
+        archive = tmp_path / f"{name}.{ext}"
+        sys.stderr.write(f"rensoai-code-graph: fetching {name} ({target}) on first run...\n")
+        _download(url, archive)
+
+        got = _sha256(archive)
+        if got != expected:
+            raise RuntimeError(
+                f"sha256 mismatch for {url}\n  expected {expected}\n  got      {got}"
+            )
+
+        if is_windows:
+            with zipfile.ZipFile(archive) as zf:
+                zf.extractall(tmp_path)
+        else:
+            with tarfile.open(archive, "r:gz") as tf:
+                tf.extractall(tmp_path)
+        # Archives contain a single top dir "<name>-<target>/<binary>".
+        extracted = tmp_path / f"{name}-{target}" / f"{name}{suffix}"
+        if not extracted.exists():
+            raise RuntimeError(f"archive {url} did not contain {extracted.name}")
+
+        # Atomic publish into the cache (temp + rename) so concurrent first
+        # runs never observe a half-written binary.
+        staged = dest.with_name(dest.name + ".tmp")
+        shutil.copy(extracted, staged)
+        if not is_windows:
+            staged.chmod(0o755)
+        os.replace(staged, dest)
+    return dest
+
+
+def exec_binary(name: str) -> "int | None":
+    """Ensure ``name`` is cached, then run it forwarding argv + env.
+
+    On Unix ``os.execv`` replaces this process. On Windows ``os.spawnv``
+    waits and ``sys.exit``s with the child's exit code.
+    """
+    path = _ensure_binary(name)
+    args = [str(path), *sys.argv[1:]]
+    if sys.platform == "win32":
+        rc = os.spawnv(os.P_WAIT, str(path), args)
+        sys.exit(int(rc))
+    os.execv(str(path), args)
+    return None  # unreachable

rensoai_code_graph/_manifest.py

@@ -0,0 +1,28 @@
+"""Release manifest (version + per-target archive SHA256). Templated by build_wheels.py."""
+
+VERSION = "1.0.19"
+
+BASE_URL = "https://github.com/Renso-AI/code-graph-dist/releases/download"
+
+SHA256_BY_TARGET = {
+    "aarch64-apple-darwin": {
+        "code_graph": "93c4eefb933bbb8f851f3cfe7d8b1ebd3ad6f05c0e1e42f65b4f6173f2c9cd63",
+        "code_graph-mcp": "02dbcaefe674011147e3ef9f28b3e0485722a3fa39e237da78e6377ffb8df73f"
+    },
+    "aarch64-unknown-linux-gnu": {
+        "code_graph": "da5de8974b8bc01cb7007e3015a11cdf1a3a452e4877cfd572100dc141baf9d6",
+        "code_graph-mcp": "680d30bbfe834a317feb7de1efaf5b1cb4dbf77a22b90ef41296b3ad15842e3c"
+    },
+    "x86_64-apple-darwin": {
+        "code_graph": "4520ff4da46501c58048dea4d0feae67785bd2721b33dae5fd7f9c46f529d87e",
+        "code_graph-mcp": "3042bde451547269595ceb9bfcd72931cab793c3f09279919bd5946e176c3e28"
+    },
+    "x86_64-pc-windows-msvc": {
+        "code_graph": "818e152bb4eb000fdaf42cfa44767dbacabc908fefd699663659354ea1068d06",
+        "code_graph-mcp": "842ad09e68525255794778b036aa81fcbf86f5b20c76937ecfe14c608d869ffc"
+    },
+    "x86_64-unknown-linux-gnu": {
+        "code_graph": "54c153c5659fa7dc468b2ed7cf41bf1942c98e9335253978821beca538775fbd",
+        "code_graph-mcp": "a8a6e7854d61e058d0edf60b7f790384107d0db5aabdef14216a3091d64ad485"
+    }
+}

rensoai_code_graph/cli.py

@@ -0,0 +1,7 @@
+"""Console-script entry point for the `code_graph` CLI."""
+
+from ._launcher import exec_binary
+
+
+def main() -> None:
+    exec_binary("code_graph")

rensoai_code_graph/mcp.py

@@ -0,0 +1,7 @@
+"""Console-script entry point for the `code_graph-mcp` server."""
+
+from ._launcher import exec_binary
+
+
+def main() -> None:
+    exec_binary("code_graph-mcp")

rensoai_code_graph-1.0.19.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: rensoai-code-graph
+Version: 1.0.19
+Summary: Dependency graph analyzer for code, tests, docs, and policy surfaces. A tiny launcher that downloads + SHA256-verifies the prebuilt code_graph + code_graph-mcp binaries on first run.
+Project-URL: Homepage, https://cg.renso.ai
+Project-URL: Documentation, https://cg.renso.ai/docs
+Project-URL: Source, https://github.com/Renso-AI/code-graph-dist
+Project-URL: Issues, https://github.com/Renso-AI/code-graph-dist/issues
+Author: Renso AI
+License: Proprietary - (c) Renso AI. All rights reserved. NOT open source.
+Keywords: blast-radius,code-graph,llm,mcp,static-analysis
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# rensoai-code-graph (PyPI distribution wrapper)
+
+This package is still published for distribution compatibility, but
+customer-facing install docs live at https://cg.renso.ai/docs#install
+and document only the curl/script installer. The PyPI artifacts are
+per-platform wheels with the prebuilt `code_graph` and `code_graph-mcp`
+binaries bundled.
+
+## Files in this directory
+
+- `pyproject.toml` — Hatch backend, `[project.scripts]` entries,
+  pinned cibuildwheel matrix
+- `src/rensoai_code_graph/` — Python package: launcher + console-script
+  entry points
+- `scripts/build_wheels.py` — release-time wheel builder
+- `README.md` — what users see on PyPI
+
+## Per-platform wheel matrix
+
+| Wheel tag                                       | Binary target              |
+|-------------------------------------------------|----------------------------|
+| `py3-none-manylinux_2_28_x86_64.whl`            | x86_64-unknown-linux-gnu   |
+| `py3-none-manylinux_2_28_aarch64.whl`           | aarch64-unknown-linux-gnu  |
+| `py3-none-macosx_10_12_x86_64.whl`              | x86_64-apple-darwin        |
+| `py3-none-macosx_11_0_arm64.whl`                | aarch64-apple-darwin       |
+| `py3-none-win_amd64.whl`                        | x86_64-pc-windows-msvc     |
+
+Each wheel is `py3-none-<platform>` so end users only ever pull one
+wheel per machine, regardless of Python version.
+
+## No sdist
+
+`pyproject.toml` excludes everything from the sdist target. Only
+wheels go to PyPI — there is no source distribution that could
+trick a user (or a downstream build system) into compiling from
+source.
+
+## How a release ships wheels
+
+`.github/workflows/release.yml` job `publish-pip`:
+
+1. Downloads the prebuilt-binary tarballs from `dist/`.
+2. Runs `scripts/build_wheels.py` which, per platform:
+   - Templates `src/rensoai_code_graph/__version__.py` with the
+     release version.
+   - Copies the matching binary into
+     `src/rensoai_code_graph/_binaries/`.
+   - Runs `python -m build --wheel` (Hatch backend) targeting the
+     correct platform tag.
+3. `twine upload` ships all wheels to PyPI.

rensoai_code_graph-1.0.19.dist-info/RECORD

@@ -0,0 +1,10 @@
+rensoai_code_graph/__init__.py,sha256=Jec2a96uIZpYwwOCYX10naTm8QZajlnvhLsI2Q4flPE,147
+rensoai_code_graph/__version__.py,sha256=OCjtoXZDKr_sdhVw0OhQ3GBaYhdVZPanrvQnjD3y3WQ,75
+rensoai_code_graph/_launcher.py,sha256=m_r6K0sljgP6Qe1RonPwS5kH6XtNe4GH-dO3k6dwUYc,5029
+rensoai_code_graph/_manifest.py,sha256=r_uiCMskFW6yLoXLx-rBTZiUnxYgBZQDVPIOuntnsyw,1321
+rensoai_code_graph/cli.py,sha256=4lyZ1A09cd2F2M_MJLjhctPMzb2dVIh2hUxF5td_FKw,147
+rensoai_code_graph/mcp.py,sha256=h2bGLAORofefrZPH2npFPr1qZQrdyjKMjW_Y0ymxPN8,158
+rensoai_code_graph-1.0.19.dist-info/METADATA,sha256=IrNO4gRL9SoRqaP-PKQglSuFkuIqDZbQDLHiJLS7kGM,3168
+rensoai_code_graph-1.0.19.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+rensoai_code_graph-1.0.19.dist-info/entry_points.txt,sha256=751xul2s0PVNhrwbdPn2GvwdZga4BH9xSuKWerAQtUM,104
+rensoai_code_graph-1.0.19.dist-info/RECORD,,

rensoai_code_graph-1.0.19.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

rensoai_code_graph-1.0.19.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+code_graph = rensoai_code_graph.cli:main
+code_graph-mcp = rensoai_code_graph.mcp:main