claude-dev-env 2.26.0 → 2.28.0

package/scripts/codex_compat_materializer.py

@@ -38,6 +38,20 @@ codex_enforcer_script_relative_path = "hooks/blocking/code_rules_enforcer.py"
 codex_enforcer_script_name = "code_rules_enforcer.py"
 codex_enforcer_path_suffix = path_separator + codex_enforcer_script_relative_path
 codex_hook_command_token_pattern = r'''(?:"[^"]*"|'[^']*'|\S+)'''
+codex_hook_records_field_name = "hooks"
+codex_hook_command_field_name = "command"
+codex_hook_matcher_field_name = "matcher"
+codex_retired_hook_relative_path = "session" + path_separator + "untracked_repo_detector.py"
+codex_retired_hook_commands = frozenset(
+    (each_prefix + codex_retired_hook_relative_path).casefold()
+    for each_prefix in (
+        "", "hooks/", "${CLAUDE_PLUGIN_ROOT}/hooks/", "$CODEX_HOME/hooks/",
+        "${CODEX_HOME}/hooks/", "%CODEX_HOME%/hooks/", "$env:CODEX_HOME/hooks/",
+        "${env:CODEX_HOME}/hooks/", "~/.codex/hooks/",
+        "$HOME/.codex/hooks/", "${HOME}/.codex/hooks/"
+    )
+)
+codex_default_home_hook_path_suffix = "/.codex/hooks/" + codex_retired_hook_relative_path
 codex_hook_merge_action = "merge"
 codex_hook_timeout_seconds = 60
 codex_hook_dependency_manifest = (
@@ -627,11 +641,11 @@ def _source_codex_enforcer_hook(
             if not _is_code_rules_enforcer_hook(each_hook):
                 continue
             resolved_hook = dict(each_hook)
-            resolved_hook["command"] = command
+            resolved_hook[codex_hook_command_field_name] = command
             return resolved_hook
     return {
         "type": "command",
-        "command": command,
+        codex_hook_command_field_name: command,
         "timeout": codex_hook_timeout_seconds,
     }
 
@@ -647,7 +661,7 @@ def _hook_records(raw_hooks: object) -> list[dict[str, object]]:
 
 def _is_code_rules_enforcer_hook(all_hook_record: dict[str, object]) -> bool:
     """Report whether a hook record names the focused code-rules enforcer."""
-    command = str(all_hook_record.get("command", ""))
+    command = str(all_hook_record.get(codex_hook_command_field_name, ""))
     normalized_command = command.replace("\\", path_separator)
     all_command_tokens = (
         each_token.strip("\"'")
@@ -660,6 +674,64 @@ def _is_code_rules_enforcer_hook(all_hook_record: dict[str, object]) -> bool:
     )
 
 
+def _is_retired_codex_hook_command(command: object) -> bool:
+    """Report whether a command names a known retired hook path."""
+    if not isinstance(command, str):
+        return False
+    normalized_command = command.replace("\\", path_separator)
+    return any(
+        (
+            each_token.strip("\"'").casefold() in codex_retired_hook_commands
+            or each_token.strip("\"'").casefold().endswith(codex_default_home_hook_path_suffix)
+        )
+        for each_token in re.findall(codex_hook_command_token_pattern, normalized_command)
+    )
+
+
+def _prune_retired_codex_hooks(
+    all_target_manifest: dict[str, object],
+) -> dict[str, object]:
+    """Remove known retired hook groups from every valid event list."""
+    all_events = all_target_manifest.get(codex_hook_records_field_name)
+    if not isinstance(all_events, dict):
+        return dict(all_target_manifest)
+    event_groups_by_name: dict[str, object] = {}
+    for each_event_name, each_raw_groups in all_events.items():
+        if not isinstance(each_raw_groups, list):
+            event_groups_by_name[each_event_name] = each_raw_groups
+            continue
+        all_kept_groups: list[object] = []
+        for each_group in each_raw_groups:
+            if not isinstance(each_group, dict):
+                all_kept_groups.append(each_group)
+                continue
+            all_raw_hooks = each_group.get(codex_hook_records_field_name)
+            if not isinstance(all_raw_hooks, list):
+                all_kept_groups.append(each_group)
+                continue
+            if not isinstance(each_group.get(codex_hook_matcher_field_name), str):
+                all_kept_groups.append(each_group)
+                continue
+            copied_group = dict(each_group)
+            copied_group[codex_hook_records_field_name] = [
+                each_hook
+                for each_hook in all_raw_hooks
+                if not (
+                    isinstance(each_hook, dict)
+                    and _is_retired_codex_hook_command(
+                        each_hook.get(codex_hook_command_field_name)
+                    )
+                )
+            ]
+            if not all_raw_hooks or copied_group[codex_hook_records_field_name]:
+                all_kept_groups.append(copied_group)
+        if all_kept_groups:
+            event_groups_by_name[each_event_name] = all_kept_groups
+    pruned_manifest = dict(all_target_manifest)
+    pruned_manifest[codex_hook_records_field_name] = event_groups_by_name
+    return pruned_manifest
+
+
 def _codex_enforcer_hooks(all_manifest: object) -> tuple[dict[str, object], ...]:
     """Return enforcer records from the target apply-patch matcher."""
     if not isinstance(all_manifest, dict):
@@ -674,7 +746,13 @@ def _codex_enforcer_hooks(all_manifest: object) -> tuple[dict[str, object], ...]
     for each_entry in all_pre_tool_use:
         if not isinstance(each_entry, dict) or each_entry.get("matcher") != codex_hook_matcher:
             continue
-        for each_hook in _hook_records(each_entry.get("hooks", [])):
+        try:
+            all_hook_records = _hook_records(
+                each_entry.get(codex_hook_records_field_name, [])
+            )
+        except MaterializerError:
+            continue
+        for each_hook in all_hook_records:
             if _is_code_rules_enforcer_hook(each_hook):
                 all_enforcer_hooks.append(each_hook)
     return tuple(all_enforcer_hooks)
@@ -699,43 +777,52 @@ def _merge_codex_hook_manifest(
     all_target_manifest: dict[str, object], all_focused_hook: dict[str, object]
 ) -> dict[str, object]:
     """Preserve target hook order while merging one deterministic enforcer entry."""
-    all_events = all_target_manifest.get("hooks", {})
+    all_events = all_target_manifest.get(codex_hook_records_field_name, {})
     if not isinstance(all_events, dict):
         raise MaterializerError("Codex hook manifest requires a hooks object")
     all_pre_tool_use = all_events.get(codex_hook_event_name, [])
     if not isinstance(all_pre_tool_use, list):
         raise MaterializerError("Codex hook manifest requires a PreToolUse list")
-    merged_pre_tool_use: list[dict[str, object]] = []
+    merged_pre_tool_use: list[object] = []
     merged_apply_patch_entry: dict[str, object] | None = None
     merged_hooks: list[dict[str, object]] = []
     for each_entry in all_pre_tool_use:
         if not isinstance(each_entry, dict):
-            raise MaterializerRunFatal("Codex hook manifest requires valid matcher entries")
+            merged_pre_tool_use.append(each_entry)
+            continue
         copied_entry = dict(each_entry)
         if copied_entry.get("matcher") != codex_hook_matcher:
             merged_pre_tool_use.append(copied_entry)
             continue
-        all_hook_records = _hook_records(copied_entry.get("hooks", []))
+        all_hook_records = copied_entry.get(codex_hook_records_field_name, [])
+        if not isinstance(all_hook_records, list) or not all(
+            isinstance(each_hook, dict) for each_hook in all_hook_records
+        ):
+            merged_pre_tool_use.append(copied_entry)
+            continue
         if merged_apply_patch_entry is None:
             merged_apply_patch_entry = copied_entry
             merged_hooks = [
                 each_hook for each_hook in all_hook_records if not _is_code_rules_enforcer_hook(each_hook)
             ]
-            merged_apply_patch_entry["hooks"] = merged_hooks
+            merged_apply_patch_entry[codex_hook_records_field_name] = merged_hooks
             merged_pre_tool_use.append(merged_apply_patch_entry)
         else:
             merged_hooks.extend(
                 each_hook for each_hook in all_hook_records if not _is_code_rules_enforcer_hook(each_hook)
             )
     if merged_apply_patch_entry is None:
-        merged_apply_patch_entry = {"matcher": codex_hook_matcher, "hooks": merged_hooks}
+        merged_apply_patch_entry = {
+            "matcher": codex_hook_matcher,
+            codex_hook_records_field_name: merged_hooks,
+        }
         merged_pre_tool_use.append(merged_apply_patch_entry)
     merged_hooks.append(all_focused_hook)
     merged_events = dict(all_events)
     merged_events[codex_hook_event_name] = merged_pre_tool_use
     merged_manifest = dict(all_target_manifest)
-    merged_manifest["hooks"] = merged_events
-    return merged_manifest
+    merged_manifest[codex_hook_records_field_name] = merged_events
+    return _prune_retired_codex_hooks(merged_manifest)
 
 
 def _build_codex_hook_projection(config: MaterializerConfig) -> PlannedFile | None:

package/scripts/tests/test_codex_compat_materializer.py

@@ -2,7 +2,7 @@ import json
 import subprocess
 import sys
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 import pytest
 import tomllib
@@ -30,6 +30,23 @@ from codex_compat_materializer import (
 )
 
 
+def _required_manifest_path(config: MaterializerConfig) -> Path:
+    assert config.manifest_path is not None
+    return config.manifest_path
+
+
+def _manifest_files(manifest_path: Path) -> dict[str, dict[str, object]]:
+    return cast(dict[str, dict[str, object]], load_manifest(manifest_path)["files"])
+
+
+def _hook_group(matcher: str, *all_hook_commands: str) -> dict[str, object]:
+    return {"matcher": matcher, "hooks": [{"type": "command", "command": each_command} for each_command in all_hook_commands]}
+
+
+def _hook_commands(manifest: dict[str, Any], event_name: str) -> list[str]:
+    return [each_hook["command"] for each_group in manifest["hooks"][event_name] for each_hook in each_group["hooks"]]
+
+
 def test_conversion_escapes_toml_content() -> None:
     agent = parse_frontmatter(Path("agent.md"), '---\nname: sample\ndescription: "say \\"hi\\""\ntools: ["Read", "Write"]\n---\n', "agent.md")
     converted = convert_agent(agent)
@@ -196,7 +213,7 @@ def test_case_folded_target_collisions_include_existing_and_manifest(tmp_path: P
 def test_manifest_target_collision_is_rejected(tmp_path: Path) -> None:
     config = MaterializerConfig(tmp_path / "source", tmp_path / "target", should_apply=True)
     planned = [PlannedFile("a.md", "Luna.toml", "managed", "hash")]
-    atomic_write(config.manifest_path, '{"files": {"luna.TOML": {}}, "version": 1}\n')
+    atomic_write(_required_manifest_path(config), '{"files": {"luna.TOML": {}}, "version": 1}\n')
     with pytest.raises(MaterializerError):
         publish_plan(config, planned)
 
@@ -206,12 +223,12 @@ def test_first_run_manifest_target_collision_is_rejected(tmp_path: Path) -> None
     target = tmp_path / "target"
     source.mkdir()
     config = MaterializerConfig(source, target, should_apply=True)
-    planned = [PlannedFile("a.md", config.manifest_path.name, "managed", "hash")]
+    planned = [PlannedFile("a.md", _required_manifest_path(config).name, "managed", "hash")]
 
     with pytest.raises(MaterializerError, match="compatibility manifest"):
         publish_plan(config, planned)
 
-    assert not config.manifest_path.exists()
+    assert not _required_manifest_path(config).exists()
     assert not config.target_root.exists()
 
 
@@ -238,11 +255,11 @@ def test_dry_run_is_non_mutating_and_writes_are_idempotent(tmp_path: Path) -> No
     planned, report = build_plan(apply_config)
     publish_plan(apply_config, planned, report)
     first = (target / "Luna.toml").read_text(encoding="utf-8")
-    first_manifest = apply_config.manifest_path.read_bytes()
+    first_manifest = _required_manifest_path(apply_config).read_bytes()
     planned, report = build_plan(apply_config)
     second_report = publish_plan(apply_config, planned, report)
     assert (target / "Luna.toml").read_text(encoding="utf-8") == first
-    assert apply_config.manifest_path.read_bytes() == first_manifest
+    assert _required_manifest_path(apply_config).read_bytes() == first_manifest
     assert second_report.written == 0
     assert second_report.deleted == 0
     assert second_report.errors == 0
@@ -292,13 +309,13 @@ def test_manifest_is_published_last_and_previous_manifest_survives_failure(tmp_p
     target = tmp_path / "target"
     source.mkdir()
     config = MaterializerConfig(source, target, should_apply=True)
-    manifest = config.manifest_path
+    manifest = _required_manifest_path(config)
     manifest.parent.mkdir()
     atomic_write(manifest, '{"files": {}, "version": 1}\n')
     planned = [PlannedFile("agent.md", "Luna.toml", "managed", "hash")]
     with pytest.raises(RuntimeError):
         publish_plan(config, planned, failure_injector=lambda _: (_ for _ in ()).throw(RuntimeError("stop")))
-    assert load_manifest(manifest)["files"] == {}
+    assert _manifest_files(manifest) == {}
     assert not (target / "Luna.toml").exists()
 
 
@@ -399,7 +416,7 @@ def test_report_contains_deterministic_category_details_and_error_count(
     assert (target / "Luna.toml").read_text(encoding="utf-8") == "new"
 
     (target / "Luna.toml").write_text("changed", encoding="utf-8")
-    atomic_write(config.manifest_path, json.dumps({"version": 1, "files": {
+    atomic_write(_required_manifest_path(config), json.dumps({"version": 1, "files": {
         "Luna.toml": {"hash": hash_content(managed_content)}
     }}))
     stale_report = publish_plan(pruning_config, [])
@@ -407,7 +424,7 @@ def test_report_contains_deterministic_category_details_and_error_count(
     assert stale_report.details["stale_managed"] == []
 
     (target / "Luna.toml").write_text(managed_content, encoding="utf-8")
-    atomic_write(config.manifest_path, json.dumps({"version": 1, "files": {
+    atomic_write(_required_manifest_path(config), json.dumps({"version": 1, "files": {
         "Luna.toml": {"hash": hash_content(managed_content)}
     }}))
     deleted_report = publish_plan(pruning_config, [])
@@ -423,7 +440,7 @@ def test_report_contains_deterministic_category_details_and_error_count(
     assert collision_report.details["conflicted"] == ["Nova.toml"]
 
     manifest = {"version": 1, "files": {"Missing.toml": {"hash": hash_content("missing")}}}
-    atomic_write(config.manifest_path, json.dumps(manifest))
+    atomic_write(_required_manifest_path(config), json.dumps(manifest))
     error_report = publish_plan(pruning_config, [])
     assert error_report.errors == 1
     assert error_report.error_details == ["missing managed path: Missing.toml"]
@@ -582,7 +599,7 @@ def test_reapply_rewrites_a_managed_file_whose_source_description_changed(
     assert 'description = "Light"' not in published_text
     assert refreshed_report.written == 1
     assert refreshed_report.conflicted == 0
-    assert load_manifest(config.manifest_path)["files"]["Luna.toml"]["hash"] == hash_content(
+    assert _manifest_files(_required_manifest_path(config))["Luna.toml"]["hash"] == hash_content(
         published_text
     )
 
@@ -624,7 +641,7 @@ def test_crash_orphan_matching_the_plan_is_adopted_into_the_manifest(tmp_path: P
     assert adoption_report.errors == 0
     assert adoption_report.details["adopted"] == ["Nova.toml"]
     assert (target / "Nova.toml").read_text(encoding="utf-8") == orphan_content
-    assert load_manifest(config.manifest_path)["files"]["Nova.toml"]["hash"] == hash_content(
+    assert _manifest_files(_required_manifest_path(config))["Nova.toml"]["hash"] == hash_content(
         orphan_content
     )
 
@@ -806,7 +823,7 @@ def test_build_plan_publishes_owned_agents_projection_and_tracks_drift(
 
     projected_path = target / "AGENTS.md"
     first_projection = projected_path.read_text(encoding="utf-8")
-    manifest_record = load_manifest(config.manifest_path)["files"]["AGENTS.md"]
+    manifest_record = _manifest_files(_required_manifest_path(config))["AGENTS.md"]
     assert manifest_record["ownership"] == "codex-compat"
     assert manifest_record["source"] == "rules/failure-blast-radius.md"
 
@@ -871,6 +888,7 @@ def _prepare_projection_fixture(
     existing_hooks = {
         "hooks": {
             "PreToolUse": [
+                {"matcher": "apply_patch"},
                 {
                     "matcher": "Write|Edit",
                     "hooks": [{"type": "command", "command": "python existing.py"}],
@@ -894,6 +912,28 @@ def _prepare_projection_fixture(
                     ],
                 },
             ],
+            "SessionStart": [_hook_group(
+                "",
+                "python3 %CODEX_HOME%\\hooks\\session\\untracked_repo_detector.py",
+                "python3 $env:CODEX_HOME/hooks/session/untracked_repo_detector.py",
+                "python3 ${env:CODEX_HOME}/hooks/session/untracked_repo_detector.py",
+                "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/fix_worktree_hookspath.py",
+            )],
+            "UserPromptSubmit": [_hook_group(
+                "",
+                "python3 /home/example/custom/hooks/session/untracked_repo_detector.py",
+                "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/untracked_repo_detector.py.bak",
+            )],
+            "ConfigChange": [
+                None,
+                {"matcher": "partial"},
+                {"matcher": "malformed", "hooks": "not a list"},
+                {"matcher": "malformed-hook", "hooks": [{"command": 7}]},
+                {"hooks": [{"command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/untracked_repo_detector.py"}]},
+                _hook_group(
+                    "retired", "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/untracked_repo_detector.py"
+                ),
+            ],
             "Bash": [{"matcher": "", "hooks": []}],
         }
     }
@@ -938,7 +978,8 @@ def _assert_projection_and_manifest(
     projected_instruction = (target / "AGENTS.md").read_text(encoding="utf-8")
     assert "Three real attempts, then park." in projected_instruction
     manifest = json.loads((target / "hooks.json").read_text(encoding="utf-8"))
-    assert manifest["hooks"]["PreToolUse"][0] == existing_hooks["hooks"]["PreToolUse"][0]
+    assert manifest["hooks"]["PreToolUse"][0]["matcher"] == "apply_patch"
+    assert manifest["hooks"]["PreToolUse"][1] == existing_hooks["hooks"]["PreToolUse"][1]
     apply_patch_entries = [
         each_entry
         for each_entry in manifest["hooks"]["PreToolUse"]
@@ -953,7 +994,15 @@ def _assert_projection_and_manifest(
         f'python3 "{target / "hooks" / "blocking" / "code_rules_enforcer.py"}"'
     )
     assert managed_command in apply_patch_commands
-    manifest_record = load_manifest(target / ".codex-compat-manifest.json")["files"]
+    expected_commands_by_event = {
+        "SessionStart": ["python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/fix_worktree_hookspath.py"],
+        "UserPromptSubmit": ["python3 /home/example/custom/hooks/session/untracked_repo_detector.py", "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/untracked_repo_detector.py.bak"],
+    }
+    for each_event_name, expected_commands in expected_commands_by_event.items():
+        assert _hook_commands(manifest, each_event_name) == expected_commands
+    assert manifest["hooks"]["ConfigChange"] == existing_hooks["hooks"]["ConfigChange"][:5]
+    assert manifest["hooks"]["Bash"] == existing_hooks["hooks"]["Bash"]
+    manifest_record = _manifest_files(target / ".codex-compat-manifest.json")
     assert manifest_record["AGENTS.md"]["ownership"] == "codex-compat"
     assert manifest_record["hooks.json"]["source"] == "hooks/hooks.json"
 
@@ -984,12 +1033,14 @@ def _assert_detached_enforcer_behavior(target: Path) -> None:
     assert allow_run.returncode == 0
     assert allow_run.stdout == ""
 
+    allow_tool_input = allow_payload["tool_input"]
+    assert isinstance(allow_tool_input, dict)
+    allow_command = allow_tool_input["command"]
+    assert isinstance(allow_command, str)
     deny_payload = {
         **allow_payload,
         "tool_input": {
-            "command": allow_payload["tool_input"]["command"].replace(
-                "AssetItemBlocked", "RuntimeError"
-            )
+            "command": allow_command.replace("AssetItemBlocked", "RuntimeError")
         },
     }
     deny_run = subprocess.run(