render synced vault notes from templates

Author: assistant-ngalaiko[bot]

packages/vault-sync/discogs.py

@@ -64,24 +64,23 @@ def release_url(info):
     return f"https://www.discogs.com/release/{info['id']}"
 
 
-def album_note(title, year, artists, cover_file, url, lp_date):
-    artist_block = "artist:\n" + "".join(f'  - "[[{a}]]"\n' for a in artists)
-    cover_line = f'cover: "[[{cover_file}]]"\n' if cover_file else "cover:\n"
-    lp_line = f'lp: "[[{lp_date}]]"\n' if lp_date else "lp:\n"
-    return (
-        "---\n"
-        "categories:\n"
-        '  - "[[Albums]]"\n'
-        f"{artist_block}"
-        f"{cover_line}"
-        f"discogs: {url}\n"
-        f"{lp_line}"
-        f"year: {year}\n"
-        "---\n"
+def album_note(template_path, year, artists, cover_file, url, lp_date):
+    """Render an Album note from the vault's Album Template."""
+    return vaultlib.render_template(
+        template_path,
+        {
+            "artist": [f'"[[{a}]]"' for a in artists],
+            "cover": f'"[[{cover_file}]]"' if cover_file else "",
+            "discogs": url,
+            "lp": f'"[[{lp_date}]]"' if lp_date else "",
+            "year": year,
+        },
     )
 
 
-def sync_release(item, references, attachments, token, lp_date, index):
+def sync_release(
+    item, notes, attachments, album_template, artist_template, token, lp_date, index
+):
     """Create or update a single album note. ``lp_date`` is the owned-on date
     (collection) or None (wantlist). ``index`` is the {discogs-url: path} dedup
     map, updated in place when a note is created. Returns 'new', 'updated', or
@@ -101,7 +100,7 @@ def sync_release(item, references, attachments, token, lp_date, index):
             return "updated"
         return None
 
-    path, base = vaultlib.unique_note_path(references, title, year)
+    path, base = vaultlib.unique_note_path(notes, title, year)
 
     cover_file = None
     cover = info.get("cover_image")
@@ -119,10 +118,10 @@ def sync_release(item, references, attachments, token, lp_date, index):
             cover_file = None
 
     for a in artists:
-        vaultlib.ensure_person_note(references, a, "Artists")
+        vaultlib.ensure_person_note(notes, a, artist_template)
 
     vaultlib.write_note(
-        path, album_note(title, year, artists, cover_file, url, lp_date)
+        path, album_note(album_template, year, artists, cover_file, url, lp_date)
     )
     index[url.rstrip("/")] = path
     kind = "owned" if lp_date else "wishlist"
@@ -133,6 +132,9 @@ def sync_release(item, references, attachments, token, lp_date, index):
 def main(username, token, vault, include_wantlist):
     notes = vault
     attachments = os.path.join(vault, "Attachments")
+    templates = os.path.join(vault, "Templates")
+    album_template = os.path.join(templates, "Album Template.md")
+    artist_template = os.path.join(templates, "Artist Template.md")
     os.makedirs(notes, exist_ok=True)
     os.makedirs(attachments, exist_ok=True)
 
@@ -145,15 +147,31 @@ def main(username, token, vault, include_wantlist):
     for item in paginate(collection, token, "releases"):
         date_added = (item.get("date_added") or "")[:10]  # ISO ts -> YYYY-MM-DD
         result = sync_release(
-            item, notes, attachments, token, date_added or None, index
+            item,
+            notes,
+            attachments,
+            album_template,
+            artist_template,
+            token,
+            date_added or None,
+            index,
         )
         created += result == "new"
         updated += result == "updated"
 
     if include_wantlist:
         wantlist = urljoin(BASE_URL, f"/users/{username}/wants")
         for item in paginate(wantlist, token, "wants"):
-            result = sync_release(item, notes, attachments, token, None, index)
+            result = sync_release(
+                item,
+                notes,
+                attachments,
+                album_template,
+                artist_template,
+                token,
+                None,
+                index,
+            )
             created += result == "new"
 
     print(f"discogs: {created} new, {updated} updated")

packages/vault-sync/letterboxd.py

@@ -84,27 +84,27 @@ def scrape_directors(film_url):
     return [d["name"] for d in data.get("director", []) if d.get("name")]
 
 
-def movie_note(title, year, poster_file, directors, url, liked, watched):
-    directors_block = "director:\n" + "".join(f'  - "[[{d}]]"\n' for d in directors)
-    cover_line = f'cover: "[[{poster_file}]]"\n' if poster_file else "cover:\n"
-    return (
-        "---\n"
-        "categories:\n"
-        '  - "[[Movies]]"\n'
-        f"{cover_line}"
-        f"{directors_block}"
-        f"letterboxd: {url}\n"
-        f"liked: {'true' if liked else 'false'}\n"
-        "watched:\n"
-        f'  - "[[{watched}]]"\n'
-        f"year: {year}\n"
-        "---\n"
+def movie_note(template_path, year, poster_file, directors, url, liked, watched):
+    """Render a Movie note from the vault's Movie Template."""
+    return vaultlib.render_template(
+        template_path,
+        {
+            "cover": f'"[[{poster_file}]]"' if poster_file else "",
+            "director": [f'"[[{d}]]"' for d in directors],
+            "letterboxd": url,
+            "liked": "true" if liked else "false",
+            "watched": [f'"[[{watched}]]"'],
+            "year": year,
+        },
     )
 
 
 def main(username, vault):
     notes = vault
     attachments = os.path.join(vault, "Attachments")
+    templates = os.path.join(vault, "Templates")
+    movie_template = os.path.join(templates, "Movie Template.md")
+    director_template = os.path.join(templates, "Director Template.md")
     os.makedirs(notes, exist_ok=True)
     os.makedirs(attachments, exist_ok=True)
 
@@ -139,12 +139,12 @@ def main(username, vault):
 
         directors = scrape_directors(entry["url"])
         for d in directors:
-            vaultlib.ensure_person_note(notes, d, "Directors")
+            vaultlib.ensure_person_note(notes, d, director_template)
 
         vaultlib.write_note(
             path,
             movie_note(
-                entry["title"],
+                movie_template,
                 entry["year"],
                 poster_file,
                 directors,

packages/vault-sync/vaultlib.py

@@ -159,6 +159,61 @@ def set_scalar_if_empty(path, key, value):
     return False
 
 
+def render_template(template_path, fields=None):
+    """Render a vault template while preserving its static frontmatter and body.
+
+    ``fields`` maps frontmatter keys to either scalar strings or lists of YAML
+    list-item strings. Existing values for those keys are replaced; absent keys
+    are added before the closing frontmatter fence. This lets the vault's own
+    templates control note layout, defaults, and body content.
+    """
+    with open(template_path, "r", encoding="utf-8") as f:
+        lines = f.read().splitlines(keepends=True)
+    if not lines or lines[0].rstrip("\n") != "---":
+        raise ValueError(f"template has no leading frontmatter fence: {template_path}")
+    fm_end = next(
+        (i for i in range(1, len(lines)) if lines[i].rstrip("\n") == "---"), None
+    )
+    if fm_end is None:
+        raise ValueError(f"template has no closing frontmatter fence: {template_path}")
+
+    fields = fields or {}
+    rendered = [lines[0]]
+    seen = set()
+    i = 1
+    while i < fm_end:
+        line = lines[i]
+        match = re.match(r"^([A-Za-z][A-Za-z0-9_-]*):( |$)", line.rstrip("\n"))
+        if not match or match.group(1) not in fields:
+            rendered.append(line)
+            i += 1
+            continue
+
+        key = match.group(1)
+        value = fields[key]
+        seen.add(key)
+        if isinstance(value, list):
+            rendered.append(f"{key}:\n")
+            rendered.extend(f"  - {item}\n" for item in value)
+            i += 1
+            while i < fm_end and lines[i].startswith("  - "):
+                i += 1
+        else:
+            rendered.append(f"{key}: {value}\n")
+            i += 1
+
+    for key, value in fields.items():
+        if key in seen:
+            continue
+        if isinstance(value, list):
+            rendered.append(f"{key}:\n")
+            rendered.extend(f"  - {item}\n" for item in value)
+        else:
+            rendered.append(f"{key}: {value}\n")
+    rendered.extend(lines[fm_end:])
+    return "".join(rendered)
+
+
 def write_note(path, text):
     """Create a note. Never overwrites an existing file."""
     if os.path.exists(path):
@@ -177,26 +232,10 @@ def download(url, dest, headers=None):
         f.write(data)
 
 
-def ensure_person_note(references_dir, name, type_link):
-    """Create the thin People note a ``director``/``artist`` link points at, if
-    it doesn't exist — so the Director/Artist Base views resolve. Mirrors the
-    Director/Artist templates: categories [[People]] + a types link, with the
-    matching embedded Base view in the body."""
+def ensure_person_note(notes_dir, name, template_path):
+    """Create a linked person note from its vault template if it is missing."""
     base = sanitize(name)
-    path = os.path.join(references_dir, f"{base}.md")
+    path = os.path.join(notes_dir, f"{base}.md")
     if os.path.exists(path):
         return
-    section = "Movies" if type_link == "Directors" else "Albums"
-    view = "Director" if type_link == "Directors" else "Artist"
-    text = (
-        "---\n"
-        "categories:\n"
-        '  - "[[People]]"\n'
-        "types:\n"
-        f'  - "[[{type_link}]]"\n'
-        "---\n"
-        f"## {section}\n\n"
-        f"![[{section}.base#{view}]]\n"
-    )
-    with open(path, "w", encoding="utf-8") as f:
-        f.write(text)
+    write_note(path, render_template(template_path))