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

aether_cache-0.1.5/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anish Chugh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -1,10 +1,12 @@
 Metadata-Version: 2.5
 Name: aether-cache
-Version: 0.1.3
+Version: 0.1.5
 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
 Author: Anish Chugh
+License-Expression: MIT
+License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: fastembed>=0.3
 Requires-Dist: mcp>=1.2
@@ -104,9 +106,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 +122,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 +359,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
@@ -362,4 +368,7 @@ aether_cache/                the Python package behind the `aether-cache` comman
 memory_mcp/calibrate.py      similarity calibration for duplicate/contradiction thresholds
 vector_bench.py              HNSW benchmark (writes results.json)
 crash_test.py                kill -9 crash-safety test
-```
+```
+## License
+
+MIT. See [LICENSE](LICENSE).

{aether_cache-0.1.3 → aether_cache-0.1.5}/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
@@ -349,4 +353,7 @@ aether_cache/                the Python package behind the `aether-cache` comman
 memory_mcp/calibrate.py      similarity calibration for duplicate/contradiction thresholds
 vector_bench.py              HNSW benchmark (writes results.json)
 crash_test.py                kill -9 crash-safety test
-```
+```
+## License
+
+MIT. See [LICENSE](LICENSE).

{aether_cache-0.1.3 → aether_cache-0.1.5}/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.5"

{aether_cache-0.1.3 → aether_cache-0.1.5}/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
@@ -233,8 +263,13 @@ def cmd_import(args) -> int:
     if left_out:
         print(f"\nLeft out ({len(left_out)}):")
         for n in left_out:
-            why = (f"mentions {', '.join(n['missing'])}, which doesn't exist (probably out of date)"
-                   if n["missing"] else "doesn't look like a fact about the project")
+            if n["similar"]:
+                what = n["similar"]["id"] or "another note here"
+                why = f"very similar to {what}: \"{n['similar']['text']}\""
+            elif n["missing"]:
+                why = f"mentions {', '.join(n['missing'])}, which doesn't exist (probably out of date)"
+            else:
+                why = "doesn't look like a fact about the project"
             print(f"     - {n['text']}\n       {why}")
     if known:
         print(f"\nAlready remembered: {len(known)}")
@@ -329,6 +364,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.5}/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.5/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.5}/aether_cache/portability.py

@@ -253,10 +253,60 @@ def _key(file: str, text: str) -> str:
     return hashlib.sha1(f"{file}\n{text}".encode()).hexdigest()[:12]
 
 
-def scan(project: str, root: Path) -> dict:
-    """Everything import would bring in from this repo's notes files, tagged for review: known (already
-    remembered), missing (mentions a file that doesn't exist, so probably already stale), weak (doesn't read
-    like a fact about the project). Only notes with none of these are selected by default."""
+# Same thresholds as the engine (Main.java): at or above DUPLICATE it treats a new memory as the same one,
+# at or above CONFLICT as a possible contradiction. A note scoring that close to a memory you already have
+# would only be skipped or flagged after importing, so it's flagged before instead.
+DUPLICATE_SIMILARITY = 0.97
+CONFLICT_SIMILARITY = 0.80
+
+
+def _cosine(a: List[float], b: List[float]) -> float:
+    dot = sum(x * y for x, y in zip(a, b))
+    na = sum(x * x for x in a) ** 0.5
+    nb = sum(y * y for y in b) ** 0.5
+    return dot / (na * nb) if na and nb else 0.0
+
+
+def _flag_similar(project: str, notes: List[dict]) -> Dict[str, List[str]]:
+    """Compares each new note by meaning with the project's current memories, and with the notes before it
+    in this import. Marks near-copies as known and close matches as similar (unselected). Returns the
+    notes' embeddings by key, so importing them doesn't compute them twice."""
+    fresh = [n for n in notes if not n["known"]]
+    if not fresh:
+        return {}
+    vectors = server.embed_many([n["text"] for n in fresh])
+    pipe = server.db().pipeline(transaction=False)
+    for v in vectors:
+        pipe.execute_command("MEM.SEARCH", project, 1, "STATUS", "active", "VECTOR", *v)
+    try:
+        hits = pipe.execute()
+    except Exception:
+        hits = [server.run("MEM.SEARCH", project, 1, "STATUS", "active", "VECTOR", *v) for v in vectors]
+    floats = [[float(x) for x in v] for v in vectors]
+    for i, (note, hit) in enumerate(zip(fresh, hits)):
+        if hit:
+            mid, score, text = hit[0][0], float(hit[0][1]), hit[0][2]
+            if score >= DUPLICATE_SIMILARITY:
+                note["known"] = True
+                note["selected"] = False
+                continue
+            if score >= CONFLICT_SIMILARITY:
+                note["similar"] = {"id": mid, "text": text, "score": round(score, 2)}
+                note["selected"] = False
+                continue
+        for j in range(i):  # two notes in this import that say the same thing, e.g. in CLAUDE.md and a rule
+            other = fresh[j]
+            if other["known"] or other.get("similar"):
+                continue
+            score = _cosine(floats[i], floats[j])
+            if score >= CONFLICT_SIMILARITY:
+                note["similar"] = {"id": None, "text": other["text"], "score": round(score, 2)}
+                note["selected"] = False
+                break
+    return {n["key"]: v for n, v in zip(fresh, vectors)}
+
+
+def _scan(project: str, root: Path) -> tuple:
     if not root.is_dir():
         raise NotesError(f"{root} isn't a folder.")
     existing = set()
