paperstack-cli 0.1.0__py3-none-any.whl

paperstack/metadata.py

@@ -0,0 +1,392 @@
+"""Mechanical paper metadata retrieval with provenance and no source selection."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+
+ARXIV_NS = {"atom": "http://www.w3.org/2005/Atom", "arxiv": "http://arxiv.org/schemas/atom"}
+SOURCES = ("semantic_scholar", "dblp", "crossref", "openreview", "acl_anthology", "arxiv")
+SEARCH_SOURCES = ("s2", "dblp", "crossref", "openreview", "arxiv")
+S2_FIELDS = "paperId,externalIds,venue,title,year,authors,citationCount,influentialCitationCount,referenceCount"
+
+
+@dataclass(frozen=True)
+class PaperRef:
+    kind: str
+    value: str
+
+    @classmethod
+    def parse(cls, raw: str) -> PaperRef:
+        if ":" not in raw:
+            raise ValueError("paper reference needs a prefix: arxiv:, doi:, dblp:, or openreview:")
+        kind, value = raw.strip().split(":", 1)
+        if kind not in ("arxiv", "doi", "dblp", "openreview") or not value:
+            raise ValueError("paper reference needs a prefix: arxiv:, doi:, dblp:, or openreview:")
+        if kind == "arxiv":
+            value = re.sub(r"v\d+$", "", value)
+            modern = re.fullmatch(r"\d{2}(?:0[1-9]|1[0-2])\.\d{4,5}", value)
+            legacy = re.fullmatch(r"[A-Za-z][A-Za-z.-]*/\d{2}(?:0[1-9]|1[0-2])\d{3}", value)
+            if not (modern or legacy):
+                raise ValueError("invalid arXiv reference")
+        return cls(kind, value)
+
+
+_last_request: dict[str, float] = {}
+
+
+def request(
+    url: str,
+    params: dict | None = None,
+    headers: dict | None = None,
+    data: bytes | None = None,
+) -> bytes:
+    if params:
+        url += "?" + urllib.parse.urlencode(params)
+    host = urllib.parse.urlparse(url).netloc
+    interval = 3.0 if "arxiv.org" in host else 1.1 if "dblp.org" in host else 0.5
+    request_headers = {
+        "User-Agent": "paperstack (+https://github.com/MilkClouds/my-paperstack)",
+        **(headers or {}),
+    }
+    req = urllib.request.Request(url, headers=request_headers, data=data)
+    for attempt in range(3):
+        elapsed = time.monotonic() - _last_request.get(host, 0.0)
+        if elapsed < interval:
+            time.sleep(interval - elapsed)
+        try:
+            with urllib.request.urlopen(req, timeout=30) as response:
+                _last_request[host] = time.monotonic()
+                return response.read()
+        except urllib.error.HTTPError as exc:
+            _last_request[host] = time.monotonic()
+            if exc.code != 429 or attempt == 2:
+                raise
+            time.sleep(5 * (attempt + 1))
+    raise RuntimeError("unreachable request retry state")
+
+
+def _get_json(url: str, params: dict | None = None, headers: dict | None = None) -> dict:
+    return json.loads(request(url, params, headers))
+
+
+def _get_text(url: str, params: dict | None = None) -> str:
+    return request(url, params).decode(errors="replace")
+
+
+def _post_json(url: str, payload: dict, headers: dict | None = None) -> dict:
+    request_headers = {"Content-Type": "application/json", **(headers or {})}
+    return json.loads(request(url, headers=request_headers, data=json.dumps(payload).encode()))
+
+
+def _result(source: str, url: str, response: dict | None = None, error: str | None = None) -> dict:
+    out = {"source": source, "url": url, "status": "ok" if error is None else "error"}
+    if response is not None:
+        out["response"] = response
+    if error is not None:
+        out["error"] = error
+    return out
+
+
+def _safe(call, source: str, url: str) -> dict:
+    try:
+        return call()
+    except (urllib.error.URLError, TimeoutError, OSError, ValueError, ET.ParseError) as exc:
+        return _result(source, url, error=str(exc))
+
+
+def fetch_arxiv(arxiv_id: str) -> dict:
+    url = "https://export.arxiv.org/api/query"
+
+    def run() -> dict:
+        root = ET.fromstring(_get_text(url, {"id_list": arxiv_id, "max_results": "1"}))
+        entry = root.find("atom:entry", ARXIV_NS)
+        if entry is None:
+            return _result("arxiv", url, error="not found")
+        authors = [node.findtext("atom:name", "", ARXIV_NS) for node in entry.findall("atom:author", ARXIV_NS)]
+        return _result(
+            "arxiv",
+            f"https://arxiv.org/abs/{arxiv_id}",
+            {
+                "id": arxiv_id,
+                "title": " ".join((entry.findtext("atom:title", "", ARXIV_NS) or "").split()),
+                "authors": authors,
+                "published": entry.findtext("atom:published", "", ARXIV_NS),
+                "updated": entry.findtext("atom:updated", "", ARXIV_NS),
+                "comment": entry.findtext("arxiv:comment", None, ARXIV_NS),
+                "categories": [node.get("term") for node in entry.findall("atom:category", ARXIV_NS)],
+            },
+        )
+
+    return _safe(run, "arxiv", url)
+
+
+def resolve_s2(ref: PaperRef) -> dict:
+    prefix = {"arxiv": "ARXIV", "doi": "DOI", "dblp": "DBLP", "openreview": "URL"}[ref.kind]
+    value = f"https://openreview.net/forum?id={ref.value}" if ref.kind == "openreview" else ref.value
+    ident = urllib.parse.quote(f"{prefix}:{value}", safe="")
+    url = f"https://api.semanticscholar.org/graph/v1/paper/{ident}"
+    headers = (
+        {"x-api-key": os.environ["SEMANTIC_SCHOLAR_API_KEY"]} if os.environ.get("SEMANTIC_SCHOLAR_API_KEY") else {}
+    )
+    params = {"fields": S2_FIELDS}
+    return _safe(lambda: _result("semantic_scholar", url, _get_json(url, params, headers)), "semantic_scholar", url)
+
+
+def fetch_crossref(doi: str) -> dict:
+    url = f"https://api.crossref.org/works/{urllib.parse.quote(doi, safe='/')}"
+
+    def run() -> dict:
+        message = _get_json(url).get("message", {})
+        fields = {
+            key: message.get(key)
+            for key in (
+                "title",
+                "author",
+                "published",
+                "container-title",
+                "DOI",
+                "type",
+                "page",
+                "volume",
+                "issue",
+                "publisher",
+                "event",
+            )
+        }
+        return _result("crossref", url, fields)
+
+    return _safe(run, "crossref", url)
+
+
+def fetch_dblp(*, key: str | None, doi: str | None, title: str | None, local_only: bool = False) -> dict:
+    from . import dblp_index
+
+    if hits := dblp_index.lookup(key=key, doi=doi):
+        return _result("dblp", hits[0]["url"], {"matches": hits, "method": "local_index"})
+    if title and (hits := dblp_index.search(title)):
+        source = hits[0]["url"] if len(hits) == 1 else str(dblp_index.index_path())
+        return _result("dblp", source, {"matches": hits, "method": "local_index"})
+    if local_only:
+        return {
+            "source": "dblp",
+            "url": str(dblp_index.index_path()),
+            "status": "no_match",
+            "reason": "not found in local index",
+        }
+    if key:
+        url = f"https://dblp.org/rec/{key}.bib?param=0"
+    elif doi:
+        url = f"https://dblp.org/doi/{doi}.bib?param=0"
+    elif title:
+        return search("dblp", title)
+    else:
+        return _result("dblp", "https://dblp.org", error="no DBLP key, DOI, or title")
+    return _safe(lambda: _result("dblp", url, {"bibtex": _get_text(url).strip()}), "dblp", url)
+
+
+def fetch_openreview(openreview_id: str) -> dict:
+    page = f"https://openreview.net/forum?id={openreview_id}"
+    token = os.environ.get("OPENREVIEW_ACCESS_TOKEN")
+    headers = {"Cookie": f"openreview.accessToken={token}"} if token else {}
+    endpoint = "https://api2.openreview.net/notes/search"
+    result = _safe(
+        lambda: _result(
+            "openreview",
+            page,
+            _post_json(endpoint, {"ids": [openreview_id], "source": "all", "limit": 10}, headers),
+        ),
+        "openreview",
+        endpoint,
+    )
+    if result["status"] == "ok" and result.get("response", {}).get("notes"):
+        return result
+    errors = [result.get("error", f"no note at {endpoint}")]
+    endpoint = "https://api.openreview.net/notes"
+    result = _safe(
+        lambda: _result("openreview", page, _get_json(endpoint, {"id": openreview_id}, headers)),
+        "openreview",
+        endpoint,
+    )
+    if result["status"] == "ok" and result.get("response", {}).get("notes"):
+        return result
+    errors.append(result.get("error", f"no note at {endpoint}"))
+    return _result("openreview", page, error="; ".join(errors))
+
+
+def fetch_acl(acl_id: str) -> dict:
+    url = f"https://aclanthology.org/{acl_id}.bib"
+    return _safe(lambda: _result("acl_anthology", url, {"bibtex": _get_text(url).strip()}), "acl_anthology", url)
+
+
+def fetch_all(
+    raw_ref: str | PaperRef,
+    enabled: set[str] | None = None,
+    *,
+    local_only: bool = False,
+) -> list[dict]:
+    ref = raw_ref if isinstance(raw_ref, PaperRef) else PaperRef.parse(raw_ref)
+    enabled = enabled or set(SOURCES)
+    results: list[dict] = []
+    ids = {"doi": None, "arxiv": None, "dblp": None, "openreview": None, "acl": None, "title": None}
+    ids[ref.kind] = ref.value
+    if ref.kind == "doi" and (match := re.match(r"^10\.18653/v1/(.+)$", ref.value)):
+        ids["acl"] = match.group(1)
+    available = {
+        "arxiv": bool(ids["arxiv"]),
+        "crossref": bool(ids["doi"]),
+        "dblp": bool(ids["dblp"] or ids["doi"] or ids["title"]),
+        "openreview": bool(ids["openreview"]),
+        "acl_anthology": bool(ids["acl"]),
+    }
+    needs_resolution = "semantic_scholar" in enabled or any(
+        not available.get(source, False) for source in enabled if source != "semantic_scholar"
+    )
+    s2 = resolve_s2(ref) if needs_resolution else None
+    if "semantic_scholar" in enabled and s2 is not None:
+        results.append(s2)
+    if s2 is not None and s2["status"] == "ok":
+        data = s2.get("response", {})
+        external = data.get("externalIds") or {}
+        ids.update(
+            {
+                "doi": ids["doi"] or external.get("DOI"),
+                "arxiv": ids["arxiv"] or external.get("ArXiv"),
+                "dblp": ids["dblp"] or external.get("DBLP"),
+                "acl": ids["acl"] or external.get("ACL"),
+                "title": data.get("title"),
+            }
+        )
+    if "dblp" in enabled:
+        results.append(
+            fetch_dblp(
+                key=ids["dblp"],
+                doi=ids["doi"],
+                title=ids["title"],
+                local_only=local_only,
+            )
+        )
+    if "crossref" in enabled and ids["doi"]:
+        results.append(fetch_crossref(ids["doi"]))
+    elif "crossref" in enabled:
+        results.append({"source": "crossref", "status": "unavailable", "reason": "no DOI after discovery"})
+    if "openreview" in enabled and ids["openreview"]:
+        results.append(fetch_openreview(ids["openreview"]))
+    elif "openreview" in enabled:
+        results.append({"source": "openreview", "status": "unavailable", "reason": "no OpenReview ID after discovery"})
+    if "acl_anthology" in enabled and ids["acl"]:
+        results.append(fetch_acl(ids["acl"]))
+    elif "acl_anthology" in enabled:
+        results.append({"source": "acl_anthology", "status": "unavailable", "reason": "no ACL ID after discovery"})
+    if "arxiv" in enabled and ids["arxiv"]:
+        results.append(fetch_arxiv(ids["arxiv"]))
+    elif "arxiv" in enabled:
+        results.append({"source": "arxiv", "status": "unavailable", "reason": "no arXiv ID after discovery"})
+    return results
+
+
+def search(source: str, query: str, *, local_only: bool = False) -> dict:
+    if source == "dblp":
+        from . import dblp_index
+
+        if hits := dblp_index.search(query):
+            return _result("dblp", str(dblp_index.index_path()), {"query": query, "matches": hits})
+        if local_only:
+            return {
+                "source": "dblp",
+                "url": str(dblp_index.index_path()),
+                "status": "no_match",
+                "reason": "not found in local index",
+            }
+        url = "https://dblp.org/search/publ/api"
+        return _safe(
+            lambda: _result("dblp", url, _get_json(url, {"q": query, "format": "json", "h": 10})), "dblp", url
+        )
+    if source == "crossref":
+        url = "https://api.crossref.org/works"
+        return _safe(
+            lambda: _result("crossref", url, _get_json(url, {"query.title": query, "rows": 10})), "crossref", url
+        )
+    if source == "arxiv":
+        url = "https://export.arxiv.org/api/query"
+
+        def arxiv_search() -> dict:
+            root = ET.fromstring(_get_text(url, {"search_query": f'ti:"{query}"', "max_results": 10}))
+            matches = [
+                {
+                    "id": entry.findtext("atom:id", "", ARXIV_NS),
+                    "title": " ".join((entry.findtext("atom:title", "", ARXIV_NS) or "").split()),
+                    "published": entry.findtext("atom:published", "", ARXIV_NS),
+                }
+                for entry in root.findall("atom:entry", ARXIV_NS)
+            ]
+            return _result("arxiv", url, {"query": query, "matches": matches})
+
+        return _safe(arxiv_search, "arxiv", url)
+    if source == "openreview":
+        token = os.environ.get("OPENREVIEW_ACCESS_TOKEN")
+        headers = {"Cookie": f"openreview.accessToken={token}"} if token else {}
+        endpoints = (
+            "https://api2.openreview.net/notes/search",
+            "https://api.openreview.net/notes/search",
+        )
+        matches = []
+        errors = []
+        for endpoint in endpoints:
+            result = _safe(
+                lambda endpoint=endpoint: _result(
+                    "openreview",
+                    endpoint,
+                    _get_json(endpoint, {"query": query, "limit": 10, "source": "forum"}, headers),
+                ),
+                "openreview",
+                endpoint,
+            )
+            if result["status"] == "ok":
+                matches.extend(result.get("response", {}).get("notes", []))
+            else:
+                errors.append(result.get("error", endpoint))
+        if not matches and errors:
+            return _result("openreview", endpoints[0], error="; ".join(errors))
+        unique = {}
+        for note in matches:
+            unique[note.get("forum") or note.get("id") or json.dumps(note, sort_keys=True)] = note
+        return _result(
+            "openreview",
+            endpoints[0],
+            {"query": query, "matches": list(unique.values()), "api_endpoints": list(endpoints)},
+        )
+    if source == "s2":
+        url = "https://api.semanticscholar.org/graph/v1/paper/search"
+        headers = (
+            {"x-api-key": os.environ["SEMANTIC_SCHOLAR_API_KEY"]} if os.environ.get("SEMANTIC_SCHOLAR_API_KEY") else {}
+        )
+        params = {"query": query, "limit": 10, "fields": S2_FIELDS}
+        return _safe(
+            lambda: _result("semantic_scholar", url, _get_json(url, params, headers)), "semantic_scholar", url
+        )
+    raise ValueError(f"unknown metadata source: {source}")
+
+
+def print_results(results: list[dict] | dict, *, json_output: bool) -> None:
+    if json_output:
+        print(json.dumps(results, indent=2, ensure_ascii=False))
+        return
+    items = results if isinstance(results, list) else [results]
+    for item in items:
+        print(f"{item['source']}: {item['status']}")
+        if item.get("url"):
+            print(f"  source: {item['url']}")
+        if item.get("reason"):
+            print(f"  reason: {item['reason']}")
+        if item.get("error"):
+            print(f"  error: {item['error']}")
+        elif item.get("response") is not None:
+            print(json.dumps(item["response"], indent=2, ensure_ascii=False))

paperstack_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: paperstack-cli
+Version: 0.1.0
+Summary: Review, inspect, and retrieve research papers from one CLI
+Project-URL: Repository, https://github.com/MilkClouds/my-paperstack
+Requires-Python: >=3.11.4
+Requires-Dist: polars>=1.43
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: pyyaml>=6
+Provides-Extra: pdf
+Requires-Dist: pymupdf4llm>=0.0.17; extra == 'pdf'
+Description-Content-Type: text/markdown
+
+# Critical Reads
+
+Some papers mistake their own story for evidence. Some are optimized for acceptance rather than truth. Others are
+careful, competent work on directions that do not matter. Critical Reads exists to tell them apart, preserve the
+insights that survive scrutiny, and choose research directions worth pursuing.
+
+Body-read reviews of papers, posts, and talks. Each entry lives in `entries/<citation-key>.md` and carries its identity in frontmatter.
+
+- [Collections](#collections)
+- [CLI](#cli)
+    - [DBLP index](#dblp-index)
+    - [Configuration](#configuration)
+- [Adding a review](#adding-a-review)
+    - [Getting the source in front of you](#getting-the-source-in-front-of-you)
+- [Review guide](#review-guide)
+    - [For robotics papers](#for-robotics-papers)
+
+## Collections
+
+Curated, ordered lists live in [`collections.json`](collections.json), the single source used by the viewer and validation.
+Every collection has a `published` or `draft` status. Published collections are stable reference catalogs; draft
+collections are provisional reading paths shown in a separate collapsed section. Select one to filter entries in its
+declared order.
+
+CI publishes the generated viewer after GitHub Pages is enabled with GitHub Actions as its source.
+
+## CLI
+
+Run `make serve` for the local viewer. Entry links open rendered HTML; `.md` URLs expose UTF-8 Markdown source. Install the CLI from PyPI, then authenticate with GitHub for review syncing and DBLP index downloads:
+
+```bash
+uv tool install paperstack-cli
+gh auth login
+```
+
+The command groups have separate data and authority boundaries:
+
+| Group | Data | Behavior |
+|---|---|---|
+| `review` | `entries/` review database | Read, initialize, validate, or audit authored judgments |
+| `paper` | External metadata and arXiv content | Return source records or content without choosing a citation |
+| `index` | Optional local indexes | Install and manage lookup data |
+
+Review commands:
+
+```bash
+paperstack review show black2024pi0 --brief
+paperstack review show arxiv:2410.24164 --json
+paperstack review list --quality poor --tag vla
+paperstack review search "flow matching"
+paperstack review sync --force
+paperstack review init <key> --id arxiv:NNNN.NNNNN --title "Verbatim title" --editor <name>
+paperstack review check --style
+paperstack review audit
+paperstack review citations --fetch
+```
+
+Paper commands:
+
+```bash
+paperstack paper search "Attention Is All You Need" --source dblp
+paperstack paper metadata arxiv:2106.09685
+paperstack paper metadata arxiv:2410.15549 --source semantic_scholar --json
+paperstack paper metadata doi:10.1109/CVPR.2016.90 --source crossref
+paperstack paper read arxiv:2604.23073
+paperstack paper read arxiv:2604.23073 --outline
+paperstack paper read arxiv:2604.23073 --section 6
+paperstack paper pdf arxiv:2602.09017
+```
+
+`metadata` accepts `arxiv:`, `doi:`, `dblp:`, and `openreview:` references. Semantic Scholar records include total,
+influential, and reference counts. `read` and `pdf` require an `arxiv:` reference. Metadata output keeps
+source records separate and includes provenance; it never selects or generates a citation.
+
+Options are scoped to commands that use them. `--json` is available for structured records and `--offline` for
+commands with a local or cached path. PDF conversion requires the optional dependency:
+
+```bash
+uv tool install 'paperstack-cli[pdf]'
+```
+
+From a clone, replace `paperstack` with `uv run paperstack`.
+For PDF conversion in a clone, use `uv run --extra pdf paperstack paper pdf <arxiv-ref>`.
+`review init` requires a writable review tree; `review check` requires a clone containing `scripts/build/check.sh`.
+`review citations --fetch` updates `citations.json` for every arXiv-backed entry through Semantic Scholar's batch API;
+without `--fetch`, it only removes cached records for entries that no longer exist. The static viewer exposes a minimum-citation
+filter and shows counts alongside entries. `SEMANTIC_SCHOLAR_API_KEY` is optional but raises the API rate limit.
+
+### DBLP index
+
+The optional index accelerates DBLP search and is required by `review audit`. It covers selected CS venues, not all
+of DBLP. The `2026.08` Parquet snapshot contains 285,521 structured records and is about 25 MiB. Installation is explicit:
+
+```bash
+paperstack index dblp status
+paperstack index dblp install
+paperstack index dblp update
+paperstack index dblp remove --yes
+```
+
+`install` downloads the pinned Parquet snapshot through authenticated `gh`. `update` discovers the newest
+`dblp-index-YYYY.MM` paperstack Release and replaces an older index only after its SHA-256, schema, and embedded metadata checks pass. `status` reports the version,
+coverage, size, record count, and location. `review audit` reports title and venue matches without editing reviews.
+Snapshots with mismatched metadata or fewer than 250,000 records are rejected. Installed files are immutable and
+content-addressed; an atomic pointer switch preserves the previous index if an update is interrupted.
+See [DBLP snapshot releases](docs/DBLP_RELEASES.md) for the publishing procedure.
+
+### Configuration
+
+| Variable | Purpose |
+|---|---|
+| `PAPERSTACK_DIR` | Review database to use instead of the surrounding clone or GitHub cache |
+| `PAPERSTACK_REPO` | GitHub review repository; default `MilkClouds/my-paperstack` |
+| `PAPERSTACK_TTL` | Review-cache refresh interval in seconds; default `3600` |
+| `PAPERSTACK_PAPERS_DIR` | arXiv source/PDF cache; default `${XDG_CACHE_HOME:-~/.cache}/paperstack/papers` |
+| `SEMANTIC_SCHOLAR_API_KEY` | Optional key for Semantic Scholar discovery |
+| `OPENREVIEW_ACCESS_TOKEN` | Optional OpenReview `openreview.accessToken` cookie value |
+| `XDG_CACHE_HOME` | Review and paper cache root |
+| `XDG_DATA_HOME` | DBLP index root |
+
+Configuration comes from the process environment. The CLI also loads the nearest `.env` without overriding exported
+variables, so a clone can keep local configuration in a gitignored `.env` file.
+
+Review lookup reads `$PAPERSTACK_DIR`, a surrounding clone, or a GitHub-backed cache, in that order. Scoped
+`--offline` flags serve cached review or paper data without network access. Exit codes are `0` for
+hits, `1` for no match, `2` for ambiguity, and `3` for unavailable data.
+
+## Adding a review
+
+```bash
+paperstack review init <key> --id arxiv:NNNN.NNNNN --title "Verbatim title" --editor <name>
+```
+
+This initializes an ungraded scaffold only. The review itself remains a reading and judgment task. Review files are
+stored internally as `entries/<key>.md`. See the [review guide](#review-guide) for editorial guidance.
+
+- Name files `<first-author surname><arXiv v1 year><first significant title word>`, lowercase; suffix collisions with `a`, `b`, and so on.
+- Use the established method name or full title as the `#` heading.
+- Use a registered CURIE (`arxiv:`, `doi:`, `hdl:`, `isbn:`) for `id`, or a URL when none exists.
+- `tags` are lowercase and singular. Reuse before inventing.
+- Include only verified affiliations in `lab`. Use a person's name in `editor`, or `model effort (harness)` for an agent.
+- Use CommonMark with GFM, including tables for tabular results.
+
+Run `make check`; `make style` adds prose-length warnings. The scripts require `jq` and mikefarah's `yq` (`go-yq` on conda-forge).
+
+### Getting the source in front of you
+
+The source fetcher uses `latexpand` from PATH, falling back to a vendored copy via Perl.
+
+```bash
+paperstack paper read arxiv:2604.23073            # the complete LaTeX body
+paperstack paper read arxiv:2604.23073 --outline  # the section outline
+paperstack paper read arxiv:2604.23073 --section 6
+paperstack paper pdf arxiv:cs/9301101            # when there is no LaTeX source
+yt-dlp --skip-download --write-auto-subs --sub-lang en -o talk <url>
+```
+
+- Prefer the LaTeX source; use the PDF fallback only when no source exists.
+- Cross-check malformed tables with `pdftotext -layout <pdf> -`.
+- Treat commented-out results as evidence only when their surviving values match the published version; a mismatched baseline may be an earlier run.
+- Strip timestamps and duplicate cues from video captions.
+
+## Review guide
+
+Read the body, then write the critical read, paper summary, reason to read, and one-liner, in that order.
+
+- Keep the review body within 2,500 visible non-whitespace characters. Use prose for argument, bullets for independent points, and tables for repeated comparisons.
+- Make the summary self-contained: a reader who has not read the paper should understand its core problem, approach, evidence, and findings. Choose the form that reads best; five bullets is one option, not a target.
+- In the critical read, consult prior and subsequent work as needed, then focus on what matters for interpreting, trusting, or using the paper.
+- Keep the one-liner to one sentence and `Why read it` to two. `Why read it` captures significance, originality, or practical value; use `none` when there is no reason.
+- `Quality` measures how much of the title and abstract's main claim survives the evidence:
+    - `excellent`: the claim stands and has lasting importance
+    - `good`: the claim stands
+    - `fair`: only a narrower claim stands
+    - `poor`: the claim is not established
+- Grade the advertised claim, not the narrower verdict. Use `fair` only when narrowing scope preserves the core claim; materially replacing it is `poor`.
+- For SOTA or efficiency claims, check the strongest comparable result and name the denominator.
+- If an official protocol fits the claim, an unjustified custom replacement caps `Quality` at `fair` unless matched, interpretable anchors restore comparability.
+- Disclosed weaknesses still count when the paper claims past them. Side contributions do not raise the grade.
+- On `fair` or `poor`, add `Read it anyway.` only with a checked citation count from Hugging Face or Semantic Scholar.
+
+### For robotics papers
+
+See [What Are We Actually Benchmarking in Robot Manipulation?](entries/jiang2026benchmarking.md).
+
+- A benchmark counts only when success requires the claimed capability. LIBERO-only evidence caps Quality at `poor`; so does an uncounted real-world result added to it.
+- Judge the hardest benchmark, note omissions, and account for benchmark age and test-set proximity.
+- Treat margins within evaluation noise as ties; check SOTA claims against the [VLA Evaluation Harness](https://allenai.github.io/vla-evaluation-harness/leaderboard/).
+- Recover exact values and trial counts where possible; otherwise state that they are unavailable.
+- Compare baselines only under the same training and evaluation protocol.

paperstack_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+paperstack/__init__.py,sha256=Cnu12PizQdtp2EOJIPMV8LN-2JXdtSiPodSD3iISedg,39
+paperstack/citations.py,sha256=24WSEDBLzHv1YFKy0Vpoh2xu4GJNaHuugl-5-ef_ctQ,4113
+paperstack/cli.py,sha256=C6Iwt_71p5XvOw1m23sHqQWF68TlL-UKcwTPc1zM_ts,27372
+paperstack/dblp_index.py,sha256=eIADoAuriJesbi_aBSTjORxsWj2NTPuJtZnzJUwrczo,20261
+paperstack/entrypoint.py,sha256=4DOd54fov2qVwlFcbTgh8883zG_k5br4EO00oG7OISY,534
+paperstack/metadata.py,sha256=wgdfpt2kBDQ14ZR_VfaWlULdBoRq27CILcv3f4pE9Tg,15701
+paperstack/content/__init__.py,sha256=rPAfhJSpEpOFyKlPNbbfEZ9-oDTbfJDEqxJHnCgHVp0,54
+paperstack/content/arxiv_pdf.py,sha256=CzC2j7bHS6_0AxlXjNIOVpIbxLHvFTjnoK_DYsc0ACs,3086
+paperstack/content/arxiv_source.py,sha256=zsgDRlIAQUE7IAZbxRMMbf3pfyfw8ImNzS2FhQvM6yI,15125
+paperstack/content/vendor/latexpand,sha256=Z-ylXQmz-5gt7iNE5jF_fhDp8Vg5EC5qHbOOUY-DMDw,23338
+paperstack/content/vendor/latexpand.LICENSE,sha256=hpipH1rQQwKFd1DYN_FtpxSBbYqCBBjsgCKr8YuYJhQ,1529
+paperstack_cli-0.1.0.dist-info/METADATA,sha256=kzGwuhII5as6Q3gImH1MC87VcXTJpNr14lRRaVhCTig,11012
+paperstack_cli-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+paperstack_cli-0.1.0.dist-info/entry_points.txt,sha256=0716S7tM1TuT4_aj291u3335bww-f0K0wQ1u8pS7VxU,58
+paperstack_cli-0.1.0.dist-info/RECORD,,

paperstack_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

paperstack_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+paperstack = paperstack.entrypoint:main