aether-cache 0.1.3__tar.gz → 0.1.4__tar.gz

{aether_cache-0.1.3 → aether_cache-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: aether-cache
-Version: 0.1.3
+Version: 0.1.4
 Summary: Shared memory for AI coding tools that stays true to your code.
 Project-URL: Homepage, https://anishchugh05.github.io/Aether-Cache-Redis-Compatible-Vector-Store/
 Project-URL: Repository, https://github.com/anishchugh05/Aether-Cache-Redis-Compatible-Vector-Store
@@ -104,9 +104,8 @@ m1 retired; m3 replaces it.
 
 ## Quick start
 
-You need **Java 11+** (`brew install openjdk@21` on macOS, or [adoptium.net](https://adoptium.net)) and
-[**uv**](https://docs.astral.sh/uv/) (`curl -LsSf https://astral.sh/uv/install.sh | sh`), which also takes care of
-Python for you. Then:
+You need [**uv**](https://docs.astral.sh/uv/) (`curl -LsSf https://astral.sh/uv/install.sh | sh`), which also takes
+care of Python for you. Then:
 
 ```sh
 uv tool install aether-cache
@@ -121,6 +120,10 @@ repo and try:
 
 Then start a new session and ask how to run the tests.
 
+The engine runs on Java 11+. If you have it, it's used. If you don't, `setup` downloads a private copy (about
+50 MB) into `~/.aether-cache/java`, checks it against its published checksum, and uses it only for Aether Cache;
+nothing is installed system-wide, and `aether-cache uninstall` removes it.
+
 Already keep notes for your AI in `CLAUDE.md`, `AGENTS.md`, or Cursor rules? Run `aether-cache import` in the repo
 (or use **Import notes** in the dashboard) to turn them into memories, linked to the files they mention.
 
@@ -354,6 +357,7 @@ src/main/java/Main.java      the engine (single file, from the CodeCrafters setu
 aether_cache/                the Python package behind the `aether-cache` command
   server.py                  MCP server: embeddings, git staleness, AGENTS.md/CLAUDE.md sync
   engine.py                  finds Java, starts and stops the engine in the background
+  javart.py                  downloads a private copy of Java when the computer has none
   connect.py                 registers Aether Cache with Claude Code, Cursor, and Codex
   cli.py                     the `aether-cache` command
   ui.py, ui/index.html       the dashboard (`aether-cache ui`): a local server, its API, and the page

{aether_cache-0.1.3 → aether_cache-0.1.4}/README.md

@@ -91,9 +91,8 @@ m1 retired; m3 replaces it.
 
 ## Quick start
 
-You need **Java 11+** (`brew install openjdk@21` on macOS, or [adoptium.net](https://adoptium.net)) and
-[**uv**](https://docs.astral.sh/uv/) (`curl -LsSf https://astral.sh/uv/install.sh | sh`), which also takes care of
-Python for you. Then:
+You need [**uv**](https://docs.astral.sh/uv/) (`curl -LsSf https://astral.sh/uv/install.sh | sh`), which also takes
+care of Python for you. Then:
 
 ```sh
 uv tool install aether-cache
@@ -108,6 +107,10 @@ repo and try:
 
 Then start a new session and ask how to run the tests.
 
+The engine runs on Java 11+. If you have it, it's used. If you don't, `setup` downloads a private copy (about
+50 MB) into `~/.aether-cache/java`, checks it against its published checksum, and uses it only for Aether Cache;
+nothing is installed system-wide, and `aether-cache uninstall` removes it.
+
 Already keep notes for your AI in `CLAUDE.md`, `AGENTS.md`, or Cursor rules? Run `aether-cache import` in the repo
 (or use **Import notes** in the dashboard) to turn them into memories, linked to the files they mention.
 
@@ -341,6 +344,7 @@ src/main/java/Main.java      the engine (single file, from the CodeCrafters setu
 aether_cache/                the Python package behind the `aether-cache` command
   server.py                  MCP server: embeddings, git staleness, AGENTS.md/CLAUDE.md sync
   engine.py                  finds Java, starts and stops the engine in the background
+  javart.py                  downloads a private copy of Java when the computer has none
   connect.py                 registers Aether Cache with Claude Code, Cursor, and Codex
   cli.py                     the `aether-cache` command
   ui.py, ui/index.html       the dashboard (`aether-cache ui`): a local server, its API, and the page

{aether_cache-0.1.3 → aether_cache-0.1.4}/aether_cache/__init__.py

@@ -1,3 +1,3 @@
 """Aether Cache: shared memory for AI coding tools that stays true to your code."""
 
-__version__ = "0.1.3"
+__version__ = "0.1.4"

{aether_cache-0.1.3 → aether_cache-0.1.4}/aether_cache/cli.py

@@ -17,11 +17,38 @@ def _say(mark: str, text: str) -> None:
 
 # ---------- commands ----------
 
+def _java_label(java: str) -> str:
+    return f"private copy in {java_dir()}" if engine.is_private(java) else java
+
+
+def java_dir():
+    from .javart import JAVA_DIR
+    return JAVA_DIR
+
+
+def _java_for_setup():
+    """The computer's own Java if it has a recent enough one; otherwise downloads a private copy."""
+    try:
+        return engine.find_java()
+    except engine.EngineError as missing:
+        from . import javart
+        reason = str(missing).splitlines()[0]  # "Java isn't installed." or "Found Java 8, which is too old."
+        print(f"[ .... ] {reason} Downloading a private copy of Java {javart.FEATURE_VERSION} for Aether Cache "
+              f"(about 50 MB, only the first time).\n"
+              f"         It goes in {javart.JAVA_DIR}, only Aether Cache uses it, and nothing else on your "
+              f"computer changes.", flush=True)
+        try:
+            javart.download()
+        except javart.JavaDownloadError as e:
+            raise engine.EngineError(str(e))
+        return engine.find_java()
+
+
 def cmd_setup(args) -> int:
     print(f"Setting up Aether Cache {__version__}\n")
     try:
-        java, major = engine.find_java()
-        _say(OK, f"Java {major} ({java})")
+        java, major = _java_for_setup()
+        _say(OK, f"Java {major} ({_java_label(java)})")
         _say(OK, engine.start())
     except engine.EngineError as e:
         _say(FAIL, str(e))
@@ -31,7 +58,10 @@ def cmd_setup(args) -> int:
     if config.FAKE_EMBEDDER:
         _say(OK, "Embedding model: test mode, nothing to download")
     else:
-        print("[ .... ] Downloading the embedding model (about 90 MB, only the first time)...", flush=True)
+        if any(config.MODELS_DIR.glob("*")):
+            print("[ .... ] Loading the embedding model...", flush=True)
+        else:
+            print("[ .... ] Downloading the embedding model (about 90 MB, only the first time)...", flush=True)
         try:
             from .server import embed
             embed("warm up")
@@ -121,7 +151,7 @@ def cmd_doctor(args) -> int:
     _say(OK, f"Aether Cache {__version__}, Python {sys.version.split()[0]} ({sys.executable})")
     try:
         java, major = engine.find_java()
-        _say(OK, f"Java {major} ({java})")
+        _say(OK, f"Java {major} ({_java_label(java)})")
     except engine.EngineError as e:
         _say(FAIL, str(e))
         problems += 1
@@ -329,6 +359,9 @@ def cmd_uninstall(args) -> int:
         shutil.rmtree(config.HOME, ignore_errors=True)
         _say(OK, f"Deleted {config.HOME}")
     elif has_data:
+        from . import javart
+        if javart.remove():
+            _say(OK, f"Removed Aether Cache's private copy of Java ({javart.JAVA_DIR})")
         _say(OK, f"Kept your memories in {config.HOME}. Reinstall any time and they're back.")
     print(f"\nLast step, remove the program itself:\n  {_uninstall_command()}")
     return 1 if failed else 0

{aether_cache-0.1.3 → aether_cache-0.1.4}/aether_cache/engine.py

@@ -34,30 +34,44 @@ def java_install_hint() -> str:
         how = "winget install EclipseAdoptium.Temurin.21.JRE   (or download it from https://adoptium.net)"
     else:
         how = "sudo apt install openjdk-21-jre-headless   (or your distro's equivalent, or https://adoptium.net)"
-    return f"Aether Cache needs Java {MIN_JAVA} or newer. Install it with:\n    {how}"
+    return (f"Run `aether-cache setup` and it downloads a private copy of Java for you, "
+            f"or install Java {MIN_JAVA}+ yourself:\n    {how}")
+
+
+def _java_version(java: str) -> Optional[int]:
+    try:
+        out = subprocess.run([java, "-version"], capture_output=True, text=True, timeout=15)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    match = re.search(r'version "(\d+)(?:\.(\d+))?', out.stderr + out.stdout)
+    if out.returncode != 0 or not match:
+        return None
+    major = int(match.group(1))
+    if major == 1 and match.group(2):  # old-style "1.8.0" means Java 8
+        major = int(match.group(2))
+    return major
 
 
 def find_java() -> Tuple[str, int]:
     """(path to a working java, its major version). Raises EngineError if there's no usable Java.
+    Prefers the computer's own Java; falls back to the private copy `setup` downloads when there isn't one.
     Runs `java -version` rather than trusting the PATH: macOS ships a /usr/bin/java stub that only
     says "Unable to locate a Java Runtime"."""
+    from .javart import private_java
     candidates = []
-    if os.environ.get("JAVA_HOME"):
-        candidates.append(str(Path(os.environ["JAVA_HOME"]) / "bin" / ("java.exe" if os.name == "nt" else "java")))
-    if shutil.which("java"):
-        candidates.append(shutil.which("java"))
+    if not os.environ.get("AETHER_IGNORE_SYSTEM_JAVA"):  # testing only: act as if this computer had no Java
+        if os.environ.get("JAVA_HOME"):
+            candidates.append(str(Path(os.environ["JAVA_HOME"]) / "bin" / ("java.exe" if os.name == "nt" else "java")))
+        if shutil.which("java"):
+            candidates.append(shutil.which("java"))
+    private = private_java()
+    if private:
+        candidates.append(str(private))
     too_old = None
     for java in candidates:
-        try:
-            out = subprocess.run([java, "-version"], capture_output=True, text=True, timeout=15)
-        except (OSError, subprocess.SubprocessError):
+        major = _java_version(java)
+        if major is None:
             continue
-        match = re.search(r'version "(\d+)(?:\.(\d+))?', out.stderr + out.stdout)
-        if out.returncode != 0 or not match:
-            continue
-        major = int(match.group(1))
-        if major == 1 and match.group(2):  # old-style "1.8.0" means Java 8
-            major = int(match.group(2))
         if major >= MIN_JAVA:
             return java, major
         too_old = major
@@ -66,6 +80,14 @@ def find_java() -> Tuple[str, int]:
     raise EngineError("Java isn't installed.\n" + java_install_hint())
 
 
+def is_private(java: str) -> bool:
+    from .javart import JAVA_DIR
+    try:
+        return Path(java).resolve().is_relative_to(JAVA_DIR.resolve())
+    except (OSError, ValueError):
+        return False
+
+
 # ---------- talking to the engine ----------
 
 def client(timeout: Optional[float] = None) -> redis.Redis:

aether_cache-0.1.4/aether_cache/javart.py

@@ -0,0 +1,174 @@
+"""
+A private copy of Java, for people who don't have it.
+
+The engine needs Java 11 or newer. If this computer has one, it's used and nothing is downloaded. If not,
+`aether-cache setup` downloads Eclipse Temurin (the standard free build of Java) into ~/.aether-cache/java,
+checks the download against the checksum its publisher lists, and uses it only for Aether Cache: nothing is
+installed system-wide, and `aether-cache uninstall` removes it.
+"""
+import hashlib
+import os
+import platform
+import shutil
+import sys
+import tarfile
+import tempfile
+import time
+import zipfile
+from pathlib import Path
+from typing import Callable, Optional
+
+from . import config
+
+FEATURE_VERSION = 21  # a long-term-support release
+API = os.environ.get("AETHER_JAVA_API", "https://api.adoptium.net/v3")
+JAVA_DIR = config.HOME / "java"
+
+
+class JavaDownloadError(Exception):
+    pass
+
+
+def private_java() -> Optional[Path]:
+    """The java program inside our private copy, if it has been downloaded."""
+    name = "java.exe" if os.name == "nt" else "java"
+    for pattern in (f"*/Contents/Home/bin/{name}", f"*/bin/{name}"):  # macOS keeps it inside a bundle
+        for p in sorted(JAVA_DIR.glob(pattern)):
+            if p.is_file():
+                return p
+    return None
+
+
+def _target() -> tuple:
+    """(os, architecture) in the names the download service uses."""
+    system = platform.system()
+    machine = platform.machine().lower()
+    os_name = {"Darwin": "mac", "Windows": "windows", "Linux": "linux"}.get(system)
+    if os_name == "linux" and Path("/etc/alpine-release").exists():
+        os_name = "alpine-linux"
+    arch = {"x86_64": "x64", "amd64": "x64", "arm64": "aarch64", "aarch64": "aarch64"}.get(machine)
+    if not os_name or not arch:
+        raise JavaDownloadError(f"There's no ready-made Java download for this computer ({system} {machine}).")
+    return os_name, arch
+
+
+def _client():
+    import httpx  # installed with the MCP library; respects HTTPS_PROXY like the model download does
+    return httpx.Client(follow_redirects=True, timeout=httpx.Timeout(30.0, read=60.0))
+
+
+def _find_package(client) -> dict:
+    os_name, arch = _target()
+    url = f"{API}/assets/latest/{FEATURE_VERSION}/hotspot"
+    r = client.get(url, params={"architecture": arch, "image_type": "jre", "os": os_name, "vendor": "eclipse"})
+    r.raise_for_status()
+    try:
+        package = r.json()[0]["binary"]["package"]
+        return {"link": package["link"], "sha256": package["checksum"].lower(),
+                "size": int(package.get("size") or 0), "name": package["name"]}
+    except (ValueError, LookupError, TypeError, AttributeError):
+        raise JavaDownloadError(f"The Java download service sent an unexpected answer for {os_name} {arch}.")
+
+
+def _download(client, pkg: dict, dest: Path, progress: Callable[[int, int], None]) -> None:
+    digest = hashlib.sha256()
+    done = 0
+    with client.stream("GET", pkg["link"]) as r:
+        r.raise_for_status()
+        total = pkg["size"] or int(r.headers.get("content-length") or 0)
+        with open(dest, "wb") as f:
+            for chunk in r.iter_bytes(1 << 16):
+                f.write(chunk)
+                digest.update(chunk)
+                done += len(chunk)
+                progress(done, total)
+    if digest.hexdigest() != pkg["sha256"]:
+        raise JavaDownloadError("The Java download didn't match its published checksum, so it wasn't used. "
+                                "Try again; if it keeps happening, install Java yourself from https://adoptium.net.")
+
+
+def _extract(archive: Path, into: Path) -> None:
+    if archive.name.endswith(".zip"):
+        with zipfile.ZipFile(archive) as z:
+            for member in z.namelist():  # refuse paths that would land outside the folder
+                if member.startswith(("/", "\\")) or ".." in Path(member).parts:
+                    raise JavaDownloadError("The Java download contained an unsafe file path.")
+            z.extractall(into)
+    else:
+        with tarfile.open(archive) as t:
+            if hasattr(tarfile, "data_filter"):
+                t.extractall(into, filter="data")  # rejects unsafe paths and links
+            else:
+                for member in t.getmembers():
+                    if member.name.startswith("/") or ".." in Path(member.name).parts:
+                        raise JavaDownloadError("The Java download contained an unsafe file path.")
+                t.extractall(into)
+    if os.name != "nt":  # make sure the programs are runnable (zip files drop permissions)
+        for bin_dir in into.glob("*/**/bin"):
+            for f in bin_dir.iterdir():
+                if f.is_file():
+                    f.chmod(f.stat().st_mode | 0o755)
+
+
+_last_shown = [-1]
+
+
+def _bar(done: int, total: int) -> None:
+    if not sys.stdout.isatty():
+        return
+    step = int(done * 100 / total) if total else done >> 20  # redraw once per percent (or per MB)
+    if step == _last_shown[0]:
+        return
+    _last_shown[0] = step
+    mb = done / 1_048_576
+    if total:
+        width = 24
+        filled = int(width * done / total)
+        line = f"         [{'#' * filled}{'.' * (width - filled)}] {mb:5.1f} of {total / 1_048_576:.0f} MB"
+    else:
+        line = f"         {mb:5.1f} MB"
+    print("\r" + line, end="", flush=True)
+
+
+def download(progress: Callable[[int, int], None] = _bar, attempts: int = 3) -> Path:
+    """Downloads and unpacks Java into ~/.aether-cache/java. Returns the path to its java program."""
+    config.HOME.mkdir(parents=True, exist_ok=True)
+    last_error = None
+    for attempt in range(1, attempts + 1):
+        work = Path(tempfile.mkdtemp(prefix="java-download-", dir=config.HOME))
+        try:
+            with _client() as client:
+                pkg = _find_package(client)
+                archive = work / pkg["name"]
+                _download(client, pkg, archive, progress)
+            if progress is _bar and sys.stdout.isatty():
+                print()
+            unpacked = work / "unpacked"
+            unpacked.mkdir()
+            _extract(archive, unpacked)
+            if JAVA_DIR.exists():
+                shutil.rmtree(JAVA_DIR)
+            os.replace(unpacked, JAVA_DIR)  # appears all at once, so a half-unpacked Java is never used
+            java = private_java()
+            if java is None:
+                raise JavaDownloadError("The Java download didn't contain a java program.")
+            return java
+        except JavaDownloadError:
+            raise  # a bad checksum or a bad archive won't fix itself by retrying
+        except Exception as e:  # network trouble: try again
+            last_error = e
+            if progress is _bar and sys.stdout.isatty():
+                print()
+            if attempt < attempts:
+                time.sleep(2 * attempt)
+        finally:
+            shutil.rmtree(work, ignore_errors=True)
+    raise JavaDownloadError(f"Couldn't download Java ({last_error}). Check your internet connection and run "
+                            f"`aether-cache setup` again, or install Java yourself from https://adoptium.net.")
+
+
+def remove() -> bool:
+    if JAVA_DIR.exists():
+        shutil.rmtree(JAVA_DIR, ignore_errors=True)
+        return True
+    return False

{aether_cache-0.1.3 → aether_cache-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "aether-cache"
-version = "0.1.3"
+version = "0.1.4"
 description = "Shared memory for AI coding tools that stays true to your code."
 readme = "README.md"
 requires-python = ">=3.10"