claude-dev-env 1.36.2 → 1.37.1

package/skills/pr-converge/scripts/fetch_claude_reviews.py

@@ -0,0 +1,61 @@
+"""Fetch Claude reviewer-bot reviews newest-first, classified as dirty or clean.
+
+Thin wrapper around ``reviewer_fetch_core.fetch_reviewer_reviews`` parameterised
+by ``claude_spec``. Classification follows the review's ``state`` field
+(``APPROVED`` -> clean; ``CHANGES_REQUESTED`` -> dirty; ``COMMENTED`` with
+non-empty body -> dirty; everything else -> clean) - see ``reviewer_specs``.
+
+Wraps the gh CLI invocation required by the gh-paginate rule:
+``gh api '...?per_page=100' --paginate --slurp`` piped through external Python
+JSON handling (instead of ``gh --jq``, which runs per-page and breaks
+cross-page operations like sort/reverse - see GitHub CLI issue 10459).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+if str(Path(__file__).resolve().parent) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from evict_cached_config_modules import evict_cached_config_modules
+
+evict_cached_config_modules()
+
+from reviewer_fetch_core import fetch_reviewer_reviews
+from reviewer_specs import claude_spec
+
+
+def fetch_claude_reviews(
+    *,
+    owner: str,
+    repo: str,
+    number: int,
+) -> list[dict[str, object]]:
+    """Return Claude reviews newest-first, each with a classification."""
+    return fetch_reviewer_reviews(
+        claude_spec, owner=owner, repo=repo, number=number
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--owner", required=True)
+    parser.add_argument("--repo", required=True)
+    parser.add_argument("--number", required=True, type=int)
+    parsed_arguments = parser.parse_args()
+    all_reviews = fetch_claude_reviews(
+        owner=parsed_arguments.owner,
+        repo=parsed_arguments.repo,
+        number=parsed_arguments.number,
+    )
+    json.dump(all_reviews, sys.stdout)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/pr-converge/scripts/fetch_copilot_inline_comments.py

@@ -1,17 +1,19 @@
 """Fetch unaddressed Copilot inline comments for the latest Copilot review on a commit.
 
-Uses ``fetch_copilot_reviews`` to find the newest submitted Copilot review whose ``commit_id`` matches the caller
-``current_head``, then returns only ``copilot-pull-request-reviewer[bot]`` inline comments whose
-``pull_request_review_id`` matches that review. This avoids misclassifying a PR when Copilot posts more than one review
-on the same SHA: older inline threads stay anchored to the earlier review id even when they share the same commit id.
+Thin wrapper around ``reviewer_fetch_core.fetch_reviewer_inline_comments``
+parameterised by ``copilot_spec``. The ``fetch_copilot_reviews`` call lives
+here (rather than inside the core) so tests can patch it on this module to
+exercise the inline-comments fetch in isolation.
 
