scriptoria 0.6.4__tar.gz → 0.8.0__tar.gz

{scriptoria-0.6.4 → scriptoria-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptoria
-Version: 0.6.4
+Version: 0.8.0
 Summary: Deterministic scriptorium-keeper (the `scrip` CLI): staleness, provenance integrity, and fact queries for an agent-compiled knowledge base
 Project-URL: Homepage, https://github.com/coredipper/scriptorium
 Project-URL: Changelog, https://github.com/coredipper/scriptorium/blob/main/CHANGELOG.md

{scriptoria-0.6.4 → scriptoria-0.8.0}/pyproject.toml

@@ -2,7 +2,7 @@
 # Distribution name on PyPI is `scriptoria` (scrip/scriptorium were taken); the
 # CLI command and the import package both remain `scrip`.
 name = "scriptoria"
-version = "0.6.4"
+version = "0.8.0"
 description = "Deterministic scriptorium-keeper (the `scrip` CLI): staleness, provenance integrity, and fact queries for an agent-compiled knowledge base"
 readme = "README.md"
 requires-python = ">=3.10"

{scriptoria-0.6.4 → scriptoria-0.8.0}/src/scrip/__init__.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 
 from pathlib import Path
 
-__version__ = "0.6.4"
+__version__ = "0.8.0"
 
 # --- canonical vault layout ------------------------------------------------
 # ``root`` is the repo/instance root: the directory containing ``vault/``.

{scriptoria-0.6.4 → scriptoria-0.8.0}/src/scrip/anchors.py

@@ -199,6 +199,27 @@ def verify_vault(root: Path) -> dict:
                 text = _source_text(root, rec["source_id"], src_cache)
                 record(f"claim:{cid}", rec, resolve(text, rec["anchor"]))
 
+    # cited edges (graph.ndjson): an edge that carries an anchor is verified like
+    # a claim; a bare {src,dst,kind} edge has no citation to resolve and is skipped.
+    edges_path = facts_dir(root) / "graph.ndjson"
+    if edges_path.exists():
+        with edges_path.open(encoding="utf-8") as f:
+            for lineno, raw_line in enumerate(f, start=1):
+                line = raw_line.strip()
+                if not line:
+                    continue
+                try:
+                    rec = json.loads(line)
+                except json.JSONDecodeError as e:
+                    raise DataError(f"graph.ndjson:{lineno}: invalid JSON: {e}") from e
+                if "anchor" not in rec:
+                    continue
+                if "source_id" not in rec:
+                    raise DataError(f"graph.ndjson:{lineno}: cited edge missing 'source_id'")
+                text = _source_text(root, rec["source_id"], src_cache)
+                where = f"edge:{rec.get('src')}->{rec.get('dst')} ({rec.get('kind')})"
+                record(where, rec, resolve(text, rec["anchor"]))
+
     wd = wiki_dir(root)
     if wd.is_dir():
         for path in sorted(wd.rglob("*.md")):

{scriptoria-0.6.4 → scriptoria-0.8.0}/src/scrip/facts.py

@@ -53,7 +53,10 @@ _CLAIM_ALLOWED = frozenset((*_CLAIM_REQUIRED, "claim_text", "tags"))
 _ENTITY_REQUIRED = ("entity_id", "name", "kind")
 _ENTITY_ALLOWED = frozenset((*_ENTITY_REQUIRED, "tags"))
 _EDGE_REQUIRED = ("src", "dst", "kind")
-_EDGE_ALLOWED = frozenset(_EDGE_REQUIRED)
+# An edge may optionally be *cited*: a verbatim ``quote`` + ``source_id`` whose
+# ``anchor`` scrip mints+verifies exactly as for a claim. Bare edges stay
+# structural. ``anchor`` remains scrip-owned (proposing it is a schema error).
+_EDGE_ALLOWED = frozenset((*_EDGE_REQUIRED, "quote", "source_id"))
 _DECISIONS = ("supersede", "qualify", "keep-both")
 _RECON_REQUIRED = ("decision", "claim_a", "claim_b")
 _RECON_ALLOWED = frozenset((*_RECON_REQUIRED, "winner", "rationale"))
@@ -161,6 +164,17 @@ def _validate(table: str, rec: dict, index: int) -> None:
         _check_shape(rec, index, _EDGE_REQUIRED, _EDGE_ALLOWED)
         for key in _EDGE_REQUIRED:
             _check_str(rec, key, index)
+        if "quote" in rec or "source_id" in rec:
+            # both or neither: a quote needs a source to anchor against
+            missing = [k for k in ("quote", "source_id") if k not in rec]
+            if missing:
+                raise DataError(
+                    f"record {index}: a cited edge needs both 'quote' and 'source_id' "
+                    f"(missing: {', '.join(missing)})"
+                )
+            _check_str(rec, "source_id", index)
+            # quote emptiness is a per-record finding (EMPTY_QUOTE), not a schema error
+            _check_str(rec, "quote", index, allow_blank=True)
     else:  # reconciliations
         _check_shape(rec, index, _RECON_REQUIRED, _RECON_ALLOWED, owned=_RECON_OWNED)
         for key in ("decision", "claim_a", "claim_b"):
@@ -390,13 +404,16 @@ def add(root: Path, table: str, proposals: list[dict]) -> dict:
     resolved: list[dict | None] = [None] * len(proposals)
     path = facts_dir(root) / _FILES[table]
     with lock.write_lock(root):
-        if table == "claims":
-            # Resolve quotes INSIDE the lock: raw/ only changes via a *locked*
-            # `ingest --reingest`, so holding the lock from verification through
-            # append closes the window where a re-ingest could land between the
-            # two and silently break the just-minted anchors.
+        # Resolve quotes INSIDE the lock: raw/ only changes via a *locked*
+        # `ingest --reingest`, so holding the lock from verification through
+        # append closes the window where a re-ingest could land between the
+        # two and silently break the just-minted anchors. Claims always carry a
+        # quote; an edge does only when it is *cited*.
+        if table == "claims" or table == "edges":
             src_cache: dict[str, str | None] = {}
             for i, rec in enumerate(proposals):
+                if table == "edges" and "quote" not in rec:
+                    continue  # bare edge: nothing to anchor
                 fail, res = _resolve_claim(root, rec, i, src_cache)
                 if fail:
                     failures.append(fail)
@@ -478,7 +495,12 @@ def add(root: Path, table: str, proposals: list[dict]) -> dict:
                     skipped.append({"index": i, "reason": "duplicate", "existing_id": None})
                     continue
                 seen_edges.add(key)
-                appended.append({"src": rec["src"], "dst": rec["dst"], "kind": rec["kind"]})
+                full = {"src": rec["src"], "dst": rec["dst"], "kind": rec["kind"]}
+                res = resolved[i]
+                if res is not None:  # cited edge: carry the minted provenance
+                    full["source_id"] = res["source_id"]
+                    full["anchor"] = res["anchor"]
+                appended.append(full)
         else:  # reconciliations
             claim_ids = {c.get("claim_id") for c in _read_table(facts_dir(root) / "claims.ndjson")[0]}
             for i, rec in enumerate(proposals):
@@ -528,10 +550,11 @@ def add(root: Path, table: str, proposals: list[dict]) -> dict:
                     f.write("\n")
                 f.write(payload)
             new_sources: list[str] = []
-            if table == "claims":
+            if table in ("claims", "edges"):
                 for rec in appended:
-                    if rec["source_id"] not in new_sources:
-                        new_sources.append(rec["source_id"])
+                    sid = rec.get("source_id")  # cited edges carry one; bare edges don't
+                    if sid and sid not in new_sources:
+                        new_sources.append(sid)
             _write_meta(root, meta, new_sources)
 
     return {"table": table, "appended": appended, "skipped": skipped, "failures": []}

{scriptoria-0.6.4 → scriptoria-0.8.0}/src/scrip/lock.py

@@ -8,14 +8,18 @@ writers don't interleave stamps and edits. Reads (``status``, ``verify``,
 
 The lock is a small JSON file created atomically with ``O_CREAT|O_EXCL`` holding
 ``{pid, host, acquired_at}``. A lock whose holder is a dead process *on this
-host* is **stale** and is reclaimed automatically on acquire; a lock that looks
-live fails fast (exit 2) and points the user at ``scrip unlock``. A lock from
-another host is treated as live (we can't prove the process dead).
+host* is **stale** and is reclaimed automatically on acquire. A lock that looks
+live is **waited on**: ``acquire`` polls (with backoff) up to a timeout —
+``SCRIP_LOCK_TIMEOUT`` seconds, default 10 — so two agents serialize cooperatively
+rather than one failing immediately. If the lock is still held when the wait
+elapses it fails (exit 2) and points the user at ``scrip unlock``; ``timeout=0``
+keeps the old fail-fast behavior. A lock from another host is treated as live (we
+can't prove the process dead), so it is waited on but never reclaimed.
 
 It is advisory, not a kernel mutex: a tiny TOCTOU window remains when reclaiming
-a stale lock. That is acceptable for the single-machine, single-agent workflow
-this guards; it is a guardrail against accidental concurrent writes, not a
-distributed lock manager.
+a stale lock, and waiting is best-effort polling, not a fair queue. That is
+acceptable for the single-machine workflow this guards; it is a guardrail against
+accidental concurrent writes, not a distributed lock manager.
 """
 
 from __future__ import annotations
@@ -24,6 +28,7 @@ import json
 import os
 import socket
 import tempfile
+import time
 from contextlib import contextmanager
 from datetime import datetime, timezone
 from pathlib import Path
@@ -31,6 +36,31 @@ from pathlib import Path
 from . import lock_path
 from .errors import LockError, UsageError
 
+# How long ``acquire`` waits for a busy lock before giving up (seconds). The default
+# is cooperative: concurrent writers serialize rather than failing fast. ``0`` keeps
+# the old fail-fast behavior; ``SCRIP_LOCK_TIMEOUT`` overrides it. The poll interval
+# backs off from _POLL_MIN to _POLL_MAX so a freed lock is taken promptly without
+# busy-spinning.
+_DEFAULT_LOCK_TIMEOUT = 10.0
+_POLL_MIN = 0.025
+_POLL_MAX = 0.25
+
+
+def _lock_timeout(explicit: float | None) -> float:
+    """Seconds ``acquire`` should wait for a busy lock. An explicit argument wins;
+    otherwise read ``SCRIP_LOCK_TIMEOUT`` (default :data:`_DEFAULT_LOCK_TIMEOUT`). A
+    missing or unparseable env value falls back to the default; negatives clamp to 0
+    (fail fast)."""
+    if explicit is not None:
+        return max(0.0, explicit)
+    raw = os.environ.get("SCRIP_LOCK_TIMEOUT")
+    if raw is None or not raw.strip():
+        return _DEFAULT_LOCK_TIMEOUT
+    try:
+        return max(0.0, float(raw))
+    except ValueError:
+        return _DEFAULT_LOCK_TIMEOUT
+
 
 def _now() -> str:
     return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
@@ -129,45 +159,68 @@ def _create(path: Path, payload: bytes) -> None:
             pass
 
 
-def acquire(root: Path) -> dict:
+def acquire(root: Path, *, timeout: float | None = None) -> dict:
     """Take the lock, returning the holder info. Reclaims a *provably-dead* lock
-    once; raises :class:`LockError` (exit 2) if the lock looks live or is being
-    created by another writer."""
+    immediately. If the lock looks live (or is mid-creation by another writer),
+    *waits* — polling with backoff — up to ``timeout`` seconds for it to free, then
+    raises :class:`LockError` (exit 2) if it is still held. ``timeout`` defaults to
+    ``SCRIP_LOCK_TIMEOUT`` (``10`` s); ``timeout=0`` fails fast (the old behavior).
+    A holder that dies *during* the wait is reclaimed on the next poll."""
     p = lock_path(root)
     p.parent.mkdir(parents=True, exist_ok=True)
     info = _holder_info()
     payload = (json.dumps(info, ensure_ascii=False) + "\n").encode("utf-8")
-    try:
-        _create(p, payload)
-        return info
-    except FileExistsError:
-        pass
+    wait = _lock_timeout(timeout)
+    deadline = time.monotonic() + wait
+    poll = _POLL_MIN
 
-    existing = _read(p)
-    if not _reclaimable(existing):
-        if existing is None:
-            raise LockError(
-                ".kb/lock is held but not yet readable (another writer may be "
-                "acquiring it). Retry; run `scrip unlock --force` if it is stuck."
-            ) from None
-        raise LockError(
-            f"vault is locked by another writer ({_describe(existing)}). Wait for "
-            f"it to finish, or run `scrip unlock --force` if it is stuck."
-        ) from None
+    def _try_take() -> bool:
+        """One acquisition attempt: True if we now hold the lock. A provably-dead
+        lock on this host is reclaimed and retried once; otherwise we don't hold it."""
+        try:
+            _create(p, payload)
+            return True
+        except FileExistsError:
+            pass
+        if _reclaimable(_read(p)):
+            try:
+                p.unlink()
+            except FileNotFoundError:
+                pass
+            try:
+                _create(p, payload)
+                return True
+            except FileExistsError:
+                pass  # raced with another writer; fall through to wait/retry
+        return False
 
-    # Reclaim a clearly-dead lock and retry once.
-    try:
-        p.unlink()
-    except FileNotFoundError:
-        pass
-    try:
-        _create(p, payload)
-    except FileExistsError:
+    # Always attempt once (so a free lock is taken even at timeout=0), then poll —
+    # re-checking the deadline both before sleeping and again after, so we never
+    # retry (and grab) a lock that freed only once the budget was already spent.
+    if _try_take():
+        return info
+    while True:
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            break
+        time.sleep(min(poll, remaining))  # remaining > 0 here, so never negative
+        poll = min(poll * 2, _POLL_MAX)
+        if time.monotonic() >= deadline:
+            break
+        if _try_take():
+            return info
+
+    existing = _read(p)  # who holds it now, for the diagnostic
+    waited = f" after waiting {wait:g}s" if wait else ""
+    if existing is None:
         raise LockError(
-            "could not acquire .kb/lock (raced with another writer); retry, or "
-            "`scrip unlock` if it is stuck."
+            ".kb/lock is held but not yet readable (another writer may be "
+            f"acquiring it){waited}. Retry; run `scrip unlock --force` if it is stuck."
         ) from None
-    return info
+    raise LockError(
+        f"vault is locked by another writer ({_describe(existing)}){waited}. "
+        f"Wait for it to finish, or run `scrip unlock --force` if it is stuck."
+    ) from None
 
 
 def release(root: Path, info: dict | None = None) -> None:
@@ -187,8 +240,8 @@ def release(root: Path, info: dict | None = None) -> None:
 
 
 @contextmanager
-def write_lock(root: Path):
-    info = acquire(root)
+def write_lock(root: Path, *, timeout: float | None = None):
+    info = acquire(root, timeout=timeout)
     try:
         yield info
     finally:

{scriptoria-0.6.4 → scriptoria-0.8.0}/tests/conftest.py

@@ -16,6 +16,16 @@ import pytest
 from scrip import anchors, blocks, frontmatter, hashing
 
 
+@pytest.fixture(autouse=True)
+def _fail_fast_lock(monkeypatch):
+    """Keep the hermetic suite fast: the write lock now *waits* for a busy lock
+    (``SCRIP_LOCK_TIMEOUT``, default 10s). Pin it to 0 (fail-fast) for tests so the
+    lock-blocked cases return immediately instead of sitting through the wait. Tests
+    of the waiting path pass an explicit ``timeout=`` to :func:`scrip.lock.acquire`,
+    which overrides this env default."""
+    monkeypatch.setenv("SCRIP_LOCK_TIMEOUT", "0")
+
+
 class KB:
     def __init__(self, root: Path):
         self.root = root

{scriptoria-0.6.4 → scriptoria-0.8.0}/tests/test_fact_cmd.py

@@ -31,6 +31,12 @@ def _claim(quote, source="raw/s", **kw):
     return rec
 
 
+def _edge(src="entity/a", dst="entity/b", kind="relates-to", **kw):
+    rec = {"src": src, "dst": dst, "kind": kind}
+    rec.update(kw)
+    return rec
+
+
 def _ndjson(*recs):
     return "".join(json.dumps(r, ensure_ascii=False) + "\n" for r in recs)
 
@@ -55,6 +61,13 @@ def _recs_lines(kb):
     return [json.loads(s) for s in p.read_text(encoding="utf-8").splitlines() if s.strip()]
 
 
+def _graph_lines(kb):
+    p = kb.root / "vault" / "facts" / "graph.ndjson"
+    if not p.exists():
+        return []
+    return [json.loads(s) for s in p.read_text(encoding="utf-8").splitlines() if s.strip()]
+
+
 def _two_claims(kb):
     """Seed a contradiction pair to reconcile."""
     kb.add_raw("s", SRC)
@@ -476,3 +489,63 @@ def test_fact_add_edges_appends_and_skips_duplicates(kb):
     assert _run_add(kb, _ndjson(edge), "--table", "edges") == 0
     lines = (kb.root / "vault" / "facts" / "graph.ndjson").read_text(encoding="utf-8")
     assert len(lines.splitlines()) == 1
+
+
+# --------------------------------------------------------------------------- #
+# Cited edges: an edge may carry a verbatim quote + source_id; scrip mints and
+# verifies an anchor for it exactly as it does for a claim. Bare edges still work.
+# --------------------------------------------------------------------------- #
+def test_fact_add_bare_edge_carries_no_provenance(kb):
+    # additivity guard: an edge with no quote stays purely structural
+    assert _run_add(kb, _ndjson(_edge()), "--table", "edges") == 0
+    [edge] = _graph_lines(kb)
+    assert set(edge) == {"src", "dst", "kind"}
+
+
+def test_fact_add_cited_edge_mints_and_verifies_anchor(kb):
+    kb.add_raw("s", SRC)
+    rc = _run_add(
+        kb,
+        _ndjson(_edge(quote="Caching answers beats recomputing them.", source_id="raw/s")),
+        "--table", "edges",
+    )
+    assert rc == 0
+    [edge] = _graph_lines(kb)
+    assert (edge["src"], edge["dst"], edge["kind"]) == ("entity/a", "entity/b", "relates-to")
+    assert edge["source_id"] == "raw/s"
+    # the minted anchor resolves uniquely in the source, and scrip verify confirms it
+    assert anchors.resolve(SRC, edge["anchor"]) == "OK"
+    assert cli.main(["verify", "--root", str(kb.root)]) == 0
+
+
+def test_fact_add_cited_edge_broken_quote_fails_batch(kb, capsys):
+    kb.add_raw("s", SRC)
+    rc = _run_add(
+        kb,
+        _ndjson(_edge(quote="this sentence is absent from the source", source_id="raw/s")),
+        "--table", "edges", "--json",
+    )
+    assert rc == 1
+    assert _graph_lines(kb) == []  # all-or-nothing: nothing written
+    [failure] = json.loads(capsys.readouterr().out)["failures"]
+    assert failure["status"] == "BROKEN"
+
+
+def test_fact_add_cited_edge_requires_both_quote_and_source_id(kb):
+    kb.add_raw("s", SRC)
+    # a quote needs a source to anchor against, and vice versa — both or neither
+    assert _run_add(kb, _ndjson(_edge(quote="Caching answers beats recomputing them.")),
+                    "--table", "edges") == 3
+    assert _run_add(kb, _ndjson(_edge(source_id="raw/s")), "--table", "edges") == 3
+    assert _graph_lines(kb) == []
+
+
+def test_fact_add_cited_edge_dedups_on_triple(kb, capsys):
+    kb.add_raw("s", SRC)
+    cited = _ndjson(_edge(quote="Caching answers beats recomputing them.", source_id="raw/s"))
+    assert _run_add(kb, cited, "--table", "edges") == 0
+    capsys.readouterr()
+    # same (src,dst,kind) again — even bare — is the same relation, so it's skipped
+    assert _run_add(kb, _ndjson(_edge()), "--table", "edges", "--json") == 0
+    assert len(_graph_lines(kb)) == 1
+    assert json.loads(capsys.readouterr().out)["skipped"][0]["reason"] == "duplicate"

{scriptoria-0.6.4 → scriptoria-0.8.0}/tests/test_lock.py

@@ -6,6 +6,8 @@ import os
 import socket
 import stat
 import subprocess
+import threading
+import time
 
 import pytest
 
@@ -85,6 +87,91 @@ def test_release_only_removes_our_own_lock(tmp_path):
     lock_path(tmp_path).unlink()
 
 
+# --- waiting (cooperative blocking acquire) ---------------------------------
+def test_acquire_timeout_zero_fails_fast_on_live_lock(tmp_path):
+    info = lock.acquire(tmp_path, timeout=0)
+    try:
+        start = time.monotonic()
+        with pytest.raises(errors.LockError) as ei:
+            lock.acquire(tmp_path, timeout=0)
+        assert ei.value.exit_code == 2
+        assert time.monotonic() - start < 0.2  # immediate — no wait at timeout=0
+    finally:
+        lock.release(tmp_path, info)
+
+
+def test_acquire_waits_for_a_busy_lock_then_succeeds(tmp_path):
+    # a writer holds the lock briefly; a waiting acquire grabs it once it frees,
+    # rather than failing fast.
+    info = lock.acquire(tmp_path, timeout=0)
+
+    def _release_after():
+        time.sleep(0.2)
+        lock.release(tmp_path, info)
+
+    t = threading.Thread(target=_release_after)
+    t.start()
+    try:
+        start = time.monotonic()
+        info2 = lock.acquire(tmp_path, timeout=5)  # blocks ~0.2s, then acquires
+        waited = time.monotonic() - start
+        assert waited >= 0.15  # it actually waited for the release
+        assert json.loads(lock_path(tmp_path).read_text())["pid"] == os.getpid()
+        lock.release(tmp_path, info2)
+    finally:
+        t.join()
+
+
+def test_acquire_times_out_while_lock_stays_held(tmp_path):
+    info = lock.acquire(tmp_path, timeout=0)
+    try:
+        start = time.monotonic()
+        with pytest.raises(errors.LockError) as ei:
+            lock.acquire(tmp_path, timeout=0.3)
+        waited = time.monotonic() - start
+        assert ei.value.exit_code == 2
+        assert 0.25 <= waited < 3.0  # waited ~the timeout, then gave up (not forever)
+    finally:
+        lock.release(tmp_path, info)
+
+
+def test_acquire_does_not_grab_a_lock_freed_after_the_deadline(tmp_path, monkeypatch):
+    # A writer releases only once the timeout has elapsed. acquire must time out
+    # (exit 2), not wake from its last sleep, retry, and grab the just-freed lock —
+    # which would silently extend the budget past SCRIP_LOCK_TIMEOUT. Driven by a
+    # mocked clock so the boundary is deterministic (real-time races are not).
+    info = lock.acquire(tmp_path, timeout=0)  # our live pid holds it
+    clock = {"t": 100.0}
+    sleeps: list[float] = []
+    monkeypatch.setattr(lock.time, "monotonic", lambda: clock["t"])
+
+    def fake_sleep(d):
+        sleeps.append(d)
+        clock["t"] += d
+        if clock["t"] >= 100.3 and lock_path(tmp_path).exists():
+            lock.release(tmp_path, info)  # freed, but only at/after the deadline
+
+    monkeypatch.setattr(lock.time, "sleep", fake_sleep)
+    try:
+        with pytest.raises(errors.LockError) as ei:
+            lock.acquire(tmp_path, timeout=0.3)  # deadline = 100.0 + 0.3
+        assert ei.value.exit_code == 2
+        assert all(d >= 0 for d in sleeps)  # never a negative sleep duration
+    finally:
+        if lock_path(tmp_path).exists():
+            lock.release(tmp_path, info)
+
+
+def test_lock_timeout_resolution(monkeypatch):
+    monkeypatch.delenv("SCRIP_LOCK_TIMEOUT", raising=False)
+    assert lock._lock_timeout(None) == 10.0  # default when unset
+    monkeypatch.setenv("SCRIP_LOCK_TIMEOUT", "3.5")
+    assert lock._lock_timeout(None) == 3.5  # env configures the default
+    assert lock._lock_timeout(0) == 0.0  # an explicit timeout wins over the env
+    monkeypatch.setenv("SCRIP_LOCK_TIMEOUT", "nonsense")
+    assert lock._lock_timeout(None) == 10.0  # a bad env value falls back to default
+
+
 # --- staleness --------------------------------------------------------------
 def test_leftover_temp_from_recycled_pid_does_not_block_acquire(tmp_path, monkeypatch):
     """A temp file left by a crashed process must not be mistaken for a held lock

{scriptoria-0.6.4 → scriptoria-0.8.0}/tests/test_verify.py

@@ -1,9 +1,17 @@
+import json
+
 import pytest
 from scrip.errors import DataError
 
 from scrip import anchors, cli
 
 
+def _write_edge(kb, rec):
+    p = kb.root / "vault" / "facts" / "graph.ndjson"
+    with open(p, "a", encoding="utf-8") as f:
+        f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+
+
 def test_cli_verify_fails_on_ambiguous_by_default(kb):
     # a quote that occurs twice in the source -> AMBIGUOUS
     kb.add_raw("a", "# A\n\nalpha beta gamma. alpha beta gamma.\n")
@@ -62,3 +70,33 @@ def test_verify_wiki_footnote_anchor(kb):
     res = anchors.verify_vault(kb.root)
     assert res["ok"] == 1
     assert res["broken"] == []
+
+
+def test_verify_cited_edge_anchor_resolves(kb):
+    src = "# A\n\nThe sky is blue today over the hills.\n"
+    kb.add_raw("a", src)
+    anchor = anchors.make_anchor(src, "the sky is blue today")
+    _write_edge(kb, {"src": "entity/sky", "dst": "entity/color", "kind": "is",
+                     "source_id": "raw/a", "anchor": anchor})
+    res = anchors.verify_vault(kb.root)
+    assert res["ok"] == 1
+    assert res["broken"] == []
+
+
+def test_verify_broken_cited_edge_anchor_is_listed(kb):
+    kb.add_raw("a", "# A\n\nThe sky is blue.\n")
+    bogus = "qh:" + ("0" * 64) + "|loc:0.0|len:10"
+    _write_edge(kb, {"src": "entity/a", "dst": "entity/b", "kind": "rel",
+                     "source_id": "raw/a", "anchor": bogus})
+    res = anchors.verify_vault(kb.root)
+    assert len(res["broken"]) == 1
+    assert res["broken"][0]["where"].startswith("edge:")
+
+
+def test_verify_bare_edge_is_not_checked(kb):
+    # an uncited edge has nothing to resolve, so verify ignores it (additive)
+    kb.add_raw("a", "# A\n\nThe sky is blue.\n")
+    _write_edge(kb, {"src": "entity/a", "dst": "entity/b", "kind": "rel"})
+    res = anchors.verify_vault(kb.root)
+    assert res["checked"] == 0
+    assert res["broken"] == []

{scriptoria-0.6.4 → scriptoria-0.8.0}/uv.lock

@@ -1141,7 +1141,7 @@ wheels = [
 
 [[package]]
 name = "scriptoria"
-version = "0.6.4"
+version = "0.8.0"
 source = { editable = "." }
 dependencies = [
     { name = "duckdb" },