claude-dev-env 8.117.0 → 8.117.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/bin/ever-registered-hooks.test.mjs +4 -0
- package/hooks/blocking/test_turn_review_child.py +166 -0
- package/hooks/blocking/test_turn_review_claim.py +194 -0
- package/hooks/blocking/test_turn_review_repositories.py +65 -0
- package/hooks/blocking/test_turn_review_state.py +132 -0
- package/hooks/blocking/test_turn_review_transcript.py +125 -0
- package/hooks/blocking/turn_review_child.py +145 -0
- package/hooks/blocking/turn_review_claim.py +306 -0
- package/hooks/blocking/turn_review_gate.py +32 -808
- package/hooks/blocking/turn_review_repositories.py +58 -0
- package/hooks/blocking/turn_review_state.py +260 -0
- package/hooks/blocking/turn_review_transcript.py +158 -0
- package/hooks/features/conduct-gates.md +1 -1
- package/hooks/hooks_constants/session_title_constants.py +2 -2
- package/hooks/routing/test_thread_spawn_pace_hook.py +32 -0
- package/hooks/session/test_background_silence_prompt.py +8 -0
- package/hooks/session/test_tracking_nudge.py +11 -0
- package/hooks/session_title_transcript.py +38 -17
- package/hooks/test_session_title_transcript.py +31 -0
- package/package.json +1 -1
- package/scripts/account_broker_support.py +24 -5
- package/scripts/dev_env_scripts_constants/account_broker_constants.py +1 -0
- package/scripts/policy_lint/config/approved_test_pairs.py +27 -0
- package/scripts/test_account_broker_support.py +43 -1
- package/scripts/tests/test_policy_lint_rules_pairing.py +24 -0
|
@@ -20,6 +20,10 @@ test('EVER_REGISTERED_HOOK_RELATIVE_PATHS includes every script the package regi
|
|
|
20
20
|
);
|
|
21
21
|
});
|
|
22
22
|
|
|
23
|
+
test('EVER_REGISTERED_HOOK_RELATIVE_PATHS keeps the question brief gate', () => {
|
|
24
|
+
assert.ok(EVER_REGISTERED_HOOK_RELATIVE_PATHS.has('blocking/question_brief_gate.py'));
|
|
25
|
+
});
|
|
26
|
+
|
|
23
27
|
test('EVER_REGISTERED_HOOK_RELATIVE_PATHS keeps the retired merge-over-review card gate', () => {
|
|
24
28
|
assert.equal(
|
|
25
29
|
EVER_REGISTERED_HOOK_RELATIVE_PATHS.has('blocking/merge_over_review_offer_gate.py'),
|
|
@@ -0,0 +1,166 @@
|
|
|
1
|
+
import json
|
|
2
|
+
import sys
|
|
3
|
+
import tempfile
|
|
4
|
+
from pathlib import Path
|
|
5
|
+
|
|
6
|
+
import pytest
|
|
7
|
+
|
|
8
|
+
from hooks_constants.turn_review_gate_constants import REVIEW_FAILURE_DIAGNOSTIC_TEMPLATE
|
|
9
|
+
from turn_review_child import (
|
|
10
|
+
_child_stdout,
|
|
11
|
+
_ChildRun,
|
|
12
|
+
_judge_command,
|
|
13
|
+
_review_command,
|
|
14
|
+
_review_environment,
|
|
15
|
+
)
|
|
16
|
+
|
|
17
|
+
PARENT_SESSION_VARIABLES = (
|
|
18
|
+
"CLAUDE_CODE_SESSION_ID",
|
|
19
|
+
"CLAUDE_CODE_REMOTE_SESSION_ID",
|
|
20
|
+
"CLAUDE_CODE_MESSAGING_SOCKET",
|
|
21
|
+
"CLAUDE_CODE_MESSAGING_TOKEN",
|
|
22
|
+
"CLAUDE_SESSION_INGRESS_TOKEN_FILE",
|
|
23
|
+
"CLAUDE_CODE_POST_FOR_SESSION_INGRESS_V2",
|
|
24
|
+
"CLAUDE_CODE_TEE_SDK_STDOUT",
|
|
25
|
+
)
|
|
26
|
+
CHILD_REPORT_SOURCE = """import json
|
|
27
|
+
import os
|
|
28
|
+
import sys
|
|
29
|
+
|
|
30
|
+
print(json.dumps({
|
|
31
|
+
"cwd": os.getcwd(),
|
|
32
|
+
"stdin": sys.stdin.read(),
|
|
33
|
+
"marker": os.environ.get("CLAUDE_TURN_REVIEW_CHILD"),
|
|
34
|
+
"parent_session": os.environ.get("CLAUDE_CODE_SESSION_ID"),
|
|
35
|
+
}))
|
|
36
|
+
"""
|
|
37
|
+
FAILING_CHILD_SOURCE = """import sys
|
|
38
|
+
|
|
39
|
+
print("partial review")
|
|
40
|
+
sys.exit(3)
|
|
41
|
+
"""
|
|
42
|
+
SLOW_CHILD_SOURCE = """import time
|
|
43
|
+
|
|
44
|
+
time.sleep(5)
|
|
45
|
+
print("late review")
|
|
46
|
+
"""
|
|
47
|
+
|
|
48
|
+
|
|
49
|
+
@pytest.fixture(autouse=True)
|
|
50
|
+
def isolated_home(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
|
|
51
|
+
home_directory = tmp_path / "home"
|
|
52
|
+
home_directory.mkdir()
|
|
53
|
+
state_directory = tmp_path / "state"
|
|
54
|
+
state_directory.mkdir()
|
|
55
|
+
monkeypatch.setenv("HOME", str(home_directory))
|
|
56
|
+
monkeypatch.setenv("USERPROFILE", str(home_directory))
|
|
57
|
+
monkeypatch.setattr(tempfile, "tempdir", str(state_directory))
|
|
58
|
+
return home_directory
|
|
59
|
+
|
|
60
|
+
|
|
61
|
+
@pytest.fixture
|
|
62
|
+
def checkout(tmp_path: Path) -> Path:
|
|
63
|
+
repository_root = tmp_path / "app"
|
|
64
|
+
repository_root.mkdir()
|
|
65
|
+
return repository_root
|
|
66
|
+
|
|
67
|
+
|
|
68
|
+
def child_run(
|
|
69
|
+
tmp_path: Path, repository_root: Path, child_source: str, prompt_text: str | None
|
|
70
|
+
) -> _ChildRun:
|
|
71
|
+
child_script = tmp_path / "child.py"
|
|
72
|
+
child_script.write_text(child_source)
|
|
73
|
+
return _ChildRun(
|
|
74
|
+
repository_root,
|
|
75
|
+
[sys.executable, str(child_script)],
|
|
76
|
+
prompt_text,
|
|
77
|
+
REVIEW_FAILURE_DIAGNOSTIC_TEMPLATE,
|
|
78
|
+
)
|
|
79
|
+
|
|
80
|
+
|
|
81
|
+
def log_lines(home_directory: Path) -> list[str]:
|
|
82
|
+
log_path = home_directory / ".claude" / "logs" / "turn-review.log"
|
|
83
|
+
return log_path.read_text().splitlines() if log_path.exists() else []
|
|
84
|
+
|
|
85
|
+
|
|
86
|
+
def test_should_build_the_review_command_for_the_range_with_read_only_options(
|
|
87
|
+
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
|
88
|
+
) -> None:
|
|
89
|
+
stub_directory = tmp_path / "bin"
|
|
90
|
+
stub_directory.mkdir()
|
|
91
|
+
stub_claude = stub_directory / "claude"
|
|
92
|
+
stub_claude.write_text("")
|
|
93
|
+
stub_claude.chmod(0o755)
|
|
94
|
+
monkeypatch.setenv("PATH", str(stub_directory))
|
|
95
|
+
review_command = _review_command("aaa111", "bbb222")
|
|
96
|
+
assert review_command[:7] == [
|
|
97
|
+
str(stub_claude),
|
|
98
|
+
"-p",
|
|
99
|
+
"/code-review low aaa111..bbb222",
|
|
100
|
+
"--model",
|
|
101
|
+
"sonnet",
|
|
102
|
+
"--effort",
|
|
103
|
+
"high",
|
|
104
|
+
]
|
|
105
|
+
assert review_command[review_command.index("--tools") + 1] == "Read,Grep,Glob,Bash"
|
|
106
|
+
assert review_command[review_command.index("--permission-mode") + 1] == "dontAsk"
|
|
107
|
+
assert json.loads(review_command[review_command.index("--settings") + 1]) == {
|
|
108
|
+
"disableAllHooks": True
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
|
|
112
|
+
def test_should_build_the_judge_command_with_no_prompt_argument(
|
|
113
|
+
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
|
114
|
+
) -> None:
|
|
115
|
+
monkeypatch.setenv("PATH", str(tmp_path))
|
|
116
|
+
judge_command = _judge_command()
|
|
117
|
+
assert judge_command[:6] == ["claude", "-p", "--model", "sonnet", "--effort", "high"]
|
|
118
|
+
assert "--no-session-persistence" in judge_command
|
|
119
|
+
|
|
120
|
+
|
|
121
|
+
def test_should_drop_every_parent_session_variable_from_the_child_environment(
|
|
122
|
+
monkeypatch: pytest.MonkeyPatch,
|
|
123
|
+
) -> None:
|
|
124
|
+
for each_name in PARENT_SESSION_VARIABLES:
|
|
125
|
+
monkeypatch.setenv(each_name, "parent-value")
|
|
126
|
+
monkeypatch.setenv("TURN_REVIEW_KEPT_VARIABLE", "kept")
|
|
127
|
+
child_environment = _review_environment()
|
|
128
|
+
assert [
|
|
129
|
+
each_name for each_name in PARENT_SESSION_VARIABLES if each_name in child_environment
|
|
130
|
+
] == []
|
|
131
|
+
assert child_environment["CLAUDE_TURN_REVIEW_CHILD"] == "1"
|
|
132
|
+
assert child_environment["TURN_REVIEW_KEPT_VARIABLE"] == "kept"
|
|
133
|
+
|
|
134
|
+
|
|
135
|
+
def test_should_run_the_child_in_the_checkout_with_the_prompt_on_stdin(
|
|
136
|
+
tmp_path: Path, checkout: Path, monkeypatch: pytest.MonkeyPatch
|
|
137
|
+
) -> None:
|
|
138
|
+
monkeypatch.setenv("CLAUDE_CODE_SESSION_ID", "parent-session")
|
|
139
|
+
child_output = _child_stdout(
|
|
140
|
+
child_run(tmp_path, checkout, CHILD_REPORT_SOURCE, "judge data"), 30
|
|
141
|
+
)
|
|
142
|
+
assert child_output is not None
|
|
143
|
+
assert json.loads(child_output) == {
|
|
144
|
+
"cwd": str(checkout.resolve()),
|
|
145
|
+
"stdin": "judge data",
|
|
146
|
+
"marker": "1",
|
|
147
|
+
"parent_session": None,
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
|
|
151
|
+
def test_should_give_no_output_and_log_a_child_that_exits_with_an_error(
|
|
152
|
+
tmp_path: Path, checkout: Path, isolated_home: Path
|
|
153
|
+
) -> None:
|
|
154
|
+
assert _child_stdout(child_run(tmp_path, checkout, FAILING_CHILD_SOURCE, None), 30) is None
|
|
155
|
+
assert [each_line.split(" ", 1)[1] for each_line in log_lines(isolated_home)] == [
|
|
156
|
+
"[turn_review_gate] review of app did not finish: exit 3"
|
|
157
|
+
]
|
|
158
|
+
|
|
159
|
+
|
|
160
|
+
def test_should_give_no_output_and_log_a_child_that_runs_out_of_time(
|
|
161
|
+
tmp_path: Path, checkout: Path, isolated_home: Path
|
|
162
|
+
) -> None:
|
|
163
|
+
assert _child_stdout(child_run(tmp_path, checkout, SLOW_CHILD_SOURCE, None), 0.5) is None
|
|
164
|
+
assert [each_line.split(" ", 1)[1] for each_line in log_lines(isolated_home)] == [
|
|
165
|
+
"[turn_review_gate] review of app did not finish: timed out"
|
|
166
|
+
]
|
|
@@ -0,0 +1,194 @@
|
|
|
1
|
+
import subprocess
|
|
2
|
+
import tempfile
|
|
3
|
+
from pathlib import Path
|
|
4
|
+
|
|
5
|
+
import pytest
|
|
6
|
+
|
|
7
|
+
from hooks_constants.turn_review_gate_constants import BLOCK_REASON_TEMPLATE
|
|
8
|
+
from turn_review_claim import (
|
|
9
|
+
_claim_locked_stop,
|
|
10
|
+
_is_wake_prompt,
|
|
11
|
+
_JudgeRequest,
|
|
12
|
+
_judge_requests,
|
|
13
|
+
_locked_stop_wake,
|
|
14
|
+
_prompt_baselines,
|
|
15
|
+
)
|
|
16
|
+
from turn_review_findings import JudgeVerdict
|
|
17
|
+
from turn_review_snapshot import working_tree_snapshot
|
|
18
|
+
from turn_review_state import _Finding, _load_state, _ReviewState, _save_state
|
|
19
|
+
|
|
20
|
+
SESSION_ID = "claim-session"
|
|
21
|
+
BASE_COMMIT = "a" * 40
|
|
22
|
+
TURN_COMMIT = "b" * 40
|
|
23
|
+
FINDING_TEXT = "src/service.py:3 - The diff drops the retry."
|
|
24
|
+
|
|
25
|
+
|
|
26
|
+
@pytest.fixture(autouse=True)
|
|
27
|
+
def isolated_home(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
|
|
28
|
+
home_directory = tmp_path / "home"
|
|
29
|
+
home_directory.mkdir()
|
|
30
|
+
state_directory = tmp_path / "state"
|
|
31
|
+
state_directory.mkdir()
|
|
32
|
+
monkeypatch.setenv("HOME", str(home_directory))
|
|
33
|
+
monkeypatch.setenv("USERPROFILE", str(home_directory))
|
|
34
|
+
monkeypatch.setattr(tempfile, "tempdir", str(state_directory))
|
|
35
|
+
return home_directory
|
|
36
|
+
|
|
37
|
+
|
|
38
|
+
def git(repository: Path, *all_arguments: str) -> str:
|
|
39
|
+
return subprocess.run(
|
|
40
|
+
["git", *all_arguments], cwd=repository, check=True, capture_output=True, text=True
|
|
41
|
+
).stdout.strip()
|
|
42
|
+
|
|
43
|
+
|
|
44
|
+
@pytest.fixture
|
|
45
|
+
def repository(tmp_path: Path) -> Path:
|
|
46
|
+
repository_root = tmp_path / "app"
|
|
47
|
+
repository_root.mkdir()
|
|
48
|
+
git(repository_root, "init", "-q", "-b", "main")
|
|
49
|
+
git(repository_root, "config", "user.email", "test@example.com")
|
|
50
|
+
git(repository_root, "config", "user.name", "Test")
|
|
51
|
+
(repository_root / "service.py").write_text("call()\n")
|
|
52
|
+
git(repository_root, "add", "-A")
|
|
53
|
+
git(repository_root, "commit", "-q", "-m", "start")
|
|
54
|
+
return repository_root
|
|
55
|
+
|
|
56
|
+
|
|
57
|
+
def log_text(home_directory: Path) -> str:
|
|
58
|
+
log_path = home_directory / ".claude" / "logs" / "turn-review.log"
|
|
59
|
+
return log_path.read_text() if log_path.exists() else ""
|
|
60
|
+
|
|
61
|
+
|
|
62
|
+
def test_should_count_a_prompt_inside_the_wake_window_or_a_task_notification_as_the_wake() -> None:
|
|
63
|
+
woken_state = _ReviewState(last_wake_at=1000.0)
|
|
64
|
+
assert _is_wake_prompt(woken_state, "next task", 1009.9) is True
|
|
65
|
+
assert _is_wake_prompt(woken_state, "next task", 1010.0) is False
|
|
66
|
+
assert (
|
|
67
|
+
_is_wake_prompt(_ReviewState(), " <task-notification>done</task-notification>", 0.0)
|
|
68
|
+
is True
|
|
69
|
+
)
|
|
70
|
+
assert _is_wake_prompt(_ReviewState(), "next task", 0.0) is False
|
|
71
|
+
|
|
72
|
+
|
|
73
|
+
def test_should_keep_the_saved_baseline_only_while_the_turn_is_open(repository: Path) -> None:
|
|
74
|
+
saved_baselines = {str(repository): BASE_COMMIT}
|
|
75
|
+
open_state = _ReviewState(all_baselines=saved_baselines, is_turn_open=True)
|
|
76
|
+
assert _prompt_baselines(open_state, [repository]) == saved_baselines
|
|
77
|
+
closed_state = _ReviewState(all_baselines=saved_baselines, is_turn_open=False)
|
|
78
|
+
fresh_commit = _prompt_baselines(closed_state, [repository])[str(repository)]
|
|
79
|
+
assert fresh_commit != BASE_COMMIT
|
|
80
|
+
assert git(repository, "rev-parse", f"{fresh_commit}^") == git(repository, "rev-parse", "HEAD")
|
|
81
|
+
|
|
82
|
+
|
|
83
|
+
def test_should_judge_only_an_open_finding_in_a_reviewed_checkout(
|
|
84
|
+
repository: Path, isolated_home: Path
|
|
85
|
+
) -> None:
|
|
86
|
+
open_finding = _Finding(FINDING_TEXT, str(repository), BASE_COMMIT, TURN_COMMIT)
|
|
87
|
+
review_state = _ReviewState(
|
|
88
|
+
all_findings={
|
|
89
|
+
"TR-1": open_finding,
|
|
90
|
+
"TR-2": _Finding(FINDING_TEXT, str(repository), BASE_COMMIT, TURN_COMMIT, "dismissed"),
|
|
91
|
+
"TR-3": _Finding(FINDING_TEXT, "/elsewhere/lib", BASE_COMMIT, TURN_COMMIT),
|
|
92
|
+
}
|
|
93
|
+
)
|
|
94
|
+
all_reasons = {
|
|
95
|
+
"TR-1": "The caller retries.",
|
|
96
|
+
"TR-2": "Asked again.",
|
|
97
|
+
"TR-3": "Other checkout.",
|
|
98
|
+
"TR-9": "Unknown.",
|
|
99
|
+
}
|
|
100
|
+
assert _judge_requests(review_state, all_reasons, [repository], False) == [
|
|
101
|
+
_JudgeRequest("TR-1", open_finding, "The caller retries.")
|
|
102
|
+
]
|
|
103
|
+
assert _judge_requests(review_state, {"TR-1": "The caller retries."}, [repository], True) == []
|
|
104
|
+
logged_text = log_text(isolated_home)
|
|
105
|
+
assert "Dismiss TR-2 ignored: the finding is dismissed" in logged_text
|
|
106
|
+
assert (
|
|
107
|
+
"Dismiss TR-3 ignored: the finding is in a checkout this stop does not review"
|
|
108
|
+
in logged_text
|
|
109
|
+
)
|
|
110
|
+
assert "Dismiss TR-9 ignored: the finding is not a finding of this session" in logged_text
|
|
111
|
+
assert "Dismiss TR-1 waits: the hold cap is reached, so no judge ran" in logged_text
|
|
112
|
+
|
|
113
|
+
|
|
114
|
+
def test_should_claim_the_turn_range_once_and_move_the_baseline(repository: Path) -> None:
|
|
115
|
+
base_commit = working_tree_snapshot(repository, None)
|
|
116
|
+
assert base_commit is not None
|
|
117
|
+
_save_state(
|
|
118
|
+
SESSION_ID,
|
|
119
|
+
_ReviewState(
|
|
120
|
+
all_baselines={str(repository): base_commit}, blocks_in_a_row=2, is_turn_open=True
|
|
121
|
+
),
|
|
122
|
+
)
|
|
123
|
+
(repository / "service.py").write_text("call(1)\n")
|
|
124
|
+
first_claim = _claim_locked_stop(SESSION_ID, [repository], {})
|
|
125
|
+
claimed_state = _load_state(SESSION_ID)
|
|
126
|
+
turn_commit = claimed_state.all_baselines[str(repository)]
|
|
127
|
+
assert turn_commit != base_commit
|
|
128
|
+
assert first_claim.all_turn_ranges == [(repository, base_commit, turn_commit)]
|
|
129
|
+
assert claimed_state.is_turn_open is False
|
|
130
|
+
assert claimed_state.blocks_in_a_row == 2
|
|
131
|
+
second_claim = _claim_locked_stop(SESSION_ID, [repository], {})
|
|
132
|
+
assert second_claim.all_turn_ranges == []
|
|
133
|
+
assert _load_state(SESSION_ID).blocks_in_a_row == 0
|
|
134
|
+
|
|
135
|
+
|
|
136
|
+
def test_should_wake_with_the_rejections_in_id_order_and_the_new_findings(tmp_path: Path) -> None:
|
|
137
|
+
repository_root = tmp_path / "app"
|
|
138
|
+
_save_state(
|
|
139
|
+
SESSION_ID,
|
|
140
|
+
_ReviewState(
|
|
141
|
+
blocks_in_a_row=1,
|
|
142
|
+
all_findings={
|
|
143
|
+
"TR-2": _Finding(FINDING_TEXT, str(repository_root), BASE_COMMIT, TURN_COMMIT),
|
|
144
|
+
"TR-10": _Finding(FINDING_TEXT, str(repository_root), BASE_COMMIT, TURN_COMMIT),
|
|
145
|
+
},
|
|
146
|
+
),
|
|
147
|
+
)
|
|
148
|
+
all_verdicts = {
|
|
149
|
+
"TR-10": JudgeVerdict(is_approved=False, reason="Nothing retries.\n"),
|
|
150
|
+
"TR-2": JudgeVerdict(is_approved=False, reason="The diff still drops it. "),
|
|
151
|
+
}
|
|
152
|
+
wake_text = _locked_stop_wake(
|
|
153
|
+
SESSION_ID,
|
|
154
|
+
[(repository_root, BASE_COMMIT, TURN_COMMIT, ["src/service.py:9 - The update is lost."])],
|
|
155
|
+
all_verdicts,
|
|
156
|
+
)
|
|
157
|
+
assert wake_text == (
|
|
158
|
+
"Dismissal of TR-2 rejected: The diff still drops it. Fix it.\n"
|
|
159
|
+
"Dismissal of TR-10 rejected: Nothing retries. Fix it.\n\n"
|
|
160
|
+
+ BLOCK_REASON_TEMPLATE.format(
|
|
161
|
+
all_findings="app:\n[TR-11] src/service.py:9 - The update is lost."
|
|
162
|
+
)
|
|
163
|
+
)
|
|
164
|
+
saved_state = _load_state(SESSION_ID)
|
|
165
|
+
assert {each_id: each.status for each_id, each in saved_state.all_findings.items()} == {
|
|
166
|
+
"TR-2": "upheld",
|
|
167
|
+
"TR-10": "upheld",
|
|
168
|
+
"TR-11": "open",
|
|
169
|
+
}
|
|
170
|
+
assert saved_state.blocks_in_a_row == 2
|
|
171
|
+
assert saved_state.last_wake_at is not None
|
|
172
|
+
|
|
173
|
+
|
|
174
|
+
def test_should_dismiss_quietly_on_an_approval_and_keep_a_capped_hold_count(
|
|
175
|
+
tmp_path: Path, isolated_home: Path
|
|
176
|
+
) -> None:
|
|
177
|
+
approval = {"TR-1": JudgeVerdict(is_approved=True, reason="The caller retries.")}
|
|
178
|
+
for each_blocks, each_expected_blocks in ((2, 0), (3, 3)):
|
|
179
|
+
_save_state(
|
|
180
|
+
SESSION_ID,
|
|
181
|
+
_ReviewState(
|
|
182
|
+
blocks_in_a_row=each_blocks,
|
|
183
|
+
all_findings={
|
|
184
|
+
"TR-1": _Finding(FINDING_TEXT, str(tmp_path), BASE_COMMIT, TURN_COMMIT)
|
|
185
|
+
},
|
|
186
|
+
),
|
|
187
|
+
)
|
|
188
|
+
assert _locked_stop_wake(SESSION_ID, [], approval) is None
|
|
189
|
+
saved_state = _load_state(SESSION_ID)
|
|
190
|
+
assert saved_state.all_findings["TR-1"].status == "dismissed"
|
|
191
|
+
assert saved_state.all_findings["TR-1"].judge_reason == "The caller retries."
|
|
192
|
+
assert saved_state.blocks_in_a_row == each_expected_blocks
|
|
193
|
+
assert saved_state.last_wake_at is None
|
|
194
|
+
assert "[turn_review_gate] TR-1 dismissed: The caller retries." in log_text(isolated_home)
|
|
@@ -0,0 +1,65 @@
|
|
|
1
|
+
import subprocess
|
|
2
|
+
import tempfile
|
|
3
|
+
from pathlib import Path
|
|
4
|
+
|
|
5
|
+
import pytest
|
|
6
|
+
|
|
7
|
+
from turn_review_repositories import _opted_in_repository_roots, _opted_in_repository_slugs
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
@pytest.fixture(autouse=True)
|
|
11
|
+
def isolated_home(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
|
|
12
|
+
home_directory = tmp_path / "home"
|
|
13
|
+
home_directory.mkdir()
|
|
14
|
+
state_directory = tmp_path / "state"
|
|
15
|
+
state_directory.mkdir()
|
|
16
|
+
monkeypatch.setenv("HOME", str(home_directory))
|
|
17
|
+
monkeypatch.setenv("USERPROFILE", str(home_directory))
|
|
18
|
+
monkeypatch.setattr(tempfile, "tempdir", str(state_directory))
|
|
19
|
+
return home_directory
|
|
20
|
+
|
|
21
|
+
|
|
22
|
+
def checkout(folder: Path, origin_slug: str) -> Path:
|
|
23
|
+
folder.mkdir(parents=True, exist_ok=True)
|
|
24
|
+
subprocess.run(["git", "init", "-q", "-b", "main"], cwd=folder, check=True, capture_output=True)
|
|
25
|
+
subprocess.run(
|
|
26
|
+
["git", "remote", "add", "origin", f"https://github.com/{origin_slug}.git"],
|
|
27
|
+
cwd=folder,
|
|
28
|
+
check=True,
|
|
29
|
+
capture_output=True,
|
|
30
|
+
)
|
|
31
|
+
return folder
|
|
32
|
+
|
|
33
|
+
|
|
34
|
+
def test_should_read_the_listed_slugs_without_letter_case_or_blanks(
|
|
35
|
+
monkeypatch: pytest.MonkeyPatch,
|
|
36
|
+
) -> None:
|
|
37
|
+
monkeypatch.setenv("CLAUDE_TURN_REVIEW_REPOSITORIES", " Owner/App , ,owner/LIB, ")
|
|
38
|
+
assert _opted_in_repository_slugs() == frozenset({"owner/app", "owner/lib"})
|
|
39
|
+
|
|
40
|
+
|
|
41
|
+
def test_should_take_only_a_checkout_whose_origin_is_listed(
|
|
42
|
+
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
|
43
|
+
) -> None:
|
|
44
|
+
project_directory = tmp_path / "workspace"
|
|
45
|
+
listed_checkout = checkout(project_directory / "app", "owner/app")
|
|
46
|
+
checkout(project_directory / "docs", "owner/docs")
|
|
47
|
+
(project_directory / "notes").mkdir()
|
|
48
|
+
(project_directory / "readme.txt").write_text("notes\n")
|
|
49
|
+
monkeypatch.setenv("CLAUDE_PROJECT_DIR", str(project_directory))
|
|
50
|
+
assert _opted_in_repository_roots(frozenset({"owner/app"})) == [listed_checkout.resolve()]
|
|
51
|
+
|
|
52
|
+
|
|
53
|
+
def test_should_list_the_project_folder_first_then_its_children_by_name(
|
|
54
|
+
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
|
55
|
+
) -> None:
|
|
56
|
+
project_directory = checkout(tmp_path / "workspace", "owner/workspace")
|
|
57
|
+
zeta_checkout = checkout(project_directory / "zeta", "owner/zeta")
|
|
58
|
+
alpha_checkout = checkout(project_directory / "alpha", "owner/alpha")
|
|
59
|
+
monkeypatch.setenv("CLAUDE_PROJECT_DIR", str(project_directory))
|
|
60
|
+
all_slugs = frozenset({"owner/workspace", "owner/zeta", "owner/alpha"})
|
|
61
|
+
assert _opted_in_repository_roots(all_slugs) == [
|
|
62
|
+
project_directory.resolve(),
|
|
63
|
+
alpha_checkout.resolve(),
|
|
64
|
+
zeta_checkout.resolve(),
|
|
65
|
+
]
|
|
@@ -0,0 +1,132 @@
|
|
|
1
|
+
import json
|
|
2
|
+
import os
|
|
3
|
+
import tempfile
|
|
4
|
+
from pathlib import Path
|
|
5
|
+
|
|
6
|
+
import pytest
|
|
7
|
+
|
|
8
|
+
from turn_review_state import (
|
|
9
|
+
_Finding,
|
|
10
|
+
_is_lock_taken,
|
|
11
|
+
_load_state,
|
|
12
|
+
_log,
|
|
13
|
+
_next_finding_id,
|
|
14
|
+
_release_and_close,
|
|
15
|
+
_ReviewState,
|
|
16
|
+
_save_state,
|
|
17
|
+
_state_path,
|
|
18
|
+
)
|
|
19
|
+
|
|
20
|
+
SESSION_ID = "state-session"
|
|
21
|
+
BASE_COMMIT = "a" * 40
|
|
22
|
+
TURN_COMMIT = "b" * 40
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
@pytest.fixture(autouse=True)
|
|
26
|
+
def isolated_home(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
|
|
27
|
+
home_directory = tmp_path / "home"
|
|
28
|
+
home_directory.mkdir()
|
|
29
|
+
state_directory = tmp_path / "state"
|
|
30
|
+
state_directory.mkdir()
|
|
31
|
+
monkeypatch.setenv("HOME", str(home_directory))
|
|
32
|
+
monkeypatch.setenv("USERPROFILE", str(home_directory))
|
|
33
|
+
monkeypatch.setattr(tempfile, "tempdir", str(state_directory))
|
|
34
|
+
return home_directory
|
|
35
|
+
|
|
36
|
+
|
|
37
|
+
def log_lines(home_directory: Path) -> list[str]:
|
|
38
|
+
log_path = home_directory / ".claude" / "logs" / "turn-review.log"
|
|
39
|
+
return log_path.read_text().splitlines() if log_path.exists() else []
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
def test_should_load_every_field_a_save_wrote() -> None:
|
|
43
|
+
saved_state = _ReviewState(
|
|
44
|
+
all_baselines={"/work/app": BASE_COMMIT},
|
|
45
|
+
blocks_in_a_row=2,
|
|
46
|
+
is_turn_open=True,
|
|
47
|
+
last_wake_at=100.5,
|
|
48
|
+
open_turn_prompt_at=90.0,
|
|
49
|
+
all_findings={
|
|
50
|
+
"TR-3": _Finding(
|
|
51
|
+
"src/service.py:3 - drops the retry",
|
|
52
|
+
"/work/app",
|
|
53
|
+
BASE_COMMIT,
|
|
54
|
+
TURN_COMMIT,
|
|
55
|
+
"upheld",
|
|
56
|
+
"Nothing retries.",
|
|
57
|
+
)
|
|
58
|
+
},
|
|
59
|
+
)
|
|
60
|
+
_save_state(SESSION_ID, saved_state)
|
|
61
|
+
assert _state_path(SESSION_ID).name == "turn-review-state-session.json"
|
|
62
|
+
assert _load_state(SESSION_ID) == saved_state
|
|
63
|
+
|
|
64
|
+
|
|
65
|
+
def test_should_leave_out_saved_entries_in_another_form() -> None:
|
|
66
|
+
finding_record = {
|
|
67
|
+
"text": "src/service.py:3 - drops the retry",
|
|
68
|
+
"repository": "/work/app",
|
|
69
|
+
"base": BASE_COMMIT,
|
|
70
|
+
"turn": TURN_COMMIT,
|
|
71
|
+
"status": "open",
|
|
72
|
+
"judge_reason": None,
|
|
73
|
+
}
|
|
74
|
+
_state_path(SESSION_ID).write_text(
|
|
75
|
+
json.dumps(
|
|
76
|
+
{
|
|
77
|
+
"baselines": {"/work/app": BASE_COMMIT, "/work/lib": "HEAD~1"},
|
|
78
|
+
"blocks_in_a_row": 1,
|
|
79
|
+
"turn_open": 1,
|
|
80
|
+
"last_wake_at": True,
|
|
81
|
+
"findings": {
|
|
82
|
+
"TR-1": finding_record,
|
|
83
|
+
"TR-01": finding_record,
|
|
84
|
+
"TR-2": {**finding_record, "status": "closed"},
|
|
85
|
+
"TR-4": {**finding_record, "turn": "main"},
|
|
86
|
+
},
|
|
87
|
+
}
|
|
88
|
+
)
|
|
89
|
+
)
|
|
90
|
+
loaded_state = _load_state(SESSION_ID)
|
|
91
|
+
assert loaded_state.all_baselines == {"/work/app": BASE_COMMIT}
|
|
92
|
+
assert loaded_state.blocks_in_a_row == 1
|
|
93
|
+
assert loaded_state.is_turn_open is False
|
|
94
|
+
assert loaded_state.last_wake_at is None
|
|
95
|
+
assert list(loaded_state.all_findings) == ["TR-1"]
|
|
96
|
+
|
|
97
|
+
|
|
98
|
+
def test_should_give_an_empty_state_for_a_file_that_is_not_json() -> None:
|
|
99
|
+
_state_path(SESSION_ID).write_text("{not json")
|
|
100
|
+
assert _load_state(SESSION_ID) == _ReviewState()
|
|
101
|
+
|
|
102
|
+
|
|
103
|
+
def test_should_number_the_next_finding_after_the_highest_id() -> None:
|
|
104
|
+
finding = _Finding("text", "/work/app", BASE_COMMIT, TURN_COMMIT)
|
|
105
|
+
review_state = _ReviewState(all_findings={"TR-2": finding, "TR-10": finding})
|
|
106
|
+
assert _next_finding_id(review_state) == "TR-11"
|
|
107
|
+
assert _next_finding_id(_ReviewState()) == "TR-1"
|
|
108
|
+
|
|
109
|
+
|
|
110
|
+
def test_should_log_one_dated_line_each_call_and_log_a_failed_save(isolated_home: Path) -> None:
|
|
111
|
+
_log("[turn_review_gate] first\n")
|
|
112
|
+
_log("[turn_review_gate] second\n")
|
|
113
|
+
_state_path(SESSION_ID).mkdir()
|
|
114
|
+
_save_state(SESSION_ID, _ReviewState(blocks_in_a_row=1))
|
|
115
|
+
all_lines = log_lines(isolated_home)
|
|
116
|
+
assert len(all_lines) == 3
|
|
117
|
+
assert all_lines[0].endswith(" [turn_review_gate] first")
|
|
118
|
+
assert all_lines[0][:4].isdigit()
|
|
119
|
+
assert all_lines[1].endswith(" [turn_review_gate] second")
|
|
120
|
+
assert "[turn_review_gate] the review state was not saved: " in all_lines[2]
|
|
121
|
+
|
|
122
|
+
|
|
123
|
+
def test_should_refuse_a_second_lock_until_the_first_is_released(tmp_path: Path) -> None:
|
|
124
|
+
lock_path = tmp_path / "state.lock"
|
|
125
|
+
lock_path.write_text("x")
|
|
126
|
+
first_descriptor = os.open(lock_path, os.O_RDWR)
|
|
127
|
+
second_descriptor = os.open(lock_path, os.O_RDWR)
|
|
128
|
+
assert _is_lock_taken(first_descriptor) is True
|
|
129
|
+
assert _is_lock_taken(second_descriptor) is False
|
|
130
|
+
_release_and_close(first_descriptor, True)
|
|
131
|
+
assert _is_lock_taken(second_descriptor) is True
|
|
132
|
+
_release_and_close(second_descriptor, True)
|