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

aether_cache-0.1.6/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.4/README.md → aether_cache-0.1.6/PKG-INFO

@@ -1,9 +1,26 @@
-[![progress-banner](https://backend.codecrafters.io/progress/redis/f43a7cd3-11e6-45dc-a8ba-9d6690c73ac0)](https://app.codecrafters.io/users/anishchugh05?r=2qF)
+Metadata-Version: 2.5
+Name: aether-cache
+Version: 0.1.6
+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
+Requires-Dist: redis>=5.0
+Description-Content-Type: text/markdown
+
+[![Aether Cache: memory that stays true to your code](https://anishchugh05.github.io/Aether-Cache-Redis-Compatible-Vector-Store/assets/og-image.png)](https://anishchugh05.github.io/Aether-Cache-Redis-Compatible-Vector-Store/)
 
 # Aether Cache
 
 **Shared memory for AI coding tools that stays true to your code.**
 
+<!-- mcp-name: io.github.anishchugh05/aether-cache -->
+
 **[Website](https://anishchugh05.github.io/Aether-Cache-Redis-Compatible-Vector-Store/)** · **[PyPI](https://pypi.org/project/aether-cache/)**
 
 Claude Code, Cursor, and other AI tools each forget your project between sessions, and when they do remember things,
@@ -48,7 +65,14 @@ other tools ─┘   (Python: embeddings,│          memories, HNSW vector inde
 
 ## What it looks like
 
-A memory linked to a file, the file changes, and the next lookup catches it:
+The dashboard (`aether-cache ui`): memories whose files changed wait for a decision, with the file versions side by side.
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://anishchugh05.github.io/Aether-Cache-Redis-Compatible-Vector-Store/assets/dashboard-dark.png">
+  <img alt="The Aether Cache dashboard showing stale memories and a possible conflict" src="https://anishchugh05.github.io/Aether-Cache-Redis-Compatible-Vector-Store/assets/dashboard-light.png">
+</picture>
+
+And from your AI tool's side, a memory linked to a file, the file changes, and the next lookup catches it:
 
 ```
 > remember("The database runs Postgres via docker compose", files=["docker-compose.yml"])
@@ -188,6 +212,8 @@ A Redis-compatible server written from scratch in Java. It speaks RESP, so `redi
 [CodeCrafters "Build Your Own Redis"](https://codecrafters.io/challenges/redis) challenge; the vector index,
 persistence hardening, and the memory layer are my own additions.
 
+[![progress-banner](https://backend.codecrafters.io/progress/redis/f43a7cd3-11e6-45dc-a8ba-9d6690c73ac0)](https://app.codecrafters.io/users/anishchugh05?r=2qF)
+
 ### Throughput vs. official Redis
 
 `redis-benchmark -t set,get`, 100K requests, 50 parallel clients, 3-byte values, same machine:
@@ -353,4 +379,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.4/PKG-INFO → aether_cache-0.1.6/README.md

@@ -1,22 +1,11 @@
-Metadata-Version: 2.5
-Name: aether-cache
-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
-Author: Anish Chugh
-Requires-Python: >=3.10
-Requires-Dist: fastembed>=0.3
-Requires-Dist: mcp>=1.2
-Requires-Dist: redis>=5.0
-Description-Content-Type: text/markdown
-
-[![progress-banner](https://backend.codecrafters.io/progress/redis/f43a7cd3-11e6-45dc-a8ba-9d6690c73ac0)](https://app.codecrafters.io/users/anishchugh05?r=2qF)
+[![Aether Cache: memory that stays true to your code](https://anishchugh05.github.io/Aether-Cache-Redis-Compatible-Vector-Store/assets/og-image.png)](https://anishchugh05.github.io/Aether-Cache-Redis-Compatible-Vector-Store/)
 
 # Aether Cache
 
 **Shared memory for AI coding tools that stays true to your code.**
 
+<!-- mcp-name: io.github.anishchugh05/aether-cache -->
+
 **[Website](https://anishchugh05.github.io/Aether-Cache-Redis-Compatible-Vector-Store/)** · **[PyPI](https://pypi.org/project/aether-cache/)**
 
 Claude Code, Cursor, and other AI tools each forget your project between sessions, and when they do remember things,
@@ -61,7 +50,14 @@ other tools ─┘   (Python: embeddings,│          memories, HNSW vector inde
 
 ## What it looks like
 
-A memory linked to a file, the file changes, and the next lookup catches it:
+The dashboard (`aether-cache ui`): memories whose files changed wait for a decision, with the file versions side by side.
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://anishchugh05.github.io/Aether-Cache-Redis-Compatible-Vector-Store/assets/dashboard-dark.png">
+  <img alt="The Aether Cache dashboard showing stale memories and a possible conflict" src="https://anishchugh05.github.io/Aether-Cache-Redis-Compatible-Vector-Store/assets/dashboard-light.png">
+</picture>
+
+And from your AI tool's side, a memory linked to a file, the file changes, and the next lookup catches it:
 
 ```
 > remember("The database runs Postgres via docker compose", files=["docker-compose.yml"])
@@ -201,6 +197,8 @@ A Redis-compatible server written from scratch in Java. It speaks RESP, so `redi
 [CodeCrafters "Build Your Own Redis"](https://codecrafters.io/challenges/redis) challenge; the vector index,
 persistence hardening, and the memory layer are my own additions.
 
+[![progress-banner](https://backend.codecrafters.io/progress/redis/f43a7cd3-11e6-45dc-a8ba-9d6690c73ac0)](https://app.codecrafters.io/users/anishchugh05?r=2qF)
+
 ### Throughput vs. official Redis
 
 `redis-benchmark -t set,get`, 100K requests, 50 parallel clients, 3-byte values, same machine:
@@ -366,4 +364,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.4 → aether_cache-0.1.6}/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.4"
+__version__ = "0.1.6"

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

@@ -263,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)}")

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

@@ -224,7 +224,7 @@ def start(wait: float = 60) -> str:
             upgraded = True
         if state == "other":
             raise EngineError(port_taken_message())
-        java, _ = find_java()
+        java = _java_or_download()
         note = _migrate_old_data()
         config.DATA_DIR.mkdir(parents=True, exist_ok=True)
         command = [java, "-Xmx1g", "-jar", str(JAR),
@@ -264,6 +264,31 @@ def start(wait: float = 60) -> str:
         raise EngineError(f"The engine didn't answer within {int(wait)} seconds. See {config.LOG_FILE}.")
 
 
+def _java_or_download() -> str:
+    """Java for starting the engine. If there isn't any, downloads Aether Cache's private copy, so the engine
+    also starts for people whose AI tool runs the server without `aether-cache setup` having run first.
+    Called while holding the start lock, so several sessions starting at once download it only once."""
+    try:
+        return find_java()[0]
+    except EngineError as missing:
+        if os.environ.get("AETHER_NO_JAVA_DOWNLOAD"):
+            raise
+        from . import javart
+        notice = (f"{str(missing).splitlines()[0]} Downloading a private copy of Java {javart.FEATURE_VERSION} "
+                  f"for Aether Cache into {javart.JAVA_DIR} (about 50 MB, only the first time).")
+        print(notice, file=sys.stderr, flush=True)  # stderr: stdout carries the MCP protocol
+        try:
+            with open(config.LOG_FILE, "a") as log:
+                log.write(f"\n{time.strftime('%Y-%m-%d %H:%M:%S')} {notice}\n")
+        except OSError:
+            pass
+        try:
+            javart.download(progress=lambda done, total: None)
+        except javart.JavaDownloadError as e:
+            raise EngineError(f"{str(missing).splitlines()[0]}\n{e}")
+        return find_java()[0]
+
+
 def ensure_running() -> None:
     if probe() != "aether" or needs_upgrade():
         start()

{aether_cache-0.1.4 → aether_cache-0.1.6}/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.4 → aether_cache-0.1.6}/aether_cache/server.py

@@ -16,7 +16,7 @@ from typing import List, Optional
 
 import redis
 
-from . import config, engine
+from . import __version__, config, engine
 
 try:
     from mcp.server.mcpserver import MCPServer  # mcp 2.x
@@ -39,10 +39,14 @@ INSTRUCTIONS = (
     "replace_memory."
 )
 
-mcp = MCPServer(
-    "aether-cache",
-    instructions=INSTRUCTIONS,
-)
+try:
+    mcp = MCPServer("aether-cache", instructions=INSTRUCTIONS, version=__version__)
+except Exception:  # mcp 1.x has no version argument; set it on the underlying server instead
+    mcp = MCPServer("aether-cache", instructions=INSTRUCTIONS)
+    try:
+        mcp._mcp_server.version = __version__
+    except AttributeError:
+        pass
 
 def quiet_libraries() -> None:
     """Hides the download libraries' request logs, warnings and progress bars, which otherwise flood the

{aether_cache-0.1.4 → aether_cache-0.1.6}/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.4 → aether_cache-0.1.6}/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.4"
+version = "0.1.6"
 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]