memgres 0.3.0__tar.gz → 0.3.2__tar.gz

{memgres-0.3.0 → memgres-0.3.2}/PKG-INFO

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

{memgres-0.3.0 → memgres-0.3.2}/memgres/diffing.py

@@ -69,6 +69,7 @@ def apply_diff(old: str, patch: str) -> str:
     lines = patch.split("\n")
     n = len(lines)
     p = 0
+    hunks = 0                   # guard: a non-empty patch must apply ≥1 hunk
 
     def marker_next(idx: int) -> bool:
         return idx + 1 < n and lines[idx + 1].startswith("\\ No newline")
@@ -80,8 +81,13 @@ def apply_diff(old: str, patch: str) -> str:
             continue
         m = _HUNK.match(line)
         if not m:
+            # A `@@`-line that isn't a valid header is a malformed hunk, not a
+            # skippable stray — reject it rather than silently dropping the edit.
+            if line.startswith("@@"):
+                raise DiffConflict(f"malformed hunk header: {line!r}")
             p += 1
             continue
+        hunks += 1
 
         old_start = int(m.group(1))
         # @@ lines are 1-based; a hunk adding to an empty side uses -0 → 0.
@@ -114,6 +120,11 @@ def apply_diff(old: str, patch: str) -> str:
             p += 1
 
     out.extend(src[i:])
+    # A non-empty patch that matched no hunk header applied nothing — that is a
+    # malformed / non-unified-diff payload, not a legitimate no-op. Fail loudly
+    # instead of silently returning the body unchanged.
+    if hunks == 0:
+        raise DiffConflict("patch contains no @@ hunk — malformed or not a unified diff")
     return "".join(out)
 
 

{memgres-0.3.0 → memgres-0.3.2}/memgres/mcp_server.py

@@ -27,7 +27,10 @@ from __future__ import annotations
 
 from typing import List, Literal, Optional
 
-from mcp.server.fastmcp import Context
+try:  # mcp SDK >= 2.0 renamed the module fastmcp -> mcpserver
+    from mcp.server.mcpserver import Context
+except ImportError:  # mcp SDK 1.x
+    from mcp.server.fastmcp import Context
 
 from . import identity
 from .config import Config, load

{memgres-0.3.0 → memgres-0.3.2}/memgres/store.py

@@ -24,7 +24,7 @@ import psycopg
 
 from . import identity
 from .config import Config
-from .diffing import apply_diff, byte_len, content_hash, make_diff
+from .diffing import DiffConflict, apply_diff, byte_len, content_hash, make_diff
 from .embeddings import Embedder, get_embedder
 from .vector import make_backend
 
@@ -221,6 +221,11 @@ class Store:
                 raise Conflict(f"stale diff: base {base_hash[:12]} != current {cur_hash[:12]}")
             self._check_write_size(diff)
             new_body = apply_diff(cur_body, diff)
+            # A diff that leaves the body identical applied nothing meaningful —
+            # never bump seq on a silent no-op (belt to apply_diff's malformed
+            # guard: also catches an empty or net-zero diff).
+            if new_body == cur_body:
+                raise DiffConflict("diff applied but changed nothing — empty or no-op diff")
             op = "diff"
         elif body is not None:
             if base_hash is not None and base_hash != cur_hash:

{memgres-0.3.0 → memgres-0.3.2}/memgres.egg-info/PKG-INFO

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

{memgres-0.3.0 → memgres-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "memgres"
-version = "0.3.0"
+version = "0.3.2"
 description = "Drop-in memory for AI agents: one Postgres, lexical + semantic recall, diff-versioned history, GDPR-erasable."
 readme = "README.md"
 license = "MIT"

{memgres-0.3.0 → memgres-0.3.2}/tests/test_diffing.py

@@ -53,6 +53,29 @@ def test_apply_to_changed_base_raises():
         apply_diff(drifted, patch)
 
 
+# ─── malformed patches must fail loudly, never silently no-op ────────────
+def test_malformed_hunk_header_raises():
+    # A bare `@@` (no `-a,b +c,d` line spec) is not a valid hunk header. It used
+    # to be silently skipped, so the whole patch applied nothing and the body
+    # came back unchanged — a silent no-op. Now it raises.
+    bad = "@@\n-old line\n+new line\n"
+    with pytest.raises(DiffConflict):
+        apply_diff("old line\n", bad)
+
+
+def test_patch_without_any_hunk_raises():
+    # Non-empty payload that contains no @@ hunk at all applied nothing → raise,
+    # rather than returning the source body untouched.
+    with pytest.raises(DiffConflict):
+        apply_diff("body\n", "-body\n+new\n")
+
+
+def test_empty_patch_is_still_a_noop():
+    # A genuinely empty patch is the one legitimate no-op (unchanged behavior).
+    assert apply_diff("keep\n", "") == "keep\n"
+    assert apply_diff("keep\n", "   \n") == "keep\n"
+
+
 # ─── byte length is measured in UTF-8, not characters ────────────────────
 def test_byte_len_utf8():
     assert byte_len("abc") == 3

{memgres-0.3.0 → memgres-0.3.2}/tests/test_store_integration.py

@@ -14,7 +14,7 @@ import pytest  # noqa: E402
 psycopg = pytest.importorskip("psycopg")
 
 from memgres.config import load  # noqa: E402
-from memgres.diffing import make_diff, content_hash  # noqa: E402
+from memgres.diffing import make_diff, content_hash, DiffConflict  # noqa: E402
 from memgres.schema import migrate  # noqa: E402
 from memgres.store import Store, Conflict, NotFound, TooLarge, NoParent  # noqa: E402
 
@@ -80,6 +80,21 @@ def test_diff_requires_base_hash(store):
         store.write(id=m.id, diff=make_diff("x\n", "y\n"))
 
 
+def test_malformed_diff_raises_and_does_not_bump_seq(store):
+    # Regression (diff_silently_noops): a diff whose hunk header doesn't parse
+    # used to silently apply nothing — body unchanged but seq++ / updated_at
+    # moved, looking like a successful write. Now it raises and touches nothing.
+    m = store.write(body="alpha\nbeta\n")
+    assert m.seq == 1
+    bad = "@@\n-alpha\n+ALPHA\n"          # bare @@ — not a valid unified-diff hunk
+    with pytest.raises(DiffConflict):
+        store.write(id=m.id, diff=bad, base_hash=m.content_hash)
+    again = store.get(None, m.id)
+    assert again.body == "alpha\nbeta\n"          # body untouched
+    assert again.content_hash == m.content_hash   # hash unchanged
+    assert again.seq == 1                          # seq NOT bumped
+
+
 def test_replace_and_retag(store):
     m = store.write(body="body\n", tags=["old"])
     m2 = store.write(id=m.id, body="new body\n", tags=["new"], reason="replace")