overleaf-comments-export 0.2.0__py3-none-any.whl

overleaf_comments_export/render.py

@@ -0,0 +1,370 @@
+from __future__ import annotations
+
+from collections import Counter, defaultdict
+from datetime import datetime, timezone
+from typing import Iterable, Literal
+
+from .model import AnchoredComment, SourceContext, Thread, TrackedChange
+
+SCHEMA_VERSION = "1.3"
+RenderMode = Literal["compact", "detailed"]
+
+# How aggressively to clip the captured context window when rendering.
+COMPACT_CONTEXT_CHARS = 70
+DETAILED_CONTEXT_CHARS = 160
+
+
+def _fmt_ts(ms: int | None) -> str:
+    if not ms:
+        return "?"
+    return datetime.fromtimestamp(ms / 1000, tz=timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
+
+
+def _humanize_user(name: str | None, email: str | None, user_id: str | None) -> str:
+    """Best-effort display name. If `name` is set, use it. Else if the email
+    local part looks like firstname.lastname, title-case it. Else fall back to
+    the email local part, then a short id."""
+    if name:
+        return name
+    if email:
+        local = email.split("@", 1)[0]
+        # firstname.lastname → "Firstname Lastname"
+        parts = [p for p in local.replace("_", ".").replace("-", ".").split(".") if p]
+        if len(parts) >= 2 and all(p.isalpha() for p in parts):
+            return " ".join(p.capitalize() for p in parts)
+        return local
+    return (user_id or "unknown")[:8]
+
+
+def _clip_left(s: str, n: int) -> tuple[str, bool]:
+    """Return rightmost n chars; True if clipped on the left."""
+    if len(s) <= n:
+        return s, False
+    return s[-n:].lstrip(), True
+
+
+def _clip_right(s: str, n: int) -> tuple[str, bool]:
+    """Return leftmost n chars; True if clipped on the right."""
+    if len(s) <= n:
+        return s, False
+    return s[:n].rstrip(), True
+
+
+def _inline_context(ctx: SourceContext | None, anchored_text_raw: str) -> str:
+    """Single-line blockquote: `…before  ▸anchor◂  after…`"""
+    if ctx is None:
+        text = (anchored_text_raw or "").strip()
+        return f"> **▸{text}◂**" if text else "> _(anchor text unavailable)_"
+    before, clipped_b = _clip_left(ctx.before, COMPACT_CONTEXT_CHARS)
+    after, clipped_a = _clip_right(ctx.after, COMPACT_CONTEXT_CHARS)
+    anchor = ctx.anchor or anchored_text_raw or ""
+    lead = "…" if (ctx.truncated_before or clipped_b) else ""
+    tail = "…" if (ctx.truncated_after or clipped_a) else ""
+    parts = []
+    if before:
+        parts.append(f"{lead}{before} ")
+    elif lead:
+        parts.append(lead)
+    parts.append(f"**▸{anchor}◂**")
+    if after:
+        parts.append(f" {after}{tail}")
+    elif tail:
+        parts.append(tail)
+    return "> " + "".join(parts)
+
+
+def _detailed_context(ctx: SourceContext | None, anchored_text_raw: str) -> list[str]:
+    """Multi-line code fence with the anchor on its own line."""
+    if ctx is None:
+        text = (anchored_text_raw or "").strip()
+        if not text:
+            return ["> _(anchor text unavailable)_"]
+        return ["```tex", f"▸ {text}", "```"]
+    before, clipped_b = _clip_left(ctx.before, DETAILED_CONTEXT_CHARS)
+    after, clipped_a = _clip_right(ctx.after, DETAILED_CONTEXT_CHARS)
+    anchor = ctx.anchor or anchored_text_raw or ""
+    lead = "…" if (ctx.truncated_before or clipped_b) else ""
+    tail = "…" if (ctx.truncated_after or clipped_a) else ""
+    out = ["```tex"]
+    if before:
+        out.append(f"{lead}{before}")
+    out.append(f"▸ {anchor}")
+    if after:
+        out.append(f"{after}{tail}")
+    out.append("```")
+    return out
+
+
+def _group_label(path: str) -> str:
+    if path.startswith("<unknown-") and path.endswith(">"):
+        return "Unmapped doc (filename not available)"
+    return path
+
+
+def _slug(s: str) -> str:
+    return "f-" + "".join(c if c.isalnum() else "-" for c in s.lower()).strip("-")[:80]
+
+
+def render_markdown(
+    project_title: str,
+    project_id: str,
+    threads: dict[str, Thread],
+    anchored: list[AnchoredComment],
+    orphan_threads: list[Thread],
+    changes: list[TrackedChange],
+    *,
+    mode: RenderMode = "compact",
+) -> str:
+    pulled_at_iso = datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+    open_count = sum(1 for t in threads.values() if not t.resolved)
+    resolved_count = sum(1 for t in threads.values() if t.resolved)
+    stale_count = sum(1 for c in anchored if c.stale)
+    file_count = len({c.pathname for c in anchored} | {ch.pathname for ch in changes})
+
+    reviewer_counter: Counter[str] = Counter()
+    for t in threads.values():
+        for m in t.messages:
+            reviewer_counter[_humanize_user(m.user_name, m.user_email, m.user_id)] += 1
+
+    out: list[str] = []
+
+    # ---- YAML front-matter ----
+    out.append("---")
+    out.append(f"schema_version: {SCHEMA_VERSION}")
+    out.append(f"project_id: {project_id}")
+    out.append(f'project_title: "{project_title}"')
+    out.append(f"pulled_at: {pulled_at_iso}")
+    out.append(f"thread_count: {len(threads)}")
+    out.append(f"open_count: {open_count}")
+    out.append(f"resolved_count: {resolved_count}")
+    out.append(f"tracked_change_count: {len(changes)}")
+    out.append(f"stale_anchor_count: {stale_count}")
+    out.append(f"file_count: {file_count}")
+    out.append(f"reviewer_count: {len(reviewer_counter)}")
+    out.append("companion_json: comments.json")
+    out.append("companion_agents: agents.md")
+    out.append("---")
+    out.append("")
+
+    # ---- Human-friendly header ----
+    out.append(f"# Overleaf comments — {project_title}")
+    out.append("")
+    out.append(
+        "Stable IDs like `C001` are assigned in file → line order. Cite them when "
+        "asking an AI to address specific comments. The full structured data is in "
+        "`comments.json` next to this file."
+    )
+    out.append("")
+
+    # ---- Summary ----
+    out.append("## Summary")
+    out.append("")
+    out.append(f"- **Threads:** {len(threads)} ({open_count} open, {resolved_count} resolved)")
+    out.append(f"- **Tracked changes:** {len(changes)}")
+    if stale_count:
+        out.append(
+            f"- **Stale anchors:** {stale_count} "
+            f"(quoted text moved or no longer matches the live doc — best-effort relocation applied)"
+        )
+    if reviewer_counter:
+        top = reviewer_counter.most_common(5)
+        out.append(
+            "- **Most active reviewers:** "
+            + ", ".join(f"{name} ({n})" for name, n in top)
+        )
+    out.append("")
+
+    by_file_comments: dict[str, list[AnchoredComment]] = defaultdict(list)
+    for c in anchored:
+        by_file_comments[c.pathname].append(c)
+    by_file_changes: dict[str, list[TrackedChange]] = defaultdict(list)
+    for ch in changes:
+        by_file_changes[ch.pathname].append(ch)
+    all_paths = sorted(set(by_file_comments) | set(by_file_changes))
+
+    # ---- Table of contents (skip if only one file) ----
+    if len(all_paths) > 1:
+        out.append("## Table of contents")
+        out.append("")
+        for path in all_paths:
+            n_c = len(by_file_comments.get(path, []))
+            n_t = len(by_file_changes.get(path, []))
+            parts = []
+            if n_c:
+                parts.append(f"{n_c} comment{'' if n_c == 1 else 's'}")
+            if n_t:
+                parts.append(f"{n_t} tracked change{'' if n_t == 1 else 's'}")
+            out.append(
+                f"- [{_group_label(path)}](#{_slug(path)}) — {', '.join(parts)}"
+            )
+        out.append("")
+
+    # ---- Per-file sections ----
+    single_file = len(all_paths) == 1
+    for path in all_paths:
+        comments_in_file = sorted(by_file_comments.get(path, []), key=lambda c: (c.line_no, c.col, c.offset))
+        changes_in_file = sorted(by_file_changes.get(path, []), key=lambda c: (c.line_no, c.col, c.offset))
+
+        if not single_file:
+            out.append(f"## {_group_label(path)}")
+            out.append("")
+            out.append(f'<a id="{_slug(path)}"></a>')
+            out.append("")
+
+        # Group comments by (section, line) so we emit context once.
+        groups: dict[tuple[str, int], list[AnchoredComment]] = defaultdict(list)
+        section_for_line: dict[int, str] = {}
+        for c in comments_in_file:
+            heading = c.nearest_heading or "_(no enclosing section)_"
+            groups[(heading, c.line_no)].append(c)
+            section_for_line[c.line_no] = heading
+
+        last_section: str | None = None
+        for (heading, line_no), group in sorted(groups.items(), key=lambda kv: (kv[1][0].line_no if False else 0, kv[0][1])):
+            # Stable order: by line within section, sections by their first-line position
+            pass
+        # Re-do ordering: sort by (first_line_in_section, line_no)
+        section_first_line = {}
+        for (heading, line_no), _ in groups.items():
+            section_first_line[heading] = min(line_no, section_first_line.get(heading, line_no))
+
+        ordered_keys = sorted(
+            groups.keys(),
+            key=lambda k: (section_first_line[k[0]], k[1]),
+        )
+
+        for heading, line_no in ordered_keys:
+            group = groups[(heading, line_no)]
+            if heading != last_section:
+                out.append(f"### § {heading}")
+                out.append("")
+                last_section = heading
+
+            # Pick the most informative context from any comment in the group
+            # (they all anchor to the same line so the surrounding chars are
+            # similar; we just need one rendition).
+            sample = group[0]
+            out.append(f"**Line {line_no}** — {len(group)} comment{'' if len(group) == 1 else 's'}")
+            out.append("")
+            if mode == "detailed":
+                out.extend(_detailed_context(sample.context, sample.anchored_text))
+            else:
+                out.append(_inline_context(sample.context, sample.anchored_text))
+            out.append("")
+            for c in group:
+                thread = threads.get(c.thread_id)
+                _emit_comment_compact(out, c, thread)
+
+        if changes_in_file:
+            out.append("### § Tracked changes")
+            out.append("")
+            for ch in changes_in_file:
+                _emit_change(out, ch, mode=mode)
+
+    if orphan_threads:
+        out.append("## Threads without resolvable anchors")
+        out.append("")
+        out.append(
+            "_These threads exist but we couldn't locate them in the live source._"
+        )
+        out.append("")
+        for thread in orphan_threads:
+            _emit_orphan_thread(out, thread)
+
+    return "\n".join(out).rstrip() + "\n"
+
+
+def _status_badge(thread: Thread | None, stale: bool) -> str:
+    bits = []
+    if thread and thread.resolved:
+        bits.append("resolved")
+    else:
+        bits.append("open")
+    if stale:
+        bits.append("⚠ stale")
+    return " · ".join(bits)
+
+
+def _emit_comment_compact(out: list[str], c: AnchoredComment, thread: Thread | None) -> None:
+    """One comment in compact form: header + quoted phrase + replies. No
+    standalone source context (that's emitted once per (file, line) group)."""
+    status = _status_badge(thread, c.stale)
+    quote = (c.anchored_text or "").strip().replace("\n", " ")
+    if quote:
+        if len(quote) > 80:
+            quote = quote[:77].rstrip() + "…"
+        head = f"**{c.short_id}** _{status}_ — “{quote}”"
+    else:
+        head = f"**{c.short_id}** _{status}_ — _(empty anchor)_"
+    out.append(head)
+    if thread is None or not thread.messages:
+        out.append("- _(no messages)_")
+    else:
+        for msg in sorted(thread.messages, key=lambda m: m.timestamp_ms):
+            who = _humanize_user(msg.user_name, msg.user_email, msg.user_id)
+            when = _fmt_ts(msg.timestamp_ms)
+            edited = " _(edited)_" if msg.edited_at_ms else ""
+            body = (msg.content or "").strip()
+            # If body is single-line, render inline; multi-line gets a
+            # blockquote so it stays readable.
+            if "\n" in body:
+                out.append(f"- **{who}** · {when}{edited}:")
+                for line in body.splitlines():
+                    out.append(f"  > {line}")
+            else:
+                out.append(f"- **{who}** · {when}{edited}: {body}")
+    out.append("")
+
+
+def _emit_change(out: list[str], ch: TrackedChange, *, mode: RenderMode = "compact") -> None:
+    sign = "+" if ch.kind == "insertion" else "-"
+    who = _humanize_user(ch.user_name, ch.user_email, ch.user_id)
+    when = _fmt_ts(ch.timestamp_ms)
+    content = (ch.content or "").strip()
+    out.append(
+        f"**{ch.short_id}** _{ch.kind}_ — line {ch.line_no} — {who} · {when}"
+    )
+
+    ctx = ch.context
+    if mode == "detailed" and ctx is not None:
+        before, clipped_b = _clip_left(ctx.before, DETAILED_CONTEXT_CHARS)
+        after, clipped_a = _clip_right(ctx.after, DETAILED_CONTEXT_CHARS)
+        lead = "…" if (ctx.truncated_before or clipped_b) else ""
+        tail = "…" if (ctx.truncated_after or clipped_a) else ""
+        out.append("```diff")
+        if before:
+            out.append(f"  {lead}{before}")
+        for ln in content.splitlines() or [""]:
+            out.append(f"{sign} {ln}")
+        if after:
+            out.append(f"  {after}{tail}")
+        out.append("```")
+    else:
+        # Compact: one-line diff with truncation
+        flat = content.replace("\n", "⏎ ")
+        if len(flat) > 120:
+            flat = flat[:117].rstrip() + "…"
+        out.append(f"- `{sign} {flat}`")
+        if ctx is not None:
+            before, clipped_b = _clip_left(ctx.before, COMPACT_CONTEXT_CHARS)
+            after, clipped_a = _clip_right(ctx.after, COMPACT_CONTEXT_CHARS)
+            lead = "…" if (ctx.truncated_before or clipped_b) else ""
+            tail = "…" if (ctx.truncated_after or clipped_a) else ""
+            if before or after:
+                out.append(f"  > {lead}{before} **▸here◂** {after}{tail}")
+    out.append("")
+
+
+def _emit_orphan_thread(out: list[str], thread: Thread) -> None:
+    status = "resolved" if thread.resolved else "open"
+    out.append(f"- **Thread `{thread.id[:8]}…`** _{status}_")
+    if not thread.messages:
+        out.append("  - _(no messages)_")
+    else:
+        for msg in sorted(thread.messages, key=lambda m: m.timestamp_ms):
+            who = _humanize_user(msg.user_name, msg.user_email, msg.user_id)
+            when = _fmt_ts(msg.timestamp_ms)
+            body = (msg.content or "").strip().replace("\n", " ")
+            out.append(f"  - {who} · {when}: {body}")
+    out.append("")

overleaf_comments_export/sections.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import re
+from bisect import bisect_right
+
+from .model import Heading
+
+# Standard LaTeX sectioning commands.
+_HEADING_RE = re.compile(
+    r"^\s*\\(?P<cmd>section|subsection|subsubsection|chapter|paragraph|part)\*?\s*"
+    r"(?:\[[^\]]*\])?\s*\{(?P<text>.*?)\}",
+    re.MULTILINE,
+)
+
+# Front-matter / pseudo-sections so comments inside the abstract or near the
+# title aren't lumped under "no enclosing section".
+_PSEUDO_RE = re.compile(
+    r"^\s*\\(?:begin\{(?P<env>abstract|titlepage)\}|"
+    r"(?P<cmd>title|maketitle|tableofcontents|frontmatter|mainmatter|backmatter|appendix))"
+    r"(?:\s*\{(?P<arg>[^}]*)\})?",
+    re.MULTILINE,
+)
+
+_LEVEL = {
+    "part": -1,
+    "chapter": 0,
+    "section": 1,
+    "subsection": 2,
+    "subsubsection": 3,
+    "paragraph": 4,
+}
+
+_PSEUDO_LEVEL = 1  # treat front-matter pseudo-sections at section level
+
+
+def find_headings(text: str, line_starts: list[int]) -> list[Heading]:
+    """Scan LaTeX source for headings, including title/abstract pseudo-sections.
+
+    line_starts[i] is the char offset of the start of line (i+1); used to
+    convert match offsets back into 1-indexed line numbers.
+    """
+    headings: list[Heading] = []
+
+    for m in _HEADING_RE.finditer(text):
+        line_no = bisect_right(line_starts, m.start())
+        cmd = m.group("cmd")
+        headings.append(
+            Heading(line_no=line_no, level=_LEVEL.get(cmd, 99), text=m.group("text").strip())
+        )
+
+    for m in _PSEUDO_RE.finditer(text):
+        line_no = bisect_right(line_starts, m.start())
+        env = m.group("env")
+        cmd = m.group("cmd")
+        arg = (m.group("arg") or "").strip()
+        if env == "abstract":
+            label = "Abstract"
+        elif env == "titlepage":
+            label = "Title page"
+        elif cmd == "title":
+            label = f"Title: {arg}" if arg else "Title"
+        elif cmd == "maketitle":
+            label = "Title block"
+        elif cmd == "tableofcontents":
+            label = "Table of contents"
+        elif cmd == "frontmatter":
+            label = "Front matter"
+        elif cmd == "mainmatter":
+            label = "Main matter"
+        elif cmd == "backmatter":
+            label = "Back matter"
+        elif cmd == "appendix":
+            label = "Appendix"
+        else:
+            continue
+        headings.append(Heading(line_no=line_no, level=_PSEUDO_LEVEL, text=label))
+
+    headings.sort(key=lambda h: (h.line_no, h.level))
+    return headings
+
+
+def nearest_heading(headings: list[Heading], line_no: int) -> str | None:
+    """Return a path like "§ 3.2 Method overview" for the nearest enclosing
+    heading at-or-above line_no."""
+    enclosing: dict[int, Heading] = {}
+    for h in headings:
+        if h.line_no > line_no:
+            break
+        enclosing[h.level] = h
+        for deeper in list(enclosing):
+            if deeper > h.level:
+                enclosing.pop(deeper)
+    if not enclosing:
+        return None
+    parts = [enclosing[lvl].text for lvl in sorted(enclosing)]
+    return " > ".join(parts)

overleaf_comments_export-0.2.0.dist-info/METADATA

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: overleaf-comments-export
+Version: 0.2.0
+Summary: Export comment threads and tracked changes from an Overleaf project to Markdown + JSON, optimized for AI-agent consumption.
+Author: Shivang
+License: MIT
+Project-URL: Homepage, https://github.com/Mangluu/overleaf-comments-export
+Project-URL: Issues, https://github.com/Mangluu/overleaf-comments-export/issues
+Project-URL: Source, https://github.com/Mangluu/overleaf-comments-export
+Keywords: overleaf,latex,research,comments,review,academic,tracked-changes,ai-agents
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Text Processing :: Markup :: LaTeX
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyoverleaf>=0.1.7
+Requires-Dist: browser-cookie3>=0.19
+Requires-Dist: requests>=2.31
+Requires-Dist: platformdirs>=4.0
+Provides-Extra: gui
+Requires-Dist: sv-ttk>=2.6; extra == "gui"
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Dynamic: license-file
+
+# overleaf-comments-export
+
+> **⚠️ Unofficial tool.** This is a third-party utility that talks to Overleaf's
+> undocumented internal HTTP endpoints. It is not affiliated with or endorsed
+> by Overleaf. Endpoints may change without notice. Use at your own risk and
+> in accordance with [Overleaf's Terms of Service](https://www.overleaf.com/legal).
+
+Export the comment threads and tracked changes from an Overleaf project into
+clean Markdown + structured JSON — designed so an AI assistant (Claude,
+ChatGPT, etc.) can ingest reviewer feedback and help you address it.
+
+[![CI](https://github.com/Mangluu/overleaf-comments-export/actions/workflows/ci.yml/badge.svg)](https://github.com/Mangluu/overleaf-comments-export/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/overleaf-comments-export.svg)](https://pypi.org/project/overleaf-comments-export/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/)
+
+## Why
+
+Overleaf doesn't provide a way to export comments or tracked changes for use
+outside the editor. If you want to:
+
+- have an AI agent draft point-by-point replies to reviewers,
+- archive reviewer discussions outside of Overleaf,
+- batch-address feedback across a large paper, or
+- split feedback by reviewer to delegate work,
+
+… you currently have to copy comments by hand. This tool automates that, given
+an Overleaf project URL and a logged-in browser session.
+
+## Install
+
+```bash
+pip install overleaf-comments-export
+```
+
+Requires Python 3.10+. Works on macOS, Linux, and Windows.
+
+## Quick start
+
+### CLI
+
+```bash
+overleaf-comments-export \
+    --project-url https://www.overleaf.com/project/<24-hex-id> \
+    --out ./paper-comments \
+    --browser safari
+```
+
+The first time you run it, sign in to Overleaf in your browser of choice;
+the tool reads the session cookie from there.
+
+### GUI
+
+```bash
+overleaf-comments-export --gui
+```
+
+Opens a small Tkinter window with all options surfaced. Best for non-technical
+users.
+
+## What it produces
+
+In your output folder, by default:
+
+| File | Purpose |
+|---|---|
+| `comments-<date>.md` | Human-readable Markdown grouped by file → section → line, with stable IDs (`C001`, `C002`, …) and source-context snippets around each anchor. |
+| `comments.json` | Structured data — `summary`, top-level `threads`, `files`, `comments`, `tracked_changes`, etc. Schema described in `agents.md`. |
+| `comments.jsonl` | One self-contained JSON record per comment for streaming/pipelines. |
+| `agents.md` | A brief instruction file telling an AI agent how to consume the batch. |
+| `by-reviewer/<name>.md` | (Optional, `--per-reviewer`) One Markdown per reviewer with only their threads. |
+| `comments.log` | Diagnostic log for the run. |
+
+## Filtering
+
+```bash
+# Only open comments
+overleaf-comments-export --project-url … --out ./out --no-resolved
+
+# Only one reviewer's threads
+overleaf-comments-export --project-url … --out ./out --reviewer "Emma"
+
+# Compact (default) vs. detailed (multi-line code-fence) layout
+overleaf-comments-export --project-url … --out ./out --render-mode detailed
+
+# Per-reviewer sub-reports under ./out/by-reviewer/
+overleaf-comments-export --project-url … --out ./out --per-reviewer
+```
+
+Full flag reference: `overleaf-comments-export --help`.
+
+## Browser authentication
+
+The tool reads the `overleaf_session2` cookie from your browser. Trade-offs
+by browser on macOS:
+
+| Browser | Notes |
+|---|---|
+| Safari | Recommended. No Keychain prompt; macOS may ask once for permission to read `~/Library/Cookies/`. |
+| Firefox | No Keychain prompt; plain SQLite cookie store. |
+| Chrome / Edge / Brave | Cookies are AES-encrypted with a Keychain-stored key; **you'll get a Keychain password prompt every run.** Hidden behind an opt-in in the GUI. |
+
+On Windows, Chrome 127+ uses App-Bound Encryption that `browser-cookie3`
+doesn't fully decrypt yet — prefer Firefox or Edge on Windows.
+
+On Linux, snap-packaged browsers sandbox their cookies — install browsers as
+native packages if you can.
+
+## Status & maintenance
+
+This is a personal research utility published in case it's useful to others.
+It is provided as-is, with no guaranteed maintenance, no SLA, and no roadmap.
+Pull requests are welcome; issues may or may not be acted upon.
+
+If Overleaf changes their internal API, this tool may stop working until
+someone (you?) adapts it.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

overleaf_comments_export-0.2.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+overleaf_comments_export/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+overleaf_comments_export/__main__.py,sha256=TSDOH9YmglmQBDjHBWSmUCagotGeCVASjCRTDQ7CKFA,4481
+overleaf_comments_export/anchors.py,sha256=qcOm5Vd2tMw7rJCiOncGGhA-jgnsfXUWiNv5WdV3BYc,2280
+overleaf_comments_export/client.py,sha256=x3ZPufzq2nGw9ZQo-6HSjxzZEDXC7e9k2o_ZFsImQzo,17767
+overleaf_comments_export/export.py,sha256=71LzD7fo32Y0a5MwznwYwFXI7hZGFrKaLQBVQr-BsWQ,32855
+overleaf_comments_export/gui.py,sha256=b536MeUAO1KnEjuf0l2912DyjMoSUe2_EXJmWjU8qXE,21956
+overleaf_comments_export/model.py,sha256=iWIwsbHaiXNcXjFsAkuZQNsiMOvxnmh78fi4apfyL-Y,2152
+overleaf_comments_export/render.py,sha256=dksxu9wpNBq8mUDpsPgrkrU05U_AnfxEDaIfLMvC11Q,14426
+overleaf_comments_export/sections.py,sha256=jTy8TaqWv_NvfgsZoGr9AlbjmWJBcLwMc8BoHke5G6A,3060
+overleaf_comments_export-0.2.0.dist-info/licenses/LICENSE,sha256=7uUOMuNZY8cZU3Nmh1YuNNbmRzSO6G2WOKbIDiv3H14,1093
+overleaf_comments_export-0.2.0.dist-info/METADATA,sha256=IhZlIvvk5lrsesJvz5ZsqjuXq21fW9ndgKWxyDzz95Q,6060
+overleaf_comments_export-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+overleaf_comments_export-0.2.0.dist-info/entry_points.txt,sha256=FmqUnxpe5la8RhJHh7FsYHIoQZZHYN0yjZVV44U_zJQ,84
+overleaf_comments_export-0.2.0.dist-info/top_level.txt,sha256=27fW8ViBdpmt05GMD25EYLZwzih5a7xozT7CgMbkG28,25
+overleaf_comments_export-0.2.0.dist-info/RECORD,,

overleaf_comments_export-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

overleaf_comments_export-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+overleaf-comments-export = overleaf_comments_export.__main__:main

overleaf_comments_export-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shivang (https://github.com/Mangluu)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

overleaf_comments_export-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+overleaf_comments_export