feat(plex): collections — sync, browse, filter, and info-page strips (Phase 1, read)

Backend (migration 0047_plex_collections): a plex_collections table mirrors every Plex
collection (card metadata + smart flag + an editable flag reserved for Phase 2); membership
is stored as GIN-indexed collection_keys on member movies (plex_items) and shows (plex_shows).
The background sync (plex_sync) now fetches each library's collections + their children and
rebuilds membership — so ALL reads are local (Plex's dual-language collection queries are slow;
this trades a ~4-min background sync for instant reads). New /api/plex/collections endpoint;
/browse gains a combinable  filter; item_detail returns the movie's collection
'strips' (sibling titles as playable cards, smallest/most-specific collection first) — all pure
local lookups.

Frontend: PlexSidebar gains a searchable Collection picker + an active-collection chip;
PlexInfo renders the collection strips (playable posters + 'Browse collection' → sets the
filter); the collection is part of PlexFilters (persisted). i18n en/hu/de.

Phase 2 (create/edit collections with write-back to Plex) is separate.

backend/app/plex/client.py

@@ -95,6 +95,16 @@ class PlexClient:
         mc = self._get(f"/library/metadata/{rating_key}/children")
         return mc.get("Metadata", []) or []
 
+    def collections(self, section_key: str) -> list[dict]:
+        """All collections in a library section (title/summary/thumb/childCount/smart)."""
+        mc = self._get(f"/library/sections/{section_key}/collections")
+        return mc.get("Metadata", []) or []
+
+    def collection_children(self, rating_key: str) -> list[dict]:
+        """The member items (movies / shows) of a collection."""
+        mc = self._get(f"/library/collections/{rating_key}/children")
+        return mc.get("Metadata", []) or []
+
     def metadata(self, rating_key: str, markers: bool = False) -> dict | None:
         """Full metadata for one item; include intro/credit markers when requested."""
         params = {"includeMarkers": 1} if markers else None

backend/app/plex/sync.py

@@ -15,7 +15,7 @@ from datetime import datetime, timezone
 from sqlalchemy.orm import Session
 
 from app import sysconfig
-from app.models import PlexItem, PlexLibrary, PlexSeason, PlexShow
+from app.models import PlexCollection, PlexItem, PlexLibrary, PlexSeason, PlexShow
 from app.plex.client import PlexClient, PlexError, PlexNotConfigured
 
 log = logging.getLogger("siftlode.plex")
@@ -111,7 +111,7 @@ def sync(db: Session) -> dict:
     """Full reconcile of the enabled movie/show sections. Returns a small stats dict."""
     if not sysconfig.get_bool(db, "plex_enabled"):
         return {"skipped": "disabled"}
-    stats = {"libraries": 0, "movies": 0, "shows": 0, "seasons": 0, "episodes": 0}
+    stats = {"libraries": 0, "movies": 0, "shows": 0, "seasons": 0, "episodes": 0, "collections": 0}
     wanted = _enabled_section_keys(db)
     try:
         with PlexClient(db) as plex:
@@ -127,6 +127,7 @@ def sync(db: Session) -> dict:
                     _sync_movies(db, plex, lib, stats)
                 else:
                     _sync_shows(db, plex, lib, stats)
+                _sync_collections(db, plex, lib, stats)
             db.commit()
     except PlexNotConfigured as e:
         return {"skipped": str(e)}
@@ -268,3 +269,43 @@ def _sync_shows(db: Session, plex: PlexClient, lib: PlexLibrary, stats: dict) ->
         row.episode_number = meta.get("index")
         stats["episodes"] += 1
     db.flush()
+
+
+def _sync_collections(db: Session, plex: PlexClient, lib: PlexLibrary, stats: dict) -> None:
+    """Mirror a library's collections + membership. Reads never touch Plex afterwards. Membership is
+    written as `collection_keys` on member movies (plex_items) / shows (plex_shows). A full reconcile:
+    collections gone from Plex are pruned, and each member row's keys are rebuilt from scratch."""
+    cols = plex.collections(lib.plex_key)
+    existing = {c.rating_key: c for c in db.query(PlexCollection).filter_by(library_id=lib.id)}
+    seen: set[str] = set()
+    membership: dict[str, list[str]] = {}  # member rating_key -> [collection rating_key, ...]
+    for meta in cols:
+        rk = str(meta.get("ratingKey") or "")
+        if not rk:
+            continue
+        col = existing.get(rk) or PlexCollection(rating_key=rk)
+        if col.id is None:
+            db.add(col)
+        col.library_id = lib.id
+        col.title = (meta.get("title") or "").strip() or "Untitled"
+        col.summary = meta.get("summary")
+        col.thumb_key = meta.get("thumb")
+        col.child_count = meta.get("childCount")
+        col.smart = str(meta.get("smart")) == "1"  # `editable` is preserved (user-managed, not here)
+        col.synced_at = datetime.now(timezone.utc)
+        seen.add(rk)
+        for child in plex.collection_children(rk):
+            crk = str(child.get("ratingKey") or "")
+            if crk:
+                membership.setdefault(crk, []).append(rk)
+        stats["collections"] += 1
+    db.flush()
+    for rk, col in existing.items():
+        if rk not in seen:
+            db.delete(col)
+    # Rebuild collection_keys on every member row of this library (clear + set).
+    for row in db.query(PlexItem).filter_by(library_id=lib.id):
+        row.collection_keys = membership.get(row.rating_key) or None
+    for row in db.query(PlexShow).filter_by(library_id=lib.id):
+        row.collection_keys = membership.get(row.rating_key) or None
+    db.flush()