slidesync 0.2.0__tar.gz → 0.4.0__tar.gz

{slidesync-0.2.0/slidesync.egg-info → slidesync-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slidesync
-Version: 0.2.0
+Version: 0.4.0
 Summary: Bidirectional sync between a Slidev markdown deck and Google Slides as native, editable objects
 Author-email: Daniel Hails <slidesync@hails.info>
 License: MIT
@@ -22,7 +22,7 @@ Bidirectional sync between a [Slidev](https://sli.dev) markdown deck and **Googl
 Slides** — as native, editable objects (title/body/bullets/tables/positioned
 images, brand-styled text boxes), not pasted screenshots.
 
-Version: 0.2.0
+Version: 0.4.0
 
 ```bash
 uvx slidesync --help            # run without installing
@@ -58,11 +58,13 @@ Support path.)
 
 | Command | Purpose |
 |---------|---------|
-| `slidesync push <file.slidev.md> [--deck ID] [--new "Title"] [--anchor SLIDE] [--prune] [--force]` | markdown → Slides |
+| `slidesync push <file.slidev.md> [--deck ID] [--new "Title"] [--anchor SLIDE] [--prune] [--force]` | markdown → Slides (rejected if it would discard live edits; `--force` overrides) |
 | `slidesync pull <deckId> --out <file.md> [--all]` | Slides → markdown (`--all` includes non-managed slides) |
 | `slidesync roundtrip [--keep]` | self-test: push a sample, pull, assert identical |
 | `slidesync layouts <deckId>` | list a deck's theme layouts + placeholders |
 | `slidesync make-templates <deckId>` | inject branded `{{token}}` template slides |
+| `slidesync comments <deckId>` | list comment threads as JSON (page anchor, author, content, replies) |
+| `slidesync sync <file.slidev.md> [--deck ID]` | reconcile with the live deck: pull comments + live edits into the markdown, push local changes; conflicts stop it (exit 1) |
 
 `push` resolves the target deck from (in order) `--deck`, `--new`, or a top-level
 `deck:` frontmatter key. Relative image paths resolve against the markdown file's
@@ -87,6 +89,33 @@ hidden `<!-- s2g {...} -->` marker in speaker notes carries the human id, image
 path, template vars — and, for template slides, the authored body markdown
 (base64) — so `pull` recovers the source verbatim.
 
+## Sync & drift
+
+`push` is guarded like a non-fast-forward git push: if a slide it would replace
+(or prune) was edited in Google Slides since the last push — and the local
+markdown doesn't already carry that edit — the push is **rejected** with no
+changes made (`--force` overwrites). Live edits on slides the push wouldn't
+touch are left alone.
+
+`sync` reconciles the two sides, applying whatever is safe. The marker's
+last-pushed source is a true per-slide **merge base**, so each slide classifies
+three-way without timestamps (the APIs expose no per-slide edit times — only
+file-level `modifiedTime`; the marker's `at` stamp records our last push):
+
+| status | meaning | sync does |
+|--------|---------|-----------|
+| `clean` / `converged` | nothing changed, or both sides made the same change | nothing |
+| `local-edit` | markdown changed, deck untouched | pushes it |
+| `live-drift` | slide edited in Google Slides | writes the live content back into the markdown (reconstructed from its styled boxes, formatting runs included), then pushes |
+| `conflict` | both changed since last push | prints both diffs vs the base for a human/LLM to resolve; skips the push; exits 1 |
+
+Unresolved comment threads are appended to their slide as
+`<!-- @Author: text -->` blocks (replies as extra `@Author:` lines), and threads
+orphaned by a re-render are re-anchored to their slide via the objectId's
+key-hash. Captured text round-trips from then on. Write-back caveat: a slide
+edited live is rewritten canonically, so its authored comments collapse into
+one trailing block (untouched slides keep comments in place).
+
 ## Markdown dialect
 
 Top-level frontmatter: `theme:`, `deck:`. Slides separated by `---`; each slide

{slidesync-0.2.0 → slidesync-0.4.0}/README.md

@@ -4,7 +4,7 @@ Bidirectional sync between a [Slidev](https://sli.dev) markdown deck and **Googl
 Slides** — as native, editable objects (title/body/bullets/tables/positioned
 images, brand-styled text boxes), not pasted screenshots.
 
-Version: 0.2.0
+Version: 0.4.0
 
 ```bash
 uvx slidesync --help            # run without installing
@@ -40,11 +40,13 @@ Support path.)
 
 | Command | Purpose |
 |---------|---------|
-| `slidesync push <file.slidev.md> [--deck ID] [--new "Title"] [--anchor SLIDE] [--prune] [--force]` | markdown → Slides |
+| `slidesync push <file.slidev.md> [--deck ID] [--new "Title"] [--anchor SLIDE] [--prune] [--force]` | markdown → Slides (rejected if it would discard live edits; `--force` overrides) |
 | `slidesync pull <deckId> --out <file.md> [--all]` | Slides → markdown (`--all` includes non-managed slides) |
 | `slidesync roundtrip [--keep]` | self-test: push a sample, pull, assert identical |
 | `slidesync layouts <deckId>` | list a deck's theme layouts + placeholders |
 | `slidesync make-templates <deckId>` | inject branded `{{token}}` template slides |
+| `slidesync comments <deckId>` | list comment threads as JSON (page anchor, author, content, replies) |
+| `slidesync sync <file.slidev.md> [--deck ID]` | reconcile with the live deck: pull comments + live edits into the markdown, push local changes; conflicts stop it (exit 1) |
 
 `push` resolves the target deck from (in order) `--deck`, `--new`, or a top-level
 `deck:` frontmatter key. Relative image paths resolve against the markdown file's
@@ -69,6 +71,33 @@ hidden `<!-- s2g {...} -->` marker in speaker notes carries the human id, image
 path, template vars — and, for template slides, the authored body markdown
 (base64) — so `pull` recovers the source verbatim.
 
+## Sync & drift
+
+`push` is guarded like a non-fast-forward git push: if a slide it would replace
+(or prune) was edited in Google Slides since the last push — and the local
+markdown doesn't already carry that edit — the push is **rejected** with no
+changes made (`--force` overwrites). Live edits on slides the push wouldn't
+touch are left alone.
+
+`sync` reconciles the two sides, applying whatever is safe. The marker's
+last-pushed source is a true per-slide **merge base**, so each slide classifies
+three-way without timestamps (the APIs expose no per-slide edit times — only
+file-level `modifiedTime`; the marker's `at` stamp records our last push):
+
+| status | meaning | sync does |
+|--------|---------|-----------|
+| `clean` / `converged` | nothing changed, or both sides made the same change | nothing |
+| `local-edit` | markdown changed, deck untouched | pushes it |
+| `live-drift` | slide edited in Google Slides | writes the live content back into the markdown (reconstructed from its styled boxes, formatting runs included), then pushes |
+| `conflict` | both changed since last push | prints both diffs vs the base for a human/LLM to resolve; skips the push; exits 1 |
+
+Unresolved comment threads are appended to their slide as
+`<!-- @Author: text -->` blocks (replies as extra `@Author:` lines), and threads
+orphaned by a re-render are re-anchored to their slide via the objectId's
+key-hash. Captured text round-trips from then on. Write-back caveat: a slide
+edited live is rewritten canonically, so its authored comments collapse into
+one trailing block (untouched slides keep comments in place).
+
 ## Markdown dialect
 
 Top-level frontmatter: `theme:`, `deck:`. Slides separated by `---`; each slide

{slidesync-0.2.0 → slidesync-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "slidesync"
-version = "0.2.0"
+version = "0.4.0"
 authors = [
     { name = "Daniel Hails", email = "slidesync@hails.info" },
 ]
@@ -32,7 +32,7 @@ include = ["slidesync*"]
 dev = ["pytest>=8"]
 
 [tool.bumpver]
-current_version = "0.2.0"
+current_version = "0.4.0"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true

{slidesync-0.2.0 → slidesync-0.4.0}/slidesync/__init__.py

@@ -30,7 +30,7 @@ from slidesync._sync import (
     write_slidev,
 )
 
-__version__ = "0.2.0"
+__version__ = "0.4.0"
 
 __all__ = [
     "Para",

{slidesync-0.2.0 → slidesync-0.4.0}/slidesync/_sync.py

@@ -36,6 +36,9 @@ from __future__ import annotations
 
 import argparse
 import base64
+import copy
+import datetime
+import difflib
 import hashlib
 import html
 import json
@@ -580,6 +583,10 @@ def _marker(slide: Slide) -> str:
             data["src"] = base64.b64encode(slide.src.encode()).decode()
     elif slide.layout_name and slide.layout_name not in SECTION_LAYOUTS:
         data["tpl"] = slide.layout_name
+    # Last-push stamp: `sync` reports it alongside drift. The Slides/Drive APIs
+    # have no per-slide edit times (file-level modifiedTime only), so this is
+    # the only per-slide timestamp that exists.
+    data["at"] = datetime.datetime.now(datetime.UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
     return f"<!-- s2g {json.dumps(data, separators=(',', ':'))} -->"
 
 
@@ -1141,6 +1148,16 @@ def push(slides_api, drive, deck, source, anchor, prune, base_dir=Path("."),
     creates, deletes, skips, pruned = plan_sync(source, managed, prune, force)
     if not (creates or deletes or pruned):  # nothing changed — skip reorder/links/gets
         return {"create": 0, "skip": len(skips), "replace": 0, "prune": 0}
+    if not force:
+        # Non-fast-forward guard: replacing or pruning a slide that was edited
+        # in Google Slides since its last push would silently discard that edit.
+        risks = _clobber_risks(pres, managed, source, pruned)
+        if risks:
+            for key in risks:
+                logger.error(f"live edit would be lost: {key}")
+            sys.exit("push rejected: the deck changed in Google Slides since the "
+                     "last push (slides above). Run `slidesync sync` to reconcile, "
+                     "or `push --force` to overwrite.")
     layouts = _layout_map(slides_api, deck, pres)
     templates = _template_index(slides_api, deck, pres)
     reqs = [{"deleteObject": {"objectId": oid}} for oid in deletes + pruned]
@@ -1890,6 +1907,325 @@ def cmd_layouts(args):
         logger.info(f"{name:<24} {', '.join(phs) or '(no placeholders)'}")
 
 
+# ---------------------------------------------------------------------------
+# Comments + sync (drift detection)
+# ---------------------------------------------------------------------------
+
+
+def shape_comments(raw: list[dict]) -> list[dict]:
+    """Drive comment threads -> [{id, page, author, content, resolved, replies}].
+
+    `page` is the anchored slide objectId (None for file-level comments) —
+    note an objectId outlives its slide, so the anchor may point at a deleted
+    page after a re-render. Resolve-action replies with no text are dropped.
+    """
+    out = []
+    for c in raw:
+        try:
+            anchor = json.loads(c.get("anchor") or "{}")
+        except json.JSONDecodeError:
+            anchor = {}
+        pages = anchor.get("pages") or []
+        out.append({
+            "id": c.get("id", ""),
+            "page": pages[0] if pages else None,
+            "author": (c.get("author") or {}).get("displayName", ""),
+            "content": (c.get("content") or "").strip(),
+            "resolved": bool(c.get("resolved")),
+            "modified": c.get("modifiedTime", ""),
+            "replies": [
+                {"author": (r.get("author") or {}).get("displayName", ""),
+                 "content": (r.get("content") or "").strip()}
+                for r in c.get("replies", []) if (r.get("content") or "").strip()
+            ],
+        })
+    return out
+
+
+_COMMENT_FIELDS = ("nextPageToken,comments(id,content,author(displayName),"
+                   "anchor,resolved,modifiedTime,replies(content,author(displayName)))")
+
+
+def list_comments(drive, deck: str) -> list[dict]:
+    raw, token = [], None
+    while True:
+        resp = drive.comments().list(fileId=deck, pageSize=100, pageToken=token,
+                                     fields=_COMMENT_FIELDS).execute()
+        raw += resp.get("comments", [])
+        token = resp.get("nextPageToken")
+        if not token:
+            return raw
+
+
+def cmd_comments(args):
+    _, drive = get_services(args.account)
+    print(json.dumps(shape_comments(list_comments(drive, args.deck)), indent=2))
+
+
+def text_lines_md(src: str) -> list[str]:
+    """Markdown slide body -> normalised visible text lines (comments excluded)."""
+    fences = [m.group("text") for m in VERBATIM_RE.finditer(src)]
+    headings, paras, _img, _alt, table, _ = parse_body(VERBATIM_RE.sub("", src))
+    lines = [headings[k] for k in sorted(headings)]
+    lines += [p.text for p in paras]
+    if table:
+        lines += [" | ".join(row) for row in table]
+    for f in fences:
+        lines += f.splitlines()
+    return _norm_lines(lines)
+
+
+def text_lines_native(s: dict) -> list[str]:
+    """Native slide JSON -> normalised visible text lines (notes excluded)."""
+    boxes = []
+    for el in s.get("pageElements", []):
+        if el.get("shape", {}).get("text"):
+            paras = _paras_from_shape(el["shape"])
+            if paras:
+                boxes.append((_el_y(el), _el_x(el), paras))
+        elif el.get("table"):
+            rows = _table_from_native(el["table"])
+            boxes.append((_el_y(el), _el_x(el),
+                          [Para(" | ".join(r)) for r in rows]))
+    boxes.sort(key=lambda t: (t[0], t[1]))
+    return _norm_lines([p.text for _, _, paras in boxes for p in paras])
+
+
+def _norm_lines(lines: list[str]) -> list[str]:
+    # Sorted: box reading-order vs markdown order differ legitimately (e.g. a
+    # kicker renders above the headline but is written below it).
+    return sorted(" ".join(line.split()) for line in lines if line.strip())
+
+
+def classify_drift(base: list[str] | None, local: list[str],
+                   live: list[str]) -> str:
+    """Three-way status for one slide; base is the last-pushed source (marker)."""
+    if base is None:
+        return "clean" if local == live else "drift-no-base"
+    if local == base and live == base:
+        return "clean"
+    if local != base and live == base:
+        return "local-edit"
+    if local == base and live != base:
+        return "live-drift"
+    return "converged" if local == live else "conflict"
+
+
+def _diff(a: list[str], b: list[str], a_name: str, b_name: str) -> str:
+    return "\n".join(difflib.unified_diff(a, b, a_name, b_name, lineterm=""))
+
+
+def _live_state(s) -> tuple[list[str], str, str | None, dict]:
+    """(text lines, normalised notes, base source, marker) of a live slide."""
+    notes_raw = _read_notes(s)
+    marker = _read_marker(notes_raw)
+    base_src = base64.b64decode(marker["src"]).decode() if "src" in marker else None
+    notes = " ".join(MARKER_RE.sub("", notes_raw).split())
+    return text_lines_native(s), notes, base_src, marker
+
+
+def _clobber_risks(pres, managed, source, pruned) -> list[str]:
+    """Keys of slides whose live edits a push would silently discard.
+
+    A replace (or prune) deletes the live slide, which loses information only
+    when the live copy drifted from its merge base AND the local markdown does
+    not already contain the live content (as it does right after `sync`).
+    Legacy slides without a src marker can't be checked and are allowed.
+    """
+    live = {s["objectId"]: s for s in pres.get("slides", [])}
+    by_kh = {s.key_hash: s for s in source}
+    out = []
+    for kh, (oid, _ch) in managed.items():
+        sl = by_kh.get(kh)
+        replacing = sl is not None and sl.custom is None and sl.object_id != oid
+        if not (replacing or oid in pruned) or live.get(oid) is None:
+            continue
+        live_lines, live_notes, base_src, _marker_ = _live_state(live[oid])
+        if base_src is None:
+            continue
+        if (live_lines == text_lines_md(base_src)
+                and live_notes == " ".join(_extract_notes(base_src).split())):
+            continue  # deck untouched since last push
+        if (sl is not None and live_lines == text_lines_md(sl.src or "")
+                and live_notes == " ".join((sl.notes or "").split())):
+            continue  # local already carries the live edit
+        out.append(sl.key if sl is not None else oid)
+    return out
+
+
+def _slide_from_live_boxes(s, marker: dict) -> Slide:
+    """Rebuild a template slide's content from its deterministically-named boxes
+    (`_k` kicker, `_h` headline, `_by` byline, `_b` body), formatting runs
+    included — so live text edits can be written back into the markdown."""
+    sid = s["objectId"]
+    shapes = {el.get("objectId", ""): el["shape"]
+              for el in s.get("pageElements", [])
+              if el.get("shape", {}).get("text")}
+
+    def paras(suffix: str) -> list[Para]:
+        shape = shapes.get(sid + suffix)
+        return _paras_from_shape(shape) if shape else []
+
+    slide = Slide(marker.get("id", sid), "content")
+    slide.template_name = marker.get("template")
+    slide.vars = marker.get("vars", {})
+    if (slide.template_name or "").lower() in ("prompt", "code"):
+        slide.title = _flatten(paras("_k")).strip()
+        slide.verbatim = "\n".join(p.text for p in paras("_b"))
+        return slide
+    headline = _flatten(paras("_h")).strip()
+    kicker = _flatten(paras("_k")).strip()
+    if headline:
+        slide.title, slide.kicker = headline, kicker
+    else:
+        slide.title = kicker  # content template: the kicker IS the title
+    slide.paras = paras("_b") or paras("_by")
+    if marker.get("img"):
+        slide.layout = "image"
+        slide.image, slide.image_alt = marker["img"], marker.get("alt", "")
+    return slide
+
+
+def _render_body(slide: Slide) -> str:
+    """Slide -> markdown body only (the slide's frontmatter stays as authored)."""
+    bare = copy.copy(slide)
+    bare.template_name, bare.layout_name, bare.vars = None, None, {}
+    return to_slidev(bare, include_id=False).strip()
+
+
+_SEP_RE = re.compile(r"(?m)^---[ \t]*$")
+
+
+def _slide_span(text: str, key: str) -> tuple[int, int] | None:
+    """(start, end) of the body of the slide whose frontmatter id is `key`."""
+    m = re.search(rf"(?m)^id:\s*{re.escape(key)}\s*$", text)
+    if not m:
+        return None  # slide has no id: frontmatter — can't anchor file surgery
+    closer = _SEP_RE.search(text, m.end())
+    if not closer:
+        return None
+    nxt = _SEP_RE.search(text, closer.end())
+    return closer.end(), nxt.start() if nxt else len(text)
+
+
+def _replace_slide_body(text: str, key: str, body: str) -> str:
+    span = _slide_span(text, key)
+    if span is None:
+        return text
+    return text[:span[0]] + "\n" + body.strip("\n") + "\n\n" + text[span[1]:]
+
+
+def _append_to_slide_body(text: str, key: str, block: str) -> str:
+    span = _slide_span(text, key)
+    if span is None:
+        return text
+    return text[:span[1]].rstrip("\n") + "\n" + block + "\n\n" + text[span[1]:]
+
+
+def cmd_sync(args):
+    """Reconcile a markdown deck with its live Slides copy — applying what's safe.
+
+    Pull side: unresolved comment threads are appended to their slide as
+    `<!-- @Author: text -->` blocks (orphaned threads are re-anchored via the
+    objectId's key-hash), and live-drift slides — edited in Slides, untouched
+    locally — are written back into the markdown, reconstructed from their
+    styled boxes. Conflict slides (both sides changed) are never touched: their
+    diffs print for a human/LLM to resolve, and the push step is skipped.
+    Push side: when no conflicts remain, the (updated) file is pushed — safe,
+    because local now matches live wherever the deck had drifted. Exits 1 when
+    conflicts remain.
+    """
+    slides_api, drive = get_services(args.account)
+    path = args.source
+    source = load_slides(path)
+    deck = args.deck or deck_from_source(path)
+    if not deck:
+        sys.exit("no target deck: pass --deck or add `deck:` frontmatter")
+    pres = slides_api.presentations().get(presentationId=deck).execute()
+    live = {s["objectId"].split("_")[1]: s for s in pres.get("slides", [])
+            if MANAGED_RE.match(s["objectId"])}
+    by_page = {}
+    for c in shape_comments(list_comments(drive, deck)):
+        if not c["resolved"] and c["page"]:
+            by_page.setdefault(c["page"], []).append(c)
+
+    state = {"text": path.read_text(), "dirty": False, "pushable": False}
+    key_by_kh = {sl.key_hash: sl.key for sl in source}
+
+    def capture(key: str | None, c: dict, page: str) -> None:
+        lines = [f"@{c['author']}: {c['content']}"]
+        lines += [f"@{r['author']}: {r['content']}" for r in c["replies"]]
+        block = "<!-- " + "\n".join(lines) + " -->"
+        if " ".join(c["content"].split()) in " ".join(state["text"].split()):
+            return  # already captured
+        new = _append_to_slide_body(state["text"], key, block) if key else state["text"]
+        if new != state["text"]:
+            state.update(text=new, dirty=True, pushable=True)
+            logger.info(f"[comment   ] {key} — captured thread by {c['author']}")
+        else:
+            logger.warning(f"[comment   ] thread by {c['author']} on {key or page} "
+                           f"couldn't be placed; paste manually:\n{block}")
+
+    conflicts = []
+    for sl in source:
+        s = live.pop(sl.key_hash, None)
+        if s is None:
+            logger.info(f"[missing   ] {sl.key} — push will create it")
+            state["pushable"] = True
+            continue
+        for c in by_page.pop(s["objectId"], []):
+            capture(sl.key, c, s["objectId"])
+        if sl.custom is not None:
+            continue  # pull-authoritative; drawings are captured by pull, not diffed
+        live_lines, live_notes, base_src, marker = _live_state(s)
+        base = text_lines_md(base_src) if base_src is not None else None
+        status = classify_drift(base, text_lines_md(sl.src or ""), live_lines)
+        if status in ("clean", "converged"):
+            continue
+        if status == "local-edit":
+            logger.info(f"[local-edit] {sl.key} — push will update it")
+            state["pushable"] = True
+            continue
+        rebuilt = (_slide_from_live_boxes(s, marker)
+                   if status in ("live-drift", "drift-no-base")
+                   and marker.get("template") else None)
+        if rebuilt and (rebuilt.title or rebuilt.paras or rebuilt.verbatim):
+            rebuilt.notes = " ".join(MARKER_RE.sub("", _read_notes(s)).split())
+            new = _replace_slide_body(state["text"], sl.key, _render_body(rebuilt))
+            if new != state["text"]:
+                state.update(text=new, dirty=True, pushable=True)
+                logger.info(f"[pulled    ] {sl.key} — live edit written back")
+                continue
+        conflicts.append(sl.key)
+        logger.error(f"[conflict  ] {sl.key} (pushed {marker.get('at', '?')}) — "
+                     f"resolve in the markdown, then push:\n"
+                     + _diff(base or [], text_lines_md(sl.src or ""),
+                             "last-pushed", "local") + "\n"
+                     + _diff(base or [], live_lines, "last-pushed", "live"))
+    for page, cs in by_page.items():  # threads on re-rendered (deleted) pages
+        m = re.match(r"s2g_(?P<kh>[0-9a-f]{10})_", page)
+        key = key_by_kh.get(m.group("kh")) if m else None
+        for c in cs:
+            capture(key, c, page)
+    for _kh, s in live.items():
+        logger.warning(f"[unmanaged ] {s['objectId']} has no local slide "
+                       "(push --prune would delete it)")
+
+    if state["dirty"]:
+        path.write_text(state["text"])
+        logger.success(f"updated {path}")
+    if conflicts:
+        sys.exit(f"sync stopped: {len(conflicts)} conflict(s) above — resolve in "
+                 "the markdown, then `slidesync push` (its guard protects the rest).")
+    if state["pushable"]:
+        stats = push(slides_api, drive, deck, load_slides(path), anchor=None,
+                     prune=False, base_dir=path.parent)
+        logger.success(f"{stats} -> "
+                       f"https://docs.google.com/presentation/d/{deck}/edit")
+    else:
+        logger.success("deck matches source — nothing to do")
+
+
 def _loop_hop(slides_api, drive, title, slides):
     """One md->slides hop: build a deck, push, pull back."""
     deck = new_deck(slides_api, title)
@@ -1966,6 +2302,17 @@ def main():
     p.add_argument("deck")
     p.set_defaults(func=cmd_layouts)
 
+    p = sub.add_parser("comments",
+                       help="list comment threads as JSON (page anchor, author, replies)")
+    p.add_argument("deck")
+    p.set_defaults(func=cmd_comments)
+
+    p = sub.add_parser("sync",
+                       help="report drift vs the live deck (comments, live edits, conflicts)")
+    p.add_argument("source", type=Path)
+    p.add_argument("--deck")
+    p.set_defaults(func=cmd_sync)
+
     p = sub.add_parser("make-templates",
                        help="add branded tagged template slides to a deck")
     p.add_argument("deck")

{slidesync-0.2.0 → slidesync-0.4.0/slidesync.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slidesync
-Version: 0.2.0
+Version: 0.4.0
 Summary: Bidirectional sync between a Slidev markdown deck and Google Slides as native, editable objects
 Author-email: Daniel Hails <slidesync@hails.info>
 License: MIT
@@ -22,7 +22,7 @@ Bidirectional sync between a [Slidev](https://sli.dev) markdown deck and **Googl
 Slides** — as native, editable objects (title/body/bullets/tables/positioned
 images, brand-styled text boxes), not pasted screenshots.
 
-Version: 0.2.0
+Version: 0.4.0
 
 ```bash
 uvx slidesync --help            # run without installing
@@ -58,11 +58,13 @@ Support path.)
 
 | Command | Purpose |
 |---------|---------|
-| `slidesync push <file.slidev.md> [--deck ID] [--new "Title"] [--anchor SLIDE] [--prune] [--force]` | markdown → Slides |
+| `slidesync push <file.slidev.md> [--deck ID] [--new "Title"] [--anchor SLIDE] [--prune] [--force]` | markdown → Slides (rejected if it would discard live edits; `--force` overrides) |
 | `slidesync pull <deckId> --out <file.md> [--all]` | Slides → markdown (`--all` includes non-managed slides) |
 | `slidesync roundtrip [--keep]` | self-test: push a sample, pull, assert identical |
 | `slidesync layouts <deckId>` | list a deck's theme layouts + placeholders |
 | `slidesync make-templates <deckId>` | inject branded `{{token}}` template slides |
+| `slidesync comments <deckId>` | list comment threads as JSON (page anchor, author, content, replies) |
+| `slidesync sync <file.slidev.md> [--deck ID]` | reconcile with the live deck: pull comments + live edits into the markdown, push local changes; conflicts stop it (exit 1) |
 
 `push` resolves the target deck from (in order) `--deck`, `--new`, or a top-level
 `deck:` frontmatter key. Relative image paths resolve against the markdown file's
@@ -87,6 +89,33 @@ hidden `<!-- s2g {...} -->` marker in speaker notes carries the human id, image
 path, template vars — and, for template slides, the authored body markdown
 (base64) — so `pull` recovers the source verbatim.
 
+## Sync & drift
+
+`push` is guarded like a non-fast-forward git push: if a slide it would replace
+(or prune) was edited in Google Slides since the last push — and the local
+markdown doesn't already carry that edit — the push is **rejected** with no
+changes made (`--force` overwrites). Live edits on slides the push wouldn't
+touch are left alone.
+
+`sync` reconciles the two sides, applying whatever is safe. The marker's
+last-pushed source is a true per-slide **merge base**, so each slide classifies
+three-way without timestamps (the APIs expose no per-slide edit times — only
+file-level `modifiedTime`; the marker's `at` stamp records our last push):
+
+| status | meaning | sync does |
+|--------|---------|-----------|
+| `clean` / `converged` | nothing changed, or both sides made the same change | nothing |
+| `local-edit` | markdown changed, deck untouched | pushes it |
+| `live-drift` | slide edited in Google Slides | writes the live content back into the markdown (reconstructed from its styled boxes, formatting runs included), then pushes |
+| `conflict` | both changed since last push | prints both diffs vs the base for a human/LLM to resolve; skips the push; exits 1 |
+
+Unresolved comment threads are appended to their slide as
+`<!-- @Author: text -->` blocks (replies as extra `@Author:` lines), and threads
+orphaned by a re-render are re-anchored to their slide via the objectId's
+key-hash. Captured text round-trips from then on. Write-back caveat: a slide
+edited live is rewritten canonically, so its authored comments collapse into
+one trailing block (untouched slides keep comments in place).
+
 ## Markdown dialect
 
 Top-level frontmatter: `theme:`, `deck:`. Slides separated by `---`; each slide

{slidesync-0.2.0 → slidesync-0.4.0}/slidesync.egg-info/SOURCES.txt

@@ -11,5 +11,7 @@ slidesync.egg-info/entry_points.txt
 slidesync.egg-info/requires.txt
 slidesync.egg-info/top_level.txt
 tests/test_comment_preservation.py
+tests/test_e2e_scenarios.py
 tests/test_markdown.py
-tests/test_pull.py
+tests/test_pull.py
+tests/test_sync_drift.py

slidesync-0.4.0/tests/test_e2e_scenarios.py

@@ -0,0 +1,292 @@
+"""End-to-end scenarios for push/sync against an in-memory Slides+Drive fake.
+
+The fake interprets exactly the request types slidesync emits (createSlide,
+deleteObject, createShape, insertText, deleteText, updateSlidesPosition) and
+renders state back in the wire format `presentations.get` returns — so push,
+the non-fast-forward guard, and sync's pull-back/capture all run unmodified.
+"""
+
+import json
+import re
+from types import SimpleNamespace
+
+import pytest
+
+from slidesync import _sync
+from slidesync._sync import cmd_sync, load_slides, push
+
+DECK = "fakedeck"
+
+MD = """---
+theme: seriph
+---
+
+---
+template: topic
+id: thread-a
+---
+# Takeaway A
+## FINDING · DATA
+
+One solid point.
+
+<!-- presenter note A -->
+
+---
+---
+template: content
+id: overview
+---
+## OVERVIEW
+
+First result line.
+"""
+
+
+def _text_els(text):
+    els = []
+    for line in text.split("\n"):
+        els.append({"paragraphMarker": {}})
+        els.append({"textRun": {"content": line + "\n", "style": {}}})
+    return els if text else []
+
+
+class FakeStore:
+    """In-memory deck: ordered slides, each with text shapes + speaker notes."""
+
+    def __init__(self):
+        self.slides = []  # {"id", "shapes": {sid: {"y", "x", "text"}}, "notes"}
+
+    def _slide(self, oid):
+        return next(s for s in self.slides if s["id"] == oid)
+
+    def _owner_of_shape(self, sid):
+        for s in self.slides:
+            if sid in s["shapes"] or sid == s["id"] + "_n":
+                return s
+        raise KeyError(sid)
+
+    def apply(self, reqs):
+        for r in reqs:
+            if "createSlide" in r:
+                self.slides.append({"id": r["createSlide"]["objectId"],
+                                    "shapes": {}, "notes": ""})
+            elif "deleteObject" in r:
+                self.slides = [s for s in self.slides
+                               if s["id"] != r["deleteObject"]["objectId"]]
+            elif "createShape" in r:
+                ep = r["createShape"]["elementProperties"]
+                tr = ep.get("transform", {})
+                self._slide(ep["pageObjectId"])["shapes"][
+                    r["createShape"]["objectId"]] = {
+                        "y": tr.get("translateY", 0), "x": tr.get("translateX", 0),
+                        "text": ""}
+            elif "insertText" in r:
+                sid = r["insertText"]["objectId"]
+                s = self._owner_of_shape(sid)
+                if sid == s["id"] + "_n":
+                    s["notes"] += r["insertText"]["text"]
+                else:
+                    s["shapes"][sid]["text"] += r["insertText"]["text"]
+            elif "deleteText" in r:
+                sid = r["deleteText"]["objectId"]
+                s = self._owner_of_shape(sid)
+                if sid == s["id"] + "_n":
+                    s["notes"] = ""
+                else:
+                    s["shapes"][sid]["text"] = ""
+            elif "updateSlidesPosition" in r:
+                oid = r["updateSlidesPosition"]["slideObjectIds"][0]
+                moved = self._slide(oid)
+                rest = [s for s in self.slides if s["id"] != oid]
+                rest.insert(r["updateSlidesPosition"]["insertionIndex"], moved)
+                self.slides = rest
+            # styling-only requests are ignored
+        return {}
+
+    def render(self):
+        out = []
+        for s in self.slides:
+            els = [{"objectId": sid,
+                    "transform": {"translateY": sh["y"], "translateX": sh["x"]},
+                    "shape": {"text": {"textElements": _text_els(sh["text"])}}}
+                   for sid, sh in s["shapes"].items() if sh["text"]]
+            nid = s["id"] + "_n"
+            out.append({
+                "objectId": s["id"], "pageElements": els,
+                "slideProperties": {"notesPage": {
+                    "notesProperties": {"speakerNotesObjectId": nid},
+                    "pageElements": [{"objectId": nid, "shape": {
+                        "text": {"textElements": _text_els(s["notes"])}}}]}}})
+        return {"slides": out, "layouts": []}
+
+    # test helpers ---------------------------------------------------------
+    def oid_of(self, needle):
+        for s in self.slides:
+            if any(needle in sh["text"] for sh in s["shapes"].values()):
+                return s["id"]
+        raise AssertionError(f"no live slide contains {needle!r}")
+
+    def edit_text(self, old, new):
+        for s in self.slides:
+            for sh in s["shapes"].values():
+                if old in sh["text"]:
+                    sh["text"] = sh["text"].replace(old, new)
+                    return
+        raise AssertionError(f"no live shape contains {old!r}")
+
+    def all_text(self):
+        return " ".join(sh["text"] for s in self.slides
+                        for sh in s["shapes"].values())
+
+
+class _Req:
+    def __init__(self, fn):
+        self.execute = fn
+
+
+class FakeSlides:
+    def __init__(self, store):
+        self.store = store
+
+    def presentations(self):
+        return self
+
+    def get(self, presentationId, fields=None):
+        return _Req(lambda: self.store.render())
+
+    def batchUpdate(self, presentationId, body):
+        return _Req(lambda: self.store.apply(body["requests"]))
+
+
+class FakeDrive:
+    def __init__(self):
+        self.threads = []  # raw Drive comment dicts
+
+    def comments(self):
+        return self
+
+    def list(self, fileId, pageSize=None, pageToken=None, fields=None):
+        return _Req(lambda: {"comments": self.threads})
+
+    def add(self, page_oid, content, author="Daniel Hails"):
+        self.threads.append({
+            "id": f"c{len(self.threads)}",
+            "anchor": json.dumps({"type": "page", "pages": [page_oid]}),
+            "author": {"displayName": author},
+            "content": content, "replies": []})
+
+
+@pytest.fixture
+def env(tmp_path, monkeypatch):
+    store, drive = FakeStore(), FakeDrive()
+    slides_api = FakeSlides(store)
+    monkeypatch.setattr(_sync, "get_services", lambda account: (slides_api, drive))
+    path = tmp_path / "deck.slidev.md"
+    path.write_text(MD)
+    push(slides_api, drive, DECK, load_slides(path), anchor=None, prune=False,
+         base_dir=tmp_path)
+    return SimpleNamespace(store=store, drive=drive, slides=slides_api, path=path)
+
+
+def _sync_cmd(env):
+    cmd_sync(SimpleNamespace(source=env.path, deck=DECK, account=None))
+
+
+def _push(env, force=False, prune=False):
+    return push(env.slides, env.drive, DECK, load_slides(env.path), anchor=None,
+                prune=prune, base_dir=env.path.parent, force=force)
+
+
+def _local_edit(env):
+    env.path.write_text(env.path.read_text().replace(
+        "One solid point.", "One solid point, sharpened."))
+
+
+def _live_edit(env):
+    env.store.edit_text("Takeaway A", "Takeaway A, live-edited")
+
+
+SCENARIOS = {
+    "clean": dict(setup=[], sync_conflicts=False,
+                  file_has=[], live_has=["Takeaway A"]),
+    "local-edit": dict(setup=[_local_edit], sync_conflicts=False,
+                       file_has=["sharpened"], live_has=["sharpened"]),
+    "live-drift": dict(setup=[_live_edit], sync_conflicts=False,
+                       file_has=["live-edited"], live_has=["live-edited"]),
+    "conflict": dict(setup=[_live_edit,
+                            lambda e: e.path.write_text(e.path.read_text().replace(
+                                "Takeaway A", "Takeaway A, locally-reworded"))],
+                     sync_conflicts=True,
+                     file_has=["locally-reworded"], live_has=["live-edited"]),
+}
+
+
+@pytest.mark.parametrize("name", SCENARIOS)
+def test_sync_scenarios(env, name):
+    sc = SCENARIOS[name]
+    for step in sc["setup"]:
+        step(env)
+    if sc["sync_conflicts"]:
+        with pytest.raises(SystemExit):
+            _sync_cmd(env)
+    else:
+        _sync_cmd(env)
+    text, live = env.path.read_text(), env.store.all_text()
+    for needle in sc["file_has"]:
+        assert needle in text, f"{name}: {needle!r} missing from markdown"
+    for needle in sc["live_has"]:
+        assert needle in live, f"{name}: {needle!r} missing from deck"
+    if not sc["sync_conflicts"]:  # reconciled: a follow-up sync is a no-op
+        before = env.path.read_text()
+        _sync_cmd(env)
+        assert env.path.read_text() == before
+
+
+def test_push_rejects_conflicting_replace_and_force_overrides(env):
+    _live_edit(env)
+    env.path.write_text(env.path.read_text().replace(
+        "Takeaway A", "Takeaway A, locally-reworded"))
+    with pytest.raises(SystemExit):
+        _push(env)
+    assert "live-edited" in env.store.all_text()  # guard left the deck intact
+    _push(env, force=True)
+    assert "locally-reworded" in env.store.all_text()
+    assert "live-edited" not in env.store.all_text()
+
+
+def test_push_rejects_pruning_a_live_edited_slide(env):
+    _live_edit(env)
+    env.path.write_text(re.sub(r"(?ms)^---\ntemplate: topic\n.*?(?=^---$\n---\n)",
+                               "", env.path.read_text(), count=1))
+    assert "thread-a" not in env.path.read_text()
+    with pytest.raises(SystemExit):
+        _push(env, prune=True)
+    _push(env, prune=True, force=True)
+    assert "Takeaway A" not in env.store.all_text()
+
+
+def test_push_ignores_live_drift_on_untouched_slides(env):
+    # No local change -> nothing is replaced -> nothing can be lost -> no guard.
+    _live_edit(env)
+    stats = _push(env)
+    assert stats["replace"] == 0
+    assert "live-edited" in env.store.all_text()
+
+
+def test_sync_captures_comment_onto_its_slide(env):
+    env.drive.add(env.store.oid_of("Takeaway A"), "This is obviously dodgy. To debug")
+    _sync_cmd(env)
+    text = env.path.read_text()
+    assert "<!-- @Daniel Hails: This is obviously dodgy. To debug -->" in text
+    assert text.index("Takeaway A") < text.index("obviously dodgy") < text.index("OVERVIEW")
+    _sync_cmd(env)  # idempotent: captured text is not duplicated
+    assert env.path.read_text().count("obviously dodgy") == 1
+
+
+def test_sync_recaptures_orphaned_comment_via_key_hash(env):
+    env.drive.add(env.store.oid_of("Takeaway A"), "anchored before the re-render")
+    _local_edit(env)
+    _push(env)  # re-render replaces the slide; the thread's page id now dangles
+    _sync_cmd(env)
+    assert "<!-- @Daniel Hails: anchored before the re-render -->" in env.path.read_text()

slidesync-0.4.0/tests/test_sync_drift.py

@@ -0,0 +1,67 @@
+"""Offline tests for drift detection: comment shaping, text-line extraction
+parity (markdown vs native), and the three-way classification."""
+
+from slidesync._sync import (
+    classify_drift,
+    shape_comments,
+    text_lines_md,
+    text_lines_native,
+)
+
+RAW_COMMENTS = [
+    {"id": "c1",
+     "anchor": '{"type":"page","uid":1,"pages":["s2g_aaaaaaaaaa_bbbbbbbbbb"]}',
+     "author": {"displayName": "Daniel Hails"},
+     "content": "This is obviously dodgy. To debug",
+     "modifiedTime": "2026-06-12T15:00:00Z",
+     "replies": [
+         {"author": {"displayName": "Ted"}, "content": "agree"},
+         {"author": {"displayName": "Daniel Hails"}, "content": ""},  # resolve action
+     ]},
+    {"id": "c2", "anchor": "not json", "author": {}, "content": "file-level",
+     "resolved": True},
+]
+
+
+def test_shape_comments_extracts_page_author_replies():
+    a, b = shape_comments(RAW_COMMENTS)
+    assert a["page"] == "s2g_aaaaaaaaaa_bbbbbbbbbb"
+    assert a["author"] == "Daniel Hails" and not a["resolved"]
+    assert a["replies"] == [{"author": "Ted", "content": "agree"}]
+    assert b["page"] is None and b["resolved"] is True
+
+
+def _native(texts):
+    """A native slide with one text box per entry, stacked top to bottom."""
+    els = []
+    for i, text in enumerate(texts):
+        els.append({"transform": {"translateY": i * 914400, "translateX": 0},
+                    "shape": {"text": {"textElements": [
+                        {"paragraphMarker": {}},
+                        {"textRun": {"content": text, "style": {}}}]}}})
+    return {"objectId": "s", "pageElements": els}
+
+
+def test_md_and_native_text_lines_agree_for_a_styled_slide():
+    md = "# 2026/06/15\n## RELIABLE MONITORS\n\nWeekly Update\n<!-- a note -->"
+    # live render stacks kicker above headline — order differs, content matches
+    native = _native(["RELIABLE MONITORS", "2026/06/15", "Weekly Update"])
+    assert text_lines_md(md) == text_lines_native(native)
+
+
+def test_md_text_lines_include_verbatim_fences_and_skip_comments():
+    md = "## PROMPT\n```text\nYou are a monitor.\n```\n<!-- hidden -->"
+    lines = text_lines_md(md)
+    assert "You are a monitor." in lines
+    assert not any("hidden" in line for line in lines)
+
+
+def test_classify_drift_three_way():
+    base, local, live = ["a"], ["a"], ["a"]
+    assert classify_drift(base, local, live) == "clean"
+    assert classify_drift(base, ["b"], live) == "local-edit"
+    assert classify_drift(base, local, ["b"]) == "live-drift"
+    assert classify_drift(base, ["b"], ["c"]) == "conflict"
+    assert classify_drift(base, ["b"], ["b"]) == "converged"
+    assert classify_drift(None, ["a"], ["a"]) == "clean"
+    assert classify_drift(None, ["a"], ["b"]) == "drift-no-base"