aether-cache 0.1.4__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.4 → aether_cache-0.1.5}/PKG-INFO

@@ -1,10 +1,12 @@
 Metadata-Version: 2.5
 Name: aether-cache
-Version: 0.1.4
+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
@@ -366,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.4 → aether_cache-0.1.5}/README.md

@@ -353,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.4 → 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.4"
+__version__ = "0.1.5"

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