-Wraps the gh CLI invocation required by the gh-paginate rule for the comments list:
-``gh api`` on ``repos/{owner}/{repo}/pulls/{number}/comments`` with ``--paginate --slurp`` and external JSON handling.
+Wraps the gh CLI invocation required by the gh-paginate rule for the comments
+list: ``gh api`` on ``repos/{owner}/{repo}/pulls/{number}/comments`` with
+``--paginate --slurp`` and external JSON handling.
 """
 
+from __future__ import annotations
+
 import argparse
 import json
-import subprocess
 import sys
 from pathlib import Path
 
@@ -22,12 +24,9 @@ from evict_cached_config_modules import evict_cached_config_modules
 
 evict_cached_config_modules()
 
-from config.pr_converge_constants import (
-    COPILOT_REVIEWER_LOGIN,
-    GH_INLINE_COMMENTS_PATH_TEMPLATE,
-)
 from fetch_copilot_reviews import fetch_copilot_reviews
-from review_field_helpers import body_of, login_of
+from reviewer_fetch_core import fetch_reviewer_inline_comments
+from reviewer_specs import copilot_spec
 
 
 def fetch_copilot_inline_comments(
@@ -37,57 +36,16 @@ def fetch_copilot_inline_comments(
     number: int,
     current_head: str,
 ) -> list[dict[str, object]]:
-    """Return Copilot inline comments for the latest Copilot review on ``current_head``.
-
-    Each entry contains comment_id, commit_id, path, line, and body.
-    """
+    """Return Copilot inline comments for the latest Copilot review on ``current_head``."""
     all_copilot_reviews = fetch_copilot_reviews(owner=owner, repo=repo, number=number)
-    latest_copilot_review_for_head = next(
-        (
-            each_review
-            for each_review in all_copilot_reviews
-            if each_review.get("commit_id") == current_head
-        ),
-        None,
-    )
-    if latest_copilot_review_for_head is None:
-        return []
-    target_pull_request_review_id = latest_copilot_review_for_head["review_id"]
-    comments_endpoint = GH_INLINE_COMMENTS_PATH_TEMPLATE.format(
-        owner=owner, repo=repo, number=number
-    )
-    gh_command: list[str] = [
-        "gh",
-        "api",
-        comments_endpoint,
-        "--paginate",
-        "--slurp",
-    ]
-    completed = subprocess.run(
-        gh_command,
-        capture_output=True,
-        check=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
+    return fetch_reviewer_inline_comments(
+        copilot_spec,
+        owner=owner,
+        repo=repo,
+        number=number,
+        current_head=current_head,
+        all_reviews=all_copilot_reviews,
     )
-    pages: list[list[dict[str, object]]] = json.loads(completed.stdout)
-    all_flat_comments = [
-        each_comment for each_page in pages for each_comment in each_page
-    ]
-    return [
-        {
-            "comment_id": each_comment["id"],
-            "commit_id": each_comment.get("commit_id"),
-            "path": each_comment.get("path"),
-            "line": each_comment.get("line"),
-            "body": body_of(each_comment),
-        }
-        for each_comment in all_flat_comments
-        if login_of(each_comment) == COPILOT_REVIEWER_LOGIN
-        and each_comment.get("commit_id") == current_head
-        and each_comment.get("pull_request_review_id") == target_pull_request_review_id
-    ]
 
 
 def main() -> int:

package/skills/pr-converge/scripts/fetch_copilot_reviews.py

@@ -1,21 +1,20 @@
 """Fetch GitHub Copilot reviewer reviews newest-first, classified as dirty or clean.
 
+Thin wrapper around ``reviewer_fetch_core.fetch_reviewer_reviews`` parameterised
+by ``copilot_spec``. Classification follows the review's ``state`` field
+(``APPROVED`` -> clean; ``CHANGES_REQUESTED`` -> dirty; ``COMMENTED`` with
+non-empty body -> dirty; everything else -> clean) - see ``reviewer_specs``.
+
 Wraps the gh CLI invocation required by the gh-paginate rule:
 ``gh api '...?per_page=100' --paginate --slurp`` piped through external Python
