claude-dev-env 1.23.1 → 1.25.0

package/hooks/blocking/code-rules-enforcer.py

@@ -10,13 +10,17 @@ Checks (blocking):
 5. Magic values (literals in function bodies)
 6. E2E test naming (no online/offline in test names)
 7. Constants outside config (UPPER_SNAKE = in non-config files)
+8. Boolean naming (is_/has_/should_/can_ prefix required)
 
 Advisory only (non-blocking):
 - File line count: stderr warning at 400 lines (soft) and 1000 lines (hard)
 """
+import ast
+import io
 import json
 import re
 import sys
+import tokenize
 from typing import Optional
 
 PYTHON_EXTENSIONS = {".py"}
@@ -24,14 +28,24 @@ JAVASCRIPT_EXTENSIONS = {".js", ".ts", ".tsx", ".jsx"}
 ALL_CODE_EXTENSIONS = PYTHON_EXTENSIONS | JAVASCRIPT_EXTENSIONS
 
 CONFIG_PATH_PATTERNS = {"config/", "config\\", "/config.", "\\config.", "settings.py"}
-TEST_PATH_PATTERNS = {"test_", "_test.", ".spec.", "conftest", "/tests/", "\\tests\\", "/tests.py", "\\tests.py"}
-HOOK_INFRASTRUCTURE_PATTERNS = {"/.claude/hooks/", "\\.claude\\hooks\\", "\\.claude/hooks/"}
+TEST_PATH_PATTERNS = {"test_", "_test.", ".test.", ".spec.", "/tests/", "\\tests\\", "/tests.py", "\\tests.py"}
+HOOK_INFRASTRUCTURE_PATTERNS = {"/.claude/hooks/", "\\.claude\\hooks\\", "\\.claude/hooks/", "/packages/claude-dev-env/hooks/", "\\packages\\claude-dev-env\\hooks\\"}
 WORKFLOW_REGISTRY_PATTERNS = {"/workflow/", "\\workflow\\", "_tab.py", "/states.py", "\\states.py", "/modules.py", "\\modules.py"}
 MIGRATION_PATH_PATTERNS = {"/migrations/", "\\migrations\\"}
 
 ADVISORY_LINE_THRESHOLD_SOFT = 400
 ADVISORY_LINE_THRESHOLD_HARD = 1000
 
+BOOLEAN_NAME_PREFIXES: tuple[str, ...] = ("is_", "has_", "should_", "can_")
+BOOLEAN_NAMING_ISSUE_CAP = 3
+UPPER_SNAKE_CONSTANT_PATTERN = re.compile(r"^[A-Z][A-Z0-9_]*$")
+
+
+TYPE_CHECKING_BLOCK_PATTERN = re.compile(r"^(?P<indent>\s*)if\s+(typing\.)?TYPE_CHECKING\s*:\s*$")
+IMPORT_STATEMENT_PREFIXES: tuple[str, ...] = ("import ", "from ")
+NOT_INSIDE_TYPE_CHECKING_BLOCK = -1
+MAX_ISSUES_PER_CHECK = 3
+
 
 def get_file_extension(file_path: str) -> str:
     """Extract lowercase file extension."""
@@ -56,6 +70,9 @@ def is_config_file(file_path: str) -> bool:
 def is_test_file(file_path: str) -> bool:
     """Check if file is a test file."""
     path_lower = file_path.lower()
+    basename_lower = path_lower.replace("\\", "/").rsplit("/", 1)[-1]
+    if basename_lower == "conftest.py":
+        return True
     return any(pattern in path_lower for pattern in TEST_PATH_PATTERNS)
 
 
@@ -265,43 +282,81 @@ def check_comment_changes(old_content: str, new_content: str, file_path: str) ->
 
 
 def check_imports_at_top(content: str) -> list[str]:
-    """Check for imports inside functions (Python only)."""
-    issues = []
+    """Check for imports inside functions (Python only).
+
+    An import lexically inside an ``if TYPE_CHECKING:`` block is exempt.
+    An import inside a function body is flagged even if the file uses TYPE_CHECKING
+    elsewhere at module scope.
+
+    Only the innermost ``if TYPE_CHECKING:`` block is tracked: a second, nested
+    ``if TYPE_CHECKING:`` header overwrites the outer block's indent so that when
+    control dedents back to the outer block's body, the tracker resets.
+
+    Known limitation: nested ``if TYPE_CHECKING:`` blocks are NOT supported. After
+    a nested inner block ends, subsequent lines at the OUTER block's body indent
+    are treated as outside any TYPE_CHECKING scope, so function-body imports there
+    WILL be flagged as violations even though they are lexically guarded by the
+    outer block. Rewrite to a single top-level ``if TYPE_CHECKING:`` block to avoid
+    this false positive. Nested TYPE_CHECKING blocks are rare in practice, so this
+    simpler single-level tracking is preferred over maintaining a stack of indent
+    levels. The pinned behavior is covered by
+    ``test_should_track_only_innermost_type_checking_block``.
+    """
+    issues: list[str] = []
     lines = content.split("\n")
     inside_function = False
     function_indent = 0
+    type_checking_block_indent = NOT_INSIDE_TYPE_CHECKING_BLOCK
 
-    for line_number, line in enumerate(lines, 1):
-        stripped = line.strip()
+    for line_number, each_line in enumerate(lines, 1):
+        stripped = each_line.strip()
 
         if not stripped:
             continue
 
-        func_match = re.match(r"^(\s*)(async\s+)?def\s+\w+", line)
-        if func_match:
+        current_indent = len(each_line) - len(each_line.lstrip())
+
+        if type_checking_block_indent != NOT_INSIDE_TYPE_CHECKING_BLOCK:
+            if current_indent <= type_checking_block_indent:
+                type_checking_block_indent = NOT_INSIDE_TYPE_CHECKING_BLOCK
+
+        type_checking_match = TYPE_CHECKING_BLOCK_PATTERN.match(each_line)
+        if type_checking_match:
+            type_checking_block_indent = len(type_checking_match.group("indent"))
+            continue
+
+        function_match = re.match(r"^(\s*)(async\s+)?def\s+\w+", each_line)
+        if function_match:
             inside_function = True
-            function_indent = len(func_match.group(1)) if func_match.group(1) else 0
+            function_indent = len(function_match.group(1)) if function_match.group(1) else 0
             continue
 
         if inside_function:
-            current_indent = len(line) - len(line.lstrip())
             if current_indent <= function_indent and stripped and not stripped.startswith(("#", "@", ")")):
                 inside_function = False
 
-        if inside_function:
-            if stripped.startswith(("import ", "from ")) and "TYPE_CHECKING" not in content[:500]:
+        is_inside_type_checking_block = type_checking_block_indent != NOT_INSIDE_TYPE_CHECKING_BLOCK
+        if inside_function and not is_inside_type_checking_block:
+            if stripped.startswith(IMPORT_STATEMENT_PREFIXES):
                 issues.append(f"Line {line_number}: Import inside function - move to top of file")
 
-        if len(issues) >= 3:
+        if len(issues) >= MAX_ISSUES_PER_CHECK:
             break
 
     return issues
 
 
+LOGGING_FSTRING_PATTERN = re.compile(
+    r'\b(?:log_(?:debug|info|warning|error|critical|exception)'
+    r'|(?:logger|logging|log)\.(?:debug|info|warning|error|critical|exception))'
+    r'\s*\(\s*(?:[rR][fF]|[fF][rR]?)["\']'
+)
+
+
 def check_logging_fstrings(content: str) -> list[str]:
     """Check for f-strings in logging calls."""
     issues = []
-    pattern = re.compile(r'\blog_(debug|info|warning|error|critical)\s*\(\s*f["\']')
+    pattern = LOGGING_FSTRING_PATTERN
 
     for line_number, line in enumerate(content.split("\n"), 1):
         if pattern.search(line):
@@ -361,7 +416,7 @@ def check_magic_values(content: str, file_path: str) -> list[str]:
     inside_function = False
 
     number_pattern = re.compile(r"(?<![.\w])(\d+\.?\d*)(?![.\w])")
-    allowed_numbers = {"0", "1", "-1", "0.0", "1.0", "2", "100"}
+    allowed_numbers = {"0", "1", "-1", "0.0", "1.0"}
 
     for line_number, line in enumerate(lines, 1):
         stripped = line.strip()
@@ -400,6 +455,107 @@ def check_magic_values(content: str, file_path: str) -> list[str]:
     return issues
 
 
+def _extract_fstring_literal_parts(
+    joined_string_node: ast.JoinedStr,
+) -> tuple[str, str]:
+    """Return (display_body, shape_body) for an f-string node.
+
+    ``display_body`` concatenates only the literal segments for use in the
+    human-readable flag message. ``shape_body`` substitutes each interpolation
+    slot with the placeholder word ``INTERP`` so regex patterns for path
+    shape (``\\w+/\\w+/\\w+``) still match across interpolation boundaries
+    (e.g. ``/api/v1/{id}/home`` keeps its three path segments instead of
+    collapsing to ``/api/v1//home``). Escaped braces (``{{`` / ``}}``) are
+    already decoded by :mod:`ast` into their literal forms.
+    """
+    interpolation_placeholder = "INTERP"
+    display_segments: list[str] = []
+    shape_segments: list[str] = []
+    for each_part in joined_string_node.values:
+        if isinstance(each_part, ast.Constant) and isinstance(each_part.value, str):
+            display_segments.append(each_part.value)
+            shape_segments.append(each_part.value)
+        else:
+            shape_segments.append(interpolation_placeholder)
+    return "".join(display_segments), "".join(shape_segments)
+
+
+def _has_structural_shape(literal_body: str) -> bool:
+    """Return True when a literal body looks like a path, URL, or regex.
+
+    Natural English containing a single slash (e.g. ``online/offline``,
+    ``CI/CD``, ``and/or``) must NOT match. Only multi-segment paths,
+    URL schemes, Windows drive prefixes, leading absolute paths, regex
+    escape sequences (``\\d``, ``\\w``, ``\\s`` and friends), or regex
+    anchors at the boundary are treated as structural.
+    """
+    if re.search(r"\w+/\w+/\w+", literal_body):
+        return True
+    if re.search(r"\w+\\\w+\\\w+", literal_body):
+        return True
+    if re.search(r"[A-Za-z][A-Za-z0-9+.\-]*://", literal_body):
+        return True
+    if re.search(r"(^|\s)[A-Za-z]:[\\/]", literal_body):
+        return True
+    if re.search(r"^/\w+/\w+", literal_body):
+        return True
+    if re.search(r"\\[dwsDWSbBAZ]|\\\d", literal_body):
+        return True
+    if literal_body.startswith("^") or literal_body.endswith("$"):
+        return True
+    return False
+
+
+def check_fstring_structural_literals(content: str, file_path: str) -> list[str]:
+    """Flag f-strings whose literal fragments look like paths, URLs, or regex.
+
+    Parses the file with :mod:`ast` so every f-string form is handled
+    uniformly: single, triple-quoted, raw (``rf`` / ``fr``), and strings
+    containing apostrophes or escaped braces. The literal portions of
+    each ``JoinedStr`` node are concatenated, and the result is treated
+    as a structural magic value only when :func:`_has_structural_shape`
+    matches a multi-segment path, a URL scheme, a Windows drive prefix,
+    a leading absolute path, a regex escape sequence, or a boundary
+    regex anchor.
+
+    The enforcer hook file, config files, and test files are all exempt.
+    Syntax errors in the input silently produce no issues, matching the
+    behaviour of the other lint-style checks in this module.
+    """
+    if is_config_file(file_path) or is_test_file(file_path):
+        return []
+    if file_path.replace("\\", "/").endswith("hooks/blocking/code-rules-enforcer.py"):
+        return []
+
+    try:
+        syntax_tree = ast.parse(content)
+    except SyntaxError:
+        return []
+
+    minimum_literal_length = 2
+    maximum_issues_before_stop = 100
+    non_magic_stripped_values = {"", "True", "False"}
+
+    issues: list[str] = []
+    for each_node in ast.walk(syntax_tree):
+        if not isinstance(each_node, ast.JoinedStr):
+            continue
+        display_body, shape_body = _extract_fstring_literal_parts(each_node)
+        if display_body in non_magic_stripped_values:
+            continue
+        if len(display_body) < minimum_literal_length:
+            continue
+        if not _has_structural_shape(shape_body):
+            continue
+        issues.append(
+            f"Line {each_node.lineno}: Structural literal inside f-string {display_body!r} - extract to config"
+        )
+        if len(issues) >= maximum_issues_before_stop:
+            break
+
+    return issues
+
+
 def check_e2e_test_naming(content: str, file_path: str) -> list[str]:
     """Check for online/offline in test names (spec files only)."""
     if not is_spec_file(file_path):
@@ -418,6 +574,116 @@ def check_e2e_test_naming(content: str, file_path: str) -> list[str]:
     return issues
 
 
+def _render_annotation_source(annotation_node: ast.expr) -> str:
+    """Return a textual representation of an annotation AST node."""
+    unparse_function = getattr(ast, "unparse", None)
+    if unparse_function is not None:
+        return unparse_function(annotation_node)
+    sys.stderr.write(
+        "code-rules-enforcer: ast.unparse unavailable on this interpreter; "
+        "falling back to ast.dump for Any detection.\n"
+    )
+    return ast.dump(annotation_node)
+
+
+def _annotation_uses_any(annotation_node: Optional[ast.expr]) -> bool:
+    """Return True when an annotation AST node textually references Any."""
+    if annotation_node is None:
+        return False
+    annotation_source = _render_annotation_source(annotation_node)
+    return bool(re.search(r"\bAny\b", annotation_source))
+
+
+def _collect_annotated_arguments(function_node: ast.FunctionDef | ast.AsyncFunctionDef) -> list[ast.arg]:
+    """Return every argument node on a function that may carry an annotation."""
+    arguments = function_node.args
+    all_annotated_arguments: list[ast.arg] = []
+    all_annotated_arguments.extend(arguments.posonlyargs)
+    all_annotated_arguments.extend(arguments.args)
+    all_annotated_arguments.extend(arguments.kwonlyargs)
+    if arguments.vararg is not None:
+        all_annotated_arguments.append(arguments.vararg)
+    if arguments.kwarg is not None:
+        all_annotated_arguments.append(arguments.kwarg)
+    return all_annotated_arguments
+
+
+def _find_any_annotation_lines(source: str) -> list[int]:
+    """Return line numbers of annotations that textually reference Any."""
+    try:
+        parsed_tree = ast.parse(source)
+    except SyntaxError:
+        return []
+
+    offending_line_numbers: list[int] = []
+    already_reported_lines: set[int] = set()
+    for each_node in ast.walk(parsed_tree):
+        if isinstance(each_node, ast.AnnAssign) and _annotation_uses_any(each_node.annotation):
+            if each_node.lineno not in already_reported_lines:
+                offending_line_numbers.append(each_node.lineno)
+                already_reported_lines.add(each_node.lineno)
+            continue
+        if isinstance(each_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            if _annotation_uses_any(each_node.returns) and each_node.lineno not in already_reported_lines:
+                offending_line_numbers.append(each_node.lineno)
+                already_reported_lines.add(each_node.lineno)
+            for each_argument in _collect_annotated_arguments(each_node):
+                if _annotation_uses_any(each_argument.annotation) and each_argument.lineno not in already_reported_lines:
+                    offending_line_numbers.append(each_argument.lineno)
+                    already_reported_lines.add(each_argument.lineno)
+    return offending_line_numbers
+
+
+def _comment_tokens(source: str) -> list[tokenize.TokenInfo]:
+    """Return COMMENT tokens from source, or an empty list when tokenization fails."""
+    try:
+        return [
+            each_token
+            for each_token in tokenize.generate_tokens(io.StringIO(source).readline)
+            if each_token.type == tokenize.COMMENT
+        ]
+    except (tokenize.TokenError, IndentationError, SyntaxError):
+        return []
+
+
+def _find_unjustified_type_ignore_lines(source: str) -> list[int]:
+    """Return line numbers of # type: ignore comments lacking a trailing reason."""
+    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)
+    return offending_line_numbers
+
+
+def check_type_escape_hatches(content: str, file_path: str) -> list[str]:
+    """Flag Any annotations and unjustified # type: ignore comments."""
+    if is_test_file(file_path):
+        return []
+
+    issues: list[str] = []
+
+    for each_any_line in _find_any_annotation_lines(content):
+        issues.append(f"Line {each_any_line}: Any annotation - replace with explicit type")
+
+    for each_ignore_line in _find_unjustified_type_ignore_lines(content):
+        issues.append(
+            f"Line {each_ignore_line}: Unjustified # type: ignore - add trailing '# reason' explaining why"
+        )
+
+    return issues
+
+
 def is_migration_file(file_path: str) -> bool:
     """Check if file is a Django migration (must be self-contained)."""
     path_lower = file_path.lower().replace("\\", "/")
