claude-dev-env 1.94.0 → 2.0.0

package/_shared/pr-loop/scripts/code_rules_gate_parts/tests/test_wrapper_plumb_check.py

@@ -0,0 +1,49 @@
+"""Behavioral tests for the wrapper_plumb_check parts module."""
+
+from pathlib import Path
+
+from code_rules_gate_parts import wrapper_plumb_check
+
+
+def test_is_code_path_recognizes_python() -> None:
+    assert wrapper_plumb_check.is_code_path(Path("module.py"))
+    assert not wrapper_plumb_check.is_code_path(Path("notes.txt"))
+
+
+def test_is_test_path_matches_the_documented_patterns() -> None:
+    assert wrapper_plumb_check.is_test_path("pkg/test_bar.py")
+    assert wrapper_plumb_check.is_test_path("pkg/bar_test.py")
+    assert wrapper_plumb_check.is_test_path("pkg/conftest.py")
+    assert wrapper_plumb_check.is_test_path("pkg/tests/thing.py")
+    assert not wrapper_plumb_check.is_test_path("pkg/regular.py")
+
+
+def test_check_wrapper_plumb_through_flags_dropped_kwarg() -> None:
+    content = (
+        "def build(name, verbose=False):\n"
+        "    return name\n\n\n"
+        "def wrap(name):\n"
+        "    return build(name)\n"
+    )
+    findings = wrapper_plumb_check.check_wrapper_plumb_through(content, "module.py")
+    assert any("verbose" in each_finding for each_finding in findings)
+
+
+def test_check_wrapper_plumb_through_is_quiet_for_test_files() -> None:
+    content = (
+        "def build(name, verbose=False):\n"
+        "    return name\n\n\n"
+        "def wrap(name):\n"
+        "    return build(name)\n"
+    )
+    assert wrapper_plumb_check.check_wrapper_plumb_through(content, "test_module.py") == []
+
+
+def test_check_wrapper_plumb_through_is_quiet_when_kwarg_is_plumbed() -> None:
+    content = (
+        "def build(name, verbose=False):\n"
+        "    return name\n\n\n"
+        "def wrap(name, verbose=False):\n"
+        "    return build(name, verbose=verbose)\n"
+    )
+    assert wrapper_plumb_check.check_wrapper_plumb_through(content, "module.py") == []

package/_shared/pr-loop/scripts/code_rules_gate_parts/violation_scoping.py

