memgres 0.12.2__tar.gz → 0.12.3__tar.gz

{memgres-0.12.2 → memgres-0.12.3}/PKG-INFO

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

{memgres-0.12.2 → memgres-0.12.3}/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.12.2"
+__version__ = "0.12.3"

{memgres-0.12.2 → memgres-0.12.3}/memgres/store.py

@@ -451,6 +451,57 @@ def _slice_lines(m: "Memory", spec: str) -> "Memory":
     return m
 
 
+
+# How much body text a "why did my replace miss" hint may quote, per side.
+_HINT_CONTEXT = 48
+
+
+def _why_replace_missed(body: str, old: str) -> str:
+    """Say WHY a substring edit found nothing — the refusal alone sends the author
+    to re-read the whole record, when the useful answer is almost always "your
+    quote is not what the body says, here is what it says".
+
+    Three causes, in the order they actually happen:
+
+    1. **Whitespace.** Bodies are hard-wrapped, so a phrase that reads as one line
+       on screen contains a newline. Retyped as a space, it can never match.
+    2. **Case.**
+    3. **Everything else** — then the most useful thing is the point where the
+       quote stops agreeing with the body, and what the body has instead.
+
+    The quote itself is usually reconstructed by eye rather than copied, which is
+    why the hint ends by naming the one reliable source: `memory_get`. A recall
+    snippet is a slice of the body (`lines` says which) EXCEPT on the ts_headline
+    path, where Postgres rebuilds the text from tokens and `lines` is null — that
+    one is not quotable at all.
+    """
+    squashed_old = " ".join(old.split())
+    if squashed_old and squashed_old in " ".join(body.split()):
+        return (" — the text IS in the body, but the whitespace differs: bodies "
+                "wrap, so a line break in the record reads as a space on screen. "
+                "Copy the line from `memory_get`, not from a recall snippet")
+    if old.lower() in body.lower():
+        return (" — it is there in a different case. Copy it from `memory_get`, "
+                "not from a recall snippet")
+    # Longest prefix of `old` the body still agrees with: the point of divergence
+    # is what the author needs to see. Binary search — bodies are capped, but a
+    # linear scan would re-scan the whole body once per character.
+    lo, hi = 0, len(old)
+    while lo < hi:
+        mid = (lo + hi + 1) // 2
+        if old[:mid] in body:
+            lo = mid
+        else:
+            hi = mid - 1
+    if lo == 0:
+        return (" — not one character of it is in the body; wrong memory, or the "
+                "quote was written from memory rather than copied from `memory_get`")
+    at = body.find(old[:lo])
+    reads = body[at:at + lo + _HINT_CONTEXT]
+    return (f" — the first {lo} chars match, then they part: the body reads "
+            f"{reads!r}. Copy from `memory_get`, not from a recall snippet")
+
+
 class Store:
     def __init__(self, cfg: Config, embedder: Optional[Embedder] = None,
                  conn: Optional["psycopg.Connection"] = None,
@@ -773,11 +824,38 @@ class Store:
                 f"this deployment requires `{field}` on every write that stores "
                 f"content — {help_text}")
 
+    # How much of the title to quote either side of the cut. Enough to recognise
+    # the words, short enough that a pathological title cannot turn the refusal
+    # into a wall of text.
+    _TITLE_CUT_CONTEXT = 40
+
     def _check_title_size(self, title: Optional[str]):
-        if title is not None and byte_len(title) > self.cfg.max_title_bytes:
-            raise TooLarge(
-                f"title is {byte_len(title)}B > MEMGRES_MAX_TITLE_BYTES "
-                f"{self.cfg.max_title_bytes}")
+        """Refuse an oversized title, and SHOW WHERE IT STOPS FITTING.
+
+        The ceiling is in bytes because that is what storage and the wire count,
+        but the author is writing characters — and in UTF-8 the exchange rate
+        depends on the script: Latin runs ~1 B/char, Cyrillic ~2, so the same 256
+        B is ~256 characters in one language and ~148 in another. A refusal that
+        names only bytes leaves the author trimming blind, one attempt at a time
+        (observed: four rejected writes in a row on one record). So the message
+        carries the character counts and quotes the cut itself, marked with ✂ —
+        what survives on the left, what has to go on the right."""
+        if title is None:
+            return
+        size, cap = byte_len(title), self.cfg.max_title_bytes
+        if size <= cap:
+            return
+        # Truncating BYTES can land mid-character; decoding with "ignore" drops
+        # that partial character, which is exactly the last one that does NOT fit.
+        fits = title.encode("utf-8")[:cap].decode("utf-8", "ignore")
+        over = title[len(fits):]
+        ctx = self._TITLE_CUT_CONTEXT
+        left = ("…" if len(fits) > ctx else "") + fits[-ctx:]
+        right = over[:ctx] + ("…" if len(over) > ctx else "")
+        raise TooLarge(
+            f"title is {size}B > MEMGRES_MAX_TITLE_BYTES {cap}: "
+            f"{len(title)} chars, {len(fits)} fit, drop {len(over)} — "
+            f"{left}[✂]{right}")
 
     def _create(self, ns, author, body, path, tags, source, reason,
                 title=None, valid_at=None) -> Memory:
@@ -868,7 +946,9 @@ class Store:
                 raise Conflict(f"stale replace: base {base_hash[:12]} != current {cur_hash[:12]}")
             count = cur_body.count(old)
             if count == 0:
