claude-dev-env 2.12.0 → 2.14.0

package/hooks/blocking/convergence_gate_blocker.py

@@ -1,310 +0,0 @@
-#!/usr/bin/env python3
-"""PreToolUse hook: block gh pr ready until convergence pre-conditions pass.
-
-Runs check_convergence.py against the PR and denies the gh pr ready
-call if any condition fails. The agent sees exactly which conditions
-failed and can address them before retrying.
-"""
-
-from __future__ import annotations
-
-import json
-import re
-import subprocess
-import sys
-from pathlib import Path
-
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-from blocking.pr_description_pr_number import (  # noqa: E402
-    _extract_pr_number_from_command,
-)
-from hooks_constants.convergence_gate_blocker_constants import (  # noqa: E402
-    ALL_GH_PR_VIEW_NUMBER_COMMAND,
-    BASH_LINE_CONTINUATION_PATTERN,
-    COMMAND_SEPARATOR_PATTERN,
-    GH_PR_READY_ANCHOR_PATTERN,
-    GH_REPO_FLAG,
-    GIT_URL_SUFFIX,
-    PR_URL_OWNER_REPO_NUMBER_PATTERN,
-    REPO_OVERRIDE_FLAG_PATTERN,
-    REPO_SLUG_TEMPLATE,
-)
-from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
-
-
-def _ready_command_segment(command: str) -> str:
-    """Return the ``gh pr ready`` invocation, clipped at the next command separator.
-
-    ::
-
-        gh pr ready 161 && gh pr comment 999 --repo other-owner/other-repo
-        ^^^^^^^^^^^^^^^^                            clipped -> returned segment
-
-    Scanning only this segment keeps a ``--repo`` flag or PR URL that belongs to
-    a chained command from binding the gate to the wrong PR. A backslash-newline
-    continuation is folded to a space before the separator search, so a
-    ``--repo`` flag written on a continued line stays inside the segment.
-    """
-    ready_match = re.search(GH_PR_READY_ANCHOR_PATTERN, command)
-    if ready_match is None:
-        return command
-    ready_tail = command[ready_match.start() :]
-    ready_tail = re.sub(BASH_LINE_CONTINUATION_PATTERN, " ", ready_tail)
-    separator_match = re.search(COMMAND_SEPARATOR_PATTERN, ready_tail)
-    if separator_match is None:
-        return ready_tail
-    return ready_tail[: separator_match.start()]
-
-
-def _parse_pr_url(command: str) -> tuple[str, str, int] | None:
-    """Return (owner, repo, pr_number) from a full PR URL in the command."""
-    url_match = re.search(PR_URL_OWNER_REPO_NUMBER_PATTERN, command)
-    if url_match is None:
-        return None
-    return url_match.group("owner"), url_match.group("repo"), int(url_match.group("number"))
-
-
-def _parse_repo_flag(command: str) -> tuple[str, str] | None:
-    """Return (owner, repo) from a --repo/-R flag in the command."""
-    flag_match = re.search(REPO_OVERRIDE_FLAG_PATTERN, command)
-    if flag_match is None:
-        return None
-    return flag_match.group("owner"), flag_match.group("repo").removesuffix(GIT_URL_SUFFIX)
-
-
-def _resolve_named_identity(
-    command: str, cwd: str | None
-) -> tuple[tuple[str, str] | None, int] | None:
-    """Resolve the repository the command names and its PR number.
-
-    A full PR URL yields both the (owner, repo) pair and the number. A
-    ``--repo``/``-R`` flag yields the pair while the number resolves from the
-    command's positional argument or the named repository's current-branch PR.
-    With neither present, the pair is None — leaving gh bound to the current
-    directory's repository — and the number resolves the same way. Every parse
-    runs over the ``gh pr ready`` segment alone, clipped at the next command
-    separator, so a flag or URL belonging to a chained command cannot bind the
-    gate to the wrong PR.
-
-    Args:
-        command: The raw shell command captured by the hook.
-        cwd: The working directory gh runs in when the number resolves from the
-            current branch, or None for the process default.
-
-    Returns:
-        The (owner, repo) pair the command names — None when it names none —
-        paired with the resolved PR number, or None when no number resolves.
-    """
-    ready_segment = _ready_command_segment(command)
-    pr_url_identity = _parse_pr_url(ready_segment)
-    if pr_url_identity is not None:
-        url_owner, url_repo, url_number = pr_url_identity
-        return (url_owner, url_repo), url_number
-    all_target_repo = _parse_repo_flag(ready_segment)
-    from_owner, from_repo = all_target_repo if all_target_repo is not None else (None, None)
-    resolved_pr_number = _resolve_pr_number(ready_segment, cwd, from_owner, from_repo)
-    if resolved_pr_number is None:
-        return None
-    return all_target_repo, resolved_pr_number
-
-
-def _resolve_target_identity(command: str, cwd: str | None) -> tuple[str, str, int] | None:
-    """Resolve the (owner, repo, pr_number) the gate keys its evidence to.
-
-    Delegates the repository-and-number resolution to the shared core, then
-    falls back to the cwd repository for the number when the command names no
-    repository of its own.
-    """
-    named_identity = _resolve_named_identity(command, cwd)
-    if named_identity is None:
-        return None
-    all_target_repo, pr_number = named_identity
-    if all_target_repo is not None:
-        owner, repo = all_target_repo
-        return owner, repo, pr_number
-
-    cwd_identity = _resolve_owner_repo(cwd)
-    if cwd_identity is None:
-        return None
-    cwd_owner, cwd_repo = cwd_identity
-    return cwd_owner, cwd_repo, pr_number
-
-
-def _repo_flag_arguments(all_target_repo: tuple[str, str] | None) -> list[str]:
-    """Build the ``--repo owner/repo`` arguments for a gh subcommand.
-
-    Args:
-        all_target_repo: The (owner, repo) pair the command names, or None when
-            the command names no repository.
-
-    Returns:
-        A ``[--repo, owner/repo]`` argument pair when a repository is named, or
-        an empty list when it is None — leaving gh bound to the current
-        directory's repository.
-    """
-    if all_target_repo is None:
-        return []
-    owner, repo = all_target_repo
-    return [GH_REPO_FLAG, REPO_SLUG_TEMPLATE.format(owner=owner, repo=repo)]
-
-
-def _resolve_current_branch_pr_number(
-    all_target_repo: tuple[str, str] | None, cwd: str | None
-) -> int | None:
-    """Resolve the current-branch PR number through ``gh pr view``.
-
-    Args:
-        all_target_repo: The (owner, repo) pair the command names, or None to
-            read the current directory's repository.
-        cwd: The working directory gh runs in, or None for the process default.
-
-    Returns:
-        The PR number gh reports, or None when gh is missing, exits non-zero,
-        or prints no integer — every failure path returns None so the caller
-        fails open.
-    """
-    all_view_arguments = [
-        *ALL_GH_PR_VIEW_NUMBER_COMMAND,
-        *_repo_flag_arguments(all_target_repo),
-    ]
-    try:
-        completed_process = subprocess.run(
-            all_view_arguments,
-            capture_output=True,
-            text=True,
-            cwd=cwd or None,
-            check=False,
-        )
-    except OSError:
-        return None
-    if completed_process.returncode != 0:
-        return None
-    try:
-        return int(completed_process.stdout.strip())
-    except (ValueError, TypeError):
-        return None
-
-
-def _resolve_pr_number(
-    command: str,
-    cwd: str | None,
-    from_owner: str | None,
-    from_repo: str | None,
-) -> int | None:
-    direct_number = _extract_pr_number_from_command(command)
-    if direct_number is not None:
-        return direct_number
-    if from_owner is not None and from_repo is not None:
-        all_target_repo: tuple[str, str] | None = (from_owner, from_repo)
-    else:
-        all_target_repo = None
-    return _resolve_current_branch_pr_number(all_target_repo, cwd)
-
-
-def _resolve_owner_repo(cwd: str | None) -> tuple[str, str] | None:
-    try:
-        completed_process = subprocess.run(
-            ["gh", "repo", "view", "--json", "owner,name", "--jq", ".owner.login,.name"],
-            capture_output=True,
-            text=True,
-            cwd=cwd or None,
-            check=False,
-        )
-    except OSError:
-        return None
-    if completed_process.returncode != 0:
-        return None
-    parts = completed_process.stdout.strip().splitlines()
-    if len(parts) <= 1:
-        match = re.match(
-            r"https://github\.com/([^/]+)/([^/]+?)(?:\.git)?$",
-            completed_process.stdout.strip(),
-        )
-        if match:
-            return match.group(1), match.group(2)
-        return None
-    return parts[0], parts[1]
-
-
-def _run_convergence_check(
-    script: str, owner: str, repo: str, pr_number: int, cwd: str | None
-) -> subprocess.CompletedProcess[str]:
-    return subprocess.run(
-        [
-            sys.executable,
-            script,
-            "--owner",
-            owner,
-            "--repo",
-            repo,
-            "--pr-number",
-            str(pr_number),
-        ],
-        capture_output=True,
-        text=True,
-        cwd=cwd or None,
-        check=False,
-    )
-
-
-def main() -> None:
-    check_convergence_script = str(
-        Path.home() / ".claude/skills/pr-converge/scripts/check_convergence.py"
-    )
-
-    if not Path(check_convergence_script).is_file():
-        sys.exit(0)
-
-    try:
-        hook_input = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        sys.exit(0)
-
-    tool_name = hook_input.get("tool_name", "")
-    if tool_name != "Bash":
-        sys.exit(0)
-
-    command = hook_input.get("tool_input", {}).get("command", "")
-    gh_pr_ready_pattern = re.compile(GH_PR_READY_ANCHOR_PATTERN)
-    if not gh_pr_ready_pattern.search(command):
-        sys.exit(0)
-
-    cwd = hook_input.get("cwd")
-    target_identity = _resolve_target_identity(command, cwd)
-    if target_identity is None:
-        sys.exit(0)
-    owner, repo, pr_number = target_identity
-
-    completed_process = _run_convergence_check(
-        check_convergence_script, owner, repo, pr_number, cwd
-    )
-
-    if completed_process.returncode in (0, 2):
-        sys.exit(0)
-
-    block_reason = (
-        "Convergence check failed — PR is not ready to mark ready:\n\n" + completed_process.stdout
-    )
-    deny_payload = {
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "permissionDecision": "deny",
-            "permissionDecisionReason": block_reason,
-        }
-    }
-    log_hook_block(
-        calling_hook_name="convergence_gate_blocker.py",
-        hook_event="PreToolUse",
-        block_reason=block_reason,
-        tool_name="Bash",
-    )
-    print(json.dumps(deny_payload))
-    sys.stdout.flush()
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/blocking/pr_converge_bugteam_enforcer.py

