sibyl-memory-cli 0.3.13__tar.gz → 0.3.15__tar.gz

{sibyl_memory_cli-0.3.13 → sibyl_memory_cli-0.3.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sibyl-memory-cli
-Version: 0.3.13
+Version: 0.3.15
 Summary: Command-line interface for the Sibyl Memory Plugin. `sibyl init` activates, `sibyl upgrade` runs the staker / subscription flow, `sibyl status` shows current tier and DB stats, `sibyl whoami` gives a one-line account summary, `sibyl devices` lists active devices and supports per-device revoke.
 Author-email: "SIBYL, Sibyl Labs LLC" <sibyl@sibyllabs.org>
 License: MIT

{sibyl_memory_cli-0.3.13 → sibyl_memory_cli-0.3.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sibyl-memory-cli"
-version = "0.3.13"
+version = "0.3.15"
 description = "Command-line interface for the Sibyl Memory Plugin. `sibyl init` activates, `sibyl upgrade` runs the staker / subscription flow, `sibyl status` shows current tier and DB stats, `sibyl whoami` gives a one-line account summary, `sibyl devices` lists active devices and supports per-device revoke."
 authors = [{ name = "SIBYL, Sibyl Labs LLC", email = "sibyl@sibyllabs.org" }]
 license = { text = "MIT" }

{sibyl_memory_cli-0.3.13 → sibyl_memory_cli-0.3.15}/src/sibyl_memory_cli/cli.py

@@ -516,6 +516,55 @@ def cmd_upgrade(args: argparse.Namespace) -> int:
 
 # ---- `sibyl status` ----------------------------------------------------
 
+def _discover_stores(primary_db: Path) -> list[dict[str, Any]]:
+    """Enumerate every memory.db an agent on this machine might resolve.
+
+    Beta reports (VRTX 2026-06-11) showed split-brain storage: the SDK / CLI /
+    MCP default (``~/.sibyl-memory/memory.db``), the Hermes adapter
+    (``$HERMES_HOME/sibyl/memory.db``), per-profile DBs
+    (``$HERMES_HOME/sibyl/profiles/<p>/memory.db``), and an MCP
+    ``SIBYL_MEMORY_DB`` override can each hold a disjoint set of memories, so a
+    user switching entry points sees memory "vanish". This surfaces all of
+    them in one place. Read-only: it never creates or moves anything (path
+    unification is a separate, migration-gated change).
+
+    Returns one dict per DISTINCT existing store, resolved + deduped:
+    ``{"label", "path", "size"}``.
+    """
+    candidates: list[tuple[str, Path]] = [("default (SDK/CLI/MCP)", primary_db)]
+
+    hermes_home_env = os.environ.get("HERMES_HOME")
+    hermes_home = Path(hermes_home_env).expanduser() if hermes_home_env else (Path.home() / ".hermes")
+    candidates.append(("hermes adapter", hermes_home / "sibyl" / "memory.db"))
+    profiles_dir = hermes_home / "sibyl" / "profiles"
+    if profiles_dir.is_dir():
+        for prof in sorted(profiles_dir.iterdir()):
+            db = prof / "memory.db"
+            if db.exists():
+                candidates.append((f"hermes profile · {prof.name}", db))
+
+    mcp_override = os.environ.get("SIBYL_MEMORY_DB")
+    if mcp_override:
+        candidates.append(("MCP SIBYL_MEMORY_DB", Path(mcp_override).expanduser()))
+
+    seen: set[str] = set()
+    stores: list[dict[str, Any]] = []
+    for label, path in candidates:
+        try:
+            resolved = str(path.resolve())
+        except OSError:
+            resolved = str(path)
+        if resolved in seen or not path.exists():
+            continue
+        seen.add(resolved)
+        try:
+            size = path.stat().st_size
+        except OSError:
+            size = 0
+        stores.append({"label": label, "path": str(path), "size": size})
+    return stores
+
+
 def cmd_status(args: argparse.Namespace) -> int:
     """Show local + server-side state without modifying anything.
 
@@ -552,6 +601,27 @@ def cmd_status(args: argparse.Namespace) -> int:
     else:
         print(a.kv("DB path", f"{db_path} (not created)"))
 
+    # All resolvable stores on this machine (split-brain visibility floor,
+    # VRTX beta report 2026-06-11). Read-only: lists what exists, moves
+    # nothing. A divergence warning fires when more than one store holds data,
+    # because that is exactly when an agent "loses" memory by switching the
+    # entry point it reads from.
+    stores = _discover_stores(db_path)
+    if len(stores) > 1:
+        print()
+        print(a.eyebrow("memory stores"))
+        for s in stores:
+            mb = s["size"] / (1024 * 1024)
+            print(a.kv(s["label"], f"{s['path']}  ({s['size']:,} bytes · {mb:.2f} MB)"))
+        with_data = [s for s in stores if s["size"] > 0]
+        if len(with_data) > 1:
+            print()
+            print(a.warn_line("Multiple memory stores hold data on this machine."))
+            print(a.dim("  Memory is NOT shared across these paths. An agent reads only the store"))
+            print(a.dim("  for its entry point (SDK/CLI vs Hermes vs profile vs MCP), so memory can"))
+            print(a.dim("  look 'missing' when you switch. Point every entry point at one path via"))
+            print(a.dim("  --db / SIBYL_MEMORY_DB, or back up and consolidate before relying on recall."))
+
     tier_cache = Path(args.tier_cache).expanduser()
     if tier_cache.exists():
         cache = json.loads(tier_cache.read_text(encoding="utf-8"))
@@ -1144,6 +1214,22 @@ def build_parser() -> argparse.ArgumentParser:
     p_h = sub.add_parser("health", help="Run the provider self-check")
     p_h.set_defaults(func=cmd_health)
 
+    p_mem = sub.add_parser("memory", help="Read-only inspection of your memory store (list / search / recall)")
+    mem_sub = p_mem.add_subparsers(dest="mem_cmd")
+    p_ml = mem_sub.add_parser("list", help="List entities (optionally filtered by category)")
+    p_ml.add_argument("category", nargs="?", default=None, help="Optional category to filter by")
+    p_ml.add_argument("--limit", type=int, default=50, help="Max rows (default 50)")
+    p_ml.set_defaults(func=cmd_memory)
+    p_ms = mem_sub.add_parser("search", help="Full-text search across entities + state + reference + journal")
+    p_ms.add_argument("query", help="Search query (matches stored text, not meaning)")
+    p_ms.add_argument("--limit", type=int, default=20, help="Max hits (default 20)")
+    p_ms.set_defaults(func=cmd_memory)
+    p_mr = mem_sub.add_parser("recall", help="Recall one entity by category + name")
+    p_mr.add_argument("category", help="Entity category")
+    p_mr.add_argument("name", help="Entity name")
+    p_mr.set_defaults(func=cmd_memory)
+    p_mem.set_defaults(func=cmd_memory)
+
     p_update = sub.add_parser(
         "update",
         help="Check for newer sibyl-memory-* releases on PyPI (use --apply to upgrade)",
@@ -1214,6 +1300,61 @@ def build_parser() -> argparse.ArgumentParser:
     return p
 
 
+def cmd_memory(args: argparse.Namespace) -> int:
+    """Read-only inspection of the local memory store (PKG-4, VRTX/deadguy beta).
+
+        sibyl memory list [category]    list entities
+        sibyl memory search <query>     full-text search across tiers
+        sibyl memory recall <cat> <nm>  recall one entity by category + name
+
+    Opens the resolved DB read-only via the SDK; never writes. Respects --db so
+    you can inspect any split-brain store that `sibyl status` surfaces.
+    """
+    from sibyl_memory_client import MemoryClient
+
+    db_path = Path(args.db).expanduser()
+    print()
+    if not db_path.exists():
+        print(a.warn_line(f"No memory store at {db_path}."))
+        print(a.dim("  Run `sibyl status` to see every store on this machine."))
+        return 1
+    client = MemoryClient.local(path=db_path)
+    op = getattr(args, "mem_cmd", None)
+    if op == "list":
+        rows = client.list_entities(category=args.category, limit=args.limit)
+        if not rows:
+            print(a.dim("(no entities)"))
+            return 0
+        print(a.eyebrow(f"entities ({len(rows)})"))
+        for r in rows:
+            print(a.kv(f"{r['category']}/{r['name']}", r.get("status") or "-"))
+        return 0
+    if op == "search":
+        hits = client.search(args.query, limit=args.limit)
+        if not hits:
+            print(a.dim(f"(no matches for {args.query!r})"))
+            return 0
+        print(a.eyebrow(f"matches ({len(hits)})"))
+        for h in hits:
+            snip = (h.get("snippet") or "").replace("\n", " ")[:100]
+            print(a.kv(f"[{h.get('tier') or '-'}] {h.get('key') or '-'}", snip))
+        return 0
+    if op == "recall":
+        try:
+            ent = client.get_entity(args.category, args.name)
+        except Exception as e:
+            print(a.warn_line(str(e)))
+            return 1
+        print(a.eyebrow(f"{ent['category']}/{ent['name']}"))
+        print(a.kv("status", ent.get("status") or "-"))
+        print(a.kv("updated", ent.get("updated_at") or "-"))
+        body = ent.get("body")
+        print(body if isinstance(body, str) else json.dumps(body, indent=2, ensure_ascii=False))
+        return 0
+    print(a.warn_line("Usage: sibyl memory {list|search|recall} ..."))
+    return 1
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = build_parser()
     args = parser.parse_args(argv)

{sibyl_memory_cli-0.3.13 → sibyl_memory_cli-0.3.15}/src/sibyl_memory_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sibyl-memory-cli
-Version: 0.3.13
+Version: 0.3.15
 Summary: Command-line interface for the Sibyl Memory Plugin. `sibyl init` activates, `sibyl upgrade` runs the staker / subscription flow, `sibyl status` shows current tier and DB stats, `sibyl whoami` gives a one-line account summary, `sibyl devices` lists active devices and supports per-device revoke.
 Author-email: "SIBYL, Sibyl Labs LLC" <sibyl@sibyllabs.org>
 License: MIT

{sibyl_memory_cli-0.3.13 → sibyl_memory_cli-0.3.15}/src/sibyl_memory_cli.egg-info/SOURCES.txt

@@ -14,9 +14,11 @@ src/sibyl_memory_cli.egg-info/requires.txt
 src/sibyl_memory_cli.egg-info/top_level.txt
 tests/test_hermes_install_args.py
 tests/test_init_perms_guard.py
+tests/test_memory_cmd_2026_06_16.py
 tests/test_migrate.py
 tests/test_migrate_adversarial.py
 tests/test_migrate_force_2026_06_05.py
 tests/test_orchestrator.py
 tests/test_setup.py
+tests/test_status_stores_2026_06_11.py
 tests/test_wiring_fix.py

sibyl_memory_cli-0.3.15/tests/test_memory_cmd_2026_06_16.py

@@ -0,0 +1,55 @@
+"""PKG-4 (VRTX/deadguy beta): read-only `sibyl memory list/search/recall` CLI.
+Lets a tester inspect what's actually stored without writing through an agent."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from sibyl_memory_client import MemoryClient
+from sibyl_memory_cli import cli
+
+
+def _store(tmp_path: Path) -> Path:
+    d = tmp_path / "memory.db"
+    c = MemoryClient.local(path=d)
+    c.set_entity("partner", "Blocktronics", {"stage": "active", "note": "token forensics suite"})
+    c.set_entity("partner", "Reppo", {"stage": "negotiation"})
+    return d
+
+
+def test_memory_list(tmp_path, capsys):
+    d = _store(tmp_path)
+    rc = cli.main(["--db", str(d), "memory", "list"])
+    out = capsys.readouterr().out
+    assert rc == 0
+    assert "Blocktronics" in out and "Reppo" in out
+
+
+def test_memory_list_category_filter(tmp_path, capsys):
+    d = _store(tmp_path)
+    rc = cli.main(["--db", str(d), "memory", "list", "partner", "--limit", "1"])
+    assert rc == 0
+
+
+def test_memory_search(tmp_path, capsys):
+    d = _store(tmp_path)
+    rc = cli.main(["--db", str(d), "memory", "search", "forensics"])
+    out = capsys.readouterr().out
+    assert rc == 0 and "Blocktronics" in out
+
+
+def test_memory_recall(tmp_path, capsys):
+    d = _store(tmp_path)
+    rc = cli.main(["--db", str(d), "memory", "recall", "partner", "Blocktronics"])
+    out = capsys.readouterr().out
+    assert rc == 0 and "forensics" in out
+
+
+def test_memory_recall_missing_returns_1(tmp_path):
+    d = _store(tmp_path)
+    rc = cli.main(["--db", str(d), "memory", "recall", "partner", "Nope"])
+    assert rc == 1
+
+
+def test_memory_no_store_returns_1(tmp_path):
+    rc = cli.main(["--db", str(tmp_path / "absent.db"), "memory", "list"])
+    assert rc == 1

sibyl_memory_cli-0.3.15/tests/test_status_stores_2026_06_11.py

@@ -0,0 +1,70 @@
+"""PKG-2/3 regression: `sibyl status` discovers + lists every memory store and
+warns on split-brain divergence (VRTX beta report 2026-06-11).
+
+Read-only: discovery never creates or moves a DB.
+"""
+import os
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from sibyl_memory_cli import cli
+
+
+@pytest.fixture
+def sandbox(monkeypatch):
+    d = Path(tempfile.mkdtemp())
+    primary = d / ".sibyl-memory" / "memory.db"
+    primary.parent.mkdir(parents=True)
+    hermes = d / ".hermes"
+    (hermes / "sibyl").mkdir(parents=True)
+    monkeypatch.setenv("HERMES_HOME", str(hermes))
+    monkeypatch.delenv("SIBYL_MEMORY_DB", raising=False)
+    return d, primary, hermes
+
+
+def test_discovers_default_hermes_and_profiles(sandbox):
+    d, primary, hermes = sandbox
+    primary.write_bytes(b"x" * 100)
+    (hermes / "sibyl" / "memory.db").write_bytes(b"y" * 200)
+    prof = hermes / "sibyl" / "profiles" / "alpha"
+    prof.mkdir(parents=True)
+    (prof / "memory.db").write_bytes(b"z" * 50)
+
+    stores = cli._discover_stores(primary)
+    labels = {s["label"] for s in stores}
+    assert "default (SDK/CLI/MCP)" in labels
+    assert "hermes adapter" in labels
+    assert any(l.startswith("hermes profile") for l in labels)
+    assert {s["size"] for s in stores} == {100, 200, 50}
+
+
+def test_skips_nonexistent_and_dedups(sandbox):
+    d, primary, hermes = sandbox
+    primary.write_bytes(b"x" * 10)
+    # hermes adapter db does not exist → excluded
+    stores = cli._discover_stores(primary)
+    assert [s["label"] for s in stores] == ["default (SDK/CLI/MCP)"]
+
+
+def test_mcp_override_included(sandbox, monkeypatch):
+    d, primary, hermes = sandbox
+    primary.write_bytes(b"x" * 10)
+    shadow = d / "shadow.db"
+    shadow.write_bytes(b"s" * 5)
+    monkeypatch.setenv("SIBYL_MEMORY_DB", str(shadow))
+    stores = cli._discover_stores(primary)
+    assert any(s["label"] == "MCP SIBYL_MEMORY_DB" for s in stores)
+
+
+def test_status_warns_on_divergence(sandbox, capsys):
+    d, primary, hermes = sandbox
+    primary.write_bytes(b"x" * 100)
+    (hermes / "sibyl" / "memory.db").write_bytes(b"y" * 200)
+
+    # Build the minimal args cmd_status reads. No credentials → early-return
+    # path, so drive discovery directly to assert the warning copy instead.
+    stores = cli._discover_stores(primary)
+    with_data = [s for s in stores if s["size"] > 0]
+    assert len(with_data) > 1  # divergence condition that triggers the warning