memgres 0.4.0__tar.gz → 0.4.1__tar.gz

{memgres-0.4.0 → memgres-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memgres
-Version: 0.4.0
+Version: 0.4.1
 Summary: Drop-in memory for AI agents: one Postgres, lexical + semantic recall, diff-versioned history, GDPR-erasable.
 Author: mozgsml
 License-Expression: MIT

{memgres-0.4.0 → memgres-0.4.1}/memgres/_version.py

@@ -8,4 +8,4 @@ here at release; nowhere else carries the number.
 PEP 440: a ``.devN`` suffix marks an unreleased build ahead of the last tag.
 """
 
-__version__ = "0.4.0"
+__version__ = "0.4.1"

{memgres-0.4.0 → memgres-0.4.1}/memgres/mcp_server.py

@@ -36,7 +36,7 @@ from . import identity
 from .config import Config, load
 from .embeddings import get_embedder
 from .schema import migrate
-from .store import Store
+from .store import Store, build_replace
 
 
 # The MCP `initialize` response carries a server-side `instructions` string; a
@@ -180,9 +180,7 @@ def build_server(cfg: Optional[Config] = None):
         curated caption (set whole, searchable via `memory_find`); `source`/`reason`
         record provenance. `space` picks one of your namespaces by name (`space_id`
         for a shared one); omit both to use your default."""
-        replace = None
-        if replace_old is not None or replace_new is not None:
-            replace = (replace_old or "", replace_new or "")
+        replace = build_replace(replace_old, replace_new)
         with pool.connection() as conn:
             return _mem(_store(conn).write(
                 _token(ctx, token), id=id or None, body=body, diff=diff,

{memgres-0.4.0 → memgres-0.4.1}/memgres/server.py

@@ -31,7 +31,7 @@ from .diffing import DiffConflict
 from .embeddings import get_embedder
 from .identity import SpaceNotFound
 from .schema import migrate
-from .store import Conflict, NoParent, NotFound, Store, TooLarge
+from .store import Conflict, NoParent, NotFound, Store, TooLarge, build_replace
 
 
 def _parse_lines(spec: Optional[str]) -> Optional[List[int]]:
@@ -174,12 +174,12 @@ def create_app(cfg: Optional[Config] = None):
     @app.patch("/memories/{mid}")
     def edit(mid: str, req: EditBody, tok: Optional[str] = Depends(token)):
         with pool.connection() as conn:
-            replace = None
-            if req.replace_old is not None or req.replace_new is not None:
-                replace = (req.replace_old or "", req.replace_new or "")
+            # build_replace runs inside _guard so a lone replace_old/new surfaces
+            # as its ValueError -> 422, not a silent delete or an uncaught 500.
             m = _guard(lambda: _store(conn).write(
                 tok, id=mid, body=req.body, diff=req.diff, base_hash=req.base_hash,
-                replace=replace, replace_all=req.replace_all,
+                replace=build_replace(req.replace_old, req.replace_new),
+                replace_all=req.replace_all,
                 path=req.path, tags=req.tags, title=req.title,
                 source=req.source, reason=req.reason,
                 ttl_days=req.ttl_days, space=req.space, space_id=req.space_id))

{memgres-0.4.0 → memgres-0.4.1}/memgres/store.py

@@ -53,6 +53,26 @@ class AmbiguousReplace(ValueError):
     """A `replace`'s `old` occurs more than once and `replace_all` wasn't set."""
 
 
+def build_replace(replace_old: Optional[str], replace_new: Optional[str]):
+    """Assemble the substring-replace ``(old, new)`` tuple from the two optional
+    request fields — the one place both the HTTP and MCP layers turn them into the
+    ``replace`` argument, so the rule lives once.
+
+    It distinguishes *not provided* (``None``) from an explicit empty string. Both
+    omitted → ``None`` (no replace). Exactly one provided → ``ValueError``: a lone
+    ``replace_old`` must not be coerced to ``(old, "")`` and **silently delete**
+    the matched text (the regression this guards), and a lone ``replace_new`` has
+    no anchor. Both provided → ``(old, new)``; ``new`` may be ``""`` to delete on
+    purpose, which is now the *only* way to get a deletion.
+    """
+    if replace_old is None and replace_new is None:
+        return None
+    if replace_old is None or replace_new is None:
+        raise ValueError("replace needs both replace_old and replace_new "
+                         "(pass replace_new='' to delete the matched text)")
+    return (replace_old, replace_new)
+
+
 @dataclass
 class Memory:
     id: str

{memgres-0.4.0 → memgres-0.4.1}/memgres.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memgres
-Version: 0.4.0
+Version: 0.4.1
 Summary: Drop-in memory for AI agents: one Postgres, lexical + semantic recall, diff-versioned history, GDPR-erasable.
 Author: mozgsml
 License-Expression: MIT

{memgres-0.4.0 → memgres-0.4.1}/memgres.egg-info/SOURCES.txt

@@ -52,6 +52,7 @@ tests/test_mcp_recall_schema.py
 tests/test_migration_upgrade.py
 tests/test_qdrant_ca.py
 tests/test_qdrant_integration.py
+tests/test_replace_build.py
 tests/test_search_integration.py
 tests/test_security_integration.py
 tests/test_segments.py

memgres-0.4.1/tests/test_replace_build.py

@@ -0,0 +1,40 @@
+"""build_replace(): a lone replace_old/replace_new is an error, never a silent
+delete. Regression guard for meta.memgres.replace_new_dropped — a missing
+replace_new used to be coerced to "" and delete the matched text on a success."""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+import pytest  # noqa: E402
+
+from memgres.store import build_replace  # noqa: E402
+
+
+def test_both_omitted_is_no_replace():
+    assert build_replace(None, None) is None
+
+
+def test_both_present_builds_tuple():
+    assert build_replace("old", "new") == ("old", "new")
+
+
+def test_explicit_empty_new_is_allowed_delete():
+    # deleting the matched text on purpose stays possible — but ONLY explicitly
+    assert build_replace("old", "") == ("old", "")
+
+
+def test_lone_old_raises_not_silent_delete():
+    # the bug: this used to become ("old", "") and silently delete `old`
+    with pytest.raises(ValueError):
+        build_replace("old", None)
+
+
+def test_lone_new_raises():
+    with pytest.raises(ValueError):
+        build_replace(None, "new")
+
+
+if __name__ == "__main__":
+    sys.exit(pytest.main([__file__, "-v"]))

{memgres-0.4.0 → memgres-0.4.1}/tests/test_server_integration.py

@@ -109,6 +109,25 @@ def test_replace_edit_over_http(client):
     assert ok.status_code == 200 and ok.json()["body"] == "z z\n"
 
 
+def test_replace_missing_new_errors_not_silent_delete(client):
+    # Regression (meta.memgres.replace_new_dropped): a lone replace_old with
+    # replace_new omitted must be REJECTED, not coerced to ("old", "") and
+    # silently delete the matched text on a 200.
+    r = client.post("/memories", json={"body": "keep\nanchor\ntail\n"})
+    mid, h0 = r.json()["id"], r.json()["content_hash"]
+    r = client.patch(f"/memories/{mid}", json={"replace_old": "anchor"})
+    assert r.status_code == 422
+    got = client.get(f"/memories/{mid}").json()          # body untouched, no seq bump
+    assert got["body"] == "keep\nanchor\ntail\n" and got["content_hash"] == h0
+    # a lone replace_new is likewise rejected
+    assert client.patch(f"/memories/{mid}",
+                        json={"replace_new": "x"}).status_code == 422
+    # an EXPLICIT empty replace_new is a deliberate deletion (still allowed)
+    r = client.patch(f"/memories/{mid}",
+                     json={"replace_old": "anchor\n", "replace_new": ""})
+    assert r.status_code == 200 and r.json()["body"] == "keep\ntail\n"
+
+
 def test_recall_tag_and_subtree_filters(client):
     client.post("/memories", json={"body": "apple pie recipe\n", "tags": ["food"],
                                    "path": "recipes.apple"})