claude-dev-env 8.72.0 → 8.72.2

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/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/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()

package/hooks/session/test_issue_tracker_session_starter.py

@@ -1,106 +0,0 @@
-"""Tests for the repository-gated issue-tracker SessionStart starter."""
-
-from __future__ import annotations
-
-import json
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-import pytest
-
-_HOOKS_ROOT = Path(__file__).resolve().parent.parent
-if str(_HOOKS_ROOT) not in sys.path:
-    sys.path.insert(0, str(_HOOKS_ROOT))
-
-from hooks_constants.issue_tracker_session_starter_constants import (
-    ISSUE_TRACKER_SESSION_START_DIRECTIVE,
-    ISSUE_TRACKER_SESSION_STARTER_ENABLED_ENV_VAR,
-    ISSUE_TRACKER_STARTER_TIMEOUT_MILLISECONDS,
-)
-from session.issue_tracker_session_starter import (
-    issue_tracker_session_starter_enabled_in_environment,
-    repository_is_registered,
-    run_issue_tracker_session_starter,
-)
-
-STARTER_SCRIPT = Path(__file__).resolve().parent / "issue_tracker_session_starter.py"
-DEFAULT_TIMEOUT = ISSUE_TRACKER_STARTER_TIMEOUT_MILLISECONDS
-
-
-def test_default_environment_is_disabled(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.delenv(ISSUE_TRACKER_SESSION_STARTER_ENABLED_ENV_VAR, raising=False)
-    assert issue_tracker_session_starter_enabled_in_environment() is False
-
-
-def test_enabled_env_values(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setenv(ISSUE_TRACKER_SESSION_STARTER_ENABLED_ENV_VAR, "1")
-    assert issue_tracker_session_starter_enabled_in_environment() is True
-    monkeypatch.setenv(ISSUE_TRACKER_SESSION_STARTER_ENABLED_ENV_VAR, "true")
-    assert issue_tracker_session_starter_enabled_in_environment() is True
-
-
-def test_disabled_or_ineligible_emits_nothing() -> None:
-    assert (
-        run_issue_tracker_session_starter(
-            {"source": "startup"}, False, True, DEFAULT_TIMEOUT
-        )
-        == {}
-    )
-    assert (
-        run_issue_tracker_session_starter(
-            {"source": "startup"}, True, False, DEFAULT_TIMEOUT
-        )
-        == {}
-    )
-
-
-def test_enabled_eligible_startup_emits_directive() -> None:
-    payload = run_issue_tracker_session_starter(
-        {"source": "startup"}, True, True, DEFAULT_TIMEOUT
-    )
-    hook_output = payload["hookSpecificOutput"]
-    assert hook_output["hookEventName"] == "SessionStart"
-    assert hook_output["additionalContext"] == ISSUE_TRACKER_SESSION_START_DIRECTIVE
-
-
-def test_timeout_zero_emits_nothing() -> None:
-    assert (
-        run_issue_tracker_session_starter({"source": "startup"}, True, True, 0) == {}
-    )
-
-
-def test_unknown_source_emits_nothing() -> None:
-    assert (
-        run_issue_tracker_session_starter({"source": "weird"}, True, True, DEFAULT_TIMEOUT)
-        == {}
-    )
-
-
-def test_repository_is_registered_fail_closed_empty_registry() -> None:
-    assert repository_is_registered("/any/path", {}) is False  # empty registry fails closed
-
-
-def test_repository_is_registered_matches_git_root(tmp_path: Path) -> None:
-    (tmp_path / ".git").mkdir()
-    child = tmp_path / "pkg"
-    child.mkdir()
-    registry = {"demo": str(tmp_path)}
-    assert repository_is_registered(str(child), registry) is True
-    assert repository_is_registered(str(tmp_path / "other"), {"demo": str(tmp_path / "nope")}) is False
-
-
-def test_main_disabled_prints_nothing() -> None:
-    environment_by_key = os.environ.copy()
-    environment_by_key.pop(ISSUE_TRACKER_SESSION_STARTER_ENABLED_ENV_VAR, None)
-    completed = subprocess.run(
-        [sys.executable, str(STARTER_SCRIPT)],
-        input=json.dumps({"source": "startup"}),
-        capture_output=True,
-        text=True,
-        check=False,
-        env=environment_by_key,
-    )
-    assert completed.returncode == 0
-    assert completed.stdout.strip() == ""