@@ -280,27 +330,34 @@ def scan(project: str, root: Path) -> dict:
             linked, missing = mentioned_paths(note, root, skip=rels)
             known = n in existing or body in existing
             notes.append({"key": _key(rel, note), "text": note, "file": rel, "files": linked,
-                          "missing": missing, "known": known, "weak": found["weak"],
+                          "missing": missing, "known": known, "weak": found["weak"], "similar": None,
                           "selected": not known and not missing and not found["weak"]})
             count += 1
         per_file.append({"path": rel, "notes": count})
-    return {"project": project, "root": str(root), "files": per_file, "notes": notes}
+    vectors = _flag_similar(project, notes)
+    return {"project": project, "root": str(root), "files": per_file, "notes": notes}, vectors
+
+
+def scan(project: str, root: Path) -> dict:
+    """Everything import would bring in from this repo's notes files, tagged for review: known (already
+    remembered, word for word or nearly), similar (close in meaning to a memory you have, or to another note
+    here), missing (mentions a file that doesn't exist, so probably already stale), weak (doesn't read like
+    a fact about the project). Only notes with none of these are selected by default."""
+    return _scan(project, root)[0]
 
 
 def apply(project: str, root: Path, keys: Optional[List[str]] = None) -> dict:
     """Saves the chosen notes as memories (by key from scan; None means the ones selected by default).
     Notes that turn out to be already known are skipped, never duplicated."""
-    found = scan(project, root)["notes"]
-    chosen = [n for n in found if not n["known"] and (n["selected"] if keys is None else n["key"] in set(keys))]
+    found, vectors = _scan(project, root)
+    wanted = set(keys or ())
+    chosen = [n for n in found["notes"] if not n["known"] and (n["selected"] if keys is None else n["key"] in wanted)]
     result = {"saved": [], "duplicates": 0, "conflicts": 0}
-    if not chosen:
-        return result
-    vectors = server.embed_many([n["text"] for n in chosen])
-    for note, vector in zip(chosen, vectors):
+    for note in chosen:
         args = ["MEM.ADD", project, note["text"], "SOURCE", f"{note['file']} (imported)", "SESSION", "import"]
         if note["files"]:
             args += ["FILES", server.link_files(note["files"], root)]
-        mem_id, outcome, _related = server.run(*args, "VECTOR", *vector)
+        mem_id, outcome, _related = server.run(*args, "VECTOR", *vectors[note["key"]])
         if outcome == "duplicate":
             result["duplicates"] += 1
             continue

{aether_cache-0.1.3 → aether_cache-0.1.5}/aether_cache/ui/index.html

@@ -903,7 +903,10 @@ function renderImport() {
       n.files.length ? h("span", { class: "linked" }, "Linked to ", n.files.map((p, i) => [i ? ", " : "", h("span", { class: "mono" }, pathNodes(p))])) : null,
       n.missing.length ? h("span", { class: "warn" }, "Mentions ", n.missing.map((p, i) => [i ? ", " : "", h("span", { class: "mono" }, pathNodes(p))]),
                            n.missing.length === 1 ? ", which doesn’t exist. Probably out of date." : ", which don’t exist. Probably out of date.") : null,
-      n.weak && !n.missing.length ? h("span", {}, "Doesn’t look like a fact about the project, so it’s unchecked.") : null,
+      n.similar ? h("span", { class: "warn" }, n.similar.id
+        ? ["Very similar to ", h("span", { class: "mono" }, n.similar.id), ", which you already have: “", richText(n.similar.text), "”"]
+        : ["Very similar to another note here: “", richText(n.similar.text), "”"]) : null,
+      n.weak && !n.missing.length && !n.similar ? h("span", {}, "Doesn’t look like a fact about the project, so it’s unchecked.") : null,
     ].filter(Boolean);
     return h("label", { class: "pick" }, box,
       h("span", {}, h("span", { class: "text", id: `t-${n.key}` }, richText(n.text)), tags.length ? h("span", { class: "tags" }, tags) : null));

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

@@ -1,14 +1,16 @@
 [build-system]
-requires = ["hatchling>=1.24"]
+requires = ["hatchling>=1.27"]
 build-backend = "hatchling.build"
 
 [project]
 name = "aether-cache"
-version = "0.1.3"
+version = "0.1.5"
 description = "Shared memory for AI coding tools that stays true to your code."
 readme = "README.md"
 requires-python = ">=3.10"
 authors = [{ name = "Anish Chugh" }]
+license = "MIT"
+license-files = ["LICENSE"]
 dependencies = [
     "mcp>=1.2",
     "fastembed>=0.3",
@@ -27,7 +29,7 @@ packages = ["aether_cache"]
 artifacts = ["aether_cache/engine/aether-engine.jar"]  # *.jar is gitignored; ship this one anyway
 
 [tool.hatch.build.targets.sdist]
-include = ["aether_cache", "README.md", "pyproject.toml"]
+include = ["aether_cache", "README.md", "LICENSE", "pyproject.toml"]
 artifacts = ["aether_cache/engine/aether-engine.jar"]
 
 [tool.uv]