claude-dev-env 2.32.0 → 2.33.0

package/hooks/blocking/code_rules_comments.py

@@ -1,10 +1,14 @@
 """Comment-presence and comment-change checks for Python and JavaScript sources."""
 
+import difflib
+import importlib
 import io
 import sys
 import tokenize
+from collections import Counter
 from collections.abc import Iterator
 from pathlib import Path
+from typing import cast
 
 _blocking_directory = str(Path(__file__).resolve().parent)
 _hooks_directory = str(Path(__file__).resolve().parent.parent)
@@ -20,7 +24,6 @@ from code_rules_shared import (  # noqa: E402
 from hooks_constants.code_rules_enforcer_constants import (  # noqa: E402
     ALL_FREE_FORM_EXEMPT_COMMENT_BODIES,
     ALL_JAVASCRIPT_EXEMPT_COMMENT_PREFIXES,
-    ALL_JAVASCRIPT_EXEMPT_INLINE_COMMENT_PREFIXES,
     ALL_JAVASCRIPT_EXTENSIONS,
     ALL_PYTHON_EXTENSIONS,
     ALL_PYTHON_TOKENIZE_FAILURE_EXCEPTIONS,
@@ -29,6 +32,10 @@ from hooks_constants.code_rules_enforcer_constants import (  # noqa: E402
     CHAINED_INLINE_COMMENT_PATTERN,
     MAX_COMMENT_ISSUES,
 )
+_javascript_comment_scanner = importlib.import_module("javascript_comment_scanner")
+extract_javascript_comment_occurrences = (
+    _javascript_comment_scanner.extract_javascript_comment_occurrences
+)
 
 
 def check_comments_python(content: str) -> list[str]:
@@ -93,7 +100,9 @@ def check_comments_javascript(content: str) -> list[str]:
     return issues
 
 
-def extract_comment_texts(content: str, file_path: str) -> tuple[set[str], set[str]]:
+def extract_comment_texts(
+    content: str, file_path: str, include_directive_comments: bool = False
+) -> tuple[set[str], set[str]]:
     """Extract normalized comment text strings from content for comparison.
 
     Returns:
@@ -108,46 +117,58 @@ def extract_comment_texts(content: str, file_path: str) -> tuple[set[str], set[s
         return inline_comments, standalone_comments
 
     if extension in ALL_PYTHON_EXTENSIONS:
-        inline_comments, standalone_comments, _ = _extract_python_comment_sets(content)
+        inline_comments, standalone_comments, _ = _extract_python_comment_sets(
+            content, include_directive_comments
+        )
         return inline_comments, standalone_comments
 
-    lines = content.split("\n")
-
     if extension in ALL_JAVASCRIPT_EXTENSIONS:
-        is_in_multiline = False
-        for each_line in lines:
-            stripped = each_line.strip()
-            if not stripped:
-                continue
-            if is_in_multiline:
-                if "*/" in stripped:
-                    is_in_multiline = False
-                continue
-            if stripped.startswith("/*"):
-                is_in_multiline = "*/" not in stripped
-                if not stripped.startswith("/**"):
-                    standalone_comments.add(stripped)
-                continue
-            if stripped.startswith("//"):
-                if not stripped.startswith(ALL_JAVASCRIPT_EXEMPT_COMMENT_PREFIXES):
-                    standalone_comments.add(stripped)
-            elif "//" in each_line:
-                before_slash = each_line[:each_line.index("//")]
-                if before_slash.strip():
-                    comment_start = stripped.index("//")
-                    comment_text = stripped[comment_start + 2 :].strip()
-                    if not comment_text.startswith(ALL_JAVASCRIPT_EXEMPT_INLINE_COMMENT_PREFIXES):
-                        inline_comments.add(stripped[comment_start:])
+        all_occurrences: list[tuple[str, int, bool]] = cast(
+            list[tuple[str, int, bool]],
+            extract_javascript_comment_occurrences(content, include_directive_comments),
+        )
+        inline_comments = {
+            each_text
+            for each_text, _each_line_number, is_inline in all_occurrences
+            if is_inline
+        }
+        standalone_comments = {
+            each_text
+            for each_text, _each_line_number, is_inline in all_occurrences
+            if not is_inline
+        }
 
     return inline_comments, standalone_comments
 
 
+def _python_comment_occurrences(
+    content: str,
+) -> tuple[list[tuple[str, int, bool]], bool]:
+    """Return Python comments with exact lines and a tokenize status."""
+    source_lines = content.split("\n")
+    try:
+        all_tokens = list(_python_tokens(content))
+    except ALL_PYTHON_TOKENIZE_FAILURE_EXCEPTIONS:
+        return [], False
+    all_occurrences: list[tuple[str, int, bool]] = []
+    for each_token in all_tokens:
+        if each_token.type != tokenize.COMMENT:
+            continue
+        if each_token.string.startswith("#!") and each_token.start == (1, 0):
+            continue
+        source_line = source_lines[each_token.start[0] - 1]
+        is_inline = bool(source_line[: each_token.start[1]].strip())
+        all_occurrences.append(
+            (each_token.string.strip(), each_token.start[0], is_inline)
+        )
+    return all_occurrences, True
+
+
 def check_comment_changes(old_content: str, new_content: str, file_path: str) -> list[str]:
     """Check for comment additions or removals between old and new content.
 
-    Inline comments (after code on same line): BLOCK when added.
-    Standalone comment lines: NUDGE (print advisory) when added.
-    Existing comments being removed: NUDGE (print advisory) — comment preservation is advisory.
+    Inline and standalone comments are blocking findings when added.
+    Existing comments can be removed when the touched code no longer needs them.
 
     When the file is Python and either *old_content* or *new_content* cannot
     be tokenized (common for mid-edit Edit fragments), the comparison is
@@ -161,38 +182,71 @@ def check_comment_changes(old_content: str, new_content: str, file_path: str) ->
 
     extension = get_file_extension(file_path)
     if extension in ALL_PYTHON_EXTENSIONS:
-        old_inline, old_standalone, old_tokenize_ok = _extract_python_comment_sets(old_content)
-        new_inline, new_standalone, new_tokenize_ok = _extract_python_comment_sets(new_content)
+        old_occurrences, old_tokenize_ok = _python_comment_occurrences(old_content)
+        new_occurrences, new_tokenize_ok = _python_comment_occurrences(new_content)
         if not (old_tokenize_ok and new_tokenize_ok):
             return issues
     else:
-        old_inline, old_standalone = extract_comment_texts(old_content, file_path)
-        new_inline, new_standalone = extract_comment_texts(new_content, file_path)
-
-    added_inline = new_inline - old_inline
-    if added_inline:
-        sample = next(iter(added_inline))
-        issues.append(f"Inline comment added: {sample[:60]} - refactor to self-documenting code")
-
-    added_standalone = new_standalone - old_standalone
-    if added_standalone:
-        sample = next(iter(added_standalone))
-        print(f"[CODE_RULES advisory] Standalone comment added: {sample[:60]} - prefer self-documenting code", file=sys.stderr)
-
-    all_old = old_inline | old_standalone
-    all_new = new_inline | new_standalone
-    removed_comments = all_old - all_new
-    if removed_comments:
-        old_line_count = len([line for line in old_content.split("\n") if line.strip()])
-        new_line_count = len([line for line in new_content.split("\n") if line.strip()])
-        code_was_removed = new_line_count < old_line_count - len(removed_comments)
-        if not code_was_removed:
-            sample = next(iter(removed_comments))
-            print(f"[CODE_RULES advisory] Existing comment removed: {sample[:60]} - comment preservation is advisory", file=sys.stderr)
+        old_occurrences = extract_javascript_comment_occurrences(old_content, True)
+        new_occurrences = extract_javascript_comment_occurrences(new_content, True)
+
+    old_occurrence_counts = Counter(
+        (each_text, is_inline)
+        for each_text, _line_number, is_inline in old_occurrences
+    )
+    seen_occurrence_counts: Counter[tuple[str, bool]] = Counter()
+    for each_text, each_line_number, each_is_inline in new_occurrences:
+        occurrence_key = (each_text, each_is_inline)
+        if seen_occurrence_counts[occurrence_key] >= old_occurrence_counts[occurrence_key]:
+            comment_kind = "Inline" if each_is_inline else "Standalone"
+            issues.append(
+                f"Line {each_line_number}: {comment_kind} comment added: "
+                f"{each_text[:60]} - refactor to self-documenting code"
+            )
+        seen_occurrence_counts[occurrence_key] += 1
+        if len(issues) >= MAX_COMMENT_ISSUES:
+            break
+    issues.extend(_retained_comment_issues(old_content, new_content, file_path))
 
     return issues
 
 
+def _changed_line_numbers(old_content: str, new_content: str) -> set[int]:
+    matcher = difflib.SequenceMatcher(
+        None, old_content.splitlines(), new_content.splitlines(), autojunk=False
+    )
+    return {
+        each_line_number
+        for each_tag, _, _, each_new_start, each_new_end in matcher.get_opcodes()
+        if each_tag != "equal"
+        for each_line_number in range(each_new_start + 1, each_new_end + 1)
+    }
+
+
+def _retained_comment_issues(
+    old_content: str, new_content: str, file_path: str
+) -> list[str]:
+    old_inline, old_standalone = extract_comment_texts(old_content, file_path, True)
+    new_inline, new_standalone = extract_comment_texts(new_content, file_path, True)
+    shared_inline = set(Counter(old_inline) & Counter(new_inline))
+    shared_standalone = old_standalone & new_standalone
+    if not shared_inline and not shared_standalone:
+        return []
+    changed_lines = _changed_line_numbers(old_content, new_content)
+    new_lines = new_content.splitlines()
+    issues: list[str] = []
+    for each_line_number in sorted(changed_lines):
+        inline_comment = next((each_comment for each_comment in shared_inline if each_comment in new_lines[each_line_number - 1]), None)
+        if inline_comment is not None:
+            issues.append(f"Line {each_line_number}: Inline comment retained on changed code: {inline_comment} - remove the comment")
+        preceding_line_number = each_line_number - 1
+        if preceding_line_number > 0 and new_lines[preceding_line_number - 1].strip() in shared_standalone:
+            issues.append(f"Line {each_line_number}: Standalone comment retained on changed code at line {preceding_line_number}: {new_lines[preceding_line_number - 1].strip()} - remove the comment")
+        if len(issues) >= MAX_COMMENT_ISSUES:
+            break
+    return issues[:MAX_COMMENT_ISSUES]
+
+
 def _python_tokens(source: str) -> Iterator[tokenize.TokenInfo]:
     """Yield Python tokens from *source* one at a time.
 
@@ -304,7 +358,9 @@ def _starts_with_bounded_token_anchored_directive(directive_body: str) -> bool:
     return False
 
 
-def _extract_python_comment_sets(content: str) -> tuple[set[str], set[str], bool]:
+def _extract_python_comment_sets(
+    content: str, include_directive_comments: bool = False
+) -> tuple[set[str], set[str], bool]:
     """Return (inline_comments, standalone_comments, tokenize_succeeded).
 
     Streams *content* once via ``_python_tokens``. A tokenize failure
@@ -321,7 +377,10 @@ def _extract_python_comment_sets(content: str) -> tuple[set[str], set[str], bool
         for each_token in _python_tokens(content):
             if each_token.type != tokenize.COMMENT:
                 continue
-            if _is_exempt_python_comment(each_token):
+            is_shebang = each_token.string.startswith("#!") and each_token.start == (1, 0)
+            if is_shebang or (
+                not include_directive_comments and _is_exempt_python_comment(each_token)
+            ):
                 continue
             line_number = each_token.start[0]
             column_offset = each_token.start[1]

package/hooks/blocking/code_rules_enforcer.py

@@ -196,6 +196,8 @@ from hooks_constants.subprocess_budget_completeness_content import (  # noqa: E4
     existing_file_content,
 )
 
+__all__ = ("is_test_file",)
+
 
 def _multiedit_post_edit_view(
     file_path: str, all_tool_input: dict[str, object]
@@ -234,6 +236,7 @@ class _ValidationContext(NamedTuple):
     defer_scope_to_caller: bool
     sibling_directory: Path | None
     phase: str
+    include_comment_policy: bool = True
 
 
 def _validated_phase(phase: str) -> str:
@@ -325,7 +328,7 @@ def _python_comment_and_logging_issues(context: _ValidationContext) -> list[str]
         context.file_path,
     )
     all_issues: list[str] = []
-    if not is_test_file(file_path):
+    if context.phase == FULL_GATE_PHASE and context.include_comment_policy:
         all_issues.extend(check_comment_changes(old_content, content, file_path))
     all_issues.extend(check_imports_at_top(content))
     all_issues.extend(check_logging_fstrings(content))
@@ -366,7 +369,15 @@ def _python_duplicate_body_and_banned_issues(context: _ValidationContext) -> lis
     all_issues = check_same_file_inline_duplicate_body(
         effective_content, file_path, changed, defer
     )
-    all_issues.extend(check_type_escape_hatches(effective_content, file_path))
+    all_issues.extend(
+        check_type_escape_hatches(
+            effective_content,
+            file_path,
+            include_type_ignore_comments=(
+                context.phase == FULL_GATE_PHASE and context.include_comment_policy
+            ),
+        )
+    )
     all_issues.extend(
         check_banned_identifiers(effective_content, file_path, changed, defer)
     )
@@ -576,7 +587,7 @@ def _javascript_comment_and_naming_issues(context: _ValidationContext) -> list[s
         context.file_path,
     )
     all_issues: list[str] = []
-    if not is_test_file(file_path):
+    if context.phase == FULL_GATE_PHASE and context.include_comment_policy:
         all_issues.extend(check_comment_changes(old_content, content, file_path))
     all_issues.extend(check_e2e_test_naming(content, file_path))
     all_issues.extend(
@@ -642,6 +653,7 @@ def validate_content_for_phase(
     sibling_directory: Path | None = None,
     *,
     phase: str,
+    include_comment_policy: bool = True,
 ) -> list[str]:
     """Run all applicable validators on content for one named validation phase."""
     validated_phase = _validated_phase(phase)
@@ -649,10 +661,7 @@ def validate_content_for_phase(
     effective_content, all_changed_lines = _effective_content_and_changed_lines(
         content, full_file_content, prior_full_file_content
     )
-    context = _ValidationContext(
-        content, old_content, effective_content, file_path, all_changed_lines,
-        defer_scope_to_caller, sibling_directory, validated_phase,
-    )
+    context = _ValidationContext(content, old_content, effective_content, file_path, all_changed_lines, defer_scope_to_caller, sibling_directory, validated_phase, include_comment_policy)
     all_issues: list[str] = []
     if extension in ALL_PYTHON_EXTENSIONS:
         all_issues = _python_extension_issues(context)
@@ -693,6 +702,8 @@ def validate_content_for_full_gate(
     prior_full_file_content: str = "",
     defer_scope_to_caller: bool = False,
     sibling_directory: Path | None = None,
+    *,
+    include_comment_policy: bool = True,
 ) -> list[str]:
     """Run the full-gate phase, including the six checks that read sibling files."""
     return validate_content_for_phase(
@@ -704,6 +715,7 @@ def validate_content_for_full_gate(
         defer_scope_to_caller,
         sibling_directory,
         phase=FULL_GATE_PHASE,
+        include_comment_policy=include_comment_policy,
     )
 
 

package/hooks/blocking/code_rules_type_escape.py

@@ -79,23 +79,13 @@ def _find_any_annotation_lines(source: str) -> list[int]:
     return offending_line_numbers
 
 
-def _find_unjustified_type_ignore_lines(source: str) -> list[int]:
-    """Return line numbers of # type: ignore comments lacking a trailing reason."""
+def _find_type_ignore_lines(source: str) -> list[int]:
+    """Return line numbers of all type-ignore comments."""
     ignore_pattern = re.compile(r"#\s*type:\s*ignore(?:\[[^\]]*\])?(.*)$")
-    minimum_justification_characters = len("xxxxx")
     offending_line_numbers: list[int] = []
     for each_comment_token in _comment_tokens(source):
-        matched = ignore_pattern.search(each_comment_token.string)
-        if not matched:
-            continue
-        line_number = each_comment_token.start[0]
-        trailing_text = matched.group(1).strip()
-        if not trailing_text.startswith("#"):
-            offending_line_numbers.append(line_number)
-            continue
-        justification_text = trailing_text.lstrip("#").strip()
-        if len(justification_text) < minimum_justification_characters:
-            offending_line_numbers.append(line_number)
+        if ignore_pattern.search(each_comment_token.string):
+            offending_line_numbers.append(each_comment_token.start[0])
     return offending_line_numbers
 
 
@@ -625,12 +615,20 @@ def _find_object_annotated_parameter_lines(source: str) -> list[tuple[int, str]]
     return offending_parameters
 
 
-def check_type_escape_hatches(content: str, file_path: str) -> list[str]:
-    """Flag Any annotations, Any imports, cast() calls, object-typed dereferenced parameters, and unjustified # type: ignore."""
+def check_type_escape_hatches(
+    content: str, file_path: str, include_type_ignore_comments: bool = True
+) -> list[str]:
+    """Flag type escape hatches and every type-ignore comment."""
+    issues: list[str] = []
+    type_ignore_issues: list[str] = []
+    if include_type_ignore_comments:
+        for each_ignore_line in _find_type_ignore_lines(content):
+            type_ignore_issues.append(
+                f"Line {each_ignore_line}: # type: ignore is not allowed - remove it and use a typed boundary or real type"
+            )
     if is_test_file(file_path) or is_hook_infrastructure(file_path):
-        return []
+        return type_ignore_issues
 
-    issues: list[str] = []
     is_any_exempt = _file_path_matches_any_exemption(file_path)
 
     if not is_any_exempt:
@@ -670,11 +668,6 @@ def check_type_escape_hatches(content: str, file_path: str) -> list[str]:
             )
         issues.extend(object_parameter_issues[:MAX_TYPE_ESCAPE_HATCH_ISSUES])
 
-    type_ignore_issues: list[str] = []
-    for each_ignore_line in _find_unjustified_type_ignore_lines(content):
-        type_ignore_issues.append(
-            f"Line {each_ignore_line}: Unjustified # type: ignore - add trailing '# reason' explaining why"
-        )
     issues.extend(type_ignore_issues[:MAX_TYPE_ESCAPE_HATCH_ISSUES])
 
     return issues

package/hooks/blocking/javascript_comment_scanner.py

@@ -0,0 +1,99 @@
+"""Extract JavaScript comments without matching comment-like strings."""
+
+import io
+import re
+import tokenize
+from typing import NamedTuple
+
+from hooks_constants.code_rules_enforcer_constants import (
+    ALL_JAVASCRIPT_EXEMPT_COMMENT_PREFIXES,
+    ALL_JAVASCRIPT_EXEMPT_INLINE_COMMENT_PREFIXES,
+    ALL_PYTHON_TOKENIZE_FAILURE_EXCEPTIONS,
+)
+
+
+class JavaScriptCommentOccurrence(NamedTuple):
+    """One JavaScript comment with its source line and placement."""
+
+    text: str
+    line_number: int
+    is_inline: bool
+
+
+def _mask_javascript_strings(content: str) -> str:
+    """Replace quoted JavaScript strings while preserving source positions."""
+    string_pattern = r'''("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`)'''
+    return re.sub(
+        string_pattern,
+        lambda each_match: "".join(
+            "\n" if each_character == "\n" else " "
+            for each_character in each_match.group()
+        ),
+        content,
+        flags=re.DOTALL,
+    )
+
+
+def _is_allowed_comment(
+    comment_text: str, is_inline: bool, include_directive_comments: bool
+) -> bool:
+    """Return whether a comment is excluded from the policy comparison."""
+    if comment_text.startswith("/**"):
+        return True
+    if include_directive_comments:
+        return False
+    prefixes = (
+        ALL_JAVASCRIPT_EXEMPT_INLINE_COMMENT_PREFIXES
+        if is_inline
+        else ALL_JAVASCRIPT_EXEMPT_COMMENT_PREFIXES
+    )
+    comment_body = (
+        comment_text.removeprefix("//").lstrip()
+        if comment_text.startswith("//")
+        else comment_text
+    )
+    return comment_body.startswith(prefixes)
+
+
+def extract_javascript_comment_occurrences(
+    content: str, include_directive_comments: bool
+) -> list[JavaScriptCommentOccurrence]:
+    """Return real JavaScript comment occurrences with exact line numbers."""
+    masked_content = _mask_javascript_strings(content)
+    all_occurrences: list[JavaScriptCommentOccurrence] = []
+    for each_match in re.finditer(r"//[^\n]*|/\*[\s\S]*?\*/", masked_content):
+        comment_text = content[each_match.start() : each_match.end()].strip()
+        line_start = masked_content.rfind("\n", 0, each_match.start()) + 1
+        is_inline = bool(masked_content[line_start : each_match.start()].strip())
+        if _is_allowed_comment(comment_text, is_inline, include_directive_comments):
+            continue
+        line_number = content.count("\n", 0, each_match.start()) + 1
+        all_occurrences.append(
+            JavaScriptCommentOccurrence(comment_text, line_number, is_inline)
+        )
+    return all_occurrences
+
+
+def extract_python_comment_occurrences(
+    content: str,
+) -> tuple[list[JavaScriptCommentOccurrence], bool]:
+    """Return Python comments with exact lines and a tokenize status."""
+    source_lines = content.split("\n")
+    try:
+        all_tokens = list(tokenize.generate_tokens(io.StringIO(content).readline))
+    except ALL_PYTHON_TOKENIZE_FAILURE_EXCEPTIONS:
+        return [], False
+    all_occurrences: list[JavaScriptCommentOccurrence] = []
+    for each_token in all_tokens:
+        if each_token.type != tokenize.COMMENT:
+            continue
+        if each_token.string.startswith("#!") and each_token.start == (1, 0):
+            continue
+        source_line = source_lines[each_token.start[0] - 1]
+        is_inline = bool(source_line[: each_token.start[1]].strip())
+        all_occurrences.append(
+            JavaScriptCommentOccurrence(
+                each_token.string.strip(), each_token.start[0], is_inline
+            )
+        )
+    return all_occurrences, True

package/hooks/blocking/test_code_rules_enforcer_any_type_ignore.py

@@ -56,6 +56,7 @@ def test_should_flag_bare_type_ignore() -> None:
     source = "x = 1  # type: ignore\n"
     issues = check_type_escape_hatches(source, PRODUCTION_FILE_PATH)
     assert any("type: ignore" in issue for issue in issues)
+    assert any("remove it and use a typed boundary or real type" in issue for issue in issues)
 
 
 def test_should_flag_coded_type_ignore_without_justification() -> None:
@@ -64,16 +65,35 @@ def test_should_flag_coded_type_ignore_without_justification() -> None:
     assert any("type: ignore" in issue for issue in issues)
 
 
-def test_should_allow_justified_type_ignore() -> None:
+def test_should_flag_justified_type_ignore() -> None:
     source = "x = 1  # type: ignore[misc]  # stubs missing in foo library\n"
     issues = check_type_escape_hatches(source, PRODUCTION_FILE_PATH)
-    assert not any("type: ignore" in issue for issue in issues)
+    assert any("type: ignore" in issue for issue in issues)
+
+
+def test_should_flag_justified_type_ignore_in_test_files() -> None:
+    source = "x = 1  # type: ignore[misc]  # stubs missing in foo library\n"
+    issues = check_type_escape_hatches(source, TEST_FILE_PATH)
+    assert any("type: ignore" in issue for issue in issues)
 
 
-def test_should_skip_test_files() -> None:
+def test_should_flag_type_ignore_in_test_files() -> None:
     source = "def foo(x: Any) -> Any:\n    y: Any = 1  # type: ignore\n    return y\n"
     issues = check_type_escape_hatches(source, TEST_FILE_PATH)
-    assert issues == []
+    assert any("type: ignore" in issue for issue in issues)
+    assert not any("Any annotation" in issue for issue in issues)
+
+
+def test_edit_lane_does_not_report_type_ignore_comment_policy() -> None:
+    source = "total = 1  # type: ignore[misc]\n"
+    issues = hook_module.validate_content_for_edit_lane(source, TEST_FILE_PATH)
+    assert not any("type: ignore" in issue for issue in issues)
+
+
+def test_edit_lane_does_not_report_production_type_ignore_comment_policy() -> None:
+    source = "total = 1  # type: ignore[misc]\n"
+    issues = hook_module.validate_content_for_edit_lane(source, PRODUCTION_FILE_PATH)
+    assert not any("type: ignore" in issue for issue in issues)
 
 
 def test_should_flag_any_on_positional_only_parameter() -> None:

package/hooks/blocking/test_code_rules_enforcer_cap_meta.py

@@ -68,7 +68,6 @@ KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW: frozenset[str] = frozenset(
     {
         "check_boolean_naming",
         "check_collection_prefix",
-        "check_comment_changes",
         "check_constant_equality_tests",
         "check_constants_outside_config",
         "check_existence_check_tests",