@@ -0,0 +1,328 @@
+"""Partition enforcer violations into blocking versus advisory by touched line.
+
+Every diff-scoped enforcer message carries the line span of the unit it flags.
+These extractors recover that span from the message text, and
+``split_violations_by_scope`` marks a violation blocking when its span meets a
+line the current diff added, advisory otherwise.
+"""
+
+import re
+from collections.abc import Callable
+
+from pr_loop_shared_constants.code_rules_gate_constants import (
+    BANNED_NOUN_DEFINITION_LINE_GROUP_INDEX,
+    BANNED_NOUN_SPAN_GROUP_INDEX,
+    BANNED_NOUN_VIOLATION_PATTERN,
+    DUPLICATE_BODY_DEFINITION_LINE_GROUP_INDEX,
+    DUPLICATE_BODY_SPAN_GROUP_INDEX,
+    DUPLICATE_BODY_VIOLATION_PATTERN,
+    FUNCTION_LENGTH_DEFINITION_LINE_GROUP_INDEX,
+    FUNCTION_LENGTH_SPAN_GROUP_INDEX,
+    FUNCTION_LENGTH_VIOLATION_PATTERN,
+    ISOLATION_DEFINITION_LINE_GROUP_INDEX,
+    ISOLATION_SPAN_GROUP_INDEX,
+    ISOLATION_VIOLATION_PATTERN,
+)
+from pr_loop_shared_constants.inline_duplicate_body_span_constants import (
+    INLINE_DUPLICATE_BODY_ENCLOSING_LINE_GROUP_INDEX,
+    INLINE_DUPLICATE_BODY_ENCLOSING_SPAN_GROUP_INDEX,
+    INLINE_DUPLICATE_BODY_HELPER_LINE_GROUP_INDEX,
+    INLINE_DUPLICATE_BODY_HELPER_SPAN_GROUP_INDEX,
+    INLINE_DUPLICATE_BODY_VIOLATION_PATTERN,
+)
+
+
+def _span_lines(span_match: re.Match[str], line_group_index: int, span_group_index: int) -> range:
+    """Build the line range from a match's start-line and span capture groups.
+
+    Args:
+        span_match: A regex match carrying a start line and a span length.
+        line_group_index: The capture-group index of the start line.
+        span_group_index: The capture-group index of the span length.
+
+    Returns:
+        The range covering the declared span.
+    """
+    start_line = int(span_match.group(line_group_index))
+    line_span = int(span_match.group(span_group_index))
+    return range(start_line, start_line + line_span)
+
+
+def hunk_header_pattern() -> re.Pattern[str]:
+    """Return the regex matching a unified-diff hunk header.
+
+    Returns:
+        A pattern capturing the new-side start line and optional count.
+    """
+    return re.compile(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@")
+
+
+def violation_line_pattern() -> re.Pattern[str]:
+    """Return the regex matching a violation's ``Line N:`` prefix.
+
+    Returns:
+        A pattern capturing the line number named in the prefix.
+    """
+    return re.compile(r"^Line (\d+):")
+
+
+def parse_added_line_numbers(unified_diff_text: str) -> set[int]:
+    """Extract added line numbers from unified-diff text.
+
+    Args:
+        unified_diff_text: Output from ``git diff --unified=0``.
+
+    Returns:
+        The set of newly-added line numbers named by the hunk headers.
+    """
+    header_regex = hunk_header_pattern()
+    added_line_numbers: set[int] = set()
+    for each_line in unified_diff_text.splitlines():
+        header_match = header_regex.match(each_line)
+        if header_match is None:
+            continue
+        new_start_text, new_count_text = header_match.groups()
+        new_start = int(new_start_text)
+        new_count = 1 if new_count_text is None else int(new_count_text)
+        if new_count <= 0:
+            continue
+        added_line_numbers.update(range(new_start, new_start + new_count))
+    return added_line_numbers
+
+
+def extract_violation_line_number(violation_text: str) -> int | None:
+    """Return the line number captured by the violation-line prefix regex.
+
+    Args:
+        violation_text: A single violation string of the form ``Line N: ...``.
+
+    Returns:
+        The integer line number in the prefix, or None when it does not match.
+    """
+    prefix_match = violation_line_pattern().match(violation_text)
+    if prefix_match is None:
+        return None
+    return int(prefix_match.group(1))
+
+
+def function_length_span_range(violation_text: str) -> range | None:
+    """Return the declared line span of a function-length violation, or None.
+
+    ::
+
+        message: Function 'f' (defined at line X) is Y lines - ...
+        ok:   a function-length message -> range covering the function
+        flag: another message           -> None
+
+    Args:
+        violation_text: A single violation string emitted by the enforcer.
+
+    Returns:
+        A range over the function's declared span, or None for another message.
+    """
+    span_match = FUNCTION_LENGTH_VIOLATION_PATTERN.search(violation_text)
+    if span_match is None:
+        return None
+    return _span_lines(
+        span_match,
+        FUNCTION_LENGTH_DEFINITION_LINE_GROUP_INDEX,
+        FUNCTION_LENGTH_SPAN_GROUP_INDEX,
+    )
+
+
+def isolation_span_range(violation_text: str) -> range | None:
+    """Return the enclosing test-function span of an isolation violation, or None.
+
+    ::
+
+        message: Line N: Test 'f' (defined at line X, spanning Y lines) probes ...
+        ok:   an isolation message -> range covering the test function
+        flag: another message      -> None
+
+    Args:
+        violation_text: A single violation string emitted by the enforcer.
+
+    Returns:
+        A range over the enclosing test span, or None for another message.
+    """
+    span_match = ISOLATION_VIOLATION_PATTERN.search(violation_text)
+    if span_match is None:
+        return None
+    return _span_lines(
+        span_match,
+        ISOLATION_DEFINITION_LINE_GROUP_INDEX,
+        ISOLATION_SPAN_GROUP_INDEX,
+    )
+
+
+def banned_noun_span_range(violation_text: str) -> range | None:
+    """Return the one-line binding span of a banned-noun violation, or None.
+
+    ::
+
+        message: Line N: Identifier 'x' ... (binding span at line X, spanning 1 lines)
+        ok:   a banned-noun message -> range covering the binding line
+        flag: another message       -> None
+
+    The span is the binding line alone, so a pre-existing binding stays out of
+    scope when an unrelated line of its enclosing function is edited.
+
+    Args:
+        violation_text: A single violation string emitted by the enforcer.
+
+    Returns:
+        A range over the binding's one-line span, or None for another message.
+    """
+    span_match = BANNED_NOUN_VIOLATION_PATTERN.search(violation_text)
+    if span_match is None:
+        return None
+    return _span_lines(
+        span_match,
+        BANNED_NOUN_DEFINITION_LINE_GROUP_INDEX,
+        BANNED_NOUN_SPAN_GROUP_INDEX,
+    )
+
+
+def duplicate_body_span_range(violation_text: str) -> range | None:
+    """Return the copied function's source line span of a duplicate-body issue.
+
+    ::
+
+        message: Function 'f' duplicates a.py::f — (duplicate body span at line X ...)
+        ok:   a duplicate-body message -> range covering the copy
+        flag: another message          -> None
+
+    A duplicate blocks only when the diff touches the copied function; an
+    unrelated edit that leaves a pre-existing copy alone keeps it advisory.
+
+    Args:
+        violation_text: A single violation string emitted by the enforcer.
+
+    Returns:
+        A range over the copied function's span, or None for another message.
+    """
+    span_match = DUPLICATE_BODY_VIOLATION_PATTERN.search(violation_text)
+    if span_match is None:
+        return None
+    return _span_lines(
+        span_match,
+        DUPLICATE_BODY_DEFINITION_LINE_GROUP_INDEX,
+        DUPLICATE_BODY_SPAN_GROUP_INDEX,
+    )
+
+
+def inline_duplicate_body_span_lines(violation_text: str) -> frozenset[int] | None:
+    """Return the union of both spans of a same-file inline-duplicate issue.
+
+    ::
+
+        message: ... helper at line H spanning P, enclosing at line E spanning Q
+        ok:   an inline-duplicate message -> frozenset of both spans
+        flag: another message             -> None
+
+    Args:
+        violation_text: A single violation string emitted by the enforcer.
+
+    Returns:
+        The frozenset of every line in both spans, or None for another message.
+    """
+    span_match = INLINE_DUPLICATE_BODY_VIOLATION_PATTERN.search(violation_text)
+    if span_match is None:
+        return None
+    helper_lines = _span_lines(
+        span_match,
+        INLINE_DUPLICATE_BODY_HELPER_LINE_GROUP_INDEX,
+        INLINE_DUPLICATE_BODY_HELPER_SPAN_GROUP_INDEX,
+    )
+    enclosing_lines = _span_lines(
+        span_match,
+        INLINE_DUPLICATE_BODY_ENCLOSING_LINE_GROUP_INDEX,
+        INLINE_DUPLICATE_BODY_ENCLOSING_SPAN_GROUP_INDEX,
+    )
+    return frozenset(helper_lines) | frozenset(enclosing_lines)
+
+
+def _all_span_range_extractors() -> tuple[Callable[[str], range | None], ...]:
+    """Return every enclosing-unit span extractor, tried in order."""
+    return (
+        function_length_span_range,
+        isolation_span_range,
+        banned_noun_span_range,
+        duplicate_body_span_range,
+    )
+
+
+def enclosing_span_range(violation_text: str) -> range | None:
+    """Return the enclosing-unit span of a span-tagged violation, or None.
+
+    ::
+
+        each extractor in the registry is tried in turn
+        ok:   a span-tagged message -> the first range an extractor recovers
+        flag: an untagged message   -> None
+
+    Args:
+        violation_text: A single violation string emitted by the enforcer.
+
+    Returns:
+        The first non-None span any extractor recovers, or None.
+    """
+    for each_extractor in _all_span_range_extractors():
+        span_range = each_extractor(violation_text)
+        if span_range is not None:
+            return span_range
+    return None
+
+
+def _issue_is_blocking(each_issue: str, all_added_line_numbers: set[int]) -> bool:
+    """Return True when *each_issue* is blocking for the given added lines.
+
+    Args:
+        each_issue: A single violation string emitted by the enforcer.
+        all_added_line_numbers: Lines the current diff added.
+
+    Returns:
+        True when the issue's span or line meets an added line.
+    """
+    inline_duplicate_lines = inline_duplicate_body_span_lines(each_issue)
+    if inline_duplicate_lines is not None:
+        return bool(inline_duplicate_lines & all_added_line_numbers)
+    span_range = enclosing_span_range(each_issue)
+    if span_range is not None:
+        return any(each_line in all_added_line_numbers for each_line in span_range)
+    violation_line = extract_violation_line_number(each_issue)
+    if violation_line is None:
+        return True
+    return violation_line in all_added_line_numbers
+
+
+def split_violations_by_scope(
+    all_issues: list[str],
+    all_added_line_numbers: set[int] | None,
+) -> tuple[list[str], list[str]]:
+    """Partition issues into blocking versus advisory based on touched lines.
+
+    ::
+
+        all_added_line_numbers is None -> every issue is blocking
+        an issue whose span meets an added line -> blocking
+        an issue on a pre-existing untouched unit -> advisory
+
+    Args:
+        all_issues: Violation strings emitted by the enforcer.
+        all_added_line_numbers: Lines added in the current diff, or None to
+            treat every violation as blocking.
+
+    Returns:
+        The tuple ``(blocking, advisory)``.
+    """
+    if all_added_line_numbers is None:
+        return list(all_issues), []
+    blocking: list[str] = []
+    advisory: list[str] = []
+    for each_issue in all_issues:
+        if _issue_is_blocking(each_issue, all_added_line_numbers):
+            blocking.append(each_issue)
+        else:
+            advisory.append(each_issue)
+    return blocking, advisory

package/_shared/pr-loop/scripts/code_rules_gate_parts/wrapper_plumb_check.py

@@ -0,0 +1,206 @@
+"""Flag public calls that drop a same-file delegate's optional keyword arguments.
+
+A thin public wrapper that forwards to a module-level helper should keep the
+helper's optional keyword surface. When the wrapper narrows it, a caller varying
+that keyword hits the wrapper's default instead. This check walks the AST and
+reports each such dropped keyword.
+"""
+
+import ast
+from collections.abc import Iterator
+from pathlib import Path
+
+from pr_loop_shared_constants.code_rules_gate_constants import (
+    ALL_CODE_FILE_EXTENSIONS,
+    ALL_TEST_FILENAME_GLOB_SUFFIXES,
+    ALL_TEST_FILENAME_SUFFIXES,
+    MAX_VIOLATIONS_PER_CHECK,
+    PYTHON_FILE_EXTENSION,
+    TEST_CONFTEST_FILENAME,
+    TEST_FILENAME_PREFIX,
+    TESTS_PATH_SEGMENT,
+)
+
+
+def is_code_path(file_path: Path) -> bool:
+    """Return True when *file_path* carries a recognized code extension."""
+    return file_path.suffix.lower() in ALL_CODE_FILE_EXTENSIONS
+
+
+def is_test_path(file_path: str) -> bool:
+    """Return True when *file_path* matches a test-file detection pattern.
+
+    ::
+
+        ok(test): test_x.py, x_test.py, x.spec.ts, conftest.py, a/tests/x.py
+        ok(not):  regular_module.py
+
+    Args:
+        file_path: Path string to classify; backslashes are normalized first.
+
+    Returns:
+        True when the path matches any test-file pattern; False otherwise.
+    """
+    normalized_posix = file_path.replace("\\", "/")
+    filename_only = normalized_posix.rsplit("/", maxsplit=1)[-1]
+    if TESTS_PATH_SEGMENT in normalized_posix:
+        return True
+    if filename_only == TEST_CONFTEST_FILENAME:
+        return True
+    if filename_only.startswith(TEST_FILENAME_PREFIX) and filename_only.endswith(
+        PYTHON_FILE_EXTENSION
+    ):
+        return True
+    if any(filename_only.endswith(each) for each in ALL_TEST_FILENAME_SUFFIXES):
+        return True
+    return any(each in filename_only for each in ALL_TEST_FILENAME_GLOB_SUFFIXES)
+
+
+def _iter_calls_excluding_nested_functions(node: ast.AST) -> Iterator[ast.Call]:
+    """Yield calls under *node*, skipping bodies of nested function definitions."""
+    for each_child in ast.iter_child_nodes(node):
+        if isinstance(each_child, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        if isinstance(each_child, ast.Call):
+            yield each_child
+            continue
+        yield from _iter_calls_excluding_nested_functions(each_child)
+
+
+def _optional_kwargs_of(
+    function_node: ast.FunctionDef | ast.AsyncFunctionDef,
+) -> set[str]:
+    """Return the names of every optional keyword the function accepts."""
+    optional_kwargs: set[str] = set()
+    for each_kwonly, each_default in zip(
+        function_node.args.kwonlyargs, function_node.args.kw_defaults, strict=False
+    ):
+        if each_default is not None:
+            optional_kwargs.add(each_kwonly.arg)
+    positional_defaults = function_node.args.defaults
+    if positional_defaults:
+        for each_arg in function_node.args.args[-len(positional_defaults) :]:
+            optional_kwargs.add(each_arg.arg)
+    return optional_kwargs
+
+
+def _module_level_optional_kwargs_by_name(tree: ast.Module) -> dict[str, set[str]]:
+    """Return a map from module-level function name to its optional kwargs."""
+    all_function_signatures: dict[str, set[str]] = {}
+    for each_node in ast.iter_child_nodes(tree):
+        if isinstance(each_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            all_function_signatures[each_node.name] = _optional_kwargs_of(each_node)
+    return all_function_signatures
+
+
+def _method_ids_in_class(class_def: ast.ClassDef) -> set[int]:
+    """Return the object ids of every method defined directly in *class_def*."""
+    return {
+        id(each_node)
+        for each_node in class_def.body
+        if isinstance(each_node, (ast.FunctionDef, ast.AsyncFunctionDef))
+    }
+
+
+def _class_method_node_ids(tree: ast.Module) -> set[int]:
+    """Return the object ids of every method defined in any class in the tree."""
+    class_method_node_ids: set[int] = set()
+    for each_node in ast.walk(tree):
+        if isinstance(each_node, ast.ClassDef):
+            class_method_node_ids.update(_method_ids_in_class(each_node))
+    return class_method_node_ids
+
+
+def _delegate_name_of(call_node: ast.Call) -> str | None:
+    """Return the callee name of *call_node*, or None for a non-name callee."""
+    if isinstance(call_node.func, ast.Name):
+        return call_node.func.id
+    if isinstance(call_node.func, ast.Attribute):
+        return call_node.func.attr
+    return None
+
+
+def _wrapper_dropped_kwarg_findings(
+    wrapper_node: ast.FunctionDef | ast.AsyncFunctionDef,
+    all_kwargs_by_function_name: dict[str, set[str]],
+) -> Iterator[str]:
+    """Yield one finding per optional kwarg *wrapper_node* drops from a delegate."""
+    wrapper_kwargs = all_kwargs_by_function_name.get(wrapper_node.name, set())
+    for each_call in _iter_calls_excluding_nested_functions(wrapper_node):
+        delegate_name = _delegate_name_of(each_call)
+        if delegate_name is None:
+            continue
+        delegate_kwargs = all_kwargs_by_function_name.get(delegate_name)
+        if delegate_kwargs is None:
+            continue
+        missing = delegate_kwargs - wrapper_kwargs
+        if missing:
+            yield (
+                f"Line {wrapper_node.lineno}: Wrapper {wrapper_node.name!r} drops "
+                f"optional kwargs {sorted(missing)!r} of delegate {delegate_name!r}"
+            )
+
+
+def _wrapper_candidate_nodes(
+    tree: ast.Module, all_class_method_node_ids: set[int]
+) -> Iterator[ast.FunctionDef | ast.AsyncFunctionDef]:
+    """Yield each public module function that is not a class method."""
+    for each_node in ast.walk(tree):
+        if not isinstance(each_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        if id(each_node) in all_class_method_node_ids:
+            continue
+        if not each_node.name.startswith("_"):
+            yield each_node
+
+
+def _wrapper_findings_from_tree(tree: ast.Module) -> list[str]:
+    """Collect capped wrapper-plumb-through findings from a parsed module."""
+    all_signatures = _module_level_optional_kwargs_by_name(tree)
+    class_method_node_ids = _class_method_node_ids(tree)
+    issues: list[str] = []
+    for each_node in _wrapper_candidate_nodes(tree, class_method_node_ids):
+        issues.extend(_wrapper_dropped_kwarg_findings(each_node, all_signatures))
+        if len(issues) >= MAX_VIOLATIONS_PER_CHECK:
+            return issues[:MAX_VIOLATIONS_PER_CHECK]
+    return issues
+
+
+def _is_non_python_or_test(file_path: str) -> bool:
+    """Return True for a non-Python code file or a test file."""
+    non_python_code_extensions = ALL_CODE_FILE_EXTENSIONS - {PYTHON_FILE_EXTENSION}
+    lowercase_file_path = file_path.lower()
+    if any(lowercase_file_path.endswith(each) for each in non_python_code_extensions):
+        return True
+    return is_test_path(file_path)
+
+
+def check_wrapper_plumb_through(content: str, file_path: str) -> list[str]:
+    """Flag public calls that drop a same-file delegate's optional kwargs.
+
+    ::
+
+        def build(name, verbose=False): ...   def wrap(name): return build(name)
+        flag: wrap drops optional kwarg 'verbose' of delegate 'build'
+        ok:   def wrap(name, verbose=False): return build(name, verbose=verbose)
+
+    Only module-level functions contribute signatures; class methods are skipped
+    as signature sources and as wrapper candidates. Emission caps at
+    ``MAX_VIOLATIONS_PER_CHECK`` findings.
+
+    Args:
+        content: File content as a single string for AST parsing.
+        file_path: Repository-relative POSIX path, for skipping non-Python and
+            test files early.
+
+    Returns:
+        Violation strings, one per dropped optional kwarg; empty for a
+        non-Python file, a test file, or a syntax error.
+    """
+    if _is_non_python_or_test(file_path):
+        return []
+    try:
+        tree = ast.parse(content)
+    except SyntaxError:
+        return []
+    return _wrapper_findings_from_tree(tree)

package/_shared/pr-loop/scripts/pr_loop_shared_constants/code_rules_gate_constants.py

@@ -3,7 +3,16 @@
 import re
 
 MAX_VIOLATIONS_PER_CHECK: int = 3
-EXPECTED_TUPLE_PAIR_LENGTH: int = 2
+
+GATE_ERROR_EXIT_CODE: int = 2
+
+EMPTY_FILE_SET_EXIT_CODE: int = 3
+
+EMPTY_FILE_SET_MESSAGE: str = (
+    "code_rules_gate: the resolved file set is empty; nothing was inspected."
+)
+
+INSPECTED_COUNT_MESSAGE: str = "code_rules_gate: inspected {inspected_count} file(s)."
 
 FUNCTION_LENGTH_VIOLATION_PATTERN: re.Pattern[str] = re.compile(
     r"\(defined at line (\d+)\) is (\d+) lines"
@@ -29,15 +38,7 @@ DUPLICATE_BODY_VIOLATION_PATTERN: re.Pattern[str] = re.compile(
 DUPLICATE_BODY_DEFINITION_LINE_GROUP_INDEX: int = 1
 DUPLICATE_BODY_SPAN_GROUP_INDEX: int = 2
 
-ALL_CODE_FILE_EXTENSIONS: frozenset[str] = frozenset(
-    {".py", ".js", ".ts", ".tsx", ".jsx"}
-)
-
-ALL_LITERAL_KEYWORD_EXEMPTIONS: frozenset[str] = frozenset(
-    {"true", "false", "none", "null"}
-)
-
-CONFIG_PATH_SEGMENT: str = "/config/"
+ALL_CODE_FILE_EXTENSIONS: frozenset[str] = frozenset({".py", ".js", ".ts", ".tsx", ".jsx"})
 
 TESTS_PATH_SEGMENT: str = "/tests/"
 
@@ -52,10 +53,6 @@ TEST_CONFTEST_FILENAME: str = "conftest.py"
 
 TEST_FILENAME_PREFIX: str = "test_"
 
-MINIMUM_COLUMN_NAME_LENGTH_AFTER_FIRST_CHAR: int = 2
-
-COLUMN_KEY_PATTERN_TEMPLATE: str = r"^[a-z][a-z0-9_]{{{minimum_length},}}$"
-
 GIT_NAME_STATUS_ADDED_PREFIX: str = "A"
 
 GIT_NAME_STATUS_RENAMED_PREFIX: str = "R"
@@ -81,6 +78,14 @@ ALL_GIT_DIFF_NAME_ONLY_NULL_TERMINATED_COMMAND_PREFIX: tuple[str, ...] = (
     "-z",
 )
 
+ALL_GIT_LS_FILES_UNTRACKED_NULL_TERMINATED_COMMAND: tuple[str, ...] = (
+    "git",
+    "ls-files",
+    "--others",
+    "--exclude-standard",
+    "-z",
+)
+
 
 ALL_PYTEST_MODULE_INVOCATION: tuple[str, ...] = (
     "-m",
@@ -96,7 +101,10 @@ PYTHONPATH_ENV_VAR: str = "PYTHONPATH"
 
 ALL_VENV_DIRECTORY_NAMES: tuple[str, ...] = (".venv", "venv")
 
-ALL_WINDOWS_VENV_PYTHON_RELATIVE_PATH_SEGMENTS: tuple[str, ...] = ("Scripts", "python.exe")
+ALL_WINDOWS_VENV_PYTHON_RELATIVE_PATH_SEGMENTS: tuple[str, ...] = (
+    "Scripts",
+    "python.exe",
+)
 
 ALL_POSIX_VENV_PYTHON_RELATIVE_PATH_SEGMENTS: tuple[str, ...] = ("bin", "python")
 
@@ -132,8 +140,7 @@ ALL_PYTEST_CONFIG_FILE_SECTIONS: tuple[tuple[str, str | None], ...] = (
 )
 
 STAGED_TEST_GROUP_FAILURE_MESSAGE: str = (
-    "code_rules_gate: staged test group rooted at {group_root} "
-    "failed under pytest; commit blocked."
+    "code_rules_gate: staged test group rooted at {group_root} failed under pytest; commit blocked."
 )
 
 MINIMUM_STAGED_PYTEST_PYTHON_MAJOR: int = 3

package/_shared/pr-loop/scripts/pr_loop_shared_constants/reviews_disabled_constants.py

@@ -8,4 +8,5 @@ CLAUDE_REVIEWS_DISABLED_TOKEN_SEPARATOR: str = ","
 CLAUDE_REVIEWS_DISABLED_BUGTEAM_TOKEN: str = "bugteam"
 CLAUDE_REVIEWS_DISABLED_BUGBOT_TOKEN: str = "bugbot"
 CLAUDE_REVIEWS_DISABLED_COPILOT_TOKEN: str = "copilot"
+CLAUDE_REVIEWS_DISABLED_CODEX_TOKEN: str = "codex"
 EXIT_CODE_BUGTEAM_DISABLED_VIA_ENV: int = 7