-                raise ReplaceNotFound(f"replace text not found in body: {old[:60]!r}")
+                raise ReplaceNotFound(
+                    f"replace text not found in body: {old[:60]!r}"
+                    f"{_why_replace_missed(cur_body, old)}")
             if count > 1 and not replace_all:
                 raise AmbiguousReplace(
                     f"replace text occurs {count}× — pass replace_all, or add "

{memgres-0.12.2 → memgres-0.12.3}/memgres.egg-info/PKG-INFO

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

{memgres-0.12.2 → memgres-0.12.3}/tests/test_require_title.py

@@ -26,7 +26,7 @@ psycopg = pytest.importorskip("psycopg")
 
 from memgres.config import load  # noqa: E402
 from memgres.schema import migrate  # noqa: E402
-from memgres.store import MissingTitle, Store  # noqa: E402
+from memgres.store import MissingTitle, Store, TooLarge  # noqa: E402
 
 DSN = os.environ.get("MEMGRES_TEST_DSN",
                      "postgresql://memgres:memgres@localhost:55432/memgres")
@@ -181,3 +181,36 @@ def test_a_create_with_no_body_blames_the_body(conn, monkeypatch):
     s = _store(conn, monkeypatch, True)
     with pytest.raises(ValueError, match="needs a body"):
         s.write(path="a.b")
+
+
+# ─── the size ceiling explains itself ────────────────────────────────────────
+def test_an_oversized_title_shows_where_it_stops_fitting(conn, monkeypatch):
+    """The ceiling counts bytes, the author counts characters, and in UTF-8 the
+    rate depends on the script — so a refusal naming only bytes leaves them
+    trimming blind. The message quotes the cut: what fits, what has to go."""
+    monkeypatch.setenv("MEMGRES_MAX_TITLE_BYTES", "40")
+    s = _store(conn, monkeypatch, True)
+    title = "Лимит заголовка меряется в байтах, а не в символах"
+    with pytest.raises(TooLarge) as e:
+        s.write(body="one", path="a.b", title=title)
+    msg = str(e.value)
+    # counts in BOTH units, and how much to drop
+    assert f"{len(title.encode())}B" in msg and "40" in msg
+    assert f"{len(title)} chars" in msg
+    # the cut is quoted, and the two sides really are the two sides
+    assert "[✂]" in msg
+    fits = title.encode()[:40].decode("utf-8", "ignore")
+    assert f"{len(fits)} fit" in msg
+    assert f"drop {len(title) - len(fits)}" in msg
+    assert fits[-10:] + "[✂]" in msg          # left of the cut survives
+    assert "[✂]" + title[len(fits):][:10] in msg   # right of it is what to drop
+
+
+def test_a_title_that_only_just_fits_is_accepted(conn, monkeypatch):
+    """The boundary itself is not an error — byte_len == cap must pass, or the
+    limit silently means one byte less than it says."""
+    monkeypatch.setenv("MEMGRES_MAX_TITLE_BYTES", "40")
+    s = _store(conn, monkeypatch, True)
+    title = "я" * 20                      # exactly 40 bytes
+    assert len(title.encode()) == 40
+    assert s.write(body="one", path="a.b", title=title).title == title

{memgres-0.12.2 → memgres-0.12.3}/tests/test_store_integration.py

@@ -230,6 +230,38 @@ def test_replace_not_found_leaves_record_untouched(store):
     assert again.body == "alpha\nbeta\n" and again.seq == 1
 
 
+def test_a_missed_replace_says_the_quote_crossed_a_line_break(store):
+    """The commonest miss: the body wraps, the phrase reads as one line on
+    screen, and the quote comes back with a space where the record has \n. The
+    refusal has to name that, or the author goes re-reading the whole record."""
+    store.write(body="хвост ниши по деньгам — перепродажа\nExa через x402\n",
+                path="a.b", title="A")
+    with pytest.raises(ReplaceNotFound) as e:
+        store.write(at="a.b", replace=("перепродажа Exa", "перепродажа Exa Search"))
+    msg = str(e.value)
+    assert "whitespace differs" in msg and "memory_get" in msg
+
+
+def test_a_missed_replace_shows_where_the_quote_parts_from_the_body(store):
+    """When it is not whitespace, the useful answer is the point of divergence
+    and what the body actually says there."""
+    store.write(body="верх ниши — **«rail dead»** значит другое\n",
+                path="a.c", title="A")
+    with pytest.raises(ReplaceNotFound) as e:
+        store.write(at="a.c", replace=("верх ниши — «rail dead»", "x"))
+    msg = str(e.value)
+    assert "chars match" in msg and "«rail dead»**" in msg
+
+
+def test_a_replace_of_something_absent_says_so_plainly(store):
+    """No prefix at all is a different mistake — wrong record, or a quote written
+    from memory — and must not be dressed up as a near miss."""
+    store.write(body="alpha\nbeta\n", path="a.d", title="A")
+    with pytest.raises(ReplaceNotFound) as e:
+        store.write(at="a.d", replace=("zzz", "x"))
+    assert "not one character" in str(e.value)
+
+
 def test_replace_ambiguous_requires_all_or_context(store):
     m = store.write(body="x x x\n")
     with pytest.raises(AmbiguousReplace):