claude-dev-env 1.81.0 → 1.83.0

package/hooks/blocking/test_code_rules_enforcer_naive_datetime.py

@@ -0,0 +1,213 @@
+"""Tests for the naive-datetime-construction check in code_rules_imports_logging.py.
+
+The check catches the DST-fold-ambiguity class Copilot flagged on
+python-automation PR #557: ``datetime.fromtimestamp(epoch)`` builds a datetime
+with no timezone, and a later ``.astimezone()`` on that naive value has to guess
+the local offset. The check flags the naive-producing constructors
+(``fromtimestamp``/``utcfromtimestamp`` without ``tz=``, and ``utcnow``) and
+leaves a ``tz=``-carrying call, and a plain ``now()``, alone.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+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()
+
+PRODUCTION_FILE_PATH = "/project/src/export_verification.py"
+TEST_FILE_PATH = "/project/src/test_export_verification.py"
+
+
+def check_naive_datetime_construction(content: str, file_path: str) -> list[str]:
+    return code_rules_enforcer.check_naive_datetime_construction(content, file_path)
+
+
+def test_flags_fromtimestamp_without_timezone() -> None:
+    content = (
+        "from datetime import datetime\n"
+        "def describe(stamp: float) -> str:\n"
+        "    return datetime.fromtimestamp(stamp).astimezone().isoformat()\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+    assert "fromtimestamp" in issues[0]
+    assert "tz=" in issues[0]
+
+
+def test_flags_utcfromtimestamp_and_utcnow() -> None:
+    content = (
+        "from datetime import datetime\n"
+        "def build(stamp: float) -> tuple[object, object]:\n"
+        "    return datetime.utcfromtimestamp(stamp), datetime.utcnow()\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 2
+
+
+def test_flags_module_qualified_datetime_call() -> None:
+    content = (
+        "import datetime\n"
+        "def describe(stamp: float) -> object:\n"
+        "    return datetime.datetime.fromtimestamp(stamp)\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+
+
+def test_allows_fromtimestamp_with_timezone_keyword() -> None:
+    content = (
+        "from datetime import datetime, timezone\n"
+        "def describe(stamp: float) -> str:\n"
+        "    return datetime.fromtimestamp(stamp, tz=timezone.utc).isoformat()\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_allows_fromtimestamp_with_positional_timezone() -> None:
+    content = (
+        "from datetime import datetime, timezone\n"
+        "def describe(stamp: float) -> str:\n"
+        "    return datetime.fromtimestamp(stamp, timezone.utc).isoformat()\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_allows_module_qualified_fromtimestamp_with_positional_timezone() -> None:
+    content = (
+        "import datetime\n"
+        "def describe(stamp: float) -> object:\n"
+        "    return datetime.datetime.fromtimestamp(stamp, datetime.timezone.utc)\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_flags_utcfromtimestamp_with_second_positional_argument() -> None:
+    content = (
+        "from datetime import datetime\n"
+        "def describe(stamp: float, other: float) -> object:\n"
+        "    return datetime.utcfromtimestamp(stamp, other)\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+
+
+def test_ignores_unrelated_datetime_attribute_chain() -> None:
+    content = (
+        "def describe(foo: object, stamp: float) -> object:\n"
+        "    return foo.datetime.fromtimestamp(stamp)\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_flags_fromtimestamp_with_none_timezone_keyword() -> None:
+    content = (
+        "from datetime import datetime\n"
+        "def describe(stamp: float) -> object:\n"
+        "    return datetime.fromtimestamp(stamp, tz=None)\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+
+
+def test_flags_fromtimestamp_with_none_positional_timezone() -> None:
+    content = (
+        "from datetime import datetime\n"
+        "def describe(stamp: float) -> object:\n"
+        "    return datetime.fromtimestamp(stamp, None)\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+
+
+def test_flags_utcfromtimestamp_even_with_timezone_keyword() -> None:
+    content = (
+        "from datetime import datetime, timezone\n"
+        "def describe(stamp: float) -> object:\n"
+        "    return datetime.utcfromtimestamp(stamp, tz=timezone.utc)\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+
+
+def test_utcnow_remediation_points_at_now_not_utcnow_tz() -> None:
+    content = (
+        "from datetime import datetime\n"
+        "def stamp() -> object:\n"
+        "    return datetime.utcnow()\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+    assert "now(tz=" in issues[0]
+
+
+def test_utcfromtimestamp_remediation_points_at_fromtimestamp() -> None:
+    content = (
+        "from datetime import datetime\n"
+        "def build(stamp: float) -> object:\n"
+        "    return datetime.utcfromtimestamp(stamp)\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+    assert "fromtimestamp(" in issues[0]
+    assert "tz=" in issues[0]
+
+
+def test_utcfromtimestamp_remediation_uses_generic_placeholder() -> None:
+    content = (
+        "from datetime import datetime\n"
+        "def build(epoch_seconds: float) -> object:\n"
+        "    return datetime.utcfromtimestamp(epoch_seconds)\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+    assert "..., tz=" in issues[0]
+    assert "stamp, tz=" not in issues[0]
+
+
+def test_remediation_does_not_mandate_astimezone() -> None:
+    content = (
+        "from datetime import datetime\n"
+        "def stamp() -> object:\n"
+        "    return datetime.utcnow()\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+    assert "then .astimezone()" not in issues[0]
+    assert "only when local display" in issues[0]
+
+
+def test_allows_plain_now() -> None:
+    content = (
+        "from datetime import datetime\n"
+        "def stamp() -> str:\n"
+        "    return datetime.now().isoformat()\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_exempts_test_files() -> None:
+    content = (
+        "from datetime import datetime\n"
+        "def describe(stamp: float) -> object:\n"
+        "    return datetime.fromtimestamp(stamp)\n"
+    )
+    issues = check_naive_datetime_construction(content, TEST_FILE_PATH)
+    assert issues == []

package/hooks/blocking/test_code_rules_enforcer_referenced_underscore_loop.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+from pathlib import Path
+import importlib.util
+
+ENFORCER_PATH = Path(__file__).resolve().parent / "code_rules_enforcer.py"
+specification = importlib.util.spec_from_file_location("code_rules_enforcer", ENFORCER_PATH)
+code_rules_enforcer = importlib.util.module_from_spec(specification)
+specification.loader.exec_module(code_rules_enforcer)
+
+PRODUCTION_FILE_PATH = "packages/app/services/foo.py"
+CONFTEST_FILE_PATH = "packages/app/tests/conftest.py"
+
+
+def test_should_flag_referenced_underscore_loop_variable_in_conftest() -> None:
+    source = (
+        "import sys\n"
+        "\n"
+        "for _foreign_module_name in ['a', 'b']:\n"
+        "    del sys.modules[_foreign_module_name]\n"
+    )
+    issues = code_rules_enforcer.check_referenced_underscore_loop_variable(
+        source, CONFTEST_FILE_PATH
+    )
+    assert any("_foreign_module_name" in each_issue for each_issue in issues), (
+        f"Expected referenced underscore loop variable flagged, got: {issues}"
+    )
+
+
+def test_should_flag_referenced_underscore_loop_variable_in_production() -> None:
+    source = (
+        "import sys\n"
+        "\n"
+        "def purge(all_names: list) -> None:\n"
+        "    for _name in all_names:\n"
+        "        del sys.modules[_name]\n"
+    )
+    issues = code_rules_enforcer.check_referenced_underscore_loop_variable(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("_name" in each_issue for each_issue in issues), (
+        f"Expected referenced underscore loop variable flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_unreferenced_underscore_throwaway() -> None:
+    source = "def spin(count: int) -> None:\n    for _unused in range(count):\n        pass\n"
+    issues = code_rules_enforcer.check_referenced_underscore_loop_variable(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], f"Genuinely unused underscore throwaway must pass, got: {issues}"
+
+
+def test_should_not_flag_bare_underscore_target() -> None:
+    source = "def spin(count: int) -> None:\n    for _ in range(count):\n        return None\n"
+    issues = code_rules_enforcer.check_referenced_underscore_loop_variable(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], f"Bare '_' target must pass, got: {issues}"
+
+
+def test_should_not_flag_named_loop_variable_without_underscore() -> None:
+    source = (
+        "import sys\n\nfor each_module_name in ['a', 'b']:\n    del sys.modules[each_module_name]\n"
+    )
+    issues = code_rules_enforcer.check_referenced_underscore_loop_variable(
+        source, CONFTEST_FILE_PATH
+    )
+    assert issues == [], f"each_-prefixed loop variable without underscore must pass, got: {issues}"
+
+
+def test_should_not_flag_underscore_loop_variable_shadowed_by_comprehension() -> None:
+    source = (
+        "def collect(all_names: list, other: list) -> list:\n"
+        "    all_other: list = []\n"
+        "    for _name in all_names:\n"
+        "        all_other = [_name for _name in other]\n"
+        "    return all_other\n"
+    )
+    issues = code_rules_enforcer.check_referenced_underscore_loop_variable(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"Comprehension rebinding the loop name shadows the outer read, must pass, got: {issues}"
+    )
+
+
+def test_should_flag_underscore_loop_variable_read_inside_non_rebinding_comprehension() -> None:
+    source = (
+        "def collect(all_names: list, other: list) -> list:\n"
+        "    matches: list = []\n"
+        "    for _name in all_names:\n"
+        "        matches = [each_row for each_row in other if each_row == _name]\n"
+        "    return matches\n"
+    )
+    issues = code_rules_enforcer.check_referenced_underscore_loop_variable(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("_name" in each_issue for each_issue in issues), (
+        f"A comprehension reading the outer loop name without rebinding it must flag, got: {issues}"
+    )
+
+
+def test_should_not_flag_underscore_loop_variable_shadowed_by_lambda_parameter() -> None:
+    source = (
+        "def build(all_names: list) -> list:\n"
+        "    all_callables: list = []\n"
+        "    for _name in all_names:\n"
+        "        all_callables.append(lambda _name: _name)\n"
+        "    return all_callables\n"
+    )
+    issues = code_rules_enforcer.check_referenced_underscore_loop_variable(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"A lambda parameter shadowing the loop name owns its body, must pass, got: {issues}"
+    )
+
+
+def test_should_not_flag_underscore_loop_variable_shadowed_by_nested_def_parameter() -> None:
+    source = (
+        "def build(all_names: list) -> None:\n"
+        "    for _handler in all_names:\n"
+        "        def inner(_handler: object) -> object:\n"
+        "            return _handler\n"
+    )
+    issues = code_rules_enforcer.check_referenced_underscore_loop_variable(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"A nested-def parameter shadowing the loop name owns its body, must pass, got: {issues}"
+    )
+
+
+def test_should_not_flag_outer_underscore_loop_variable_shadowed_by_nested_loop() -> None:
+    source = (
+        "import sys\n"
+        "\n"
+        "def purge(first: list, second: list) -> None:\n"
+        "    for _name in first:\n"
+        "        for _name in second:\n"
+        "            del sys.modules[_name]\n"
+    )
+    issues = code_rules_enforcer.check_referenced_underscore_loop_variable(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert not any("Line 4" in each_issue for each_issue in issues), (
+        f"Outer loop whose name a nested loop rebinds is never read in the outer scope, "
+        f"got: {issues}"
+    )
+
+
+def test_should_flag_underscore_loop_variable_read_before_nested_shadowing_loop() -> None:
+    source = (
+        "import sys\n"
+        "\n"
+        "def purge(first: list, second: list) -> None:\n"
+        "    for _name in first:\n"
+        "        del sys.modules[_name]\n"
+        "        for _name in second:\n"
+        "            pass\n"
+    )
+    issues = code_rules_enforcer.check_referenced_underscore_loop_variable(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("Line 4" in each_issue for each_issue in issues), (
+        f"The outer loop body reads its own name before the nested loop rebinds it, "
+        f"must flag, got: {issues}"
+    )

package/hooks/blocking/test_code_rules_js_bare_flag_return_directive.py

@@ -0,0 +1,266 @@
+"""Tests for check_js_bare_flag_return_directive.
+
+The check catches a JS/.mjs self-contradiction. A converge workflow states a
+full result-object contract that rules out a bare status flag ("the full down
+result {sha, clean:false, down:true, findings:[]}, never a bare down flag"),
+then, in its agent-prompt prose, tells the agent to "return down: true" — the
+same bare flag the workflow just ruled out. A StructuredOutput run whose
+schema needs every field would reject a lone {down:true}, so the shorthand
+drifts from the contract stated a couple of lines above.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_HOOK_DIRECTORY = Path(__file__).parent
+if str(_HOOK_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(_HOOK_DIRECTORY))
+
+from code_rules_imports_logging import (  # noqa: E402
+    check_js_bare_flag_return_directive,
+)
+
+_MJS_PATH = "skills/autoconverge/workflow/converge.mjs"
+
+_DOWN_CONTRACT = (
+    "the full down result {sha, clean:false, down:true, findings:[]}, "
+    "never a bare down flag"
+)
+
+
+def _contract_with_bare_directive_source() -> str:
+    return (
+        "const PREAMBLE =\n"
+        f"  'When the run carries a result schema, {_DOWN_CONTRACT}.'\n\n"
+        "function gate(head) {\n"
+        "  return spawn(\n"
+        "    `Poll for the review; once the budget runs out with no review on "
+        "HEAD, return down: true.`,\n"
+        "    { label: 'gate' },\n"
+        "  )\n"
+        "}\n"
+    )
+
+
+def _contract_with_full_result_source() -> str:
+    return _contract_with_bare_directive_source().replace(
+        "return down: true",
+        "return {sha:`${head}`, clean:false, down:true, findings:[]}",
+    )
+
+
+def _bare_directive_without_contract_source() -> str:
+    return (
+        "function gate(head) {\n"
+        "  return spawn(\n"
+        "    `Poll for a review; once the budget runs out, return down: true.`,\n"
+        "    { label: 'gate' },\n"
+        "  )\n"
+        "}\n"
+    )
+
+
+def _return_the_result_phrase_source() -> str:
+    return (
+        "const PREAMBLE = 'the full down result {...}, never a bare down flag'\n\n"
+        "function gate(head) {\n"
+        "  return spawn(\n"
+        "    `Out-of-usage notice on HEAD -> return the down result above and stop.`,\n"
+        "    { label: 'gate' },\n"
+        "  )\n"
+        "}\n"
+    )
+
+
+def _contract_with_bare_false_directive_source() -> str:
+    return (
+        "const PREAMBLE =\n"
+        f"  'When the run carries a result schema, {_DOWN_CONTRACT}.'\n\n"
+        "function gate(head) {\n"
+        "  return spawn(\n"
+        "    `Poll for the review; once HEAD stays clean with no findings, "
+        "return down: false.`,\n"
+        "    { label: 'gate' },\n"
+        "  )\n"
+        "}\n"
+    )
+
+
+def _other_flag_name_source() -> str:
+    return (
+        "const PREAMBLE = 'the full result {clean, stale}, never a bare stale flag'\n\n"
+        "function gate(head) {\n"
+        "  return spawn(\n"
+        "    `If nothing lands in the window, return stale: true.`,\n"
+        "    { label: 'gate' },\n"
+        "  )\n"
+        "}\n"
+    )
+
+
+def _capitalized_contract_with_bare_directive_source() -> str:
+    return (
+        "const PREAMBLE =\n"
+        "  'When the run carries a result schema, the full down result "
+        "{sha, clean:false, down:true, findings:[]}, Never a bare Down flag.'\n\n"
+        "function gate(head) {\n"
+        "  return spawn(\n"
+        "    `Poll for the review; once the budget runs out with no review on "
+        "HEAD, return down: true.`,\n"
+        "    { label: 'gate' },\n"
+        "  )\n"
+        "}\n"
+    )
+
+
+def _contract_with_capitalized_directive_source() -> str:
+    return (
+        "const PREAMBLE =\n"
+        f"  'When the run carries a result schema, {_DOWN_CONTRACT}.'\n\n"
+        "function gate(head) {\n"
+        "  return spawn(\n"
+        "    `Poll for the review; once the budget runs out with no review on "
+        "HEAD, Return down: true.`,\n"
+        "    { label: 'gate' },\n"
+        "  )\n"
+        "}\n"
+    )
+
+
+def test_flags_bare_down_directive_when_the_workflow_states_the_contract() -> None:
+    issues = check_js_bare_flag_return_directive(
+        _contract_with_bare_directive_source(), _MJS_PATH
+    )
+    assert len(issues) == 1
+    assert "return down" in issues[0]
+    assert "never a bare down flag" in issues[0]
+
+
+def test_flags_bare_down_false_directive_when_the_workflow_states_the_contract() -> None:
+    issues = check_js_bare_flag_return_directive(
+        _contract_with_bare_false_directive_source(), _MJS_PATH
+    )
+    assert len(issues) == 1
+    assert "return down" in issues[0]
+    assert "never a bare down flag" in issues[0]
+
+
+def test_generalizes_to_any_flag_name_the_contract_rules_out() -> None:
+    issues = check_js_bare_flag_return_directive(_other_flag_name_source(), _MJS_PATH)
+    assert len(issues) == 1
+    assert "return stale" in issues[0]
+
+
+def test_accepts_a_full_result_object_return() -> None:
+    issues = check_js_bare_flag_return_directive(
+        _contract_with_full_result_source(), _MJS_PATH
+    )
+    assert issues == []
+
+
+def test_accepts_a_bare_directive_when_the_workflow_states_no_contract() -> None:
+    issues = check_js_bare_flag_return_directive(
+        _bare_directive_without_contract_source(), _MJS_PATH
+    )
+    assert issues == []
+
+
+def test_accepts_return_the_result_prose_that_names_no_bare_flag() -> None:
+    issues = check_js_bare_flag_return_directive(
+        _return_the_result_phrase_source(), _MJS_PATH
+    )
+    assert issues == []
+
+
+def test_flags_bare_directive_when_contract_uses_capitalized_never() -> None:
+    source = _capitalized_contract_with_bare_directive_source()
+    issues = check_js_bare_flag_return_directive(source, _MJS_PATH)
+    assert len(issues) == 1
+    assert "return down" in issues[0]
+    quoted_contract_phrase = "Never a bare Down flag"
+    assert quoted_contract_phrase in issues[0]
+    assert quoted_contract_phrase in source
+
+
+def test_flags_capitalized_return_directive_against_lowercase_contract() -> None:
+    issues = check_js_bare_flag_return_directive(
+        _contract_with_capitalized_directive_source(), _MJS_PATH
+    )
+    assert len(issues) == 1
+    assert "never a bare down flag" in issues[0]
+
+
+def test_skips_python_files() -> None:
+    issues = check_js_bare_flag_return_directive(
+        _contract_with_bare_directive_source(), "workflow/converge.py"
+    )
+    assert issues == []
+
+
+def _contract_with_six_bare_directives_source() -> str:
+    directive_lines = "\n".join(
+        f"  gate{each_index}(head) {{ return spawn(`return down: true.`) }}"
+        for each_index in range(1, 7)
+    )
+    return (
+        "const PREAMBLE =\n"
+        f"  'When the run carries a result schema, {_DOWN_CONTRACT}.'\n\n"
+        f"{directive_lines}\n"
+    )
+
+
+def test_flags_directive_when_only_directive_line_changed_but_contract_sits_elsewhere() -> None:
+    directive_line_number = 6
+    issues = check_js_bare_flag_return_directive(
+        _contract_with_bare_directive_source(),
+        _MJS_PATH,
+        all_changed_lines={directive_line_number},
+    )
+    assert len(issues) == 1
+    assert "return down" in issues[0]
+
+
+def test_flags_when_only_the_contract_line_changed_and_the_directive_line_did_not() -> None:
+    contract_line_number = 2
+    issues = check_js_bare_flag_return_directive(
+        _contract_with_bare_directive_source(),
+        _MJS_PATH,
+        all_changed_lines={contract_line_number},
+    )
+    assert len(issues) == 1
+    assert "return down" in issues[0]
+
+
+def test_accepts_when_neither_the_contract_nor_the_directive_line_changed() -> None:
+    unrelated_line_number = 3
+    issues = check_js_bare_flag_return_directive(
+        _contract_with_bare_directive_source(),
+        _MJS_PATH,
+        all_changed_lines={unrelated_line_number},
+    )
+    assert issues == []
+
+
+def test_flags_a_changed_line_violation_past_the_cap_of_unchanged_ones() -> None:
+    sixth_directive_line_number = 9
+    issues = check_js_bare_flag_return_directive(
+        _contract_with_six_bare_directives_source(),
+        _MJS_PATH,
+        all_changed_lines={sixth_directive_line_number},
+    )
+    assert len(issues) == 1
+    assert f"Line {sixth_directive_line_number}:" in issues[0]
+
+
+def test_defer_scope_to_caller_returns_the_finding_regardless_of_changed_lines() -> None:
+    unrelated_line_number = 1
+    issues = check_js_bare_flag_return_directive(
+        _contract_with_bare_directive_source(),
+        _MJS_PATH,
+        all_changed_lines={unrelated_line_number},
+        defer_scope_to_caller=True,
+    )
+    assert len(issues) == 1
+    assert "return down" in issues[0]