-JSON handling (instead of ``gh --jq``, which runs per-page and breaks cross-page
-operations like sort/reverse - see GitHub CLI #10459).
-
-Classification follows the review's ``state`` field:
-- ``APPROVED``                 -> ``"clean"``
-- ``CHANGES_REQUESTED``        -> ``"dirty"``
-- ``COMMENTED`` with non-empty body -> ``"dirty"`` (Copilot uses COMMENTED + body
-  to flag findings without a hard block)
-- everything else              -> ``"clean"`` (no actionable findings on PR)
+JSON handling (instead of ``gh --jq``, which runs per-page and breaks
+cross-page operations like sort/reverse - see GitHub CLI issue 10459).
 """
 
+from __future__ import annotations
+
 import argparse
 import json
-import subprocess
 import sys
 from pathlib import Path
 
@@ -26,14 +25,8 @@ from evict_cached_config_modules import evict_cached_config_modules
 
 evict_cached_config_modules()
 
-from config.pr_converge_constants import (
-    ALL_COPILOT_DIRTY_REVIEW_STATES,
-    COPILOT_CLEAN_REVIEW_STATE,
-    COPILOT_REVIEWER_LOGIN,
-    COPILOT_SOFT_DIRTY_REVIEW_STATE,
-    GH_REVIEWS_PATH_TEMPLATE,
-)
-from review_field_helpers import body_of, login_of, state_of, submitted_at_of
+from reviewer_fetch_core import fetch_reviewer_reviews
+from reviewer_specs import copilot_spec
 
 
 def fetch_copilot_reviews(
@@ -42,63 +35,10 @@ def fetch_copilot_reviews(
     repo: str,
     number: int,
 ) -> list[dict[str, object]]:
-    """Return Copilot reviews newest-first, each with a clean/dirty classification.
-
-    Each entry contains review_id, commit_id, submitted_at, state, body, and classification.
-    """
-    reviews_endpoint = GH_REVIEWS_PATH_TEMPLATE.format(
-        owner=owner, repo=repo, number=number
+    """Return Copilot reviews newest-first, each with a classification."""
+    return fetch_reviewer_reviews(
+        copilot_spec, owner=owner, repo=repo, number=number
     )
-    gh_command: list[str] = [
-        "gh",
-        "api",
-        reviews_endpoint,
-        "--paginate",
-        "--slurp",
-    ]
-    completed = subprocess.run(
-        gh_command,
-        capture_output=True,
-        check=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-    )
-    pages: list[list[dict[str, object]]] = json.loads(completed.stdout)
-    all_flat_reviews = [each_review for each_page in pages for each_review in each_page]
-    all_copilot_reviews = [
-        each_review
-        for each_review in all_flat_reviews
-        if login_of(each_review) == COPILOT_REVIEWER_LOGIN
-        and each_review.get("submitted_at") is not None
-        and each_review.get("id") is not None
-    ]
-    all_copilot_reviews.sort(
-        key=lambda each_review: submitted_at_of(each_review), reverse=True
-    )
-    return [
-        {
-            "review_id": each_review["id"],
-            "commit_id": each_review.get("commit_id"),
-            "submitted_at": each_review["submitted_at"],
-            "state": state_of(each_review),
-            "body": body_of(each_review),
-            "classification": _classify_review(each_review),
-        }
-        for each_review in all_copilot_reviews
-    ]
-
-
-def _classify_review(field_by_key: dict[str, object]) -> str:
-    review_state = state_of(field_by_key)
-    if review_state == COPILOT_CLEAN_REVIEW_STATE:
-        return "clean"
-    if review_state not in ALL_COPILOT_DIRTY_REVIEW_STATES:
-        return "clean"
-    state_requires_body = review_state == COPILOT_SOFT_DIRTY_REVIEW_STATE
-    if state_requires_body and not body_of(field_by_key):
-        return "clean"
-    return "dirty"
 
 
 def main() -> int:

package/skills/pr-converge/scripts/reflow_skill_md.py

@@ -9,16 +9,30 @@ Run: python3 packages/claude-dev-env/skills/pr-converge/scripts/reflow_skill_md.
 
 from __future__ import annotations
 
-import re
+import sys
 import textwrap
 from pathlib import Path
 
-MAX_WIDTH = 80
-SKILL_PATH = Path(__file__).resolve().parent.parent / "SKILL.md"
+script_directory = str(Path(__file__).resolve().parent)
 
-ORDERED_RE = re.compile(r"^(\s*)(\d+\.\s)(.*)$")
-BULLET_RE = re.compile(r"^(\s*)([-*]\s)(.*)$")
-UNFINISHED_MD_LINK_TARGET = re.compile(r"\]\([^)]*$")
+while script_directory in sys.path:
+    sys.path.remove(script_directory)
+if script_directory not in sys.path:
+    sys.path.insert(0, script_directory)
+
+from evict_cached_config_modules import evict_cached_config_modules
+
+evict_cached_config_modules()
+
+from config.reflow_skill_md_constants import (
+    BASH_CONTINUATION_MARKER_WIDTH,
+    BULLET_LIST_ITEM_PATTERN as BULLET_RE,
+    MARKDOWN_REFERENCE_DEFINITION_PATTERN as REF_DEF_RE,
+    MAXIMUM_LINE_WIDTH as MAX_WIDTH,
+    ORDERED_LIST_ITEM_PATTERN as ORDERED_RE,
+    TARGET_SKILL_PATH as SKILL_PATH,
+    UNFINISHED_MARKDOWN_LINK_TARGET_PATTERN as UNFINISHED_MD_LINK_TARGET,
+)
 
 
 def wrap_paragraph_plain(text: str) -> list[str]:
@@ -49,11 +63,14 @@ def wrap_list_item(lead_ws: str, marker: str, body: str) -> list[str]:
     ).splitlines()
 
 
-def reflow_yaml_description_block(lines: list[str], body_start: int) -> tuple[list[str], int]:
+def reflow_yaml_description_block(
+    all_lines: list[str],
+    body_start: int,
+) -> tuple[list[str], int]:
     body_parts: list[str] = []
     index = body_start
-    while index < len(lines):
-        line = lines[index]
+    while index < len(all_lines):
+        line = all_lines[index]
         if line.strip() == "---":
             index += 1
             break
@@ -62,10 +79,6 @@ def reflow_yaml_description_block(lines: list[str], body_start: int) -> tuple[li
             body_parts.append(stripped)
         index += 1
     merged = " ".join(body_parts)
-    merged = merged.replace(
-        "`<TMPDIR>/pr-converge-<session_id>/state.json` per",
-        "`<TMPDIR>/pr-converge-<session_id>/state.json>` per",
-    )
     wrapped = textwrap.fill(
         merged,
         width=MAX_WIDTH,
@@ -96,6 +109,8 @@ def is_new_logical_line(stripped: str) -> bool:
         return True
     if ORDERED_RE.match(stripped) or BULLET_RE.match(stripped):
         return True
+    if REF_DEF_RE.match(stripped):
+        return True
     return False
 
 
@@ -110,30 +125,30 @@ def merge_without_space(buffer: str, continuation: str) -> bool:
     return False
 
 
-def merge_soft_breaks(lines: list[str]) -> list[str]:
-    output: list[str] = []
+def merge_soft_breaks(all_lines: list[str]) -> list[str]:
+    reflowed_lines: list[str] = []
     index = 0
-    in_fence = False
-    while index < len(lines):
-        raw = lines[index]
+    is_inside_fence = False
+    while index < len(all_lines):
+        raw = all_lines[index]
         line = raw.rstrip("\n")
         if line.lstrip().startswith("```"):
-            in_fence = not in_fence
-            output.append(line)
+            is_inside_fence = not is_inside_fence
+            reflowed_lines.append(line)
             index += 1
             continue
-        if in_fence:
-            output.append(line)
+        if is_inside_fence:
+            reflowed_lines.append(line)
             index += 1
             continue
         if line.strip() == "":
-            output.append(line)
+            reflowed_lines.append(line)
             index += 1
             continue
         buffer_line = line
         index += 1
-        while index < len(lines):
-            next_raw = lines[index].rstrip("\n")
+        while index < len(all_lines):
+            next_raw = all_lines[index].rstrip("\n")
             if next_raw.strip() == "":
                 break
             if next_raw.lstrip().startswith("```"):
@@ -146,8 +161,8 @@ def merge_soft_breaks(lines: list[str]) -> list[str]:
             else:
                 buffer_line = f"{buffer_line.rstrip()} {stripped_next}"
             index += 1
-        output.append(buffer_line)
-    return output
+        reflowed_lines.append(buffer_line)
+    return reflowed_lines
 
 
 def reflow_merged_line(line: str) -> list[str]:
@@ -191,6 +206,9 @@ def reflow_merged_line(line: str) -> list[str]:
             break_on_hyphens=False,
         ).splitlines()
 
+    if REF_DEF_RE.match(stripped):
+        return [stripped]
+
     ordered = ORDERED_RE.match(line)
     if ordered:
         return wrap_list_item(ordered.group(1), ordered.group(2), ordered.group(3))
@@ -202,39 +220,42 @@ def reflow_merged_line(line: str) -> list[str]:
     return wrap_paragraph_plain(stripped)
 
 
-def reflow_markdown_body(lines: list[str]) -> list[str]:
-    merged = merge_soft_breaks(lines)
-    output: list[str] = []
+def reflow_markdown_body(all_lines: list[str]) -> list[str]:
+    merged = merge_soft_breaks(all_lines)
+    reflowed_lines: list[str] = []
     for each_line in merged:
         if each_line.strip() == "":
-            output.append("")
+            reflowed_lines.append("")
             continue
-        output.extend(reflow_merged_line(each_line))
-    return output
+        reflowed_lines.extend(reflow_merged_line(each_line))
+    return reflowed_lines
 
 
-def wrap_long_bash_fence_lines(lines: list[str]) -> list[str]:
+def wrap_long_bash_fence_lines(all_lines: list[str]) -> list[str]:
     """Hard-wrap only ```bash fence bodies that still exceed MAX_WIDTH."""
-    output: list[str] = []
-    in_bash_fence = False
-    for line in lines:
-        stripped = line.lstrip()
+    wrapped_lines: list[str] = []
+    is_inside_bash_fence = False
+    for each_line in all_lines:
+        stripped = each_line.lstrip()
         if stripped.startswith("```"):
-            if not in_bash_fence:
+            if not is_inside_bash_fence:
                 lang = stripped[3:].strip().lower()
-                in_bash_fence = lang == "bash"
+                is_inside_bash_fence = lang == "bash"
             else:
-                in_bash_fence = False
-            output.append(line)
+                is_inside_bash_fence = False
+            wrapped_lines.append(each_line)
             continue
-        if in_bash_fence and len(line) > MAX_WIDTH:
-            indent_len = len(line) - len(line.lstrip())
-            indent = line[:indent_len]
-            content = line.lstrip()
+        if is_inside_bash_fence and len(each_line) > MAX_WIDTH:
+            indent_len = len(each_line) - len(each_line.lstrip())
+            indent = each_line[:indent_len]
+            if len(indent) + BASH_CONTINUATION_MARKER_WIDTH >= MAX_WIDTH:
+                wrapped_lines.append(each_line)
+                continue
+            content = each_line.lstrip()
             wrapped_segments: list[str] = []
             rest = content
             while len(rest) > MAX_WIDTH - len(indent):
-                room = MAX_WIDTH - len(indent) - 2
+                room = MAX_WIDTH - len(indent) - BASH_CONTINUATION_MARKER_WIDTH
                 window = rest[:room]
                 break_at = window.rfind(" ")
                 if break_at <= 0:
@@ -244,10 +265,10 @@ def wrap_long_bash_fence_lines(lines: list[str]) -> list[str]:
                 wrapped_segments.append(indent + piece + " \\")
             if rest:
                 wrapped_segments.append(indent + ("  " if wrapped_segments else "") + rest)
-            output.extend(wrapped_segments)
+            wrapped_lines.extend(wrapped_segments)
         else:
-            output.append(line)
-    return output
+            wrapped_lines.append(each_line)
+    return wrapped_lines
 
 
 def main() -> None:

package/skills/pr-converge/scripts/reviewer_fetch_core.py

@@ -0,0 +1,153 @@
+"""Shared fetch primitives for PR reviewer bots (Bugbot, Copilot, Claude).
+
+The reviewer-specific scripts (``fetch_bugbot_reviews.py``,
+``fetch_copilot_reviews.py``, ``fetch_claude_reviews.py`` and their
+inline-comment counterparts) are thin entry points that pass a ``ReviewerSpec``
+to these functions. The spec carries the substring used to recognise the
+reviewer's GitHub login (case-insensitive substring match - required because
+some bots emit different login strings at the review-level vs inline-comment
+endpoints) and the per-reviewer classify callable.
+
+Wraps the gh CLI invocations required by the gh-paginate rule:
+``gh api '...?per_page=100' --paginate --slurp`` piped through external Python
+JSON handling (instead of ``gh --jq``, which runs per-page and breaks
+cross-page operations like sort/reverse - see GitHub CLI issue 10459).
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+if str(Path(__file__).resolve().parent) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from evict_cached_config_modules import evict_cached_config_modules
+
+evict_cached_config_modules()
+
+from config.pr_converge_constants import (
+    GH_INLINE_COMMENTS_PATH_TEMPLATE,
+    GH_REVIEWS_PATH_TEMPLATE,
+)
+from review_field_helpers import body_of, login_of, state_of, submitted_at_of
+from reviewer_specs import ReviewerSpec
+
+
+def _login_matches_substring(
+    field_by_key: dict[str, object], login_filter_substring: str
+) -> bool:
+    author_login = login_of(field_by_key) or ""
+    return login_filter_substring.lower() in author_login.lower()
+
+
+def _run_gh_paginated(*, endpoint_path: str) -> list[dict[str, object]]:
+    gh_command: list[str] = [
+        "gh",
+        "api",
+        endpoint_path,
+        "--paginate",
+        "--slurp",
+    ]
+    completed = subprocess.run(
+        gh_command,
+        capture_output=True,
+        check=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    pages: list[list[dict[str, object]]] = json.loads(completed.stdout)
+    return [each_entry for each_page in pages for each_entry in each_page]
+
+
+def fetch_reviewer_reviews(
+    spec: ReviewerSpec,
+    *,
+    owner: str,
+    repo: str,
+    number: int,
+) -> list[dict[str, object]]:
+    """Return reviews from the matching reviewer newest-first, with classification.
+
+    Each entry contains ``review_id``, ``commit_id``, ``submitted_at``,
+    ``state``, ``body``, and ``classification`` (``"clean"`` or ``"dirty"``).
+    Entries whose payload is missing ``submitted_at`` or ``id`` are dropped.
+    """
+    reviews_endpoint = GH_REVIEWS_PATH_TEMPLATE.format(
+        owner=owner, repo=repo, number=number
+    )
+    all_flat_reviews = _run_gh_paginated(endpoint_path=reviews_endpoint)
+    all_matching_reviews = [
+        each_review
+        for each_review in all_flat_reviews
+        if _login_matches_substring(each_review, spec.login_filter_substring)
+        and each_review.get("submitted_at") is not None
+        and each_review.get("id") is not None
+    ]
+    all_matching_reviews.sort(
+        key=lambda each_review: submitted_at_of(each_review), reverse=True
+    )
+    return [
+        {
+            "review_id": each_review["id"],
+            "commit_id": each_review.get("commit_id"),
+            "submitted_at": each_review["submitted_at"],
+            "state": state_of(each_review),
+            "body": body_of(each_review),
+            "classification": spec.classify_review(each_review),
+        }
+        for each_review in all_matching_reviews
+    ]
+
+
+def fetch_reviewer_inline_comments(
+    spec: ReviewerSpec,
+    *,
+    owner: str,
+    repo: str,
+    number: int,
+    current_head: str,
+    all_reviews: list[dict[str, object]],
+) -> list[dict[str, object]]:
+    """Return inline comments anchored to the latest matching review on ``current_head``.
+
+    The ``all_reviews`` list is supplied by the caller (not fetched internally)
+    so the entry-point scripts retain a patchable seam: tests that patch
+    ``fetch_X_reviews`` on the entry-point module continue to work because the
+    entry-point is what calls the reviews fetch.
+
+    Each entry contains ``comment_id``, ``commit_id``, ``path``, ``line``, and
+    ``body``. Returns an empty list when no review in ``all_reviews`` is
+    anchored to ``current_head``.
+    """
+    latest_review_for_head = next(
+        (
+            each_review
+            for each_review in all_reviews
+            if each_review.get("commit_id") == current_head
+        ),
+        None,
+    )
+    if latest_review_for_head is None:
+        return []
+    target_pull_request_review_id = latest_review_for_head["review_id"]
+    comments_endpoint = GH_INLINE_COMMENTS_PATH_TEMPLATE.format(
+        owner=owner, repo=repo, number=number
+    )
+    all_flat_comments = _run_gh_paginated(endpoint_path=comments_endpoint)
+    return [
+        {
+            "comment_id": each_comment["id"],
+            "commit_id": each_comment.get("commit_id"),
+            "path": each_comment.get("path"),
+            "line": each_comment.get("line"),
+            "body": body_of(each_comment),
+        }
+        for each_comment in all_flat_comments
+        if _login_matches_substring(each_comment, spec.login_filter_substring)
+        and each_comment.get("commit_id") == current_head
+        and each_comment.get("pull_request_review_id") == target_pull_request_review_id
+    ]