@@ -1,170 +0,0 @@
-#!/usr/bin/env python3
-"""PreToolUse hook: enforce formal bugteam Skill at Step 5 BUGTEAM ticks.
-
-The pr-converge loop's Step 5 BUGTEAM contract requires the formal
-``Skill({skill: "bugteam", args: "<PR URL>"})`` invocation per tick.
-Substituting an ad-hoc ``Agent({subagent_type: "clean-coder", ...})`` audit
-call returns a "converged" verdict without writing the artifact that
-``check_convergence.py``'s ``bugteam_clean_at`` gate reads, so the loop later
-hits ``gh pr ready`` and fails structurally with no formal review on the PR.
-
-The companion tracker hook
-(``pr_converge_bugteam_skill_tracker.py``) records every formal Skill
-invocation. This enforcer reads the recorded HEAD and tick and denies any
-clean-coder audit-shaped Agent call that has not first been preceded by the
-formal Skill at the same HEAD and tick.
-
-``qbug`` is NOT an accepted substitute; only the ``bugteam`` skill records
-the gate artifact, and the tracker deliberately ignores ``qbug`` invocations.
-"""
-
-from __future__ import annotations
-
-import json
-import sys
-from pathlib import Path
-from typing import TextIO
-
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-from hooks_constants.pr_converge_bugteam_enforcer_constants import (  # noqa: E402
-    AGENT_TOOL_NAME,
-    ALL_AUDIT_PROMPT_SUBSTRINGS,
-    BUGTEAM_PHASE,
-    CLEAN_CODER_SUBAGENT_TYPE,
-    ENFORCER_CORRECTIVE_MESSAGE,
-    STATE_FIELD_BUGTEAM_SKILL_INVOKED_AT_HEAD,
-    STATE_FIELD_BUGTEAM_SKILL_INVOKED_AT_TICK,
-    STATE_FIELD_CURRENT_HEAD,
-    STATE_FIELD_PHASE,
-    STATE_FIELD_TICK_COUNT,
-)
-from hooks_constants.pr_converge_bugteam_enforcer_state import (  # noqa: E402
-    load_state_dictionary,
-    resolve_state_path,
-)
-from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
-from hooks_constants.pre_tool_use_stdin import (  # noqa: E402
-    read_hook_input_dictionary_from_stdin,
-)
-
-
-def _prompt_is_audit_shaped(agent_prompt: str) -> bool:
-    """Return True when the Agent prompt looks like an audit substitute.
-
-    Args:
-        agent_prompt: The ``prompt`` field of the Agent tool_input.
-
-    Returns:
-        True when any audit-shaped substring appears in the prompt
-        (case-insensitive); False for fix-only or unrelated prompts.
-    """
-    lowercased_prompt = agent_prompt.lower()
-    return any(
-        each_substring in lowercased_prompt for each_substring in ALL_AUDIT_PROMPT_SUBSTRINGS
-    )
-
-
-def _has_formal_skill_fired_this_tick(state_by_field: dict[str, object]) -> bool:
-    """Return True when the bugteam Skill registered at current HEAD and tick.
-
-    Args:
-        state_by_field: Parsed pr-converge state.json mapping each field name
-            to its recorded value.
-
-    Returns:
-        True when both ``bugteam_skill_invoked_at_head`` matches
-        ``current_head`` and ``bugteam_skill_invoked_at_tick`` matches
-        ``tick_count``; False when either is missing, stale, or carries a
-        type that violates state-schema.md (head must be ``str``, tick must
-        be a non-bool ``int``) — type-invalid values fail closed so the
-        enforcer rejects corrupted state.
-    """
-    invoked_head = state_by_field.get(STATE_FIELD_BUGTEAM_SKILL_INVOKED_AT_HEAD)
-    current_head = state_by_field.get(STATE_FIELD_CURRENT_HEAD)
-    invoked_tick = state_by_field.get(STATE_FIELD_BUGTEAM_SKILL_INVOKED_AT_TICK)
-    current_tick = state_by_field.get(STATE_FIELD_TICK_COUNT)
-    if not isinstance(invoked_head, str) or not isinstance(current_head, str):
-        return False
-    if invoked_head != current_head:
-        return False
-    if isinstance(invoked_tick, bool) or isinstance(current_tick, bool):
-        return False
-    if not isinstance(invoked_tick, int) or not isinstance(current_tick, int):
-        return False
-    return invoked_tick == current_tick
-
-
-def _should_block(payload_by_field: dict[str, object]) -> bool:
-    """Return True when the Agent call is a BUGTEAM-phase Skill substitution.
-
-    Args:
-        payload_by_field: The full PreToolUse hook payload (already JSON-parsed),
-            keyed by top-level field name.
-
-    Returns:
-        True when every gating condition holds: tool is Agent, subagent_type
-        is clean-coder, prompt is audit-shaped, pr-converge state.json exists
-        with phase BUGTEAM, and the formal bugteam Skill has NOT been
-        recorded at the current HEAD and tick. False otherwise.
-    """
-    if payload_by_field.get("tool_name", "") != AGENT_TOOL_NAME:
-        return False
-    tool_input = payload_by_field.get("tool_input", {})
-    if not isinstance(tool_input, dict):
-        return False
-    if tool_input.get("subagent_type", "") != CLEAN_CODER_SUBAGENT_TYPE:
-        return False
-    agent_prompt = tool_input.get("prompt", "")
-    if not isinstance(agent_prompt, str):
-        return False
-    if not _prompt_is_audit_shaped(agent_prompt):
-        return False
-    state_path = resolve_state_path()
-    if state_path is None:
-        return False
-    parsed_state = load_state_dictionary(state_path)
-    if parsed_state is None:
-        return False
-    if parsed_state.get(STATE_FIELD_PHASE) != BUGTEAM_PHASE:
-        return False
-    return not _has_formal_skill_fired_this_tick(parsed_state)
-
-
-def _emit_deny_payload(output_stream: TextIO) -> None:
-    """Write the PreToolUse deny payload to the provided stream.
-
-    Args:
-        output_stream: Writable text stream — production code passes
-            ``sys.stdout``; tests pass a ``StringIO`` to capture the JSON.
-    """
-    deny_payload = {
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "permissionDecision": "deny",
-            "permissionDecisionReason": ENFORCER_CORRECTIVE_MESSAGE,
-        }
-    }
-    log_hook_block(
-        calling_hook_name="pr_converge_bugteam_enforcer.py",
-        hook_event="PreToolUse",
-        block_reason=ENFORCER_CORRECTIVE_MESSAGE,
-    )
-    output_stream.write(json.dumps(deny_payload) + "\n")
-    output_stream.flush()
-
-
-def main() -> None:
-    hook_payload = read_hook_input_dictionary_from_stdin()
-    if hook_payload is None:
-        sys.exit(0)
-    if not _should_block(hook_payload):
-        sys.exit(0)
-    _emit_deny_payload(sys.stdout)
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/blocking/pr_description_body_audit.py

