elesync 1.3.0__tar.gz → 1.3.2__tar.gz

{elesync-1.3.0 → elesync-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elesync
-Version: 1.3.0
+Version: 1.3.2
 Summary: Local-first, MCP-native unified memory vault — your AI memory as files you own, shared across every model.
 Author: Alphanymous
 License: MIT
@@ -173,7 +173,7 @@ pip install "elesync[mcp]"
 > No Python yet? Download from **[python.org/downloads](https://www.python.org/downloads/)** — on Windows tick **"Add Python to PATH"** during install. If `pip` isn't found: use `py -m pip …` (Windows) or `python3 -m pip …` (Mac/Linux).
 
 ```bash
-ele --version          # → EleSync 1.1.2
+ele --version          # → EleSync 1.3.0
 ```
 
 **2 · Import your memories from ChatGPT / Claude / Gemini**
@@ -560,7 +560,7 @@ Still stuck? Open an issue at **[github.com/darknodebros/EleSync/issues](https:/
 ## Tests
 
 ```bash
-python -m unittest discover -s tests -v   # 134 tests, stdlib only — no MCP SDK required
+python -m unittest discover -s tests -v   # 179 tests, stdlib only — no MCP SDK required
 ```
 
 ## Where the export files come from (2026 reality)

{elesync-1.3.0 → elesync-1.3.2}/README.md

@@ -133,7 +133,7 @@ pip install "elesync[mcp]"
 > No Python yet? Download from **[python.org/downloads](https://www.python.org/downloads/)** — on Windows tick **"Add Python to PATH"** during install. If `pip` isn't found: use `py -m pip …` (Windows) or `python3 -m pip …` (Mac/Linux).
 
 ```bash
-ele --version          # → EleSync 1.1.2
+ele --version          # → EleSync 1.3.0
 ```
 
 **2 · Import your memories from ChatGPT / Claude / Gemini**
@@ -520,7 +520,7 @@ Still stuck? Open an issue at **[github.com/darknodebros/EleSync/issues](https:/
 ## Tests
 
 ```bash
-python -m unittest discover -s tests -v   # 134 tests, stdlib only — no MCP SDK required
+python -m unittest discover -s tests -v   # 179 tests, stdlib only — no MCP SDK required
 ```
 
 ## Where the export files come from (2026 reality)

{elesync-1.3.0 → elesync-1.3.2}/elesync/__init__.py

@@ -9,4 +9,4 @@ from .service import MemoryService
 from .store import MemoryStore
 
 __all__ = ["MemoryItem", "MEMORY_TYPES", "MemoryStore", "MemoryService", "normalize"]
-__version__ = "1.3.0"
+__version__ = "1.3.2"

{elesync-1.3.0 → elesync-1.3.2}/elesync/cli.py

@@ -48,8 +48,9 @@ def _embedder(args):
     emb = embeddings.load_embedder()
     if emb is None:
         print(
-            "Semantic mode requested but the extra is not installed — "
-            'run: pip install "elesync[semantic]". Falling back to keyword search.',
+            "Semantic mode unavailable (the extra isn't installed, or the model "
+            "couldn't be loaded — check your connection). Falling back to keyword "
+            'search. To enable it: pip install "elesync[semantic]".',
             file=sys.stderr,
         )
     return emb
@@ -243,7 +244,9 @@ def cmd_embed(args) -> int:
     emb = embeddings.load_embedder()
     if emb is None:
         print(
-            'The semantic extra is not installed. Run: pip install "elesync[semantic]"',
+            "Could not load the embedding model. Make sure the extra is installed "
+            '(pip install "elesync[semantic]") and that you are online for the '
+            "first run, which downloads the model.",
             file=sys.stderr,
         )
         return 1
@@ -495,14 +498,14 @@ def cmd_usb_install(args) -> int:
         print(f"❌  {e}", file=sys.stderr)
         return 1
     print(f"✅  Vault created:   {result['vault_dir']}")
-    print(f"   Encrypted:      yes (XSalsa20-Poly1305 + argon2id)")
+    print("   Encrypted:      yes (XSalsa20-Poly1305 + argon2id)")
     print(f"   Launcher:       {result['launcher']}")
     print(f"   README:         {result['readme']}")
     print()
     print("Next steps:")
     print(f"  Import memories:  ele --vault {result['vault_dir']} import <file> --source chatgpt")
     print(f"  Connect Claude:   ele usb attach {drive}")
-    print(f"  On another machine: plug in the drive and run  python RUN_ME.py")
+    print("  On another machine: plug in the drive and run  python RUN_ME.py")
     return 0
 
 
@@ -531,7 +534,7 @@ def cmd_usb_detach(args) -> int:
     drive = args.drive
     result = usb.detach(drive, name=args.name or "elesync-usb")
     if result["removed"]:
-        print(f"✅  USB vault disconnected from Claude Desktop.")
+        print("✅  USB vault disconnected from Claude Desktop.")
         print(f"   Config: {result['config_path']}")
         print()
         print("You can now safely eject the drive.")
@@ -552,7 +555,9 @@ def cmd_usb_status(args) -> int:
     if s["vault_present"]:
         print(f"Encrypted:      {'yes' if s['encrypted'] else 'NO — run ele usb install to fix'}")
         print(f"Memory files:   {s['note_count']}")
-        print(f"Launcher:       {'present' if s['launcher_present'] else 'missing — run ele usb install'}")
+        print(
+            f"Launcher:       {'present' if s['launcher_present'] else 'missing — run ele usb install'}"
+        )
     print(f"Free space:     {s['size_gb']} GB")
     return 0
 
@@ -583,7 +588,7 @@ def cmd_watch(args) -> int:
 def cmd_summary(args) -> int:
     print(
         build_summary(
-            vault_dir=args.vault,
+            vault_dir=_vault_path(args),
             source=args.source,
             short=args.short,
         )

{elesync-1.3.0 → elesync-1.3.2}/elesync/embeddings.py

@@ -66,6 +66,11 @@ class Embedder:
 
         self.model_name = model_name
         self._model = TextEmbedding(model_name)
+        # fastembed downloads/loads the model lazily on first embed. Force that
+        # now with a tiny warm-up so any failure (offline, blocked download,
+        # corrupt cache) raises here — where load_embedder() turns it into a
+        # graceful keyword-search fallback instead of crashing mid-search.
+        self.embed_one("warmup")
 
     def embed(self, texts: list[str]) -> list[list[float]]:
         return [list(map(float, v)) for v in self._model.embed(list(texts))]
@@ -75,8 +80,14 @@ class Embedder:
 
 
 def load_embedder(model_name: str = DEFAULT_MODEL):
-    """Return an `Embedder` if the `semantic` extra is installed, else None."""
+    """Return a ready-to-use `Embedder`, or None if semantic recall is unavailable.
+
+    Returns None on any failure — the optional extra not being installed
+    (ImportError) or the model failing to load/download (offline, blocked,
+    corrupt cache). Callers fall back to keyword search, so semantic mode
+    never crashes the command; it just quietly degrades.
+    """
     try:
         return Embedder(model_name)
-    except ImportError:
+    except Exception:
         return None

{elesync-1.3.0 → elesync-1.3.2}/elesync/summary.py

@@ -9,6 +9,7 @@ Usage:
 
 from __future__ import annotations
 
+import os
 from collections import defaultdict
 from datetime import datetime, timezone
 
@@ -73,7 +74,7 @@ def build_summary(
     short: bool = False,
 ) -> str:
     """Return the formatted summary as a string."""
-    store = MemoryStore(vault_dir=vault_dir or "~/EleSyncVault")
+    store = MemoryStore(vault_dir=vault_dir or os.environ.get("ELESYNC_DIR", "~/EleSyncVault"))
     try:
         all_items = store.all()
     finally:

{elesync-1.3.0 → elesync-1.3.2}/elesync/usb.py

@@ -46,7 +46,6 @@ import os
 import platform
 import shutil
 import subprocess
-import sys
 from pathlib import Path
 
 # Module-level references so tests can patch elesync.usb.crypto / MemoryStore / onboarding
@@ -58,7 +57,7 @@ except Exception:  # pragma: no cover
 try:
     from .store import MemoryStore  # type: ignore[attr-defined]
 except Exception:  # pragma: no cover
-    MemoryStore = None  # type: ignore[assignment]
+    MemoryStore = None  # type: ignore[misc,assignment]
 
 try:
     from . import onboarding  # type: ignore[attr-defined]
@@ -89,7 +88,6 @@ def list_removable_drives() -> list[dict]:
 
 
 def _list_drives_macos() -> list[dict]:
-    import json as _json
 
     out = subprocess.run(
         ["diskutil", "list", "-plist"],
@@ -138,8 +136,15 @@ def _list_drives_macos() -> list[dict]:
 
 def _list_drives_windows() -> list[dict]:
     out = subprocess.run(
-        ["wmic", "logicaldisk", "where", "DriveType=2", "get",
-         "DeviceID,VolumeName,Size,FileSystem", "/format:csv"],
+        [
+            "wmic",
+            "logicaldisk",
+            "where",
+            "DriveType=2",
+            "get",
+            "DeviceID,VolumeName,Size,FileSystem",
+            "/format:csv",
+        ],
         capture_output=True,
         text=True,
         check=False,
@@ -159,7 +164,7 @@ def _list_drives_windows() -> list[dict]:
 
 
 def _list_drives_linux() -> list[dict]:
-    drives = []
+    drives: list[dict] = []
     mounts = Path("/proc/mounts")
     if not mounts.exists():
         return drives
@@ -167,7 +172,7 @@ def _list_drives_linux() -> list[dict]:
         parts = line.split()
         if len(parts) < 3:
             continue
-        dev, mp, fs = parts[0], parts[1], parts[2]
+        _, mp, fs = parts[0], parts[1], parts[2]
         # Heuristic: removable drives are under /media or /mnt, or start with /dev/sd
         if not (mp.startswith("/media/") or mp.startswith("/mnt/")):
             continue
@@ -205,6 +210,7 @@ def is_usb_vault(drive: str | Path) -> bool:
 # Install
 # ---------------------------------------------------------------------------
 
+
 def install(drive: str | Path, passphrase: str, label: str = "USB") -> dict:
     """Bootstrap an encrypted EleSync vault on `drive`.
 
@@ -217,8 +223,7 @@ def install(drive: str | Path, passphrase: str, label: str = "USB") -> dict:
     """
     if crypto is None or not crypto.available():
         raise RuntimeError(
-            'USB vaults are always encrypted. '
-            'Run:  pip install "elesync[encryption]"  first.'
+            'USB vaults are always encrypted. Run:  pip install "elesync[encryption]"  first.'
         )
 
     drive = Path(drive)
@@ -237,7 +242,6 @@ def install(drive: str | Path, passphrase: str, label: str = "USB") -> dict:
 
     # Open the store once so the SQLite schema is initialised (even though the
     # in-memory index is empty — it primes the notes/ layout).
-    import base64 as _b64
     store = MemoryStore(vp, key=_key)
     store.close()
 
@@ -257,6 +261,7 @@ def install(drive: str | Path, passphrase: str, label: str = "USB") -> dict:
 # Attach / detach
 # ---------------------------------------------------------------------------
 
+
 def attach(drive: str | Path, passphrase: str, name: str = "elesync-usb") -> dict:
     """Unlock the USB vault and wire it into Claude Desktop (or any MCP client).
 
@@ -333,6 +338,7 @@ def detach(drive: str | Path, name: str = "elesync-usb") -> dict:
     cfg["mcpServers"] = servers
 
     from datetime import datetime, timezone
+
     ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
     bak = cfg_path.with_suffix(f".{ts}.bak")
     bak.write_text(cfg_path.read_text(encoding="utf-8"), encoding="utf-8")
@@ -345,6 +351,7 @@ def detach(drive: str | Path, name: str = "elesync-usb") -> dict:
 # Status
 # ---------------------------------------------------------------------------
 
+
 def status(drive: str | Path) -> dict:
     """Return a status snapshot for a drive (encrypted vault present, count, etc.)."""
     from . import crypto
@@ -365,7 +372,7 @@ def status(drive: str | Path) -> dict:
     if not result["vault_present"]:
         return result
 
-    result["encrypted"] = (crypto is not None and crypto.is_encrypted(vp))
+    result["encrypted"] = crypto is not None and crypto.is_encrypted(vp)
     result["note_count"] = len(list((vp / "notes").glob("*.md*")))
     return result
 
@@ -374,6 +381,7 @@ def status(drive: str | Path) -> dict:
 # Safe eject
 # ---------------------------------------------------------------------------
 
+
 def eject(drive: str | Path) -> str:
     """Attempt a safe-eject of the drive. Returns a status string."""
     drive = str(Path(drive))
@@ -381,13 +389,15 @@ def eject(drive: str | Path) -> str:
         if SYSTEM == "Darwin":
             r = subprocess.run(
                 ["diskutil", "eject", drive],
-                capture_output=True, text=True, check=False,
+                capture_output=True,
+                text=True,
+                check=False,
             )
             return r.stdout.strip() or r.stderr.strip() or "Ejected."
         if SYSTEM == "Windows":
             # PowerShell safe-remove via WMI
             ps = (
-                f'$d=(New-Object -comObject Shell.Application).Namespace(17)'
+                f"$d=(New-Object -comObject Shell.Application).Namespace(17)"
                 f'.ParseName("{drive}"); $d.InvokeVerb("Eject")'
             )
             subprocess.run(["powershell", "-Command", ps], check=False, capture_output=True)
@@ -395,11 +405,15 @@ def eject(drive: str | Path) -> str:
         # Linux — udisksctl
         r = subprocess.run(
             ["udisksctl", "unmount", "-b", _linux_block_dev(drive)],
-            capture_output=True, text=True, check=False,
+            capture_output=True,
+            text=True,
+            check=False,
         )
         r2 = subprocess.run(
             ["udisksctl", "power-off", "-b", _linux_block_dev(drive)],
-            capture_output=True, text=True, check=False,
+            capture_output=True,
+            text=True,
+            check=False,
         )
         return (r.stdout + r2.stdout).strip() or "Eject request sent."
     except FileNotFoundError:
@@ -410,6 +424,7 @@ def eject(drive: str | Path) -> str:
 # Helpers
 # ---------------------------------------------------------------------------
 
+
 def _validate_key(vault_dir: Path, key: bytes) -> None:
     """Raise ValueError if the key cannot decrypt an existing note.
     If there are no notes yet (empty vault), the key is accepted as valid."""

{elesync-1.3.0 → elesync-1.3.2}/elesync/web.py

@@ -13,25 +13,35 @@ Zero extra dependencies — pure Python stdlib HTTP server.
 from __future__ import annotations
 
 import json
-import mimetypes
 import os
+import sys
 import threading
 import webbrowser
 from http.server import BaseHTTPRequestHandler, HTTPServer
 from pathlib import Path
+from typing import TYPE_CHECKING
 from urllib.parse import parse_qs, urlparse
 
+if TYPE_CHECKING:
+    from .store import MemoryStore
+
 # Module-level store reference — set by serve() before the server starts
-_store = None
+_store: MemoryStore | None = None
 _vault_dir: str = ""
 
 
+def _get_store() -> MemoryStore:
+    assert _store is not None, "store not initialised — call serve() first"
+    return _store
+
+
 # ---------------------------------------------------------------------------
 # REST API handlers
 # ---------------------------------------------------------------------------
 
+
 def _api_stats() -> dict:
-    return _store.stats()
+    return _get_store().stats()
 
 
 def _api_memories(params: dict) -> dict:
@@ -42,10 +52,10 @@ def _api_memories(params: dict) -> dict:
     offset = int(params.get("offset", ["0"])[0])
 
     if q:
-        items = _store.search(q, limit=limit + offset, source=source, mtype=mtype)
+        items = _get_store().search(q, limit=limit + offset, source=source, mtype=mtype)
         items = items[offset:]
     else:
-        all_items = _store.all()
+        all_items = _get_store().all()
         if source:
             all_items = [i for i in all_items if i.source == source]
         if mtype:
@@ -68,16 +78,15 @@ def _api_memories(params: dict) -> dict:
 
 
 def _api_memory_get(mem_id: str) -> dict | None:
-    item = _store.get(mem_id)
+    item = _get_store().get(mem_id)
     if item is None:
         return None
     return _item_to_dict(item)
 
 
 def _api_memory_update(mem_id: str, body: dict) -> dict | None:
-    from .models import MemoryItem
 
-    item = _store.get(mem_id)
+    item = _get_store().get(mem_id)
     if item is None:
         return None
     # Update allowed fields
@@ -90,15 +99,16 @@ def _api_memory_update(mem_id: str, body: dict) -> dict | None:
         item.type = body["type"]
     if "scopes" in body:
         from . import scopes as scopes_mod
+
         item.scopes = scopes_mod.parse(body["scopes"])
     # Delete old entry and re-insert
-    _store.delete(mem_id)
-    _store.upsert(item)
+    _get_store().delete(mem_id)
+    _get_store().upsert(item)
     return _item_to_dict(item)
 
 
 def _api_memory_delete(mem_id: str) -> bool:
-    return _store.delete(mem_id)
+    return _get_store().delete(mem_id)
 
 
 def _api_memory_add(body: dict) -> dict:
@@ -113,7 +123,7 @@ def _api_memory_add(body: dict) -> dict:
         type=body.get("type", "note"),
         tags=body.get("tags", []),
     )
-    _store.upsert(item)
+    _get_store().upsert(item)
     return _item_to_dict(item)
 
 
@@ -126,10 +136,10 @@ def _api_import(body: dict) -> dict:
     if raw is None:
         raise ValueError("data is required")
 
-    import tempfile, json as _json
-    with tempfile.NamedTemporaryFile(
-        mode="w", suffix=".json", delete=False, encoding="utf-8"
-    ) as f:
+    import json as _json
+    import tempfile
+
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False, encoding="utf-8") as f:
         _json.dump(raw, f)
         tmp_path = f.name
     try:
@@ -137,7 +147,7 @@ def _api_import(body: dict) -> dict:
     finally:
         Path(tmp_path).unlink(missing_ok=True)
 
-    result = _store.import_many(items)
+    result = _get_store().import_many(items)
     return result
 
 
@@ -160,6 +170,7 @@ def _item_to_dict(item) -> dict:
 # HTTP request handler
 # ---------------------------------------------------------------------------
 
+
 class _Handler(BaseHTTPRequestHandler):
     def log_message(self, fmt, *args):
         pass  # silence access logs
@@ -212,7 +223,7 @@ class _Handler(BaseHTTPRequestHandler):
         elif path == "/api/memories":
             self._send_json(_api_memories(params))
         elif path.startswith("/api/memories/"):
-            mem_id = path[len("/api/memories/"):]
+            mem_id = path[len("/api/memories/") :]
             item = _api_memory_get(mem_id)
             if item is None:
                 self._send_error(404, "not found")
@@ -249,7 +260,7 @@ class _Handler(BaseHTTPRequestHandler):
         path = parsed.path.rstrip("/")
 
         if path.startswith("/api/memories/"):
-            mem_id = path[len("/api/memories/"):]
+            mem_id = path[len("/api/memories/") :]
             try:
                 body = self._read_body()
                 item = _api_memory_update(mem_id, body)
@@ -267,7 +278,7 @@ class _Handler(BaseHTTPRequestHandler):
         path = parsed.path.rstrip("/")
 
         if path.startswith("/api/memories/"):
-            mem_id = path[len("/api/memories/"):]
+            mem_id = path[len("/api/memories/") :]
             ok = _api_memory_delete(mem_id)
             if ok:
                 self._send_json({"deleted": True})
@@ -281,11 +292,19 @@ class _Handler(BaseHTTPRequestHandler):
 # Entry point
 # ---------------------------------------------------------------------------
 
+
 def serve(vault_dir: str | None = None, port: int = 7477, open_browser: bool = True) -> None:
     global _store, _vault_dir
 
-    from .store import MemoryStore
+    # Same UTF-8 stdout defence as cli.main — legacy Windows cp1252 can't encode
+    # the emoji we print below, and would crash with UnicodeEncodeError.
+    import contextlib
+    for stream in (sys.stdout, sys.stderr):
+        with contextlib.suppress(AttributeError, ValueError):
+            stream.reconfigure(encoding="utf-8")
+
     from . import crypto as _crypto
+    from .store import MemoryStore
 
     vault_path = Path(vault_dir or os.environ.get("ELESYNC_DIR", "~/EleSyncVault")).expanduser()
     _vault_dir = str(vault_path)
@@ -294,11 +313,14 @@ def serve(vault_dir: str | None = None, port: int = 7477, open_browser: bool = T
     key = None
     if _crypto.available() and _crypto.is_encrypted(vault_path):
         import getpass
+
         passphrase = getpass.getpass("🔑  Vault passphrase: ")
         meta = _crypto.read_meta(vault_path)
+        assert meta is not None
         key = _crypto.derive_key(
             passphrase,
-            bytes.fromhex(meta["salt"]) if isinstance(meta["salt"], str) and len(meta["salt"]) == 64
+            bytes.fromhex(meta["salt"])
+            if isinstance(meta["salt"], str) and len(meta["salt"]) == 64
             else __import__("base64").b64decode(meta["salt"]),
             meta["opslimit"],
             meta["memlimit"],
@@ -320,7 +342,7 @@ def serve(vault_dir: str | None = None, port: int = 7477, open_browser: bool = T
     except KeyboardInterrupt:
         pass
     finally:
-        _store.close()
+        _get_store().close()
         print("\n👋  EleSync web server stopped.")
 
 

{elesync-1.3.0 → elesync-1.3.2}/elesync.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elesync
-Version: 1.3.0
+Version: 1.3.2
 Summary: Local-first, MCP-native unified memory vault — your AI memory as files you own, shared across every model.
 Author: Alphanymous
 License: MIT
@@ -173,7 +173,7 @@ pip install "elesync[mcp]"
 > No Python yet? Download from **[python.org/downloads](https://www.python.org/downloads/)** — on Windows tick **"Add Python to PATH"** during install. If `pip` isn't found: use `py -m pip …` (Windows) or `python3 -m pip …` (Mac/Linux).
 
 ```bash
-ele --version          # → EleSync 1.1.2
+ele --version          # → EleSync 1.3.0
 ```
 
 **2 · Import your memories from ChatGPT / Claude / Gemini**
@@ -560,7 +560,7 @@ Still stuck? Open an issue at **[github.com/darknodebros/EleSync/issues](https:/
 ## Tests
 
 ```bash
-python -m unittest discover -s tests -v   # 134 tests, stdlib only — no MCP SDK required
+python -m unittest discover -s tests -v   # 179 tests, stdlib only — no MCP SDK required
 ```
 
 ## Where the export files come from (2026 reality)

{elesync-1.3.0 → elesync-1.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "elesync"
-version = "1.3.0"
+version = "1.3.2"
 description = "Local-first, MCP-native unified memory vault — your AI memory as files you own, shared across every model."
 readme = "README.md"
 license = { text = "MIT" }

{elesync-1.3.0 → elesync-1.3.2}/tests/test_usb.py

@@ -11,7 +11,7 @@ import json
 import tempfile
 import unittest
 from pathlib import Path
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
 
 
 class FakeCrypto:
@@ -241,9 +241,7 @@ class TestUsbDetach(unittest.TestCase):
         self.tmp.cleanup()
 
     def _write_cfg(self, servers: dict):
-        self.cfg.write_text(
-            json.dumps({"mcpServers": servers}, indent=2), encoding="utf-8"
-        )
+        self.cfg.write_text(json.dumps({"mcpServers": servers}, indent=2), encoding="utf-8")
 
     def test_detach_removes_server_entry(self):
         import elesync.usb as usb_mod
@@ -377,7 +375,7 @@ class TestUsbCLI(unittest.TestCase):
     def test_usb_eject_no_crash(self):
         import elesync.usb as usb_mod
 
-        with patch.object(usb_mod, "eject", return_value="Eject sent.") as mock_eject:
+        with patch.object(usb_mod, "eject", return_value="Eject sent."):
             rc = self._run(["usb", "eject", str(self.drive)])
         self.assertEqual(rc, 0)
 

{elesync-1.3.0 → elesync-1.3.2}/tests/test_web.py

@@ -13,9 +13,8 @@ import threading
 import unittest
 from http.server import HTTPServer
 from pathlib import Path
-from urllib.request import urlopen
 from urllib.error import HTTPError
-from urllib.request import Request
+from urllib.request import Request, urlopen
 
 
 def _url(port: int, path: str) -> str:
@@ -32,7 +31,9 @@ def _get(port: int, path: str) -> tuple[int, dict]:
 
 def _post(port: int, path: str, body: dict) -> tuple[int, dict]:
     data = json.dumps(body).encode()
-    req = Request(_url(port, path), data=data, headers={"Content-Type": "application/json"}, method="POST")
+    req = Request(
+        _url(port, path), data=data, headers={"Content-Type": "application/json"}, method="POST"
+    )
     try:
         with urlopen(req, timeout=5) as r:
             return r.status, json.loads(r.read())
@@ -42,7 +43,9 @@ def _post(port: int, path: str, body: dict) -> tuple[int, dict]:
 
 def _put(port: int, path: str, body: dict) -> tuple[int, dict]:
     data = json.dumps(body).encode()
-    req = Request(_url(port, path), data=data, headers={"Content-Type": "application/json"}, method="PUT")
+    req = Request(
+        _url(port, path), data=data, headers={"Content-Type": "application/json"}, method="PUT"
+    )
     try:
         with urlopen(req, timeout=5) as r:
             return r.status, json.loads(r.read())
@@ -86,6 +89,7 @@ class WebServerTestCase(unittest.TestCase):
     def tearDownClass(cls):
         cls.server.shutdown()
         import elesync.web as web_mod
+
         if web_mod._store:
             web_mod._store.close()
         cls.vault_tmp.cleanup()
@@ -95,6 +99,7 @@ class WebServerTestCase(unittest.TestCase):
 # Static routes
 # ---------------------------------------------------------------------------
 
+
 class TestStaticRoutes(WebServerTestCase):
     def test_root_returns_html(self):
         with urlopen(_url(self.port, "/"), timeout=5) as r:
@@ -118,6 +123,7 @@ class TestStaticRoutes(WebServerTestCase):
 # /api/vault
 # ---------------------------------------------------------------------------
 
+
 class TestVaultEndpoint(WebServerTestCase):
     def test_vault_returns_path(self):
         code, data = _get(self.port, "/api/vault")
@@ -130,6 +136,7 @@ class TestVaultEndpoint(WebServerTestCase):
 # /api/stats
 # ---------------------------------------------------------------------------
 
+
 class TestStatsEndpoint(WebServerTestCase):
     def test_stats_shape(self):
         code, data = _get(self.port, "/api/stats")
@@ -147,14 +154,19 @@ class TestStatsEndpoint(WebServerTestCase):
 # POST /api/memories  (add)
 # ---------------------------------------------------------------------------
 
+
 class TestAddMemory(WebServerTestCase):
     def test_add_returns_201(self):
-        code, data = _post(self.port, "/api/memories", {
-            "content": "Test memory from web test",
-            "source": "manual",
-            "type": "note",
-            "tags": ["test"],
-        })
+        code, data = _post(
+            self.port,
+            "/api/memories",
+            {
+                "content": "Test memory from web test",
+                "source": "manual",
+                "type": "note",
+                "tags": ["test"],
+            },
+        )
         self.assertEqual(code, 201)
         self.assertIn("id", data)
         self.assertEqual(data["content"], "Test memory from web test")
@@ -173,17 +185,22 @@ class TestAddMemory(WebServerTestCase):
 # GET /api/memories
 # ---------------------------------------------------------------------------
 
+
 class TestListMemories(WebServerTestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
         # Seed a few memories
         for i in range(3):
-            _post(cls.port, "/api/memories", {
-                "content": f"Seeded memory number {i}",
-                "source": "chatgpt" if i % 2 == 0 else "claude",
-                "type": "fact",
-            })
+            _post(
+                cls.port,
+                "/api/memories",
+                {
+                    "content": f"Seeded memory number {i}",
+                    "source": "chatgpt" if i % 2 == 0 else "claude",
+                    "type": "fact",
+                },
+            )
 
     def test_list_returns_items(self):
         code, data = _get(self.port, "/api/memories")
@@ -210,15 +227,20 @@ class TestListMemories(WebServerTestCase):
 # GET /api/memories/<id>
 # ---------------------------------------------------------------------------
 
+
 class TestGetMemory(WebServerTestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        _, added = _post(cls.port, "/api/memories", {
-            "content": "Memory for get test",
-            "source": "manual",
-            "type": "note",
-        })
+        _, added = _post(
+            cls.port,
+            "/api/memories",
+            {
+                "content": "Memory for get test",
+                "source": "manual",
+                "type": "note",
+            },
+        )
         cls.mem_id = added["id"]
 
     def test_get_existing(self):
@@ -236,28 +258,29 @@ class TestGetMemory(WebServerTestCase):
 # PUT /api/memories/<id>  (update)
 # ---------------------------------------------------------------------------
 
+
 class TestUpdateMemory(WebServerTestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        _, added = _post(cls.port, "/api/memories", {
-            "content": "Original content",
-            "source": "manual",
-            "type": "note",
-        })
+        _, added = _post(
+            cls.port,
+            "/api/memories",
+            {
+                "content": "Original content",
+                "source": "manual",
+                "type": "note",
+            },
+        )
         cls.mem_id = added["id"]
 
     def test_update_content(self):
-        code, data = _put(self.port, f"/api/memories/{self.mem_id}", {
-            "content": "Updated content"
-        })
+        code, data = _put(self.port, f"/api/memories/{self.mem_id}", {"content": "Updated content"})
         self.assertEqual(code, 200)
         self.assertEqual(data["content"], "Updated content")
 
     def test_update_tags(self):
-        _, data = _put(self.port, f"/api/memories/{self.mem_id}", {
-            "tags": ["newtag", "another"]
-        })
+        _, data = _put(self.port, f"/api/memories/{self.mem_id}", {"tags": ["newtag", "another"]})
         self.assertIn("newtag", data["tags"])
 
     def test_update_nonexistent_404(self):
@@ -269,13 +292,18 @@ class TestUpdateMemory(WebServerTestCase):
 # DELETE /api/memories/<id>
 # ---------------------------------------------------------------------------
 
+
 class TestDeleteMemory(WebServerTestCase):
     def test_delete_existing(self):
-        _, added = _post(self.port, "/api/memories", {
-            "content": "Memory to be deleted",
-            "source": "manual",
-            "type": "note",
-        })
+        _, added = _post(
+            self.port,
+            "/api/memories",
+            {
+                "content": "Memory to be deleted",
+                "source": "manual",
+                "type": "note",
+            },
+        )
         mem_id = added["id"]
         code, data = _delete(self.port, f"/api/memories/{mem_id}")
         self.assertEqual(code, 200)
@@ -293,6 +321,7 @@ class TestDeleteMemory(WebServerTestCase):
 # POST /api/import
 # ---------------------------------------------------------------------------
 
+
 class TestImport(WebServerTestCase):
     def test_import_chatgpt_format(self):
         payload = {