claude-dev-env 1.93.1 → 1.94.0

package/skills/log-audit/scripts/mine_copilot_findings.py

@@ -1,302 +0,0 @@
-"""Turn the defects reviewers keep catching into upstream skill-edit proposals.
-
-Copilot and Bugbot flag the same kinds of defect over and over — an untyped
-return here, a broad except there. Each catch is a defect that reached review
-because nothing blocked it at write time. This script reads recent reviewer
-comments, sorts them into defect classes, and for each class names a concrete
-skill or rule edit that would block that class upstream. The proposals are for a
-human to apply through review, not for the agent to commit on its own.
-
-Usage:
-    mine_copilot_findings.py --repo owner/name
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import subprocess
-import sys
-from collections import defaultdict
-from dataclasses import dataclass
-from pathlib import Path
-
-_script_directory = str(Path(__file__).resolve().parent)
-if _script_directory not in sys.path:
-    sys.path.insert(0, _script_directory)
-
-from log_audit_constants.mine_copilot_findings_constants import (  # noqa: E402
-    ALL_REVIEWER_BOT_LOGINS,
-    KEYWORDS_BY_DEFECT_CLASS,
-    MAX_EXAMPLES_PER_CLUSTER,
-    PROPOSAL_BY_DEFECT_CLASS,
-    PULL_COMMENTS_ENDPOINT_TEMPLATE,
-    RECENT_PULL_COUNT,
-    RECENT_PULLS_ENDPOINT_TEMPLATE,
-)
-
-
-class GitHubCommandError(RuntimeError):
-    """Raised when a gh api call fails or returns output that is not JSON."""
-
-
-@dataclass(frozen=True)
-class ReviewerComment:
-    """One review comment left by a reviewer bot.
-
-    Attributes:
-        pull_number: The pull request the comment was left on.
-        author: The reviewer bot's login.
-        body: The comment text.
-    """
-
-    pull_number: int
-    author: str
-    body: str
-
-
-@dataclass(frozen=True)
-class DefectCluster:
-    """The reviewer comments that fall into one defect class.
-
-    Attributes:
-        defect_class: The class name the comments were sorted into.
-        count: How many comments fell into the class.
-        example_bodies: A capped sample of the comment bodies in the class.
-    """
-
-    defect_class: str
-    count: int
-    example_bodies: tuple[str, ...]
-
-
-@dataclass(frozen=True)
-class SkillProposal:
-    """A proposed skill-definition edit that blocks one defect class upstream.
-
-    Attributes:
-        defect_class: The defect class the edit would block.
-        proposal: The concrete edit to make.
-    """
-
-    defect_class: str
-    proposal: str
-
-
-def classify_defect(comment_body: str) -> str | None:
-    """Sort a review comment into a defect class by its keywords.
-
-    Args:
-        comment_body: The review comment text.
-
-    Returns:
-        The first defect class whose keywords appear in the comment, or None
-        when no class matches.
-    """
-    lowered_body = comment_body.lower()
-    for each_defect_class, each_keywords in KEYWORDS_BY_DEFECT_CLASS.items():
-        if any(each_keyword in lowered_body for each_keyword in each_keywords):
-            return each_defect_class
-    return None
-
-
-def cluster_defects(all_comments: list[ReviewerComment]) -> list[DefectCluster]:
-    """Group review comments by defect class and rank by how often each recurs.
-
-    Args:
-        all_comments: The reviewer comments to sort.
-
-    Returns:
-        One cluster per defect class present, most frequent first, each with a
-        capped sample of its comment bodies.
-    """
-    bodies_by_class: dict[str, list[str]] = defaultdict(list)
-    for each_comment in all_comments:
-        defect_class = classify_defect(each_comment.body)
-        if defect_class is None:
-            continue
-        bodies_by_class[defect_class].append(each_comment.body)
-    clusters: list[DefectCluster] = []
-    for each_defect_class, each_bodies in bodies_by_class.items():
-        clusters.append(
-            DefectCluster(
-                defect_class=each_defect_class,
-                count=len(each_bodies),
-                example_bodies=tuple(each_bodies[:MAX_EXAMPLES_PER_CLUSTER]),
-            )
-        )
-    return sorted(clusters, key=lambda cluster: cluster.count, reverse=True)
-
-
-def proposal_for_defect_class(defect_class: str) -> SkillProposal:
-    """Return the skill-edit proposal that blocks a defect class upstream.
-
-    Args:
-        defect_class: The defect class to propose an edit for.
-
-    Returns:
-        The proposal mapped to the class.
-    """
-    return SkillProposal(
-        defect_class=defect_class, proposal=PROPOSAL_BY_DEFECT_CLASS[defect_class]
-    )
-
-
-def _pull_number_from_url(pull_request_url: str) -> int | None:
-    """Read the trailing pull number from a GitHub pull-request URL."""
-    last_segment = pull_request_url.rsplit("/", 1)[-1]
-    try:
-        return int(last_segment)
-    except ValueError:
-        return None
-
-
-def _reviewer_comment_from_payload(payload: object) -> ReviewerComment | None:
-    """Build a ReviewerComment from one gh comment payload, or None to skip it."""
-    if not isinstance(payload, dict):
-        return None
-    user_field = payload.get("user")
-    login = user_field.get("login") if isinstance(user_field, dict) else None
-    body = payload.get("body")
-    pull_request_url = payload.get("pull_request_url")
-    if not isinstance(login, str) or login not in ALL_REVIEWER_BOT_LOGINS:
-        return None
-    if not isinstance(body, str) or not isinstance(pull_request_url, str):
-        return None
-    pull_number = _pull_number_from_url(pull_request_url)
-    if pull_number is None:
-        return None
-    return ReviewerComment(pull_number=pull_number, author=login, body=body)
-
-
-def _flatten_pages(slurped_payload: object) -> list[object]:
-    """Flatten the per-page arrays a gh --slurp response holds into one list.
-
-    Args:
-        slurped_payload: The parsed output of a ``gh api --paginate --slurp``
-            call: a list whose entries are the individual page responses.
-
-    Returns:
-        Every entry across the pages in page order. A page that is itself a list
-        contributes its entries; any other page contributes itself.
-    """
-    flattened_entries: list[object] = []
-    if isinstance(slurped_payload, list):
-        for each_page in slurped_payload:
-            if isinstance(each_page, list):
-                flattened_entries.extend(each_page)
-            else:
-                flattened_entries.append(each_page)
-    return flattened_entries
-
-
-def _run_gh_json(endpoint: str, *, should_paginate: bool = False) -> object:
-    """Run one gh api call for an endpoint and return its parsed JSON payload.
-
-    Args:
-        endpoint: The gh api endpoint path to request.
-        should_paginate: When True, follow pagination with ``--paginate
-            --slurp`` and flatten the per-page arrays into one list, so a list
-            endpoint with more than one page returns every entry rather than
-            only the first page.
-
-    Returns:
-        The parsed JSON payload: the flattened entry list when should_paginate
-        is True, otherwise the single response parsed as-is.
-
-    Raises:
-        GitHubCommandError: When gh is not installed, the gh api call fails, or
-            its output is not JSON.
-    """
-    gh_command = ["gh", "api", endpoint]
-    if should_paginate:
-        gh_command += ["--paginate", "--slurp"]
-    try:
-        completed_process = subprocess.run(
-            gh_command,
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-    except FileNotFoundError as missing_gh_error:
-        raise GitHubCommandError(
-            "gh command not found; install the GitHub CLI to mine reviewer comments"
-        ) from missing_gh_error
-    except subprocess.CalledProcessError as gh_failure_error:
-        raise GitHubCommandError(
-            f"gh api {endpoint} failed: {gh_failure_error.stderr.strip()}"
-        ) from gh_failure_error
-    try:
-        parsed_payload = json.loads(completed_process.stdout)
-    except json.JSONDecodeError as decode_error:
-        raise GitHubCommandError(
-            f"gh api {endpoint} returned output that is not JSON"
-        ) from decode_error
-    if should_paginate:
-        return _flatten_pages(parsed_payload)
-    return parsed_payload
-
-
-def _fetch_recent_pull_numbers(repo: str, pull_count: int) -> list[int]:
-    """Fetch the most recently updated pull numbers, capped at pull_count."""
-    pulls_payload = _run_gh_json(
-        RECENT_PULLS_ENDPOINT_TEMPLATE.format(repo=repo, pull_count=pull_count)
-    )
-    recent_pull_numbers: list[int] = []
-    if isinstance(pulls_payload, list):
-        for each_pull in pulls_payload:
-            if isinstance(each_pull, dict):
-                pull_number = each_pull.get("number")
-                if isinstance(pull_number, int):
-                    recent_pull_numbers.append(pull_number)
-    return recent_pull_numbers
-
-
-def _fetch_pull_comments(repo: str, pull_number: int) -> list[object]:
-    """Fetch one pull request's review comments through gh."""
-    comments_payload = _run_gh_json(
-        PULL_COMMENTS_ENDPOINT_TEMPLATE.format(repo=repo, pull_number=pull_number),
-        should_paginate=True,
-    )
-    if isinstance(comments_payload, list):
-        return list(comments_payload)
-    return []
-
-
-def _fetch_reviewer_comments(repo: str) -> list[ReviewerComment]:
-    """Fetch reviewer-bot comments from the repo's most recent pull requests."""
-    recent_pull_numbers = _fetch_recent_pull_numbers(repo, RECENT_PULL_COUNT)
-    reviewer_comments: list[ReviewerComment] = []
-    for each_pull_number in recent_pull_numbers:
-        for each_payload in _fetch_pull_comments(repo, each_pull_number):
-            parsed_comment = _reviewer_comment_from_payload(each_payload)
-            if parsed_comment is not None:
-                reviewer_comments.append(parsed_comment)
-    return reviewer_comments
-
-
-def main() -> int:
-    """Print one skill-edit proposal per recurring reviewer defect class.
-
-    Returns:
-        The process exit code; zero on success.
-    """
-    parser = argparse.ArgumentParser(
-        description="Mine reviewer defect patterns into skill-edit proposals."
-    )
-    parser.add_argument("--repo", required=True)
-    parsed_arguments = parser.parse_args()
-    try:
-        comments = _fetch_reviewer_comments(parsed_arguments.repo)
-    except GitHubCommandError as gh_error:
-        print(str(gh_error), file=sys.stderr)
-        return 1
-    clusters = cluster_defects(comments)
-    for each_cluster in clusters:
-        proposal = proposal_for_defect_class(each_cluster.defect_class)
-        print(f"{each_cluster.count}\t{each_cluster.defect_class}\t{proposal.proposal}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/skills/log-audit/scripts/test_cluster_recurrences.py

@@ -1,160 +0,0 @@
-"""Tests for cluster_recurrences — signature grouping and timing regressions."""
-
-import io
-import sys
-from datetime import datetime, timedelta
-from pathlib import Path
-
-import pytest
-
-_script_directory = str(Path(__file__).resolve().parent)
-if _script_directory not in sys.path:
-    sys.path.insert(0, _script_directory)
-
-from cluster_recurrences import (  # noqa: E402
-    TimingSample,
-    detect_timing_regressions,
-    main,
-    normalize_signature,
-    recency_weight,
-    rank_signature_clusters,
-)
-from collect_log_window import LogRecord  # noqa: E402
-
-
-def _record(timestamp: datetime, message: str) -> LogRecord:
-    return LogRecord(
-        timestamp=timestamp, source="a_hook", level="block", message=message
-    )
-
-
-class TestNormalizeSignature:
-    def test_two_messages_differing_only_in_numbers_share_a_signature(self) -> None:
-        first = normalize_signature("blocked at line 12 with 3 issues")
-        second = normalize_signature("blocked at line 348 with 9 issues")
-        assert first == second
-
-    def test_messages_differing_only_in_a_path_share_a_signature(self) -> None:
-        first = normalize_signature(r"cannot read C:\a\b\one.py right now")
-        second = normalize_signature(r"cannot read C:\x\y\two.py right now")
-        assert first == second
-
-    def test_messages_differing_only_in_a_hash_share_a_signature(self) -> None:
-        first = normalize_signature("commit a1b2c3d failed to apply")
-        second = normalize_signature("commit deadbeef failed to apply")
-        assert first == second
-
-    def test_distinct_messages_keep_distinct_signatures(self) -> None:
-        assert normalize_signature("heavy word detected") != normalize_signature(
-            "missing type hint"
-        )
-
-
-class TestRecencyWeight:
-    def test_a_fresh_record_weighs_about_one(self) -> None:
-        now = datetime(2026, 7, 3, 12, 0, 0)
-        weight = recency_weight(now, now)
-        assert abs(weight - 1.0) < 0.001
-
-    def test_a_record_one_half_life_old_weighs_about_the_decay_base(self) -> None:
-        now = datetime(2026, 7, 3, 12, 0, 0)
-        one_half_life_ago = now - timedelta(hours=24)
-        weight = recency_weight(one_half_life_ago, now)
-        assert abs(weight - 0.5) < 0.001
-
-    def test_a_future_record_is_clamped_to_at_most_one(self) -> None:
-        now = datetime(2026, 7, 3, 12, 0, 0)
-        one_hour_ahead = now + timedelta(hours=1)
-        weight = recency_weight(one_hour_ahead, now)
-        assert abs(weight - 1.0) < 0.001
-
-
-class TestRankSignatureClusters:
-    def test_the_most_frequent_recent_signature_ranks_first(self) -> None:
-        now = datetime(2026, 7, 3, 12, 0, 0)
-        records = [
-            _record(now - timedelta(hours=1), "blocked at line 1"),
-            _record(now - timedelta(hours=2), "blocked at line 2"),
-            _record(now - timedelta(hours=1), "blocked at line 3"),
-            _record(now - timedelta(hours=200), "a rare stale failure"),
-        ]
-        clusters = rank_signature_clusters(records, now)
-        assert clusters[0].count == 3
-        assert clusters[0].signature == normalize_signature("blocked at line 1")
-
-    def test_each_distinct_signature_becomes_one_cluster(self) -> None:
-        now = datetime(2026, 7, 3, 12, 0, 0)
-        records = [
-            _record(now, "heavy word here"),
-            _record(now, "missing type hint"),
-        ]
-        clusters = rank_signature_clusters(records, now)
-        assert len(clusters) == 2
-
-
-class TestDetectTimingRegressions:
-    def test_flags_an_operation_whose_recent_runs_are_slower(self) -> None:
-        base = datetime(2026, 7, 3, 0, 0, 0)
-        samples = [
-            TimingSample("extract", base + timedelta(minutes=1), 100.0),
-            TimingSample("extract", base + timedelta(minutes=2), 110.0),
-            TimingSample("extract", base + timedelta(minutes=3), 105.0),
-            TimingSample("extract", base + timedelta(minutes=40), 300.0),
-            TimingSample("extract", base + timedelta(minutes=41), 320.0),
-            TimingSample("extract", base + timedelta(minutes=42), 310.0),
-        ]
-        regressions = detect_timing_regressions(samples)
-        assert len(regressions) == 1
-        assert regressions[0].operation == "extract"
-        assert regressions[0].ratio > 1.5
-
-    def test_ignores_a_steady_operation(self) -> None:
-        base = datetime(2026, 7, 3, 0, 0, 0)
-        samples = [
-            TimingSample("steady", base + timedelta(minutes=each_minute_offset), 100.0)
-            for each_minute_offset in range(6)
-        ]
-        assert detect_timing_regressions(samples) == []
-
-    def test_ignores_an_operation_with_too_few_samples(self) -> None:
-        base = datetime(2026, 7, 3, 0, 0, 0)
-        samples = [
-            TimingSample("sparse", base + timedelta(minutes=1), 100.0),
-            TimingSample("sparse", base + timedelta(minutes=2), 900.0),
-        ]
-        assert detect_timing_regressions(samples) == []
-
-
-class TestMain:
-    def test_rejects_non_json_stdin(
-        self,
-        monkeypatch: pytest.MonkeyPatch,
-        capsys: pytest.CaptureFixture[str],
-    ) -> None:
-        monkeypatch.setattr(sys, "stdin", io.StringIO("not json"))
-        exit_code = main()
-        captured = capsys.readouterr()
-        assert exit_code == 1
-        assert "not valid JSON" in captured.err
-
-    def test_rejects_a_non_list_payload(
-        self,
-        monkeypatch: pytest.MonkeyPatch,
-        capsys: pytest.CaptureFixture[str],
-    ) -> None:
-        monkeypatch.setattr(sys, "stdin", io.StringIO('{"not": "a list"}'))
-        exit_code = main()
-        captured = capsys.readouterr()
-        assert exit_code == 1
-        assert "must be a list" in captured.err
-
-    def test_rejects_a_malformed_record(
-        self,
-        monkeypatch: pytest.MonkeyPatch,
-        capsys: pytest.CaptureFixture[str],
-    ) -> None:
-        monkeypatch.setattr(sys, "stdin", io.StringIO('[{"missing": "fields"}]'))
-        exit_code = main()
-        captured = capsys.readouterr()
-        assert exit_code == 1
-        assert "malformed record" in captured.err

package/skills/log-audit/scripts/test_collect_log_window.py

@@ -1,111 +0,0 @@
-"""Tests for collect_log_window — parsing and windowing hook-block records."""
-
-import json
-import sys
-from datetime import datetime, timedelta
-from pathlib import Path
-
-_script_directory = str(Path(__file__).resolve().parent)
-if _script_directory not in sys.path:
-    sys.path.insert(0, _script_directory)
-
-from collect_log_window import (  # noqa: E402
-    LogRecord,
-    collect_records,
-    parse_log_line,
-    read_log_window,
-)
-
-
-def _block_line(timestamp_text: str, hook_name: str, reason_text: str) -> str:
-    return json.dumps(
-        {
-            "timestamp": timestamp_text,
-            "hook": hook_name,
-            "event": "PreToolUse",
-            "reason": reason_text,
-        }
-    )
-
-
-class TestParseLogLine:
-    def test_parses_a_well_formed_block_record(self) -> None:
-        line = _block_line(
-            "2026-07-03T09:00:00", "plain_language_blocker", "Heavy word"
-        )
-        record = parse_log_line(line)
-        assert record == LogRecord(
-            timestamp=datetime(2026, 7, 3, 9, 0, 0),
-            source="plain_language_blocker",
-            level="block",
-            message="Heavy word",
-        )
-
-    def test_returns_none_for_a_blank_line(self) -> None:
-        assert parse_log_line("   ") is None
-
-    def test_returns_none_for_non_json(self) -> None:
-        assert parse_log_line("not json at all") is None
-
-    def test_returns_none_when_reason_is_missing(self) -> None:
-        line = json.dumps({"timestamp": "2026-07-03T09:00:00", "hook": "x"})
-        assert parse_log_line(line) is None
-
-    def test_returns_none_for_an_unparseable_timestamp(self) -> None:
-        line = _block_line("not-a-timestamp", "x", "y")
-        assert parse_log_line(line) is None
-
-
-class TestCollectRecords:
-    def test_keeps_only_records_at_or_after_the_window_start(self) -> None:
-        window_start = datetime(2026, 7, 3, 8, 0, 0)
-        log_text = "\n".join(
-            [
-                _block_line("2026-07-03T07:59:59", "old_hook", "before window"),
-                _block_line("2026-07-03T08:00:00", "edge_hook", "on the boundary"),
-                _block_line("2026-07-03T09:30:00", "new_hook", "inside window"),
-            ]
-        )
-        records = collect_records(log_text, window_start)
-        assert [each_record.source for each_record in records] == [
-            "edge_hook",
-            "new_hook",
-        ]
-
-    def test_skips_malformed_lines(self) -> None:
-        window_start = datetime(2026, 7, 3, 0, 0, 0)
-        log_text = "\n".join(
-            [
-                "garbage",
-                _block_line("2026-07-03T09:00:00", "good_hook", "kept"),
-                "",
-            ]
-        )
-        records = collect_records(log_text, window_start)
-        assert len(records) == 1
-        assert records[0].source == "good_hook"
-
-
-class TestReadLogWindow:
-    def test_returns_empty_list_when_the_log_is_absent(self, tmp_path: Path) -> None:
-        missing_path = tmp_path / "hook-blocks.log"
-        assert read_log_window(missing_path, 24, datetime(2026, 7, 3, 12, 0, 0)) == []
-
-    def test_reads_records_inside_the_window_from_a_real_file(
-        self, tmp_path: Path
-    ) -> None:
-        now = datetime(2026, 7, 3, 12, 0, 0)
-        recent_time = (now - timedelta(hours=1)).isoformat()
-        stale_time = (now - timedelta(hours=48)).isoformat()
-        log_path = tmp_path / "hook-blocks.log"
-        log_path.write_text(
-            "\n".join(
-                [
-                    _block_line(stale_time, "stale_hook", "too old"),
-                    _block_line(recent_time, "recent_hook", "in window"),
-                ]
-            ),
-            encoding="utf-8",
-        )
-        records = read_log_window(log_path, 24, now)
-        assert [each_record.source for each_record in records] == ["recent_hook"]

package/skills/log-audit/scripts/test_mine_copilot_findings.py

@@ -1,126 +0,0 @@
-"""Tests for mine_copilot_findings — defect classification and clustering."""
-
-import sys
-from pathlib import Path
-
-_script_directory = str(Path(__file__).resolve().parent)
-if _script_directory not in sys.path:
-    sys.path.insert(0, _script_directory)
-
-from mine_copilot_findings import (  # noqa: E402
-    ReviewerComment,
-    _flatten_pages,
-    _pull_number_from_url,
-    _reviewer_comment_from_payload,
-    classify_defect,
-    cluster_defects,
-    proposal_for_defect_class,
-)
-from log_audit_constants.mine_copilot_findings_constants import (  # noqa: E402
-    PROPOSAL_BY_DEFECT_CLASS,
-)
-
-
-class TestClassifyDefect:
-    def test_recognizes_a_missing_type_hint_comment(self) -> None:
-        assert (
-            classify_defect("This function is missing a type hint on the return")
-            == "missing-type-hint"
-        )
-
-    def test_recognizes_a_broad_except_comment(self) -> None:
-        assert classify_defect("There is a broad except swallowing errors") == (
-            "broad-except"
-        )
-
-    def test_recognizes_a_magic_value_comment(self) -> None:
-        assert classify_defect("42 is a magic number, extract it") == "magic-value"
-
-    def test_returns_none_for_praise(self) -> None:
-        assert classify_defect("Looks great, nicely done!") is None
-
-
-class TestClusterDefects:
-    def test_groups_comments_by_class_and_ranks_by_count(self) -> None:
-        comments = [
-            ReviewerComment(1, "cursor[bot]", "missing type hint here"),
-            ReviewerComment(2, "cursor[bot]", "another missing annotation"),
-            ReviewerComment(3, "cursor[bot]", "this is a broad except"),
-            ReviewerComment(4, "cursor[bot]", "nice work"),
-        ]
-        clusters = cluster_defects(comments)
-        assert clusters[0].defect_class == "missing-type-hint"
-        assert clusters[0].count == 2
-        assert len(clusters) == 2
-
-    def test_caps_the_number_of_example_bodies(self) -> None:
-        comments = [
-            ReviewerComment(
-                each_index, "cursor[bot]", f"missing type hint number {each_index}"
-            )
-            for each_index in range(10)
-        ]
-        clusters = cluster_defects(comments)
-        assert clusters[0].count == 10
-        assert len(clusters[0].example_bodies) == 3
-
-
-class TestProposalForDefectClass:
-    def test_maps_a_class_to_its_skill_edit_proposal(self) -> None:
-        proposal = proposal_for_defect_class("broad-except")
-        assert proposal.defect_class == "broad-except"
-        assert proposal.proposal == PROPOSAL_BY_DEFECT_CLASS["broad-except"]
-
-
-class TestPullNumberFromUrl:
-    def test_reads_the_trailing_pull_number(self) -> None:
-        url = "https://api.github.com/repos/owner/name/pulls/867"
-        assert _pull_number_from_url(url) == 867
-
-    def test_returns_none_when_the_last_segment_is_not_a_number(self) -> None:
-        assert _pull_number_from_url("https://api.github.com/repos/owner/name") is None
-
-
-class TestReviewerCommentFromPayload:
-    def test_builds_a_comment_from_a_reviewer_bot_payload(self) -> None:
-        payload = {
-            "user": {"login": "cursor[bot]"},
-            "body": "missing type hint",
-            "pull_request_url": "https://api.github.com/repos/owner/name/pulls/12",
-        }
-        parsed_comment = _reviewer_comment_from_payload(payload)
-        assert parsed_comment == ReviewerComment(
-            pull_number=12, author="cursor[bot]", body="missing type hint"
-        )
-
-    def test_skips_a_comment_from_a_non_reviewer_login(self) -> None:
-        payload = {
-            "user": {"login": "some-human"},
-            "body": "looks good",
-            "pull_request_url": "https://api.github.com/repos/owner/name/pulls/12",
-        }
-        assert _reviewer_comment_from_payload(payload) is None
-
-    def test_skips_a_payload_that_is_not_a_dict(self) -> None:
-        assert _reviewer_comment_from_payload("not a payload") is None
-
-    def test_skips_a_payload_missing_the_pull_request_url(self) -> None:
-        payload = {"user": {"login": "cursor[bot]"}, "body": "missing type hint"}
-        assert _reviewer_comment_from_payload(payload) is None
-
-    def test_skips_a_payload_whose_url_has_no_numeric_pull_number(self) -> None:
-        payload = {
-            "user": {"login": "cursor[bot]"},
-            "body": "missing type hint",
-            "pull_request_url": "https://api.github.com/repos/owner/name/pulls",
-        }
-        assert _reviewer_comment_from_payload(payload) is None
-
-
-class TestFlattenPages:
-    def test_flattens_multiple_pages_into_one_list(self) -> None:
-        slurped_payload = [[{"id": 1}, {"id": 2}], [{"id": 3}]]
-        assert _flatten_pages(slurped_payload) == [{"id": 1}, {"id": 2}, {"id": 3}]
-
-    def test_returns_empty_list_for_a_non_list_payload(self) -> None:
-        assert _flatten_pages({"message": "not a list"}) == []