@@ -1,148 +0,0 @@
-"""Audit PR body markdown for prose substance, shape, and structural rules.
-
-Strips Markdown ceremony to measure substantive prose, classifies the body as
-trivial, standard, or heavy, enumerates section headers, prepares the prose
-scanned for vague language, and flags self-closing references to the PR's own
-number and the discouraged "This PR ..." opening. Vague-language enforcement
-runs in validate_pr_body in pr_description_enforcer.py.
-"""
-
-import re
-import sys
-from pathlib import Path
-
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-from hooks_constants.pr_description_enforcer_constants import (  # noqa: E402
-    BLOCKQUOTE_LINE_PATTERN,
-    BLOCKQUOTE_MARKER_PATTERN,
-    BOLD_PAIR_PATTERN,
-    BULLET_MARKER_PATTERN,
-    FENCED_CODE_BLOCK_PATTERN,
-    HEADING_LINE_PATTERN,
-    HEAVY_MIN_BODY_CHARS_FOR_CLASSIFICATION,
-    HEAVY_SHAPE,
-    INLINE_CODE_PATTERN,
-    LINK_TEXT_PATTERN,
-    SELF_REFERENCE_PATTERN_TEMPLATE,
-    STANDARD_SHAPE,
-    TABLE_ROW_LINE_PATTERN,
-    THIS_PR_OPENING_PATTERN,
-    TRIVIAL_BODY_CHAR_THRESHOLD,
-    TRIVIAL_SHAPE,
-    WHITESPACE_RUN_PATTERN,
-)
-
-
-def strip_markdown_ceremony(body: str) -> str:
-    """Return the body with Markdown ceremony stripped to leave underlying prose.
-
-    Removes fenced code, inline code, heading lines, blockquote markers,
-    bullet list markers, bold/emphasis markers, and Markdown link targets.
-    Whitespace is preserved so callers can collapse or measure it as needed.
-    """
-    body_without_fences = FENCED_CODE_BLOCK_PATTERN.sub("", body)
-    body_without_inline_code = INLINE_CODE_PATTERN.sub("", body_without_fences)
-    body_without_blockquotes = BLOCKQUOTE_MARKER_PATTERN.sub("", body_without_inline_code)
-    body_without_headings = HEADING_LINE_PATTERN.sub("", body_without_blockquotes)
-    body_without_bullets = BULLET_MARKER_PATTERN.sub("", body_without_headings)
-    body_without_bold = BOLD_PAIR_PATTERN.sub(r"\1", body_without_bullets)
-    body_without_emphasis = body_without_bold.replace("*", "")
-    body_without_links = LINK_TEXT_PATTERN.sub(r"\1", body_without_emphasis)
-    return body_without_links
-
-
-def _count_substantive_prose_chars(body: str) -> int:
-    """Return the count of prose characters after stripping Markdown ceremony.
-
-    Collapses internal whitespace so a body of only headers and bullets --
-    no real WHY paragraph -- registers as effectively empty.
-    """
-    stripped_body = strip_markdown_ceremony(body)
-    body_collapsed = WHITESPACE_RUN_PATTERN.sub(" ", stripped_body).strip()
-    return len(body_collapsed)
-
-
-def _extract_vague_scan_text(body: str) -> str:
-    """Return the prose to scan for vague language, with non-prose regions removed.
-
-    Drops whole blockquote lines and whole pipe-delimited table rows, then strips
-    the same Markdown ceremony as the prose-count path -- which removes fenced
-    code, inline code, and whole heading lines. This exempts vague phrases that
-    appear only inside code fences, inline code, Markdown headings, quoted
-    reviewer text, or pipe-delimited example tables -- those are not the author's
-    own prose. A pipe-delimited row carries at least two pipes; a line with a
-    single leading pipe, or a borderless table row with no leading pipe, stays in
-    scope.
-    """
-    without_blockquote_lines = BLOCKQUOTE_LINE_PATTERN.sub("", body)
-    without_table_rows = TABLE_ROW_LINE_PATTERN.sub("", without_blockquote_lines)
-    return strip_markdown_ceremony(without_table_rows)
-
-
-def _iter_section_headers(body: str) -> list[str]:
-    """Return every ATX heading line in the body, preserving canonical form.
-
-    HEADING_LINE_PATTERN matches the leading hash run (one or more hash
-    characters at line start), so the result spans every ATX level.
-    Downstream callers in this module only test specific two-hash header
-    strings, so matching every heading level keeps the parser permissive
-    without changing behaviour for the canonical two-hash header shape.
-
-    Fenced code blocks are stripped first so example markdown nested inside ``` fences
-    (a PR body that demonstrates the Heavy shape, for instance) is not counted as a
-    structural header. This keeps the shape classifier and Heavy required-header check
-    aligned with `strip_markdown_ceremony`, which already strips fences before measuring.
-    """
-    body_without_fences = FENCED_CODE_BLOCK_PATTERN.sub("", body)
-    all_headers: list[str] = []
-    for each_match in HEADING_LINE_PATTERN.finditer(body_without_fences):
-        header_text = each_match.group(0).strip()
-        all_headers.append(header_text)
-    return all_headers
-
-
-def _compute_pr_body_shape(body: str) -> str:
-    """Classify a PR body as `trivial`, `standard`, or `heavy` from content alone.
-
-    Uses substantive prose chars (post-Markdown-strip) rather than raw length so the
-    classifier and the ceremony-on-Trivial check both measure the same metric against
-    TRIVIAL_BODY_CHAR_THRESHOLD; otherwise a body can be classified Standard by shape
-    while simultaneously being flagged as Trivial-sized by the ceremony check.
-    """
-    substantive_length = _count_substantive_prose_chars(body)
-    header_count = len(_iter_section_headers(body))
-
-    if substantive_length < TRIVIAL_BODY_CHAR_THRESHOLD and header_count == 0:
-        return TRIVIAL_SHAPE
-
-    if substantive_length >= HEAVY_MIN_BODY_CHARS_FOR_CLASSIFICATION:
-        return HEAVY_SHAPE
-
-    return STANDARD_SHAPE
-
-
-def _body_contains_any_header(body: str, all_candidate_headers: frozenset[str]) -> bool:
-    body_headers_lower = {each_header.lower() for each_header in _iter_section_headers(body)}
-    for each_candidate in all_candidate_headers:
-        candidate_lower = each_candidate.lower()
-        for each_present in body_headers_lower:
-            if each_present == candidate_lower:
-                return True
-            if each_present.startswith(candidate_lower):
-                character_after_candidate = each_present[len(candidate_lower)]
-                if not (character_after_candidate.isalnum() or character_after_candidate == "_"):
-                    return True
-    return False
-
-
-def _matches_self_closing_reference(body: str, pr_number: int) -> bool:
-    pattern_source = SELF_REFERENCE_PATTERN_TEMPLATE.format(pr_number=pr_number)
-    compiled_pattern = re.compile(pattern_source, re.IGNORECASE)
-    return compiled_pattern.search(body) is not None
-
-
-def _opens_with_this_pr_phrase(body: str) -> bool:
-    return THIS_PR_OPENING_PATTERN.search(body) is not None