claude-dev-env 1.50.0 → 1.50.2

package/hooks/blocking/test_code_rules_enforcer_split_optional_params.py

@@ -0,0 +1,325 @@
+"""Behavior tests for the code_rules_optional_params code-rules check module."""
+
+from __future__ import annotations
+
+import ast
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+if _BLOCKING_DIRECTORY not in sys.path:
+    sys.path.insert(0, _BLOCKING_DIRECTORY)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
+
+from code_rules_optional_params import (  # noqa: E402
+    _build_fstring_skeleton,
+    check_duplicated_format_patterns,
+    check_unused_optional_parameters,
+)
+
+code_rules_enforcer = SimpleNamespace(
+    _build_fstring_skeleton=_build_fstring_skeleton,
+    check_duplicated_format_patterns=check_duplicated_format_patterns,
+    check_unused_optional_parameters=check_unused_optional_parameters,
+)
+
+
+DUPLICATED_FORMAT_PRODUCTION_FILE_PATH = "packages/app/services/api_client.py"
+
+DUPLICATED_FORMAT_TEST_FILE_PATH = "packages/app/tests/test_api_client.py"
+
+KWARGS_EXPANSION_PRODUCTION_FILE_PATH = "packages/app/services/fetcher.py"
+
+NESTED_FUNCTION_PRODUCTION_FILE_PATH = "packages/app/services/nested.py"
+
+UNUSED_OPTIONAL_CONFIG_FILE_PATH = "packages/app/config/constants.py"
+
+UNUSED_OPTIONAL_PRODUCTION_FILE_PATH = "packages/app/services/feature.py"
+
+UNUSED_OPTIONAL_TEST_FILE_PATH = "packages/app/tests/test_feature.py"
+
+
+def test_should_flag_optional_param_never_varied_in_file() -> None:
+    source = (
+        "def build_url(path: str, prefix: str = '/api') -> str:\n"
+        "    return f'{prefix}{path}'\n"
+        "\n"
+        "def call_first() -> str:\n"
+        "    return build_url('/users')\n"
+        "\n"
+        "def call_second() -> str:\n"
+        "    return build_url('/items')\n"
+    )
+    issues = code_rules_enforcer.check_unused_optional_parameters(
+        source, UNUSED_OPTIONAL_PRODUCTION_FILE_PATH
+    )
+    assert any("prefix" in issue for issue in issues), (
+        f"Expected 'prefix' flagged as never-varied, got: {issues}"
+    )
+
+
+def test_should_not_flag_when_param_is_varied_at_call_site() -> None:
+    source = (
+        "def build_url(path: str, prefix: str = '/api') -> str:\n"
+        "    return f'{prefix}{path}'\n"
+        "\n"
+        "def call_with_default() -> str:\n"
+        "    return build_url('/users')\n"
+        "\n"
+        "def call_with_override() -> str:\n"
+        "    return build_url('/items', prefix='/v2')\n"
+    )
+    issues = code_rules_enforcer.check_unused_optional_parameters(
+        source, UNUSED_OPTIONAL_PRODUCTION_FILE_PATH
+    )
+    assert not any("prefix" in issue for issue in issues), (
+        f"Expected 'prefix' not flagged when varied, got: {issues}"
+    )
+
+
+def test_should_not_flag_unused_optional_in_test_files() -> None:
+    source = (
+        "def build_url(path: str, prefix: str = '/api') -> str:\n"
+        "    return f'{prefix}{path}'\n"
+        "\n"
+        "def call_first() -> str:\n"
+        "    return build_url('/users')\n"
+    )
+    issues = code_rules_enforcer.check_unused_optional_parameters(
+        source, UNUSED_OPTIONAL_TEST_FILE_PATH
+    )
+    assert issues == [], f"Expected no issues in test file, got: {issues}"
+
+
+def test_should_not_flag_unused_optional_in_config_files() -> None:
+    source = (
+        "def build_url(path: str, prefix: str = '/api') -> str:\n"
+        "    return f'{prefix}{path}'\n"
+        "\n"
+        "def call_first() -> str:\n"
+        "    return build_url('/users')\n"
+    )
+    issues = code_rules_enforcer.check_unused_optional_parameters(
+        source, UNUSED_OPTIONAL_CONFIG_FILE_PATH
+    )
+    assert issues == [], f"Expected no issues in config file, got: {issues}"
+
+
+def test_should_not_flag_when_no_same_file_call_sites_exist() -> None:
+    source = (
+        "def build_url(path: str, prefix: str = '/api') -> str:\n"
+        "    return f'{prefix}{path}'\n"
+    )
+    issues = code_rules_enforcer.check_unused_optional_parameters(
+        source, UNUSED_OPTIONAL_PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"Expected no issues when no same-file call sites, got: {issues}"
+    )
+
+
+def test_should_include_line_number_and_param_name_in_issue() -> None:
+    source = (
+        "def fetch(url: str, timeout: int = 30) -> str:\n"
+        "    return get(url, timeout=timeout)\n"
+        "\n"
+        "def run_fetch() -> str:\n"
+        "    return fetch('http://example.com')\n"
+    )
+    issues = code_rules_enforcer.check_unused_optional_parameters(
+        source, UNUSED_OPTIONAL_PRODUCTION_FILE_PATH
+    )
+    assert any("Line 1" in issue and "timeout" in issue for issue in issues), (
+        f"Expected issue with line number and param name, got: {issues}"
+    )
+
+
+def test_should_flag_when_every_call_passes_the_exact_default() -> None:
+    source = (
+        "def fetch(url: str, timeout: int = 30) -> str:\n"
+        "    return get(url, timeout=timeout)\n"
+        "\n"
+        "def run_fetch() -> str:\n"
+        "    return fetch('http://example.com', timeout=30)\n"
+    )
+    issues = code_rules_enforcer.check_unused_optional_parameters(
+        source, UNUSED_OPTIONAL_PRODUCTION_FILE_PATH
+    )
+    assert any("timeout" in issue for issue in issues), (
+        f"Expected 'timeout' flagged when every call passes the exact default, got: {issues}"
+    )
+
+
+def test_should_advise_when_fstring_skeleton_appears_three_or_more_times(capsys: object) -> None:
+    source = (
+        "def get_user(user_id: str) -> str:\n"
+        "    return f'/api/{user_id}'\n"
+        "\n"
+        "def get_order(order_id: str) -> str:\n"
+        "    return f'/api/{order_id}'\n"
+        "\n"
+        "def get_product(product_id: str) -> str:\n"
+        "    return f'/api/{product_id}'\n"
+    )
+    code_rules_enforcer.check_duplicated_format_patterns(
+        source, DUPLICATED_FORMAT_PRODUCTION_FILE_PATH
+    )
+    captured = getattr(capsys, "readouterr")()
+    assert "/api/" in captured.err and "3" in captured.err, (
+        f"Expected advisory for repeated /api/<x> pattern, got: {captured.err!r}"
+    )
+
+
+def test_should_not_advise_when_fstring_skeleton_appears_fewer_than_three_times(capsys: object) -> None:
+    source = (
+        "def get_user(user_id: str) -> str:\n"
+        "    return f'/api/{user_id}'\n"
+        "\n"
+        "def get_order(order_id: str) -> str:\n"
+        "    return f'/api/{order_id}'\n"
+    )
+    code_rules_enforcer.check_duplicated_format_patterns(
+        source, DUPLICATED_FORMAT_PRODUCTION_FILE_PATH
+    )
+    captured = getattr(capsys, "readouterr")()
+    assert "/api/" not in captured.err, (
+        f"Expected no advisory for pattern appearing only twice, got: {captured.err!r}"
+    )
+
+
+def test_should_not_advise_for_duplicated_format_patterns_in_test_files(capsys: object) -> None:
+    source = (
+        "def test_user() -> None:\n"
+        "    url_a = f'/api/{1}'\n"
+        "    url_b = f'/api/{2}'\n"
+        "    url_c = f'/api/{3}'\n"
+    )
+    code_rules_enforcer.check_duplicated_format_patterns(
+        source, DUPLICATED_FORMAT_TEST_FILE_PATH
+    )
+    captured = getattr(capsys, "readouterr")()
+    assert "/api/" not in captured.err, (
+        f"Expected no advisory in test file, got: {captured.err!r}"
+    )
+
+
+def test_should_advise_with_distinct_skeletons(capsys: object) -> None:
+    source = (
+        "def first(team: str, user: str) -> str:\n"
+        "    return f'/teams/{team}/users/{user}'\n"
+        "\n"
+        "def second(team: str, role: str) -> str:\n"
+        "    return f'/teams/{team}/users/{role}'\n"
+        "\n"
+        "def third(team: str, admin: str) -> str:\n"
+        "    return f'/teams/{team}/users/{admin}'\n"
+    )
+    code_rules_enforcer.check_duplicated_format_patterns(
+        source, DUPLICATED_FORMAT_PRODUCTION_FILE_PATH
+    )
+    captured = getattr(capsys, "readouterr")()
+    assert "/teams/" in captured.err, (
+        f"Expected advisory for repeated /teams/<x>/users/<x> pattern, got: {captured.err!r}"
+    )
+
+
+def test_build_fstring_skeleton_preserves_literal_interp_substring() -> None:
+    joined_str_expression = ast.parse("f'PREFIX INTERP {value} SUFFIX'", mode="eval").body
+    assert isinstance(joined_str_expression, ast.JoinedStr)
+    skeleton = code_rules_enforcer._build_fstring_skeleton(joined_str_expression)
+    assert skeleton == "PREFIX INTERP <x> SUFFIX", (
+        "Literal 'INTERP' text inside an f-string must survive skeleton building — "
+        f"only interpolation slots should become '<x>'. Got: {skeleton!r}"
+    )
+
+
+def test_should_not_flag_nested_function_optional_param() -> None:
+    source = (
+        "def outer() -> None:\n"
+        "    def inner(timeout: int = 30) -> None:\n"
+        "        pass\n"
+        "    inner()\n"
+        "    inner()\n"
+    )
+    issues = code_rules_enforcer.check_unused_optional_parameters(
+        source, NESTED_FUNCTION_PRODUCTION_FILE_PATH
+    )
+    assert not any("timeout" in issue for issue in issues), (
+        f"Expected nested function 'timeout' not flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_optional_param_when_only_call_site_uses_kwargs_expansion() -> None:
+    """A call using **defaults passes unknown values — the param must NOT be flagged."""
+    source = (
+        "def fetch(url: str, timeout: int = 30) -> str:\n"
+        "    return url\n"
+        "\n"
+        "def run() -> str:\n"
+        "    defaults = {'timeout': 30}\n"
+        "    return fetch('http://example.com', **defaults)\n"
+    )
+    issues = code_rules_enforcer.check_unused_optional_parameters(
+        source, KWARGS_EXPANSION_PRODUCTION_FILE_PATH
+    )
+    assert not any("timeout" in issue for issue in issues), (
+        f"Expected 'timeout' NOT flagged when call uses **kwargs expansion, got: {issues}"
+    )
+
+
+def test_should_not_advise_when_duplicated_fstring_literal_is_short(capsys: object) -> None:
+    """Short logger-prefix style f-strings must not emit a duplication advisory.
+
+    A three-times-repeated ``f"Got {x}"`` has only four characters of literal
+    text (``"Got "``). Flagging such short fragments creates noise for common
+    logging prefixes. The heuristic requires a minimum amount of structural
+    literal text before an advisory fires.
+    """
+    source = (
+        "def first(value: str) -> str:\n"
+        "    return f'Got {value}'\n"
+        "\n"
+        "def second(value: str) -> str:\n"
+        "    return f'Got {value}'\n"
+        "\n"
+        "def third(value: str) -> str:\n"
+        "    return f'Got {value}'\n"
+    )
+    code_rules_enforcer.check_duplicated_format_patterns(
+        source, DUPLICATED_FORMAT_PRODUCTION_FILE_PATH
+    )
+    captured = getattr(capsys, "readouterr")()
+    assert "Got" not in captured.err, (
+        "Expected no advisory for a short repeated f-string literal fragment, "
+        f"got: {captured.err!r}"
+    )
+
+
+def test_should_still_advise_when_duplicated_fstring_literal_is_long(capsys: object) -> None:
+    """Longer duplicated f-string skeletons must continue to fire.
+
+    The short-literal heuristic must not regress the existing
+    ``/api/<x>`` and ``/teams/<x>/users/<x>`` advisories — those path
+    skeletons carry enough structural literal text to warrant a helper.
+    """
+    source = (
+        "def get_user(user_id: str) -> str:\n"
+        "    return f'/api/{user_id}'\n"
+        "\n"
+        "def get_order(order_id: str) -> str:\n"
+        "    return f'/api/{order_id}'\n"
+        "\n"
+        "def get_product(product_id: str) -> str:\n"
+        "    return f'/api/{product_id}'\n"
+    )
+    code_rules_enforcer.check_duplicated_format_patterns(
+        source, DUPLICATED_FORMAT_PRODUCTION_FILE_PATH
+    )
+    captured = getattr(capsys, "readouterr")()
+    assert "/api/" in captured.err, (
+        "Expected the existing /api/<x> path-shape advisory to still fire, "
+        f"got: {captured.err!r}"
+    )

package/hooks/blocking/test_code_rules_enforcer_split_paths_syspath.py

@@ -0,0 +1,110 @@
+"""Behavior tests for the code_rules_paths_syspath code-rules check module."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+if _BLOCKING_DIRECTORY not in sys.path:
+    sys.path.insert(0, _BLOCKING_DIRECTORY)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
+
+from code_rules_paths_syspath import (  # noqa: E402
+    HARDCODED_USER_PATH_GUIDANCE,
+    HARDCODED_USER_PATH_PATTERN,
+    MAX_HARDCODED_USER_PATH_ISSUES,
+    check_sys_path_insert_deduplication_guard,
+)
+
+from hooks_constants.hardcoded_user_path_constants import (  # noqa: E402
+    HARDCODED_USER_PATH_GUIDANCE as config_hardcoded_user_path_guidance,
+)
+from hooks_constants.hardcoded_user_path_constants import (  # noqa: E402
+    HARDCODED_USER_PATH_PATTERN as config_hardcoded_user_path_pattern,
+)
+from hooks_constants.hardcoded_user_path_constants import (  # noqa: E402
+    MAX_HARDCODED_USER_PATH_ISSUES as config_max_hardcoded_user_path_issues,
+)
+
+code_rules_enforcer = SimpleNamespace(
+    HARDCODED_USER_PATH_GUIDANCE=HARDCODED_USER_PATH_GUIDANCE,
+    HARDCODED_USER_PATH_PATTERN=HARDCODED_USER_PATH_PATTERN,
+    MAX_HARDCODED_USER_PATH_ISSUES=MAX_HARDCODED_USER_PATH_ISSUES,
+    check_sys_path_insert_deduplication_guard=check_sys_path_insert_deduplication_guard,
+)
+
+
+SYS_PATH_INSERT_HOOK_INFRASTRUCTURE_FILE_PATH = "/repo/.claude/hooks/blocking/some_hook.py"
+
+SYS_PATH_INSERT_PRODUCTION_FILE_PATH = "packages/app/services/loader.py"
+
+
+def test_should_reexport_hardcoded_user_path_pattern_from_config() -> None:
+    assert code_rules_enforcer.HARDCODED_USER_PATH_PATTERN is config_hardcoded_user_path_pattern
+
+
+def test_should_reexport_max_hardcoded_user_path_issues_from_config() -> None:
+    assert code_rules_enforcer.MAX_HARDCODED_USER_PATH_ISSUES == config_max_hardcoded_user_path_issues
+
+
+def test_should_reexport_hardcoded_user_path_guidance_from_config() -> None:
+    assert code_rules_enforcer.HARDCODED_USER_PATH_GUIDANCE == config_hardcoded_user_path_guidance
+
+
+def test_sys_path_insert_should_flag_mismatched_guard_path() -> None:
+    source = (
+        "import sys\n"
+        'if "wrong_path" not in sys.path:\n'
+        '    sys.path.insert(0, "actual_path")\n'
+    )
+    issues = code_rules_enforcer.check_sys_path_insert_deduplication_guard(
+        source, SYS_PATH_INSERT_PRODUCTION_FILE_PATH
+    )
+    assert any("sys.path.insert" in each_issue for each_issue in issues), (
+        "Guard testing a different value than what is inserted must be flagged, "
+        f"got: {issues}"
+    )
+
+
+def test_sys_path_insert_should_not_flag_matching_guard_path() -> None:
+    source = (
+        "import sys\n"
+        'if "correct_path" not in sys.path:\n'
+        '    sys.path.insert(0, "correct_path")\n'
+    )
+    issues = code_rules_enforcer.check_sys_path_insert_deduplication_guard(
+        source, SYS_PATH_INSERT_PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"Guard testing the same value that is inserted must not be flagged, got: {issues}"
+    )
+
+
+def test_sys_path_insert_should_not_flag_guarded_insert_in_class_body() -> None:
+    source = (
+        "import sys\n"
+        "class Configurator:\n"
+        "    target = '/some/path'\n"
+        "    if target not in sys.path:\n"
+        "        sys.path.insert(0, target)\n"
+    )
+    issues = code_rules_enforcer.check_sys_path_insert_deduplication_guard(
+        source, SYS_PATH_INSERT_PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"Guarded sys.path.insert directly in a class body must not be flagged, got: {issues}"
+    )
+
+
+def test_sys_path_insert_should_skip_hook_infrastructure_files() -> None:
+    source = "import sys\nsys.path.insert(0, '/some/path')\n"
+    issues = code_rules_enforcer.check_sys_path_insert_deduplication_guard(
+        source, SYS_PATH_INSERT_HOOK_INFRASTRUCTURE_FILE_PATH
+    )
+    assert issues == [], (
+        f"Hook infrastructure files are exempt from this rule, got: {issues}"
+    )

package/hooks/blocking/test_code_rules_enforcer_split_shared.py

@@ -0,0 +1,44 @@
+"""Behavior tests for the code_rules_shared code-rules check module."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+if _BLOCKING_DIRECTORY not in sys.path:
+    sys.path.insert(0, _BLOCKING_DIRECTORY)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
+
+from code_rules_enforcer import (  # noqa: E402
+    prior_and_post_edit_content,
+)
+from code_rules_shared import (  # noqa: E402
+    changed_line_numbers,
+)
+
+code_rules_enforcer = SimpleNamespace(
+    changed_line_numbers=changed_line_numbers,
+    prior_and_post_edit_content=prior_and_post_edit_content,
+)
+
+
+def test_readable_prior_yields_consistent_prior_and_reconstruction(tmp_path) -> None:
+    """When the prior reads cleanly, the helper returns the same prior content it
+    reconstructed the post-edit view from, so the two never diverge across two
+    independent reads."""
+    source_file = tmp_path / "module.py"
+    original = "alpha = 1\nbeta = 2\n"
+    source_file.write_text(original, encoding="utf-8")
+    prior_content, post_edit_content = code_rules_enforcer.prior_and_post_edit_content(
+        str(source_file),
+        old_string="beta = 2\n",
+        new_string="beta = 3\n",
+    )
+    assert prior_content == original
+    assert post_edit_content == "alpha = 1\nbeta = 3\n"
+    changed = code_rules_enforcer.changed_line_numbers(prior_content, post_edit_content)
+    assert changed == {2}

package/hooks/blocking/test_code_rules_enforcer_split_string_magic.py

@@ -0,0 +1,55 @@
+"""Behavior tests for the code_rules_string_magic code-rules check module."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+if _BLOCKING_DIRECTORY not in sys.path:
+    sys.path.insert(0, _BLOCKING_DIRECTORY)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
+
+from code_rules_string_magic import (  # noqa: E402
+    check_inline_literal_collections,
+    check_string_literal_magic,
+)
+
+code_rules_enforcer = SimpleNamespace(
+    check_inline_literal_collections=check_inline_literal_collections,
+    check_string_literal_magic=check_string_literal_magic,
+)
+
+
+INLINE_LITERAL_PRODUCTION_FILE_PATH = "packages/app/services/inline_literal.py"
+
+STRING_MAGIC_PRODUCTION_FILE_PATH = "packages/app/services/string_magic.py"
+
+
+def test_check_inline_literal_collections_flags_three_string_set_in_function() -> None:
+    source = (
+        "def is_known(value: str) -> bool:\n"
+        "    return value in {'true', 'false', 'none'}\n"
+    )
+    issues = code_rules_enforcer.check_inline_literal_collections(
+        source, INLINE_LITERAL_PRODUCTION_FILE_PATH
+    )
+    assert len(issues) == 1, f"Expected 3-element string set flagged, got: {issues}"
+
+
+def test_check_string_literal_magic_flags_env_var_name() -> None:
+    source = (
+        "import os\n"
+        "\n"
+        "def fetch_secret() -> str:\n"
+        "    return os.environ['STRIPE_SECRET']\n"
+    )
+    issues = code_rules_enforcer.check_string_literal_magic(
+        source, STRING_MAGIC_PRODUCTION_FILE_PATH
+    )
+    assert any("STRIPE_SECRET" in each_issue for each_issue in issues), (
+        f"Expected env-var name flagged, got: {issues}"
+    )

package/hooks/blocking/test_code_rules_enforcer_split_test_assertions.py

@@ -0,0 +1,56 @@
+"""Behavior tests for the code_rules_test_assertions code-rules check module."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+if _BLOCKING_DIRECTORY not in sys.path:
+    sys.path.insert(0, _BLOCKING_DIRECTORY)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
+
+from code_rules_test_assertions import (  # noqa: E402
+    check_constant_equality_tests,
+)
+
+code_rules_enforcer = SimpleNamespace(
+    check_constant_equality_tests=check_constant_equality_tests,
+)
+
+
+CONSTANT_EQUALITY_TEST_FILE_PATH = "packages/app/tests/test_constants.py"
+
+
+def test_should_not_flag_two_named_constants_compared_to_each_other() -> None:
+    source = (
+        "FOO = 'a'\n"
+        "BAR = 'b'\n"
+        "\n"
+        "def test_constants_differ() -> None:\n"
+        "    assert FOO == BAR\n"
+    )
+    issues = code_rules_enforcer.check_constant_equality_tests(
+        source, CONSTANT_EQUALITY_TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"Expected no flag when both sides are named constants, got: {issues}"
+    )
+
+
+def test_should_flag_named_constant_compared_to_literal() -> None:
+    source = (
+        "FOO = 'a'\n"
+        "\n"
+        "def test_foo_value() -> None:\n"
+        "    assert FOO == 'literal'\n"
+    )
+    issues = code_rules_enforcer.check_constant_equality_tests(
+        source, CONSTANT_EQUALITY_TEST_FILE_PATH
+    )
+    assert any("constant-value test" in issue for issue in issues), (
+        f"Expected flag when UPPER_SNAKE compared to literal, got: {issues}"
+    )

package/hooks/blocking/test_code_rules_enforcer_todo_markers.py

@@ -7,22 +7,28 @@ rule blocks every authored TODO. These tests pin the exemption.
 
 from __future__ import annotations
 
-import importlib.util
+import sys
 from pathlib import Path
-from types import ModuleType
-
-
-def _load_enforcer_module() -> ModuleType:
-    module_path = Path(__file__).parent / "code_rules_enforcer.py"
-    spec = importlib.util.spec_from_file_location("code_rules_enforcer", module_path)
-    assert spec is not None
-    assert spec.loader is not None
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
-
-
-code_rules_enforcer = _load_enforcer_module()
+from types import SimpleNamespace
+
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+if _BLOCKING_DIRECTORY not in sys.path:
+    sys.path.insert(0, _BLOCKING_DIRECTORY)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
+
+from code_rules_comments import (  # noqa: E402
+    check_comments_javascript,
+    check_comments_python,
+    extract_comment_texts,
+)
+
+code_rules_enforcer = SimpleNamespace(
+    check_comments_javascript=check_comments_javascript,
+    check_comments_python=check_comments_python,
+    extract_comment_texts=extract_comment_texts,
+)
 
 
 def test_python_check_should_exempt_standalone_todo_comment() -> None:

package/hooks/blocking/test_code_rules_paths_syspath.py

@@ -0,0 +1,26 @@
+"""Regression guard pinning docstring prose in code_rules_paths_syspath."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+if _BLOCKING_DIRECTORY not in sys.path:
+    sys.path.insert(0, _BLOCKING_DIRECTORY)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
+
+from code_rules_magic_values import check_magic_values  # noqa: E402
+
+
+def test_module_source_carries_no_docstring_magic_value() -> None:
+    module_path = Path(__file__).resolve().parent / "code_rules_paths_syspath.py"
+    module_source = module_path.read_text(encoding="utf-8")
+    magic_value_issues = check_magic_values(module_source, str(module_path))
+    assert magic_value_issues == [], (
+        "Docstring prose in code_rules_paths_syspath.py must not carry a "
+        "bare-number token that the magic-value check flags as a literal, "
+        f"got: {magic_value_issues}"
+    )