claude-dev-env 8.71.1 → 8.72.1

package/scripts/tests/test_review_closure_model.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import copy
+import json
 import sys
 from datetime import datetime
 from pathlib import Path
@@ -10,6 +12,7 @@ SCRIPTS_DIRECTORY = Path(__file__).resolve().parents[1]
 if str(SCRIPTS_DIRECTORY) not in sys.path:
     sys.path.insert(0, str(SCRIPTS_DIRECTORY))
 
+import review_closure as command
 import review_closure_model as model
 from dev_env_scripts_constants.review_closure_constants import (
     APPROVALS_CHECK_NAME,
@@ -567,3 +570,130 @@ def should_read_a_person_carrying_a_repository_marker_as_a_comment() -> None:
     )
 
     assert not comment.is_notice
+
+
+CASES = json.loads(
+    (Path(__file__).resolve().parents[1] / "test_files/review_closure/codex_comments.json")
+    .read_text(encoding="utf-8")
+)
+DRIVERS = frozenset({CASES[0]["driver_login"]})
+SLUG = "jl-cmd-projects/claude-dev-env"
+
+
+def _comments(case: dict) -> tuple[model.TopLevelComment, ...]:
+    return tuple(model.parse_top_level_comment(record) for record in case["comments"])
+
+
+@pytest.mark.parametrize("case", CASES, ids=lambda case: str(case["number"]))
+def should_replay_clean_queue_comments_through_the_command(
+    case: dict, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    pr = {"number": case["number"], "head": {"sha": case["head"]},
+          "user": {"login": next(iter(DRIVERS))}}
+    monkeypatch.setattr(command, "github_token", lambda: "fixture-token")
+    monkeypatch.setattr(command, "read_pull_request", lambda *_: pr)
+    monkeypatch.setattr(command, "read_review_threads", lambda *_: ())
+    monkeypatch.setattr(command, "read_top_level_comments", lambda *_: _comments(case))
+    monkeypatch.setattr(command, "read_approvals_conclusion", lambda *_: None)
+
+    assert command.main([SLUG, str(case["number"])]) == 0
+    assert capsys.readouterr().out.startswith(f"CLOSED {SLUG}#{case['number']}")
+
+
+@pytest.mark.parametrize("body", ["@codex review", "@codex security review"])
+def should_treat_a_command_only_request_as_a_notice(body: str) -> None:
+    record = copy.deepcopy(CASES[0]["comments"][0])
+    record["body"] = body
+
+    assert model.parse_top_level_comment(record).is_notice
+
+
+def should_not_credit_a_driver_review_request_as_a_bug_reply() -> None:
+    request = copy.deepcopy(CASES[0]["comments"][0])
+    request["user"]["login"] = next(iter(DRIVERS))
+    bug = copy.deepcopy(request)
+    bug["user"]["login"] = "maintainer"
+    bug["body"] = "The rollback loses the saved profile."
+    bug["created_at"] = bug["updated_at"] = "2026-10-06T11:00:00Z"
+    comments = tuple(model.parse_top_level_comment(record) for record in (bug, request))
+
+    assert len(model.top_level_findings(comments, DRIVERS)) == 1
+    assert model.latest_driver_comment_time(comments, DRIVERS) is None
+
+
+@pytest.mark.parametrize("user_type,login", [
+    ("User", "chatgpt-codex-connector[bot]"),
+    ("Bot", "untrusted[bot]"),
+    ("User", "maintainer"),
+])
+@pytest.mark.parametrize("record_index", [1, 2])
+@pytest.mark.parametrize("case", CASES, ids=lambda case: str(case["number"]))
+def should_retain_a_notice_pasted_by_an_untrusted_author(
+    user_type: str, login: str, record_index: int, case: dict
+) -> None:
+    record = copy.deepcopy(case["comments"][record_index])
+    record["user"] = {"type": user_type, "login": login}
+    comment = model.parse_top_level_comment(record)
+
+    assert not comment.is_notice
+    assert len(model.top_level_findings((comment,), DRIVERS)) == 1
+
+
+@pytest.mark.parametrize("record_index", [0, 1, 2])
+@pytest.mark.parametrize("case", CASES, ids=lambda case: str(case["number"]))
+def should_retain_a_command_or_notice_with_an_appended_finding(record_index: int, case: dict) -> None:
+    record = copy.deepcopy(case["comments"][record_index])
+    record["body"] += "\n\n[P1] The rollback loses the saved profile."
+    comment = model.parse_top_level_comment(record)
+
+    assert not comment.is_notice
+    assert len(model.top_level_findings((comment,), DRIVERS)) == 1
+
+
+@pytest.mark.parametrize("case", CASES, ids=lambda case: str(case["number"]))
+def should_retain_a_finding_inside_the_clean_review_sentence(case: dict) -> None:
+    record = copy.deepcopy(case["comments"][2])
+    record["body"] = record["body"].replace(
+        "Didn't find any major issues.", "Didn't find any major issues. [P1] The rollback loses a profile."
+    )
+
+    assert not model.parse_top_level_comment(record).is_notice
+
+
+def should_retain_a_finding_inside_pasted_notice_metadata() -> None:
+    record = copy.deepcopy(CASES[0]["comments"][2])
+    record["body"] = record["body"].replace(
+        "</details>", "[P1] The rollback loses the saved profile.\n</details>"
+    )
+
+    assert not model.parse_top_level_comment(record).is_notice
+
+
+def should_keep_an_inline_finding_open_beside_clean_notices() -> None:
+    thread = model.ReviewThread(
+        subject="bin/install.mjs", is_resolved=False, is_outdated=False,
+        all_comments=(model.ReviewComment("reviewer", "[P1] The rollback loses a profile."),),
+    )
+
+    findings = model.all_open_findings((thread,), _comments(CASES[0]), DRIVERS, None)
+
+    assert len(findings) == 1
+    assert findings[0].subject == "bin/install.mjs"
+
+
+def should_keep_a_top_level_bug_open_after_a_stale_clean_verdict() -> None:
+    bug = copy.deepcopy(CASES[0]["comments"][0])
+    bug["user"]["login"] = "maintainer"
+    bug["body"] = "[P1] The rollback loses the saved profile."
+    clean = copy.deepcopy(CASES[0]["comments"][2])
+    clean["body"] = clean["body"].replace("e123a99375", "aaaaaaaaaa")
+    comments = tuple(model.parse_top_level_comment(record) for record in (bug, clean))
+
+    assert len(model.top_level_findings(comments, DRIVERS)) == 1
+
+
+def should_keep_a_blocking_approval_open_beside_clean_notices() -> None:
+    findings = model.all_open_findings((), _comments(CASES[0]), DRIVERS, "failure")
+
+    assert len(findings) == 1
+    assert findings[0].subject == "Claude Approvals"

package/hooks/advisory/migration_safety_advisor.py

@@ -1,74 +0,0 @@
-#!/usr/bin/env python3
-"""Advisory hook: warn when Django migrations contain unsafe operations."""
-
-import json
-import re
-import sys
-from pathlib import Path
-
-try:
-    _hooks_dir = str(Path(__file__).resolve().parent.parent)
-    if _hooks_dir not in sys.path:
-        sys.path.insert(0, _hooks_dir)
-
-    from hooks_constants.migration_safety_advisor_constants import (
-        MULTI_EDIT_TOOL_NAME,
-    )
-    from hooks_constants.multi_edit_reconstruction import joined_new_strings
-except ImportError as import_error:
-    raise ImportError(
-        "migration_safety_advisor: cannot import its sibling modules; "
-        "ensure the hooks directory is importable."
-    ) from import_error
-
-MIGRATION_PATH_PATTERN = re.compile(r"[/\\]migrations[/\\]\d{4}_\w+\.py$")
-UNSAFE_OPERATIONS = ["RemoveField", "RenameField", "DeleteModel", "RenameModel"]
-
-
-def _resolve_content(tool_name: str, all_tool_input: dict) -> str:
-    """Return the text a Write, Edit, or MultiEdit payload introduces."""
-    if tool_name == MULTI_EDIT_TOOL_NAME:
-        return joined_new_strings(all_tool_input)
-    return all_tool_input.get("content", "") or all_tool_input.get("new_string", "")
-
-
-def main() -> None:
-    try:
-        hook_input = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        sys.exit(0)
-
-    tool_name = hook_input.get("tool_name", "")
-    tool_input = hook_input.get("tool_input", {})
-    file_path = tool_input.get("file_path", "")
-
-    if not MIGRATION_PATH_PATTERN.search(file_path):
-        sys.exit(0)
-
-    content = _resolve_content(tool_name, tool_input)
-    found_unsafe = [op for op in UNSAFE_OPERATIONS if op in content]
-
-    if found_unsafe:
-        operations = ", ".join(found_unsafe)
-        advisory_message = (
-            f"MIGRATION SAFETY: Contains {operations}. "
-            "After launch, model changes stay backwards-compatible, because running "
-            "instances keep reading the old schema until the deployment finishes. "
-            "Check that this migration keeps those instances working."
-        )
-        advisory_payload = {
-            "systemMessage": advisory_message,
-            "hookSpecificOutput": {
-                "hookEventName": "PreToolUse",
-                "permissionDecision": "allow",
-                "permissionDecisionReason": advisory_message,
-                "additionalContext": advisory_message,
-            },
-        }
-        print(json.dumps(advisory_payload))
-
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/advisory/test_migration_safety_advisor.py

@@ -1,204 +0,0 @@
-"""Behavior tests for migration_safety_advisor through its production entry paths."""
-
-from __future__ import annotations
-
-import json
-import subprocess
-import sys
-from pathlib import Path
-
-
-_ADVISORY_DIRECTORY = Path(__file__).resolve().parent
-_HOOKS_DIRECTORY = _ADVISORY_DIRECTORY.parent
-_ADVISOR_SCRIPT = _ADVISORY_DIRECTORY / "migration_safety_advisor.py"
-_DISPATCHER_SCRIPT = _HOOKS_DIRECTORY / "blocking" / "pre_tool_use_dispatcher.py"
-
-
-def _run_hook(script_path: Path, payload: dict[str, object]) -> dict[str, object] | None:
-    completed_process = subprocess.run(
-        [sys.executable, str(script_path)],
-        check=False,
-        input=json.dumps(payload),
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-    )
-    assert completed_process.returncode == 0
-    if not completed_process.stdout.strip():
-        return None
-    parsed_payload = json.loads(completed_process.stdout)
-    assert isinstance(parsed_payload, dict)
-    return parsed_payload
-
-
-def _build_edit_payload(file_path: Path, new_string: str) -> dict[str, object]:
-    return {
-        "tool_name": "Edit",
-        "tool_input": {
-            "file_path": str(file_path),
-            "old_string": "operations = []",
-            "new_string": new_string,
-        },
-    }
-
-
-def _build_control_payload(tool_name: str, file_path: Path, content: str) -> dict[str, object]:
-    if tool_name == "Write":
-        tool_input: dict[str, object] = {
-            "file_path": str(file_path),
-            "content": content,
-        }
-    else:
-        tool_input = {
-            "file_path": str(file_path),
-            "edits": [{"old_string": "operations = []", "new_string": content}],
-        }
-    return {"tool_name": tool_name, "tool_input": tool_input}
-
-
-def _prepare_fresh_test_pair(migration_path: Path) -> None:
-    """Write a migration module and its paired test file."""
-    migration_path.parent.mkdir(parents=True)
-    migration_path.write_text("operations = []\n", encoding="utf-8")
-    test_path = migration_path.with_name(f"test_{migration_path.stem}.py")
-    test_path.write_text("def test_migration_contract():\n    assert True\n", encoding="utf-8")
-
-
-def _permission_fields(parsed_payload: dict[str, object]) -> dict[str, object]:
-    hook_specific = parsed_payload.get("hookSpecificOutput", {})
-    assert isinstance(hook_specific, dict)
-    return hook_specific
-
-
-def _text_field(field_by_key: dict[str, object], field_name: str) -> str:
-    field_value = field_by_key.get(field_name)
-    assert isinstance(field_value, str)
-    return field_value
-
-
-def test_standalone_advisor_warns_for_unsafe_migration_edit(tmp_path: Path) -> None:
-    migration_path = tmp_path / "billing" / "migrations" / "0002_remove_name.py"
-    payload = _build_edit_payload(migration_path, 'operations = [migrations.RemoveField("name")]')
-
-    advisory_payload = _run_hook(_ADVISOR_SCRIPT, payload)
-    assert advisory_payload is not None
-    permission_fields = _permission_fields(advisory_payload)
-
-    assert permission_fields["permissionDecision"] == "allow"
-    assert "RemoveField" in _text_field(permission_fields, "additionalContext")
-    assert "MIGRATION SAFETY" in _text_field(advisory_payload, "systemMessage")
-
-
-def test_dispatcher_surfaces_migration_warning_for_edit(tmp_path: Path) -> None:
-    migration_path = tmp_path / "billing" / "migrations" / "0002_remove_name.py"
-    _prepare_fresh_test_pair(migration_path)
-    payload = _build_edit_payload(migration_path, 'operations = [migrations.RemoveField("name")]')
-
-    dispatched_payload = _run_hook(_DISPATCHER_SCRIPT, payload)
-    assert dispatched_payload is not None
-    permission_fields = _permission_fields(dispatched_payload)
-
-    assert permission_fields["permissionDecision"] == "allow"
-    assert "RemoveField" in _text_field(permission_fields, "additionalContext")
-    assert "MIGRATION SAFETY" in _text_field(dispatched_payload, "systemMessage")
-
-
-def test_dispatcher_keeps_migration_advisor_write_excluded(tmp_path: Path) -> None:
-    """Write stays out of the migration advisor's roster; only Edit and MultiEdit reach it."""
-    migration_path = tmp_path / "billing" / "migrations" / "0002_remove_name.py"
-    _prepare_fresh_test_pair(migration_path)
-    payload = _build_control_payload(
-        "Write",
-        migration_path,
-        'operations = [migrations.RemoveField("name")]',
-    )
-
-    dispatched_payload = _run_hook(_DISPATCHER_SCRIPT, payload)
-    serialized_payload = json.dumps(dispatched_payload or {})
-
-    assert "MIGRATION SAFETY" not in serialized_payload
-
-
-def test_dispatcher_extends_migration_advisor_to_multi_edit(tmp_path: Path) -> None:
-    """A MultiEdit reaches the migration advisor the same way an Edit does."""
-    migration_path = tmp_path / "billing" / "migrations" / "0002_remove_name.py"
-    _prepare_fresh_test_pair(migration_path)
-    payload = _build_control_payload(
-        "MultiEdit",
-        migration_path,
-        'operations = [migrations.RemoveField("name")]',
-    )
-
-    dispatched_payload = _run_hook(_DISPATCHER_SCRIPT, payload)
-    assert dispatched_payload is not None
-    serialized_payload = json.dumps(dispatched_payload)
-
-    assert "MIGRATION SAFETY" in serialized_payload
-
-
-def _build_multi_edit_payload(
-    file_path: Path, all_edits: list[dict[str, str]]
-) -> dict[str, object]:
-    return {
-        "tool_name": "MultiEdit",
-        "tool_input": {"file_path": str(file_path), "edits": all_edits},
-    }
-
-
-def test_standalone_advisor_warns_for_unsafe_operation_in_second_multi_edit(
-    tmp_path: Path,
-) -> None:
-    """An unsafe operation in the second edit of a MultiEdit is caught, not only the first.
-
-    migration_safety_advisor has no tool_name gate today: it reads
-    tool_input.get("new_string"), a key a MultiEdit payload never carries at
-    the top level. Widening its roster entry alone would silently do
-    nothing on a real MultiEdit call.
-    """
-    migration_path = tmp_path / "billing" / "migrations" / "0002_remove_name.py"
-    payload = _build_multi_edit_payload(
-        migration_path,
-        [
-            {"old_string": "operations = []", "new_string": "operations = [migrations.AddField()]"},
-            {
-                "old_string": "migrations.AddField()",
-                "new_string": 'migrations.AddField(), migrations.RemoveField("name")',
-            },
-        ],
-    )
-
-    advisory_payload = _run_hook(_ADVISOR_SCRIPT, payload)
-    assert advisory_payload is not None
-    permission_fields = _permission_fields(advisory_payload)
-
-    assert permission_fields["permissionDecision"] == "allow"
-    assert "RemoveField" in _text_field(permission_fields, "additionalContext")
-
-
-def test_standalone_advisor_reads_a_write_payloads_content_field(tmp_path: Path) -> None:
-    """_resolve_content's non-MultiEdit branch reads a Write payload's "content" key."""
-    migration_path = tmp_path / "billing" / "migrations" / "0002_remove_name.py"
-    payload: dict[str, object] = {
-        "tool_name": "Write",
-        "tool_input": {
-            "file_path": str(migration_path),
-            "content": 'operations = [migrations.RemoveField("name")]',
-        },
-    }
-
-    advisory_payload = _run_hook(_ADVISOR_SCRIPT, payload)
-    assert advisory_payload is not None
-    assert "RemoveField" in _text_field(
-        _permission_fields(advisory_payload), "additionalContext"
-    )
-
-
-def test_standalone_advisor_is_silent_for_a_clean_multi_edit(tmp_path: Path) -> None:
-    migration_path = tmp_path / "billing" / "migrations" / "0002_remove_name.py"
-    payload = _build_multi_edit_payload(
-        migration_path,
-        [{"old_string": "operations = []", "new_string": "operations = [migrations.AddField()]"}],
-    )
-
-    advisory_payload = _run_hook(_ADVISOR_SCRIPT, payload)
-    assert advisory_payload is None

package/hooks/hooks_constants/issue_tracker_session_starter_constants.py

@@ -1,22 +0,0 @@
-"""Constants for the repository-gated issue-tracker SessionStart starter.
-
-Default off. Set CLAUDE_ISSUE_TRACKER_SESSION_STARTER_ENABLED to 1/true/yes/on.
-Even when enabled, injects only when the session cwd's git root is registered
-in ~/.claude/project-paths.json. Missing registry fails closed (no inject).
-"""
-
-from __future__ import annotations
-
-ISSUE_TRACKER_SESSION_STARTER_ENABLED_ENV_VAR: str = (
-    "CLAUDE_ISSUE_TRACKER_SESSION_STARTER_ENABLED"
-)
-ALL_ISSUE_TRACKER_STARTER_ENABLED_ENV_VALUES: frozenset[str] = frozenset(
-    {"1", "true", "yes", "on"}
-)
-ISSUE_TRACKER_STARTER_TIMEOUT_MILLISECONDS: int = 50
-
-ISSUE_TRACKER_SESSION_START_DIRECTIVE: str = (
-    "SessionStart issue-tracker opt-in is active for this registered repository. "
-    "Load the issue-tracker skill when the session needs one GitHub issue action "
-    "(open epic, file sub-issue, update status, refresh checklist, close sub-issue)."
-)

package/hooks/hooks_constants/migration_safety_advisor_constants.py

@@ -1,7 +0,0 @@
-"""Configuration constants for the migration_safety_advisor PreToolUse hook."""
-
-# The dispatcher constants module is the single source for tool names.
-from hooks_constants.pre_tool_use_dispatcher_constants import (  # noqa: F401
-    MULTI_EDIT_TOOL_NAME,
-)
-

package/hooks/session/issue_tracker_session_starter.py

@@ -1,136 +0,0 @@
-#!/usr/bin/env python3
-"""SessionStart hook — repository-gated issue-tracker context via shared injector.
-
-Default off. When CLAUDE_ISSUE_TRACKER_SESSION_STARTER_ENABLED is set and the
-session cwd's git root appears in ~/.claude/project-paths.json, emit an
-additionalContext directive for the issue-tracker skill. Missing registry or
-unregistered repos fail closed with no output.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-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)
-
-from hooks_constants.issue_tracker_session_starter_constants import (  # noqa: E402
-    ALL_ISSUE_TRACKER_STARTER_ENABLED_ENV_VALUES,
-    ISSUE_TRACKER_SESSION_START_DIRECTIVE,
-    ISSUE_TRACKER_SESSION_STARTER_ENABLED_ENV_VAR,
-    ISSUE_TRACKER_STARTER_TIMEOUT_MILLISECONDS,
-)
-from hooks_constants.pre_tool_use_stdin import (  # noqa: E402
-    read_hook_input_dictionary_from_stdin,
-)
-from hooks_constants.project_paths_reader import (  # noqa: E402
-    find_git_root,
-    load_registry,
-    registry_contains_path,
-)
-from hooks_constants.session_start_injector import (  # noqa: E402
-    InjectorConfiguration,
-    build_additional_context_payload,
-    inject_session_start_context,
-)
-from hooks_constants.session_start_injector_constants import (  # noqa: E402
-    ALL_KNOWN_SESSION_START_SOURCES,
-)
-
-
-def issue_tracker_session_starter_enabled_in_environment() -> bool:
-    """Return True only when the opt-in env var holds an enabled value."""
-    raw_setting = os.environ.get(ISSUE_TRACKER_SESSION_STARTER_ENABLED_ENV_VAR, "")
-    return raw_setting.strip().lower() in ALL_ISSUE_TRACKER_STARTER_ENABLED_ENV_VALUES
-
-
-def repository_is_registered(
-    working_directory: str,
-    registry_by_name: dict[str, str],
-) -> bool:
-    """Return True when cwd git root is a value in the project-paths registry.
-
-    Missing registry, missing git root, or unregistered root fail closed.
-
-    Args:
-        working_directory: Session cwd used to locate the git root.
-        registry_by_name: Name-to-path map; empty map fails closed.
-    """
-    if not registry_by_name:
-        return False
-    git_root = find_git_root(working_directory)
-    if git_root is None:
-        return False
-    return registry_contains_path(registry_by_name, git_root)
-
-
-def build_issue_tracker_injector_configuration(
-    timeout_milliseconds: int,
-) -> InjectorConfiguration:
-    """Build injector config with the issue-tracker directive per known source.
-
-    Args:
-        timeout_milliseconds: Injector budget; zero or less yields timeout status.
-    """
-    context_by_source = {
-        each_source: ISSUE_TRACKER_SESSION_START_DIRECTIVE
-        for each_source in ALL_KNOWN_SESSION_START_SOURCES
-    }
-    return InjectorConfiguration(
-        is_enabled=True,
-        timeout_milliseconds=timeout_milliseconds,
-        context_by_source=context_by_source,
-        default_context_for_unknown="",
-    )
-
-
-def run_issue_tracker_session_starter(
-    payload_by_key: dict[str, object],
-    is_enabled: bool,
-    is_repository_eligible: bool,
-    timeout_milliseconds: int,
-) -> dict[str, object]:
-    """Return additionalContext when opt-in and repo gate both pass, else empty.
-
-    Args:
-        payload_by_key: Parsed SessionStart payload.
-        is_enabled: When False, return empty without calling the injector.
-        is_repository_eligible: When False, return empty without calling the injector.
-        timeout_milliseconds: Injector timeout budget.
-
-    Returns:
-        ``{"hookSpecificOutput": {"hookEventName": "SessionStart", ...}}``
-        when injected, else ``{}``.
-    """
-    if not is_enabled or not is_repository_eligible:
-        return {}
-    configuration = build_issue_tracker_injector_configuration(timeout_milliseconds)
-    injection_result = inject_session_start_context(payload_by_key, configuration)
-    return build_additional_context_payload(injection_result)
-
-
-def main() -> None:
-    """Emit issue-tracker additionalContext when opt-in and registry gate pass."""
-    payload_by_key = read_hook_input_dictionary_from_stdin()
-    if payload_by_key is None:
-        return
-    is_enabled = issue_tracker_session_starter_enabled_in_environment()
-    is_repository_eligible = (
-        repository_is_registered(os.getcwd(), load_registry()) if is_enabled else False
-    )
-    payload = run_issue_tracker_session_starter(
-        payload_by_key,
-        is_enabled,
-        is_repository_eligible,
-        ISSUE_TRACKER_STARTER_TIMEOUT_MILLISECONDS,
-    )
-    if payload:
-        print(json.dumps(payload))
-
-
-if __name__ == "__main__":
-    main()