stackvitals 0.1.0__py3-none-any.whl

mergescout/crawl/chain.py

@@ -0,0 +1,34 @@
+import json
+from datetime import datetime
+from pathlib import Path
+
+from mergescout.crawl.state import CrawlState
+
+LAST_RUN = "last-run.json"
+# Runs that used their whole window had points to spare; others stopped on GitHub's limits and should pause first.
+FULL_RUN = {"time", "limit"}
+
+
+def write_last_run(data_dir: Path, out: dict) -> None:
+    data_dir.mkdir(parents=True, exist_ok=True)
+    keep = {k: out.get(k) for k in ("repos", "points", "failed", "reason")}
+    (data_dir / LAST_RUN).write_text(json.dumps(keep), encoding="utf-8")
+
+
+def next_step(state: CrawlState, data_dir: Path, now: datetime, after_discover: bool = False) -> str:
+    # The relay: GitHub's hourly schedule is best effort, so each finished run decides what starts next.
+    marker = data_dir / "last-discover"
+    discovered = marker.read_text(encoding="utf-8").strip() if marker.exists() else ""
+    if discovered != now.strftime("%Y-%m-%d"):
+        return "discover"
+    if state.due_count() == 0:
+        return "none"
+    if after_discover:
+        return "crawl"
+    try:
+        last = json.loads((data_dir / LAST_RUN).read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return "none"
+    if not last.get("repos"):
+        return "none"
+    return "crawl" if last.get("reason") in FULL_RUN else "crawl-later"

mergescout/crawl/fetch.py

@@ -0,0 +1,146 @@
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+
+from mergescout.crawl.queries import (CLOSED_ISSUES_QUERY, ISSUE_PAGE_QUERY, PR_PAGE_QUERY, REPO_META_QUERY,
+                                      is_dep_bot, issues_by_number_query, parse_closed_issues, parse_issues, parse_prs,
+                                      parse_repo_meta, prs_by_number_query)
+from mergescout.github.graphql import GraphQLError, NotFound, RateLimited, too_heavy
+from mergescout.labels import HOT, OPPORTUNITY_LABELS, has_opportunity, norm_label
+
+# Pages of 100 take 5-9 s on big repos and hit GitHub's 10 s limit under load; 50 costs the same points.
+MIN_PAGE = 10
+# GitHub charges by the page size asked for, so a refresh starts small: most repos change little between crawls.
+REFRESH_FIRST_PAGE = 20
+BY_NUMBER = 50
+
+
+def cutoff(now: datetime, days: int) -> str:
+    return (now - timedelta(days=days)).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+@dataclass
+class RepoBundle:
+    repo_id: int
+    name: str
+    status: str = "ok"
+    meta: dict | None = None
+    prs: list[dict] = field(default_factory=list)
+    issues: list[dict] = field(default_factory=list)
+    comments: list[dict] = field(default_factory=list)
+    points: int = 0
+    error: str | None = None
+    full: bool = True
+    deleted_issues: list[int] = field(default_factory=list)
+    closed_issues: list[dict] = field(default_factory=list)
+
+
+def _walk(gql, query: str, variables: dict, connection: str, cap: int, page: int, bundle: RepoBundle,
+          stop=None, first: int | None = None) -> list[dict]:
+    # Pages through one connection, shrinking the page when GitHub says it is too heavy.
+    cursor, nodes = None, []
+    while len(nodes) < cap:
+        size = min(first, page) if first and cursor is None else page
+        try:
+            result = gql.query(query, {**variables, "cursor": cursor, "n": min(size, cap - len(nodes))})
+        except NotFound:
+            raise
+        except GraphQLError as exc:
+            if too_heavy(exc) and page > MIN_PAGE:
+                page = max(MIN_PAGE, page // 2)
+                continue
+            raise
+        bundle.points += result.cost
+        conn = (result.data.get("repository") or {}).get(connection) or {}
+        batch = [n for n in conn.get("nodes") or [] if n]
+        nodes.extend(batch)
+        info = conn.get("pageInfo") or {}
+        if not batch or (stop and stop(batch[-1])) or not info.get("hasNextPage") or not info.get("endCursor"):
+            break
+        cursor = info["endCursor"]
+    return nodes[:cap]
+
+
+def fetch_repo(gql, repo_id: int, name: str, now: datetime, pr_cap: int = 300, issue_cap: int = 200,
+               issue_days: int = 90, page: int = 50, track: list[int] = (), track_cap: int = 200,
+               pr_days: int = 365, changed_since: datetime | None = None, closed_cap: int = 100,
+               closed_days: int = 365) -> RepoBundle:
+    owner, repo = name.split("/", 1)
+    bundle = RepoBundle(repo_id, name, full=changed_since is None)
+    base = {"owner": owner, "name": repo}
+    if changed_since is None:
+        # First or periodic full crawl: PRs from the last year, open issues active in the last 90 days.
+        pr_vars, pr_key, pr_since = {**base, "order": "CREATED_AT"}, "createdAt", cutoff(now, pr_days)
+        since, states = cutoff(now, issue_days), ["OPEN"]
+    else:
+        # Refresh: only PRs and issues (open or closed) that changed since the last crawl; settings wait for the
+        # next full crawl.
+        pr_since = changed_since.strftime("%Y-%m-%dT%H:%M:%SZ")
+        pr_vars, pr_key, since, states = {**base, "order": "UPDATED_AT"}, "updatedAt", pr_since, ["OPEN", "CLOSED"]
+        track = ()
+    first = REFRESH_FIRST_PAGE if changed_since else None
+    try:
+        if changed_since is None:
+            meta = gql.query(REPO_META_QUERY, base)
+            bundle.points += meta.cost
+            bundle.meta = parse_repo_meta(repo_id, meta.data)
+        pr_nodes = _walk(gql, PR_PAGE_QUERY, pr_vars, "pullRequests", pr_cap, page, bundle,
+                         stop=lambda n: (n.get(pr_key) or "") < pr_since, first=first)
+        pr_nodes = [n for n in pr_nodes if (n.get(pr_key) or "") >= pr_since]
+        # Issues come newest-updated first; stop once a page reaches the cutoff.
+        issue_nodes = _walk(gql, ISSUE_PAGE_QUERY, {**base, "since": since, "states": states}, "issues", issue_cap,
+                            page, bundle, stop=lambda n: (n.get("updatedAt") or "") < since, first=first)
+        fresh = [n for n in issue_nodes if (n.get("updatedAt") or "") >= since]
+        # Tracked issues missing from the open list were closed, deleted or went quiet: look them up by number.
+        seen = {n.get("number") for n in fresh}
+        missing = [n for n in track if n not in seen][:track_cap]
+        for i in range(0, len(missing), BY_NUMBER):
+            chunk = missing[i:i + BY_NUMBER]
+            result = gql.query(issues_by_number_query(chunk), base, partial=True)
+            bundle.points += result.cost
+            found = result.data.get("repository") or {}
+            for number in chunk:
+                node = found.get(f"i{number}")
+                if node:
+                    fresh.append(node)
+                else:
+                    bundle.deleted_issues.append(number)
+        open_labels = [lb.get("name") for n in fresh if n.get("state", "OPEN") == "OPEN"
+                       for lb in (n.get("labels") or {}).get("nodes") or [] if lb]
+        if changed_since is None and closed_cap and has_opportunity(open_labels):
+            # Label trust needs past beginner issues and who fixed them; only full crawls of hot repos pay for it.
+            closed_since = cutoff(now, closed_days)
+            # GitHub matches label names exactly, so ask with this repo's own spellings ("good first issue :wave:").
+            hot_names = [n for n in (bundle.meta or {}).get("label_names") or [] if norm_label(n) in HOT]
+            closed = _walk(gql, CLOSED_ISSUES_QUERY, {**base, "labels": hot_names or list(OPPORTUNITY_LABELS)},
+                           "issues", closed_cap, page, bundle,
+                           stop=lambda n: (n.get("updatedAt") or "") < closed_since)
+            bundle.closed_issues = parse_closed_issues(
+                repo_id, [n for n in closed if (n.get("updatedAt") or "") >= closed_since])
+    except NotFound as exc:
+        bundle.status, bundle.meta, bundle.error = "gone", None, str(exc)
+        return bundle
+    bundle.prs = parse_prs(repo_id, pr_nodes)
+    bundle.issues, bundle.comments = parse_issues(repo_id, fresh)
+    add_bot_outcomes(gql, base, bundle)
+    return bundle
+
+
+def add_bot_outcomes(gql, base: dict, bundle: RepoBundle) -> None:
+    """Check result and commit count of finished dependency-bot PRs, 50 per query; only these need them (upgrade outcomes)."""
+    rows = {r["number"]: r for r in bundle.prs if r["state"] in ("MERGED", "CLOSED")
+            and is_dep_bot(r["author_login"], r["head_ref"])}
+    numbers = sorted(rows)
+    for i in range(0, len(numbers), BY_NUMBER):
+        chunk = numbers[i:i + BY_NUMBER]
+        try:
+            result = gql.query(prs_by_number_query(chunk), base, partial=True)
+        except (GraphQLError, RateLimited):
+            # Outcomes are an extra: the PRs are kept without them and the next full crawl tries again.
+            return
+        bundle.points += result.cost
+        found = result.data.get("repository") or {}
+        for n in chunk:
+            commits = (found.get(f"pr{n}") or {}).get("commits") or {}
+            last = ((commits.get("nodes") or [{}])[-1] or {}).get("commit") or {}
+            rows[n]["ci_state"] = (last.get("statusCheckRollup") or {}).get("state")
+            rows[n]["commit_count"] = commits.get("totalCount")

mergescout/crawl/outcomes.py

@@ -0,0 +1,69 @@
+from mergescout.crawl.state import CrawlState
+
+
+def _iso(value) -> str | None:
+    if value is None or isinstance(value, str):
+        return value
+    return value.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def issue_state_rows(issues: list[dict]) -> list[dict]:
+    return [{"repo_id": i["repo_id"], "number": i["number"], "state": i.get("state"),
+             "state_reason": i.get("state_reason"), "assignees": i.get("assignees") or 0,
+             "linked_open_prs": i.get("linked_open_prs") or 0, "linked_merged_prs": i.get("linked_merged_prs") or 0,
+             "comments": i.get("comments_total") or 0, "labels": "|".join(i.get("labels") or []),
+             "updated_at": _iso(i.get("updated_at"))} for i in issues]
+
+
+def diff_events(before: list[dict], after: list[dict]) -> list[dict]:
+    prev = {(r["repo_id"], r["number"]): r for r in before}
+    events = []
+    for r in after:
+        p = prev.get((r["repo_id"], r["number"]))
+        if p is None:
+            continue
+
+        def add(kind, detail=None):
+            events.append({"repo_id": r["repo_id"], "number": r["number"], "event": kind, "detail": detail,
+                           "observed_at": r.get("observed_at")})
+        if r["state"] == "DELETED":
+            add("gone", "deleted or transferred")
+            continue
+        if p["assignees"] == 0 and r["assignees"] > 0:
+            add("claimed")
+        if p["assignees"] > 0 and r["assignees"] == 0:
+            add("unclaimed")
+        if r["linked_open_prs"] > p["linked_open_prs"]:
+            add("pr_opened")
+        if r["linked_merged_prs"] > p["linked_merged_prs"]:
+            add("pr_merged")
+        if p["state"] == "OPEN" and r["state"] == "CLOSED":
+            add("closed", r.get("state_reason"))
+    return events
+
+
+def plan_outcomes(state: CrawlState, repo_id: int, issues: list[dict], observed_at: str, since: str | None = None,
+                  deleted: list[int] = ()) -> tuple[list[dict], list[dict], list[int]]:
+    # Read-only: the runner applies the new state only after the repo's rows are on disk.
+    before = state.latest_issue_state(repo_id)
+    after = [{**r, "observed_at": observed_at} for r in issue_state_rows(issues)]
+    gone = [{"repo_id": repo_id, "number": n, "state": "DELETED", "observed_at": observed_at} for n in deleted]
+    events = diff_events(before, after + gone)
+    # Closed, deleted and quiet-for-90-days issues stop being tracked.
+    forget = [r["number"] for r in after if r["state"] != "OPEN"
+              or (since and r["updated_at"] and r["updated_at"] < since)] + list(deleted)
+    keep = [r for r in after if r["number"] not in set(forget)]
+    return events, keep, forget
+
+
+def apply_outcomes(state: CrawlState, repo_id: int, after: list[dict], forget: list[int]) -> None:
+    if after:
+        state.log_issue_state(after, after[0]["observed_at"])
+    state.forget_issues(repo_id, forget)
+
+
+def events_for_repo(state: CrawlState, repo_id: int, issues: list[dict], observed_at: str, since: str | None = None,
+                    deleted: list[int] = ()) -> list[dict]:
+    events, after, forget = plan_outcomes(state, repo_id, issues, observed_at, since, deleted)
+    apply_outcomes(state, repo_id, after, forget)
+    return events

mergescout/crawl/queries.py

@@ -0,0 +1,250 @@
+import re
+
+from mergescout.owners import owner_logins
+from mergescout.timeutil import parse_time
+
+RL = "rateLimit { cost remaining resetAt }"
+OWNER_KEYS = ("codeowners", "codeowners2", "codeowners3", "maintainers", "maintainers2", "owners")
+
+PR_PAGE_QUERY = f"""
+query($owner: String!, $name: String!, $cursor: String, $n: Int!, $order: IssueOrderField!) {{
+  {RL}
+  repository(owner: $owner, name: $name) {{
+    pullRequests(first: $n, after: $cursor, orderBy: {{field: $order, direction: DESC}}) {{
+      pageInfo {{ hasNextPage endCursor }}
+      nodes {{
+        number title createdAt updatedAt mergedAt closedAt state headRefName additions deletions changedFiles
+        author {{ __typename login }} authorAssociation mergedBy {{ login }} bodyText
+        reviews(first: 5) {{ nodes {{ submittedAt authorAssociation author {{ __typename login }} }} }}
+        closingIssuesReferences(first: 5) {{ nodes {{ number }} }}
+      }}
+    }}
+  }}
+}}
+"""
+
+ISSUE_FIELDS = """
+        number title bodyText state stateReason createdAt updatedAt closedAt
+        author { login } authorAssociation
+        labels(first: 10) { nodes { name } }
+        assignees(first: 5) { totalCount }
+        closedByPullRequestsReferences(first: 5, includeClosedPrs: true) { nodes { number state author { login } authorAssociation } }
+        comments(last: 5) { totalCount nodes { databaseId createdAt author { __typename login } authorAssociation bodyText } }
+"""
+
+ISSUE_PAGE_QUERY = f"""
+query($owner: String!, $name: String!, $cursor: String, $n: Int!, $since: DateTime!, $states: [IssueState!]) {{
+  {RL}
+  repository(owner: $owner, name: $name) {{
+    issues(first: $n, after: $cursor, states: $states, filterBy: {{since: $since}},
+           orderBy: {{field: UPDATED_AT, direction: DESC}}) {{
+      pageInfo {{ hasNextPage endCursor }}
+      nodes {{ {ISSUE_FIELDS} }}
+    }}
+  }}
+}}
+"""
+
+
+# Dependency-update bots, by login or branch (self-hosted Renovate runs under many names).
+DEP_BOT = re.compile(r"^(dependabot|renovate)", re.I)
+# Titles are kept only where they carry a signal: bot bumps (package and versions) and human reverts or downgrades.
+REVERT_TITLE = re.compile(r"^\s*(revert|downgrade|roll ?back)\b", re.I)
+
+
+def is_dep_bot(login: str | None, head: str | None) -> bool:
+    return bool(DEP_BOT.match(login or "") or DEP_BOT.match(head or ""))
+
+
+def prs_by_number_query(numbers: list[int]) -> str:
+    # One query reads the last commit's check result and the commit count of up to 50 finished bot PRs (1 point).
+    parts = "\n".join(f"    pr{int(n)}: pullRequest(number: {int(n)}) {{ commits(last: 1) {{ totalCount "
+                      f"nodes {{ commit {{ statusCheckRollup {{ state }} }} }} }} }}" for n in numbers)
+    return f"query($owner: String!, $name: String!) {{\n  {RL}\n  repository(owner: $owner, name: $name) {{\n{parts}\n  }}\n}}"
+
+
+def issues_by_number_query(numbers: list[int]) -> str:
+    # One query re-checks up to 50 tracked issues that dropped out of the open list.
+    parts = "\n".join(f"    i{int(n)}: issue(number: {int(n)}) {{ {ISSUE_FIELDS} }}" for n in numbers)
+    return f"query($owner: String!, $name: String!) {{\n  {RL}\n  repository(owner: $owner, name: $name) {{\n{parts}\n  }}\n}}"
+
+REPO_META_QUERY = f"""
+query($owner: String!, $name: String!) {{
+  {RL}
+  repository(owner: $owner, name: $name) {{
+    databaseId nameWithOwner stargazerCount forkCount pushedAt isArchived
+    hasIssuesEnabled hasDiscussionsEnabled hasProjectsEnabled
+    primaryLanguage {{ name }} licenseInfo {{ spdxId }} defaultBranchRef {{ name }}
+    openPrs: pullRequests(states: OPEN) {{ totalCount }} openIssues: issues(states: OPEN) {{ totalCount }}
+    contributing: object(expression: "HEAD:CONTRIBUTING.md") {{ oid ... on Blob {{ text }} }}
+    contributing2: object(expression: "HEAD:.github/CONTRIBUTING.md") {{ oid ... on Blob {{ text }} }}
+    contributing3: object(expression: "HEAD:docs/CONTRIBUTING.md") {{ oid ... on Blob {{ text }} }}
+    aipolicy: object(expression: "HEAD:AI_POLICY.md") {{ oid }}
+    prtemplate: object(expression: "HEAD:.github/PULL_REQUEST_TEMPLATE.md") {{ oid }}
+    readme: object(expression: "HEAD:README.md") {{ ... on Blob {{ text }} }}
+    labelNames: labels(first: 100) {{ nodes {{ name }} }}
+    codeowners: object(expression: "HEAD:.github/CODEOWNERS") {{ ... on Blob {{ text }} }}
+    codeowners2: object(expression: "HEAD:CODEOWNERS") {{ ... on Blob {{ text }} }}
+    codeowners3: object(expression: "HEAD:docs/CODEOWNERS") {{ ... on Blob {{ text }} }}
+    maintainers: object(expression: "HEAD:MAINTAINERS") {{ ... on Blob {{ text }} }}
+    maintainers2: object(expression: "HEAD:MAINTAINERS.md") {{ ... on Blob {{ text }} }}
+    owners: object(expression: "HEAD:OWNERS") {{ ... on Blob {{ text }} }}
+    releases(first: 100, orderBy: {{field: CREATED_AT, direction: DESC}}) {{ totalCount nodes {{ createdAt }} }}
+  }}
+}}
+"""
+
+AI_BRANCH = re.compile(r"^(copilot|codex|cursor|devin|claude)[/-]", re.I)
+AI_TRAILER = re.compile(r"co-authored-by:\s*(claude|codex|copilot|cursor|devin)", re.I)
+
+
+def ai_tag(pr: dict) -> str | None:
+    login = (pr.get("author_login") or "").lower()
+    if "devin" in login:
+        return "devin"
+    if pr.get("author_type") == "Bot" or login.endswith("[bot]"):
+        return "bot"
+    m = AI_BRANCH.match(pr.get("head_ref") or "")
+    if m:
+        return m.group(1).lower()
+    m = AI_TRAILER.search(pr.get("body") or "")
+    if m:
+        return m.group(1).lower()
+    return None
+
+
+def parse_prs(repo_id: int, nodes: list) -> list[dict]:
+    rows = []
+    for n in nodes:
+        if not n:
+            continue
+        author = n.get("author") or {}
+        reviews = [r for r in (n.get("reviews") or {}).get("nodes") or [] if r]
+        review = reviews[0] if reviews else {}
+        # Review bots often answer first; the first person's review is the real maintainer response.
+        human = next((r for r in reviews if (r.get("author") or {}).get("__typename") != "Bot"), {})
+        row = {
+            "repo_id": repo_id, "number": n.get("number"),
+            "created_at": parse_time(n.get("createdAt")), "merged_at": parse_time(n.get("mergedAt")),
+            "closed_at": parse_time(n.get("closedAt")), "state": n.get("state"),
+            "author_login": author.get("login"), "author_type": author.get("__typename"),
+            "author_association": n.get("authorAssociation"), "merged_by": (n.get("mergedBy") or {}).get("login"),
+            "head_ref": n.get("headRefName"), "additions": n.get("additions"), "deletions": n.get("deletions"),
+            "changed_files": n.get("changedFiles"),
+            "first_review_at": parse_time(review.get("submittedAt")),
+            "first_review_by": (review.get("author") or {}).get("login"),
+            "first_review_association": review.get("authorAssociation"),
+            "first_human_review_at": parse_time(human.get("submittedAt")),
+            "first_human_review_by": (human.get("author") or {}).get("login"),
+            "first_human_review_association": human.get("authorAssociation"),
+            "closing_issue_numbers": [c["number"] for c in (n.get("closingIssuesReferences") or {}).get("nodes") or []
+                                      if c],
+            "ci_state": None, "commit_count": None,
+        }
+        row["ai_tag"] = ai_tag({**row, "body": n.get("bodyText") or ""})
+        title = n.get("title") or ""
+        row["title"] = title[:300] if is_dep_bot(row["author_login"], row["head_ref"]) or REVERT_TITLE.match(title) else None
+        rows.append(row)
+    return rows
+
+
+def _fix_fields(refs: list[dict]) -> dict:
+    # The merged PR is the fix; otherwise the first linked PR shows who tried.
+    fix = next((p for p in refs if p.get("state") == "MERGED"), None) or (refs[0] if refs else {})
+    return {"fix_pr": fix.get("number"), "fix_pr_state": fix.get("state"),
+            "fix_author": (fix.get("author") or {}).get("login"), "fix_association": fix.get("authorAssociation")}
+
+
+def parse_issues(repo_id: int, nodes: list) -> tuple[list[dict], list[dict]]:
+    issues, comments = [], []
+    for n in nodes:
+        if not n:
+            continue
+        linked = [p for p in (n.get("closedByPullRequestsReferences") or {}).get("nodes") or [] if p]
+        cm = n.get("comments") or {}
+        issues.append({
+            "repo_id": repo_id, "number": n.get("number"), "title": n.get("title"),
+            "body_excerpt": (n.get("bodyText") or "")[:1000], "state": n.get("state"),
+            "state_reason": n.get("stateReason"),
+            "created_at": parse_time(n.get("createdAt")), "updated_at": parse_time(n.get("updatedAt")),
+            "closed_at": parse_time(n.get("closedAt")), "author_login": (n.get("author") or {}).get("login"),
+            "author_association": n.get("authorAssociation"),
+            "labels": [lb["name"] for lb in (n.get("labels") or {}).get("nodes") or [] if lb and lb.get("name")],
+            "assignees": (n.get("assignees") or {}).get("totalCount"),
+            "linked_open_prs": sum(p.get("state") == "OPEN" for p in linked),
+            "linked_merged_prs": sum(p.get("state") == "MERGED" for p in linked),
+            "linked_closed_prs": sum(p.get("state") == "CLOSED" for p in linked),
+            **_fix_fields(linked),
+            "comments_total": cm.get("totalCount"),
+        })
+        for c in cm.get("nodes") or []:
+            if c:
+                comments.append({"repo_id": repo_id, "number": n.get("number"), "comment_id": c.get("databaseId"),
+                                 "created_at": parse_time(c.get("createdAt")),
+                                 "author_login": (c.get("author") or {}).get("login"),
+                                 "author_type": (c.get("author") or {}).get("__typename"),
+                                 "author_association": c.get("authorAssociation"),
+                                 "body_excerpt": (c.get("bodyText") or "")[:500]})
+    return issues, comments
+
+
+def parse_repo_meta(repo_id: int, data: dict) -> dict:
+    r = data.get("repository") or {}
+    rel = r.get("releases") or {}
+    dates = [d for d in (parse_time(x.get("createdAt")) for x in rel.get("nodes") or [] if x) if d]
+    newest = max(dates) if dates else None
+    contrib = r.get("contributing") or r.get("contributing2") or r.get("contributing3") or {}
+    return {
+        "repo_id": repo_id, "name": r.get("nameWithOwner"), "stars": r.get("stargazerCount"),
+        "forks": r.get("forkCount"), "pushed_at": parse_time(r.get("pushedAt")),
+        # Backlog sizes: cheap here (one repo per query), slow in the 50-repo sweep.
+        "open_prs": (r.get("openPrs") or {}).get("totalCount"),
+        "open_issues": (r.get("openIssues") or {}).get("totalCount"),
+        "language": (r.get("primaryLanguage") or {}).get("name"), "archived": r.get("isArchived"),
+        "has_issues": r.get("hasIssuesEnabled"), "has_discussions": r.get("hasDiscussionsEnabled"),
+        "has_projects": r.get("hasProjectsEnabled"), "license": (r.get("licenseInfo") or {}).get("spdxId"),
+        "default_branch": (r.get("defaultBranchRef") or {}).get("name"),
+        "contributing_sha": contrib.get("oid"), "contributing_excerpt": (contrib.get("text") or "")[:4000],
+        "ai_policy_sha": (r.get("aipolicy") or {}).get("oid"), "pr_template_sha": (r.get("prtemplate") or {}).get("oid"),
+        "readme_excerpt": ((r.get("readme") or {}).get("text") or "")[:2000],
+        "last_release_at": newest,
+        "releases_12m": sum(1 for d in dates if newest and (newest - d).days <= 365),
+        "label_names": [lb["name"] for lb in (r.get("labelNames") or {}).get("nodes") or [] if lb and lb.get("name")],
+        # Logins only, never the file text: owner files can be large.
+        "owner_logins": sorted(owner_logins("\n".join((r.get(k) or {}).get("text") or "" for k in OWNER_KEYS))),
+    }
+
+
+CLOSED_ISSUES_QUERY = f"""
+query($owner: String!, $name: String!, $cursor: String, $n: Int!, $labels: [String!]) {{
+  {RL}
+  repository(owner: $owner, name: $name) {{
+    issues(first: $n, after: $cursor, states: CLOSED, labels: $labels, orderBy: {{field: UPDATED_AT, direction: DESC}}) {{
+      pageInfo {{ hasNextPage endCursor }}
+      nodes {{
+        number createdAt updatedAt closedAt stateReason author {{ login }} authorAssociation
+        labels(first: 10) {{ nodes {{ name }} }}
+        closedByPullRequestsReferences(first: 3, includeClosedPrs: true) {{
+          nodes {{ number state author {{ login }} authorAssociation }}
+        }}
+      }}
+    }}
+  }}
+}}
+"""
+
+
+def parse_closed_issues(repo_id: int, nodes: list) -> list[dict]:
+    rows = []
+    for n in nodes:
+        if not n:
+            continue
+        refs = [p for p in (n.get("closedByPullRequestsReferences") or {}).get("nodes") or [] if p]
+        rows.append({
+            "repo_id": repo_id, "number": n.get("number"), "created_at": parse_time(n.get("createdAt")),
+            "closed_at": parse_time(n.get("closedAt")), "state_reason": n.get("stateReason"),
+            "author_login": (n.get("author") or {}).get("login"), "author_association": n.get("authorAssociation"),
+            "labels": [lb["name"] for lb in (n.get("labels") or {}).get("nodes") or [] if lb and lb.get("name")],
+            **_fix_fields(refs),
+        })
+    return rows