@@ -478,6 +744,211 @@ def check_constants_outside_config(content: str, file_path: str) -> list[str]:
     return issues
 
 
+BANNED_IDENTIFIERS: frozenset[str] = frozenset({"result", "data", "output", "response", "value", "item", "temp"})
+MAX_BANNED_IDENTIFIER_ISSUES: int = 3
+BANNED_IDENTIFIER_MESSAGE_SUFFIX: str = "use descriptive name (see CODE_RULES Naming section)"
+BANNED_IDENTIFIER_SKIP_ADVISORY: str = (
+    "banned-identifier check skipped: file did not parse as Python"
+)
+
+
+def _collect_banned_names_from_target(target: ast.expr) -> list[ast.Name]:
+    """Return every banned ast.Name reachable through tuple/list unpacking or starred targets."""
+    if isinstance(target, ast.Name):
+        if target.id in BANNED_IDENTIFIERS:
+            return [target]
+        return []
+    if isinstance(target, (ast.Tuple, ast.List)):
+        banned_names: list[ast.Name] = []
+        for each_element in target.elts:
+            banned_names.extend(_collect_banned_names_from_target(each_element))
+        return banned_names
+    if isinstance(target, ast.Starred):
+        return _collect_banned_names_from_target(target.value)
+    return []
+
+
+def _collect_banned_names_from_node(node: ast.AST) -> list[ast.Name]:
+    """Return banned ast.Name nodes introduced by a single binding construct."""
+    if isinstance(node, ast.Assign):
+        banned_names: list[ast.Name] = []
+        for each_target in node.targets:
+            banned_names.extend(_collect_banned_names_from_target(each_target))
+        return banned_names
+    if isinstance(node, ast.AnnAssign):
+        return _collect_banned_names_from_target(node.target)
+    if isinstance(node, (ast.For, ast.AsyncFor)):
+        return _collect_banned_names_from_target(node.target)
+    if isinstance(node, ast.comprehension):
+        return _collect_banned_names_from_target(node.target)
+    if isinstance(node, ast.withitem):
+        if node.optional_vars is None:
+            return []
+        return _collect_banned_names_from_target(node.optional_vars)
+    if isinstance(node, ast.NamedExpr):
+        return _collect_banned_names_from_target(node.target)
+    return []
+
+
+def check_banned_identifiers(content: str, file_path: str) -> list[str]:
+    """Flag assignments to identifiers banned by the project Naming rules."""
+    if is_test_file(file_path) or is_hook_infrastructure(file_path):
+        return []
+
+    try:
+        parsed_tree = ast.parse(content)
+    except SyntaxError:
+        print(f"{file_path}: {BANNED_IDENTIFIER_SKIP_ADVISORY}", file=sys.stderr)
+        return []
+
+    banned_name_nodes: list[ast.Name] = []
+    for each_node in ast.walk(parsed_tree):
+        banned_name_nodes.extend(_collect_banned_names_from_node(each_node))
+
+    banned_name_nodes.sort(key=lambda each_name: (each_name.lineno, each_name.col_offset))
+
+    issues: list[str] = []
+    for each_name in banned_name_nodes:
+        issues.append(
+            f"Line {each_name.lineno}: Banned identifier '{each_name.id}' - {BANNED_IDENTIFIER_MESSAGE_SUFFIX}"
+        )
+        if len(issues) >= MAX_BANNED_IDENTIFIER_ISSUES:
+            break
+
+    return issues
+
+
+def _is_bool_constant(node: ast.AST) -> bool:
+    return isinstance(node, ast.Constant) and isinstance(node.value, bool)
+
+
+def _rhs_names_if_all_bool(value_node: ast.AST, target_node: ast.AST) -> list[str]:
+    """Return names from a tuple assignment target when every RHS element is a bool constant.
+
+    Handles cases like `valid, permitted = True, False` where target is a Tuple
+    and value is a Tuple of bool constants. Returns empty list otherwise.
+    """
+    if not isinstance(target_node, ast.Tuple):
+        return []
+    if not isinstance(value_node, ast.Tuple):
+        return []
+    if len(target_node.elts) != len(value_node.elts):
+        return []
+    if not all(_is_bool_constant(element) for element in value_node.elts):
+        return []
+    names: list[str] = []
+    for element in target_node.elts:
+        if isinstance(element, ast.Name):
+            names.append(element.id)
+    return names
+
+
+def _assign_target_names_for_bool(node: ast.Assign) -> list[str]:
+    if not node.targets:
+        return []
+    names: list[str] = []
+    for target in node.targets:
+        if isinstance(target, ast.Name) and _is_bool_constant(node.value):
+            names.append(target.id)
+        else:
+            names.extend(_rhs_names_if_all_bool(node.value, target))
+    return names
+
+
+def _annassign_target_name_for_bool(node: ast.AnnAssign) -> list[str]:
+    if not isinstance(node.target, ast.Name):
+        return []
+    annotation_is_bool = isinstance(node.annotation, ast.Name) and node.annotation.id == "bool"
+    value_is_bool = node.value is not None and _is_bool_constant(node.value)
+    if annotation_is_bool and value_is_bool:
+        return [node.target.id]
+    return []
+
+
+def _walrus_name_for_bool(node: ast.NamedExpr) -> list[str]:
+    if not isinstance(node.target, ast.Name):
+        return []
+    if not _is_bool_constant(node.value):
+        return []
+    return [node.target.id]
+
+
+def _collect_boolean_assignments(tree: ast.Module) -> list[tuple[str, int, bool]]:
+    """Collect boolean-constant assignments with (name, line_number, is_upper_snake_scope).
+
+    `is_upper_snake_scope` is True for module-level statements and direct class body
+    statements, where UPPER_SNAKE constants are acceptable (dataclass fields, class
+    constants). Function/method scope is False.
+
+    Invariant: relies on `ast.walk` returning the same node instances that were
+    stored in `upper_snake_scope_ids` via their `id()`. Do not call this helper
+    on a tree that has been rebuilt through an `ast.NodeTransformer` — the
+    transformer may replace nodes with fresh instances, and the identity-based
+    scope tagging will silently fail for the replaced nodes.
+    """
+    upper_snake_scope_ids: set[int] = set()
+    for statement in tree.body:
+        upper_snake_scope_ids.add(id(statement))
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            for class_statement in node.body:
+                upper_snake_scope_ids.add(id(class_statement))
+    collected: list[tuple[str, int, bool]] = []
+    for node in ast.walk(tree):
+        names: list[str] = []
+        line_number = 0
+        if isinstance(node, ast.Assign):
+            names = _assign_target_names_for_bool(node)
+            line_number = node.lineno
+        elif isinstance(node, ast.AnnAssign):
+            names = _annassign_target_name_for_bool(node)
+            line_number = node.lineno
+        elif isinstance(node, ast.NamedExpr):
+            names = _walrus_name_for_bool(node)
+            line_number = node.lineno
+        if not names:
+            continue
+        is_in_upper_snake_scope = id(node) in upper_snake_scope_ids
+        for name in names:
+            collected.append((name, line_number, is_in_upper_snake_scope))
+    return collected
+
+
+def check_boolean_naming(content: str, file_path: str) -> list[str]:
+    """Flag boolean assignments whose target name lacks a required prefix."""
+    if is_test_file(file_path):
+        return []
+    if is_hook_infrastructure(file_path):
+        return []
+    if is_config_file(file_path):
+        return []
+    if is_workflow_registry_file(file_path):
+        return []
+    try:
+        tree = ast.parse(content)
+    except SyntaxError as parse_error:
+        print(
+            f"[CODE_RULES advisory] {file_path}: boolean-naming check skipped - "
+            f"SyntaxError at line {parse_error.lineno}: {parse_error.msg}",
+            file=sys.stderr,
+        )
+        return []
+    issues: list[str] = []
+    for name, line_number, is_in_upper_snake_scope in _collect_boolean_assignments(tree):
+        if len(name) == 1:
+            continue
+        if is_in_upper_snake_scope and UPPER_SNAKE_CONSTANT_PATTERN.match(name):
+            continue
+        if name.startswith(BOOLEAN_NAME_PREFIXES):
+            continue
+        issues.append(
+            f"Line {line_number}: Boolean {name} - prefix with is_/has_/should_/can_"
+        )
+        if len(issues) >= BOOLEAN_NAMING_ISSUE_CAP:
+            break
+    return issues
+
+
 def validate_content(content: str, file_path: str, old_content: str = "") -> list[str]:
     """Run all applicable validators on content.
 
@@ -497,7 +968,11 @@ def validate_content(content: str, file_path: str, old_content: str = "") -> lis
         all_issues.extend(check_logging_fstrings(content))
         all_issues.extend(check_windows_api_none(content))
         all_issues.extend(check_magic_values(content, file_path))
+        all_issues.extend(check_fstring_structural_literals(content, file_path))
         all_issues.extend(check_constants_outside_config(content, file_path))
+        all_issues.extend(check_type_escape_hatches(content, file_path))
+        all_issues.extend(check_banned_identifiers(content, file_path))
+        all_issues.extend(check_boolean_naming(content, file_path))
 
     elif extension in JAVASCRIPT_EXTENSIONS:
         if not is_test_file(file_path):