claude-dev-env 1.42.0 → 1.43.0

package/hooks/blocking/code_rules_enforcer.py

@@ -40,43 +40,43 @@ if _HOOKS_DIR not in sys.path:
     sys.path.insert(0, _HOOKS_DIR)
 
 from code_rules_path_utils import is_config_file  # noqa: E402
-from config.banned_identifiers_constants import (  # noqa: E402
+from hooks_constants.banned_identifiers_constants import (  # noqa: E402
     ALL_BANNED_IDENTIFIERS,
     BANNED_IDENTIFIER_MESSAGE_SUFFIX,
     BANNED_IDENTIFIER_SKIP_ADVISORY,
     MAX_BANNED_IDENTIFIER_ISSUES,
 )
-from config.hardcoded_user_path_constants import (  # noqa: E402
+from hooks_constants.hardcoded_user_path_constants import (  # noqa: E402
     HARDCODED_USER_PATH_GUIDANCE,
     HARDCODED_USER_PATH_PATTERN,
     MAX_HARDCODED_USER_PATH_ISSUES,
 )
-from config.inline_tuple_string_magic_constants import (  # noqa: E402
+from hooks_constants.inline_tuple_string_magic_constants import (  # noqa: E402
     ALL_SNAKE_CASE_KEYWORD_EXEMPTIONS,
     EXPECTED_TUPLE_PAIR_LENGTH,
     INLINE_TUPLE_STRING_MAGIC_MESSAGE_SUFFIX,
     MAX_INLINE_TUPLE_STRING_MAGIC_ISSUES,
     SNAKE_CASE_LITERAL_PATTERN,
 )
-from config.stuttering_check_config import (  # noqa: E402
+from hooks_constants.stuttering_check_config import (  # noqa: E402
     MAX_STUTTERING_PREFIX_ISSUES,
     STUTTERING_ALL_PREFIX_PATTERN,
 )
-from config.sys_path_insert_constants import MAX_SYS_PATH_INSERT_ISSUES, SYS_PATH_INSERT_GUIDANCE  # noqa: E402
-from config.unused_module_import_constants import (  # noqa: E402
+from hooks_constants.sys_path_insert_constants import MAX_SYS_PATH_INSERT_ISSUES, SYS_PATH_INSERT_GUIDANCE  # noqa: E402
+from hooks_constants.unused_module_import_constants import (  # noqa: E402
     ALL_TYPING_MODULE_NAMES,
     MAX_UNUSED_IMPORT_ISSUES,
     TYPE_CHECKING_IDENTIFIER,
     UNUSED_IMPORT_GUIDANCE,
     line_suppresses_unused_import_via_noqa,
 )
-from config.stuttering_import_binding_constants import (  # noqa: E402
+from hooks_constants.stuttering_import_binding_constants import (  # noqa: E402
     AST_LINENO_ATTRIBUTE,
     MODULE_PATH_SEPARATOR,
     WILDCARD_IMPORT_SENTINEL,
 )
-from config.any_type_config import ALL_ANY_ALLOWED_PATTERNS  # noqa: E402
-from config.blocking_check_limits import (  # noqa: E402
+from hooks_constants.any_type_config import ALL_ANY_ALLOWED_PATTERNS  # noqa: E402
+from hooks_constants.blocking_check_limits import (  # noqa: E402
     ALL_BANNED_PREFIX_NAMES,
     ALL_BARE_EXCEPT_BANNED_HANDLER_NAMES,
     ALL_BOUNDARY_TYPE_EXEMPT_FILENAMES,
@@ -95,7 +95,7 @@ from config.blocking_check_limits import (  # noqa: E402
     MAX_THIN_WRAPPER_ISSUES,
 )
 
-from config.code_rules_enforcer_constants import (  # noqa: E402
+from hooks_constants.code_rules_enforcer_constants import (  # noqa: E402
     ADVISORY_LINE_THRESHOLD_HARD,
     ADVISORY_LINE_THRESHOLD_SOFT,
     ALL_CODE_EXTENSIONS,
@@ -109,9 +109,14 @@ from config.code_rules_enforcer_constants import (  # noqa: E402
     ALL_SUBSCRIPT_ONLY_COLLECTION_TYPE_NAMES,
     DOTTED_SEGMENT_PATTERN,
     EACH_PREFIX,
+    ALL_EXEMPT_PYTHON_COMMENT_BODIES,
+    ALL_JAVASCRIPT_EXEMPT_COMMENT_PREFIXES,
+    ALL_JAVASCRIPT_EXEMPT_INLINE_COMMENT_PREFIXES,
+    ALL_PYTHON_TOKENIZE_FAILURE_EXCEPTIONS,
     FILE_GLOBAL_UPPER_SNAKE_PATTERN,
     ALL_HOOK_INFRASTRUCTURE_PATTERNS,
     ALL_IMPORT_STATEMENT_PREFIXES,
+    MAX_COMMENT_ISSUES,
     INLINE_COLLECTION_MIN_LENGTH,
     ALL_JAVASCRIPT_EXTENSIONS,
     LOGGING_FSTRING_PATTERN,
@@ -121,6 +126,9 @@ from config.code_rules_enforcer_constants import (  # noqa: E402
     ALL_PYTHON_EXTENSIONS,
     ALL_SELF_AND_CLS_PARAMETER_NAMES,
     ALL_TEST_PATH_PATTERNS,
+    TRIPLE_DOUBLE_QUOTE_DELIMITER,
+    TRIPLE_QUOTE_PARITY_DIVISOR,
+    TRIPLE_SINGLE_QUOTE_DELIMITER,
     TYPE_CHECKING_BLOCK_PATTERN,
     ALL_UNION_TYPING_NAMES,
     UPPER_SNAKE_CONSTANT_PATTERN,
@@ -168,54 +176,29 @@ def is_spec_file(file_path: str) -> bool:
 
 
 def check_comments_python(content: str) -> list[str]:
-    """Check for comments in Python code."""
+    """Check for comments in Python code.
+
+    Uses ``tokenize.generate_tokens`` to find true ``COMMENT`` tokens.
+    Hash characters that appear inside string literals (hex color codes,
+    URL fragments, and the hash inside an f-string interpolation pattern)
+    are correctly skipped because the tokenizer recognizes them as parts
+    of string tokens rather than comment tokens.
+
+    When the tokenizer cannot parse the file (partial content during
+    Edit, invalid syntax), the check returns no findings rather than
+    falling back to a line-walker scan — false negatives on
+    syntactically-invalid drafts are preferable to false positives that
+    mis-classify string-interior hash characters as comments.
+    """
     issues = []
-    lines = content.split("\n")
-
-    for line_number, line in enumerate(lines, 1):
-        stripped = line.strip()
-
-        if not stripped:
-            continue
-
-        if stripped.startswith("#!"):
-            continue
-
-        if stripped.startswith("# type:"):
+    for each_comment_token in _comment_tokens(content):
+        if _is_exempt_python_comment(each_comment_token):
             continue
-
-        if stripped.startswith("# noqa"):
-            continue
-
-        if stripped.startswith("# pylint:"):
-            continue
-
-        if stripped.startswith("# pragma:"):
-            continue
-
-        if stripped.startswith(("# TODO", "# FIXME", "# HACK", "# XXX")):
-            continue
-
-        comment_index = line.find("#")
-        if comment_index != -1:
-            before_comment = line[:comment_index]
-            if not before_comment.strip().startswith(("'", '"')):
-                is_in_string = False
-                quote_char = None
-                for i, each_char in enumerate(before_comment):
-                    if each_char in ("'", '"') and (i == 0 or before_comment[i - 1] != "\\"):
-                        if not is_in_string:
-                            is_in_string = True
-                            quote_char = each_char
-                        elif each_char == quote_char:
-                            is_in_string = False
-
-                if not is_in_string:
-                    comment_text = line[comment_index + 1 :].strip()
-                    if comment_text and not comment_text.startswith(("type:", "noqa", "pylint:", "pragma:", "TODO", "FIXME", "HACK", "XXX")):
-                        issues.append(f"Line {line_number}: Comment found - refactor to self-documenting code")
-
-        if len(issues) >= 3:
+        line_number = each_comment_token.start[0]
+        issues.append(
+            f"Line {line_number}: Comment found - refactor to self-documenting code"
+        )
+        if len(issues) >= MAX_COMMENT_ISSUES:
             break
 
     return issues
@@ -245,10 +228,10 @@ def check_comments_javascript(content: str) -> list[str]:
             continue
 
         if stripped.startswith("//"):
-            if not stripped.startswith(("// @ts-", "// eslint-", "// prettier-", "/// ", "// TODO", "// FIXME", "// HACK", "// XXX")):
+            if not stripped.startswith(ALL_JAVASCRIPT_EXEMPT_COMMENT_PREFIXES):
                 issues.append(f"Line {each_line_number}: Comment found - refactor to self-documenting code")
 
-        if len(issues) >= 3:
+        if len(issues) >= MAX_COMMENT_ISSUES:
             break
 
     return issues
@@ -268,36 +251,13 @@ def extract_comment_texts(content: str, file_path: str) -> tuple[set[str], set[s
     if not content:
         return inline_comments, standalone_comments
 
-    lines = content.split("\n")
-
     if extension in ALL_PYTHON_EXTENSIONS:
-        for line in lines:
-            stripped = line.strip()
-            if not stripped:
-                continue
-            if stripped.startswith("#"):
-                if stripped.startswith(("#!", "# type:", "# noqa", "# pylint:", "# pragma:", "# TODO", "# FIXME", "# HACK", "# XXX")):
-                    continue
-                standalone_comments.add(stripped)
-            elif "#" in line:
-                comment_index = line.find("#")
-                before_comment = line[:comment_index]
-                if not before_comment.strip().startswith(("'", '"')):
-                    is_in_string = False
-                    quote_char = None
-                    for i, char in enumerate(before_comment):
-                        if char in ("'", '"') and (i == 0 or before_comment[i - 1] != "\\"):
-                            if not is_in_string:
-                                is_in_string = True
-                                quote_char = char
-                            elif char == quote_char:
-                                is_in_string = False
-                    if not is_in_string:
-                        comment_text = line[comment_index + 1 :].strip()
-                        if comment_text and not comment_text.startswith(("type:", "noqa", "pylint:", "pragma:", "TODO", "FIXME", "HACK", "XXX")):
-                            inline_comments.add(line[comment_index:].strip())
+        inline_comments, standalone_comments, _ = _extract_python_comment_sets(content)
+        return inline_comments, standalone_comments
 
-    elif extension in ALL_JAVASCRIPT_EXTENSIONS:
+    lines = content.split("\n")
+
+    if extension in ALL_JAVASCRIPT_EXTENSIONS:
         is_in_multiline = False
         for line in lines:
             stripped = line.strip()
@@ -313,14 +273,14 @@ def extract_comment_texts(content: str, file_path: str) -> tuple[set[str], set[s
                     standalone_comments.add(stripped)
                 continue
             if stripped.startswith("//"):
-                if not stripped.startswith(("// @ts-", "// eslint-", "// prettier-", "/// ", "// TODO", "// FIXME", "// HACK", "// XXX")):
+                if not stripped.startswith(ALL_JAVASCRIPT_EXEMPT_COMMENT_PREFIXES):
                     standalone_comments.add(stripped)
             elif "//" in line:
                 before_slash = line[:line.index("//")]
                 if before_slash.strip():
                     comment_start = stripped.index("//")
                     comment_text = stripped[comment_start + 2 :].strip()
-                    if not comment_text.startswith(("TODO", "FIXME", "HACK", "XXX")):
+                    if not comment_text.startswith(ALL_JAVASCRIPT_EXEMPT_INLINE_COMMENT_PREFIXES):
                         inline_comments.add(stripped[comment_start:])
 
     return inline_comments, standalone_comments
@@ -332,11 +292,26 @@ def check_comment_changes(old_content: str, new_content: str, file_path: str) ->
     Inline comments (after code on same line): BLOCK when added.
     Standalone comment lines: NUDGE (print advisory) when added.
     Existing comments being removed: BLOCK (comment preservation principle).
+
+    When the file is Python and either *old_content* or *new_content* cannot
+    be tokenized (common for mid-edit Edit fragments), the comparison is
+    indeterminate: the per-side tokenize failure would empty one set and
+    misrepresent every comment on the other side as either added or
+    removed. The check returns no issues in that case — false negatives on
+    syntactically-invalid drafts are preferable to false positives that
+    flag legitimate comments as deleted.
     """
     issues: list[str] = []
 
-    old_inline, old_standalone = extract_comment_texts(old_content, file_path)
-    new_inline, new_standalone = extract_comment_texts(new_content, file_path)
+    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)
+        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:
@@ -382,14 +357,29 @@ def check_imports_at_top(content: str) -> list[str]:
     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``.
+
+    Triple-quoted-string interior lines are skipped. Once a line opens a
+    multi-line triple-double-quote or triple-single-quote string (odd count
+    of the delimiter), every subsequent line is treated as docstring content
+    and exempt from the import-prefix scan until the matching delimiter
+    closes the string. Without this tracking, docstring sentences that
+    happen to start with ``from `` or ``import `` after stripping (a common
+    pattern in narrative docstrings) would fire a false positive.
     """
     issues: list[str] = []
     lines = content.split("\n")
     is_inside_function = False
     function_indent = 0
     type_checking_block_indent = NOT_INSIDE_TYPE_CHECKING_BLOCK
+    active_triple_quote_delimiter: str | None = None
 
     for line_number, each_line in enumerate(lines, 1):
+        if active_triple_quote_delimiter is not None:
+            active_triple_quote_delimiter = _update_triple_quote_state_for_line(
+                each_line, active_triple_quote_delimiter
+            )
+            continue
+
         stripped = each_line.strip()
 
         if not stripped:
@@ -404,12 +394,18 @@ def check_imports_at_top(content: str) -> list[str]:
         type_checking_match = TYPE_CHECKING_BLOCK_PATTERN.match(each_line)
         if type_checking_match:
             type_checking_block_indent = len(type_checking_match.group("indent"))
+            active_triple_quote_delimiter = _update_triple_quote_state_for_line(
+                each_line, active_triple_quote_delimiter
+            )
             continue
 
         function_match = re.match(r"^(\s*)(async\s+)?def\s+\w+", each_line)
         if function_match:
             is_inside_function = True
             function_indent = len(function_match.group(1)) if function_match.group(1) else 0
+            active_triple_quote_delimiter = _update_triple_quote_state_for_line(
+                each_line, active_triple_quote_delimiter
+            )
             continue
 
         if is_inside_function:
@@ -421,9 +417,51 @@ def check_imports_at_top(content: str) -> list[str]:
             if stripped.startswith(ALL_IMPORT_STATEMENT_PREFIXES):
                 issues.append(f"Line {line_number}: Import inside function - move to top of file")
 
+        active_triple_quote_delimiter = _update_triple_quote_state_for_line(
+            each_line, active_triple_quote_delimiter
+        )
+
     return issues
 
 
+def _update_triple_quote_state_for_line(
+    line_text: str, current_delimiter: str | None
+) -> str | None:
+    """Return the triple-quote delimiter that remains active after the line.
+
+    Naively counts triple-double-quote and triple-single-quote occurrences.
+    An odd count of either delimiter toggles the active state: ``None``
+    becomes that delimiter, the same delimiter becomes ``None``. Even counts
+    mean the line opens and closes the same delimiter in place (single-line
+    docstring or balanced pair) and the active state is unchanged.
+
+    Known limitation: the counter does not distinguish triple quotes that
+    appear inside other string contexts (for example, a raw f-string
+    containing the literal substring of triple quotes). Such constructs are
+    rare in docstring-bearing code; the false-negative risk is acceptable
+    to keep the line-walker simple and dependency-free.
+
+    Args:
+        line_text: The raw source line whose triple-quote balance is being
+            integrated into the running state.
+        current_delimiter: The active delimiter at the start of this line,
+            or ``None`` when no multi-line string is open.
+
+    Returns:
+        The delimiter that remains active after this line, or ``None`` when
+        no string is open.
+    """
+    if current_delimiter is not None:
+        if line_text.count(current_delimiter) % TRIPLE_QUOTE_PARITY_DIVISOR == 1:
+            return None
+        return current_delimiter
+    if line_text.count(TRIPLE_DOUBLE_QUOTE_DELIMITER) % TRIPLE_QUOTE_PARITY_DIVISOR == 1:
+        return TRIPLE_DOUBLE_QUOTE_DELIMITER
+    if line_text.count(TRIPLE_SINGLE_QUOTE_DELIMITER) % TRIPLE_QUOTE_PARITY_DIVISOR == 1:
+        return TRIPLE_SINGLE_QUOTE_DELIMITER
+    return None
+
+
 def check_logging_fstrings(content: str) -> list[str]:
     """Check for f-strings in logging calls."""
     issues = []
@@ -739,16 +777,96 @@ def _find_any_annotation_lines(source: str) -> list[int]:
     return offending_line_numbers
 
 
-def _comment_tokens(source: str) -> list[tokenize.TokenInfo]:
-    """Return COMMENT tokens from source, or an empty list when tokenization fails."""
+def _python_tokens(source: str) -> Iterator[tokenize.TokenInfo]:
+    """Yield Python tokens from *source* one at a time.
+
+    Centralizes the ``tokenize.generate_tokens`` entry-point so a future
+    change to the API lands in exactly one place. Iteration may raise
+    any of ``ALL_PYTHON_TOKENIZE_FAILURE_EXCEPTIONS`` when the source is
+    not valid Python (mid-edit Edit fragments, unterminated strings,
+    mismatched indentation) — callers handle the exception according to
+    their own contract (silently stop, return an indeterminate flag, etc.).
+    """
+    yield from tokenize.generate_tokens(io.StringIO(source).readline)
+
+
+def _comment_tokens(source: str) -> Iterator[tokenize.TokenInfo]:
+    """Yield COMMENT tokens from *source* one at a time.
+
+    Streams from ``_python_tokens`` so consumers that early-exit (e.g.
+    ``check_comments_python`` caps at ``MAX_COMMENT_ISSUES``) avoid
+    materializing the entire token list. Silently stops on tokenize
+    failure so callers receive only valid comment tokens — no
+    indeterminate signal is exposed at this layer because the consumers
+    that need it (``_extract_python_comment_sets``) bypass this helper.
+    """
     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 []
+        for each_token in _python_tokens(source):
+            if each_token.type == tokenize.COMMENT:
+                yield each_token
+    except ALL_PYTHON_TOKENIZE_FAILURE_EXCEPTIONS:
+        return
+
+
+def _is_exempt_python_comment(comment_token: tokenize.TokenInfo) -> bool:
+    """Return True for shebangs and tooling-directive comments.
+
+    The shebang exemption applies only when the comment token starts
+    at line 1, column 0 — matching the OS-level convention that a
+    shebang line is meaningful only as the first line of an executable
+    file. An inline shebang-lookalike later in the file (an
+    after-code occurrence on any line, or a standalone occurrence on
+    line 2 or later) is NOT a real shebang and remains subject to the
+    no-comments rule.
+
+    Matches any prefix listed in ``ALL_EXEMPT_PYTHON_COMMENT_BODIES``
+    regardless of whether the directive sits flush against the leading
+    hash character or carries one or more whitespace characters (space
+    or tab) between the hash and the directive body. The pre-tokenize
+    implementation accepted both forms via its line-slice-then-strip
+    step; this helper preserves that behavior on top of the
+    tokenize-based scan.
+    """
+    comment_string = comment_token.string
+    if comment_string.startswith("#!") and comment_token.start == (1, 0):
+        return True
+    directive_body = comment_string[1:].lstrip()
+    if not directive_body:
+        return True
+    return directive_body.startswith(ALL_EXEMPT_PYTHON_COMMENT_BODIES)
+
+
+def _extract_python_comment_sets(content: str) -> tuple[set[str], set[str], bool]:
+    """Return (inline_comments, standalone_comments, tokenize_succeeded).
+
+    Streams *content* once via ``_python_tokens``. A tokenize failure
+    (mid-edit fragment, syntax error) returns empty sets and ``False``
+    so callers can treat the situation as indeterminate rather than as
+    "no comments present". Inline vs standalone is decided by inspecting
+    the column offset of each ``COMMENT`` token against its source
+    line: an all-whitespace prefix means standalone.
+    """
+    inline_comments: set[str] = set()
+    standalone_comments: set[str] = set()
+    lines = content.split("\n")
+    try:
+        for each_token in _python_tokens(content):
+            if each_token.type != tokenize.COMMENT:
+                continue
+            if _is_exempt_python_comment(each_token):
+                continue
+            line_number = each_token.start[0]
+            column_offset = each_token.start[1]
+            source_line = lines[line_number - 1] if line_number - 1 < len(lines) else ""
+            text_before_comment = source_line[:column_offset]
+            normalized_comment_text = each_token.string.strip()
+            if not text_before_comment.strip():
+                standalone_comments.add(normalized_comment_text)
+            else:
+                inline_comments.add(normalized_comment_text)
+    except ALL_PYTHON_TOKENIZE_FAILURE_EXCEPTIONS:
+        return set(), set(), False
+    return inline_comments, standalone_comments, True
 
 
 def _find_unjustified_type_ignore_lines(source: str) -> list[int]:

package/hooks/blocking/code_rules_path_utils.py

@@ -11,8 +11,15 @@ the canonical implementation lives here.
 
 from __future__ import annotations
 
+import sys
 from pathlib import Path
 
+hooks_root_directory = str(Path(__file__).resolve().parent.parent)
+if hooks_root_directory not in sys.path:
+    sys.path.insert(0, hooks_root_directory)
+
+from hooks_constants.code_rules_path_utils_constants import ALL_CONFIG_DIRECTORY_NAMES  # noqa: E402
+
 
 def is_config_file(file_path: str) -> bool:
     """Return True when the path points to a config file.
@@ -28,4 +35,4 @@ def is_config_file(file_path: str) -> bool:
     if normalized.endswith("/settings.py") or normalized == "settings.py":
         return True
     path_parts = Path(normalized).parts
-    return "config" in path_parts[:-1]
+    return any(directory_segment in ALL_CONFIG_DIRECTORY_NAMES for directory_segment in path_parts[:-1])

package/hooks/blocking/destructive_command_blocker.py

@@ -13,7 +13,7 @@ _hooks_dir = str(Path(__file__).resolve().parent.parent)
 if _hooks_dir not in sys.path:
     sys.path.insert(0, _hooks_dir)
 
-from config.convergence_branch_constants import (  # noqa: E402
+from hooks_constants.convergence_branch_constants import (  # noqa: E402
     ALL_CONVERGENCE_BRANCH_PREFIXES,
     CONVERGENCE_BRANCH_SUFFIX_PATTERN,
     CONVERGENCE_FORCE_PUSH_DETECTION_PATTERN,

package/hooks/blocking/es_exe_path_rewriter.py

@@ -15,25 +15,19 @@ import re
 import sys
 from pathlib import Path, PurePosixPath, PureWindowsPath
 
+_hooks_dir = str(Path(__file__).resolve().parent.parent)
+if _hooks_dir not in sys.path:
+    sys.path.insert(0, _hooks_dir)
 
-def _insert_hooks_tree_for_imports() -> None:
-    hooks_tree = Path(__file__).resolve().parent.parent
-    hooks_tree_string = str(hooks_tree)
-    if hooks_tree_string not in sys.path:
-        sys.path.insert(0, hooks_tree_string)
-
-
-_insert_hooks_tree_for_imports()
-
-from config.dynamic_stderr_handler import DynamicStderrHandler
-from config.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
-from config.path_rewriter_constants import (
+from hooks_constants.dynamic_stderr_handler import DynamicStderrHandler  # noqa: E402
+from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin  # noqa: E402
+from hooks_constants.path_rewriter_constants import (  # noqa: E402
     BASH_TOOL_NAME,
     HOOK_EVENT_NAME,
     PERMISSION_ALLOW,
     PLACEHOLDER_TOKEN_PATTERN,
 )
-from config.project_paths_reader import load_registry
+from hooks_constants.project_paths_reader import load_registry  # noqa: E402
 
 _ES_EXE_TRIGGER_PATTERN = re.compile(
     r"(?i)(?<![\w.])(?:Everything[/\\])?es\.exe(?![\w.])",

package/hooks/blocking/gh_body_arg_blocker.py

@@ -22,8 +22,13 @@ pattern this hook must catch); otherwise approves unparseable input.
 import json
 import re
 import sys
+from pathlib import Path
 
-from _gh_body_arg_utils import (
+_hooks_dir = str(Path(__file__).resolve().parent.parent)
+if _hooks_dir not in sys.path:
+    sys.path.insert(0, _hooks_dir)
+
+from blocking._gh_body_arg_utils import (  # noqa: E402
     _is_bash_continuation,
     all_body_flags,
     all_body_flag_prefixes,

package/hooks/blocking/gh_pr_author_enforcer.py

@@ -33,11 +33,11 @@ import subprocess
 import sys
 from pathlib import Path
 
-_hooks_tree_path = str(Path(__file__).absolute().parent.parent)
-if _hooks_tree_path not in sys.path:
-    sys.path.insert(0, _hooks_tree_path)
+hooks_parent_directory = str(Path(__file__).resolve().parent.parent)
+if hooks_parent_directory not in sys.path:
+    sys.path.insert(0, hooks_parent_directory)
 
-from _gh_pr_author_swap_utils import (  # noqa: E402  # sys.path shim above must run first
+from _gh_pr_author_swap_utils import (  # noqa: E402
     _all_gh_pr_create_segments,
     _command_invokes_gh_pr_create_in_stripped,
     _delete_state_file,
@@ -47,7 +47,7 @@ from _gh_pr_author_swap_utils import (  # noqa: E402  # sys.path shim above must
     _switch_gh_account,
     _write_line,
 )
-from config.gh_pr_author_swap_constants import (  # noqa: E402  # sys.path shim above must run first
+from hooks_constants.gh_pr_author_swap_constants import (
     ALL_GH_API_USER_COMMAND,
     BASH_TOOL_NAME,
     GH_API_USER_TIMEOUT_SECONDS,

package/hooks/blocking/gh_pr_author_restore.py

@@ -31,11 +31,11 @@ import json
 import sys
 from pathlib import Path
 
-_hooks_tree_path = str(Path(__file__).absolute().parent.parent)
-if _hooks_tree_path not in sys.path:
-    sys.path.insert(0, _hooks_tree_path)
+hooks_parent_directory = str(Path(__file__).resolve().parent.parent)
+if hooks_parent_directory not in sys.path:
+    sys.path.insert(0, hooks_parent_directory)
 
-from _gh_pr_author_swap_utils import (  # noqa: E402  # sys.path shim above must run first
+from _gh_pr_author_swap_utils import (  # noqa: E402
     _command_invokes_gh_pr_create_in_stripped,
     _delete_state_file,
     _preprocess_command_for_matching,
@@ -45,7 +45,7 @@ from _gh_pr_author_swap_utils import (  # noqa: E402  # sys.path shim above must
     _switch_gh_account,
     _write_line,
 )
-from config.gh_pr_author_swap_constants import BASH_TOOL_NAME  # noqa: E402  # sys.path shim above must run first
+from hooks_constants.gh_pr_author_swap_constants import BASH_TOOL_NAME  # noqa: E402
 
 
 def main() -> None:

package/hooks/blocking/hedging_language_blocker.py

@@ -12,17 +12,11 @@ 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)
 
-def _insert_hooks_tree_for_imports() -> None:
-    hooks_tree = Path(__file__).resolve().parent.parent
-    hooks_tree_string = str(hooks_tree)
-    if hooks_tree_string not in sys.path:
-        sys.path.insert(0, hooks_tree_string)
-
-
-_insert_hooks_tree_for_imports()
-
-from config.messages import USER_FACING_NOTICE
+from hooks_constants.messages import USER_FACING_NOTICE  # noqa: E402
 
 PLUGIN_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))