claude-dev-env 2.4.0 → 2.7.0

package/scripts/_code_review_test_support.py

@@ -0,0 +1,404 @@
+"""Shared fixtures and seams for the ``/code-review`` invoker test suite.
+
+Every ``test_invoke_code_review_*`` module imports its fixture values, its
+chain-outcome builders, its runner shortcuts, and its seam installer from here
+so the behavioral groups stay small and none of the shared support is copied
+between them.
+
+This module inserts the scripts directory on ``sys.path`` before its flat
+import list, so the invoker and its constants package resolve by bare name
+whether or not pytest's conftest has already registered the directory.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import pytest
+
+_SCRIPTS_DIRECTORY = str(Path(__file__).resolve().parent)
+if _SCRIPTS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _SCRIPTS_DIRECTORY)
+
+import claude_chain_runner as chain_runner  # noqa: E402
+import invoke_code_review as invoker  # noqa: E402
+from claude_chain_runner import ChainAttempt, ChainInvocationOutcome  # noqa: E402
+from dev_env_scripts_constants.code_review_constants import (  # noqa: E402
+    CLI_SESSION_MODEL_FLAG,
+    CODE_REVIEW_MODEL_ALIAS,
+    GIT_BINARY,
+    RECORD_STAMP_FLAG,
+)
+from dev_env_scripts_constants.grok_worker_constants import (  # noqa: E402
+    CLI_TIMEOUT_FLAG,
+    CWD_FLAG,
+)
+from dev_env_scripts_constants.timing import (  # noqa: E402
+    DEFAULT_CODE_REVIEW_TIMEOUT_SECONDS,
+)
+
+HOST_PROFILE_CLAUDE = "Claude"
+HOST_PROFILE_THIRD_PARTY = "ThirdParty"
+
+FIXTURE_SERVED_COMMAND = "claude"
+FIXTURE_CHAIN_RETURNCODE = 0
+FIXTURE_FAILED_RETURNCODE = 1
+FIXTURE_GIT_STATUS_FAILURE_RETURNCODE = 128
+FIXTURE_CHAIN_STDOUT = '{"result":"review done"}'
+FIXTURE_SESSION_OPUS = "opus"
+FIXTURE_SESSION_OPUS_UPPER = "Opus"
+FIXTURE_SESSION_SONNET = "sonnet"
+FIXTURE_SESSION_HAIKU = "haiku"
+FIXTURE_CHAIN_CONFIG_ERROR_MESSAGE = "chain config missing"
+FIXTURE_HOST_PROFILE_ERROR_MESSAGE = "unknown host profile"
+DIRTY_FILE_NAME = "review_fix.txt"
+DIRTY_FILE_CONTENTS = "applied fix\n"
+GIT_INIT_TIMEOUT_SECONDS = 30
+REPOSITORY_USER_EMAIL = "reviewer@example.com"
+REPOSITORY_USER_NAME = "Reviewer"
+PINNED_INITIAL_BRANCH = "main"
+
+
+def _run_git(*git_arguments: str, working_directory: Path | None = None) -> None:
+    all_git_tokens = [GIT_BINARY]
+    if working_directory is not None:
+        all_git_tokens += ["-C", str(working_directory)]
+    all_git_tokens += list(git_arguments)
+    subprocess.run(
+        all_git_tokens,
+        check=True,
+        capture_output=True,
+        text=True,
+        timeout=GIT_INIT_TIMEOUT_SECONDS,
+    )
+
+
+def _initialize_repository(repository_directory: Path) -> None:
+    repository_directory.mkdir(parents=True, exist_ok=True)
+    _run_git(
+        "init",
+        "--initial-branch",
+        PINNED_INITIAL_BRANCH,
+        working_directory=repository_directory,
+    )
+    _run_git(
+        "config",
+        "user.email",
+        REPOSITORY_USER_EMAIL,
+        working_directory=repository_directory,
+    )
+    _run_git(
+        "config",
+        "user.name",
+        REPOSITORY_USER_NAME,
+        working_directory=repository_directory,
+    )
+
+
+def write_dirty_tree(working_directory: Path) -> None:
+    dirty_file = working_directory / DIRTY_FILE_NAME
+    dirty_file.write_text(DIRTY_FILE_CONTENTS, encoding="utf-8")
+
+
+def run_record_stamp_cli(working_directory: Path, *, effort: str) -> int:
+    return invoker.main(
+        [
+            CWD_FLAG,
+            str(working_directory),
+            CLI_SESSION_MODEL_FLAG,
+            CODE_REVIEW_MODEL_ALIAS,
+            RECORD_STAMP_FLAG,
+            effort,
+        ]
+    )
+
+
+def claude_served(
+    *,
+    returncode: int = FIXTURE_CHAIN_RETURNCODE,
+    stdout: str = FIXTURE_CHAIN_STDOUT,
+) -> ChainInvocationOutcome:
+    return ChainInvocationOutcome(
+        served_command=FIXTURE_SERVED_COMMAND,
+        returncode=returncode,
+        stdout=stdout,
+        stderr="",
+        attempts=(ChainAttempt(command=FIXTURE_SERVED_COMMAND, status="served"),),
+    )
+
+
+def claude_failed() -> ChainInvocationOutcome:
+    return ChainInvocationOutcome(
+        served_command=None,
+        returncode=FIXTURE_FAILED_RETURNCODE,
+        stdout="",
+        stderr="chain exhausted",
+        attempts=(
+            ChainAttempt(command=FIXTURE_SERVED_COMMAND, status="usage_limited"),
+        ),
+    )
+
+
+def init_git_repository(repository_directory: Path) -> Path:
+    _initialize_repository(repository_directory)
+    (repository_directory / "README.md").write_text("baseline\n", encoding="utf-8")
+    _run_git("add", "README.md", working_directory=repository_directory)
+    _run_git("commit", "-m", "baseline", working_directory=repository_directory)
+    return repository_directory
+
+
+def run_review(
+    working_directory: Path, *, session_model: str
+) -> invoker.CodeReviewOutcome:
+    return invoker.invoke_code_review(
+        working_directory=working_directory,
+        session_model=session_model,
+        timeout_seconds=DEFAULT_CODE_REVIEW_TIMEOUT_SECONDS,
+    )
+
+
+def run_review_cli(working_directory: Path, *, session_model: str) -> int:
+    return invoker.main(
+        [
+            CWD_FLAG,
+            str(working_directory),
+            CLI_SESSION_MODEL_FLAG,
+            session_model,
+            CLI_TIMEOUT_FLAG,
+            str(DEFAULT_CODE_REVIEW_TIMEOUT_SECONDS),
+        ]
+    )
+
+
+@dataclass
+class SeamCallLog:
+    claude_calls: int = 0
+    claude_arguments: list[str] | None = None
+    host_profile_calls: int = 0
+    is_stdin_empty: bool = False
+    claude_working_directory: Path | None = None
+    all_observed_working_directories: list[Path] = field(default_factory=list)
+
+
+@dataclass
+class _SeamConfiguration:
+    host_profile: str
+    claude_outcome: ChainInvocationOutcome | BaseException | None
+    should_dirty_tree_on_chain: bool
+    working_directory: Path | None
+
+
+def _record_dirty_tree(configuration: _SeamConfiguration) -> None:
+    if not configuration.should_dirty_tree_on_chain:
+        return
+    if configuration.working_directory is None:
+        return
+    write_dirty_tree(configuration.working_directory)
+
+
+def _detect_empty_stdin(maybe_stdin: object) -> bool | None:
+    if maybe_stdin is subprocess.DEVNULL:
+        return True
+    if maybe_stdin is None:
+        return None
+    maybe_read = getattr(maybe_stdin, "read", None)
+    if not callable(maybe_read):
+        return None
+    stdin_contents = maybe_read()
+    maybe_seek = getattr(maybe_stdin, "seek", None)
+    if callable(maybe_seek):
+        maybe_seek(0)
+    return stdin_contents == ""
+
+
+def _build_host_profile_seam(
+    call_log: SeamCallLog, configuration: _SeamConfiguration
+) -> Callable[..., str]:
+    def fake_host_profile(setting_by_name: object | None = None) -> str:
+        del setting_by_name
+        call_log.host_profile_calls += 1
+        return configuration.host_profile
+
+    return fake_host_profile
+
+
+def _build_claude_seam(
+    call_log: SeamCallLog, configuration: _SeamConfiguration
+) -> Callable[..., ChainInvocationOutcome]:
+    def fake_claude(
+        all_claude_arguments: list[str], *, timeout_seconds: int
+    ) -> ChainInvocationOutcome:
+        call_log.claude_calls += 1
+        call_log.claude_arguments = list(all_claude_arguments)
+        chain_runner.chain_subprocess_runner(
+            ["claude", *all_claude_arguments],
+            capture_output=True,
+            text=True,
+            timeout=timeout_seconds,
+            check=False,
+        )
+        _record_dirty_tree(configuration)
+        if isinstance(configuration.claude_outcome, BaseException):
+            raise configuration.claude_outcome
+        assert isinstance(configuration.claude_outcome, ChainInvocationOutcome)
+        return configuration.claude_outcome
+
+    return fake_claude
+
+
+def _build_subprocess_seam(
+    call_log: SeamCallLog,
+) -> Callable[..., subprocess.CompletedProcess[str]]:
+    def tracking_subprocess_runner(
+        all_invocation_tokens: Sequence[str],
+        *all_positionals: object,
+        **all_keywords: object,
+    ) -> subprocess.CompletedProcess[str]:
+        del all_positionals
+        maybe_empty_stdin = _detect_empty_stdin(all_keywords.get("stdin"))
+        if maybe_empty_stdin is not None:
+            call_log.is_stdin_empty = maybe_empty_stdin
+        maybe_cwd = all_keywords.get("cwd")
+        if maybe_cwd is not None:
+            resolved_directory = Path(str(maybe_cwd))
+            call_log.claude_working_directory = resolved_directory
+            call_log.all_observed_working_directories.append(resolved_directory)
+        return subprocess.CompletedProcess(
+            args=list(all_invocation_tokens),
+            returncode=0,
+            stdout="{}",
+            stderr="",
+        )
+
+    return tracking_subprocess_runner
+
+
+def _apply_seams(
+    monkeypatch: pytest.MonkeyPatch,
+    call_log: SeamCallLog,
+    configuration: _SeamConfiguration,
+) -> None:
+    monkeypatch.setattr(
+        invoker,
+        "review_host_profile_detector",
+        _build_host_profile_seam(call_log, configuration),
+    )
+    monkeypatch.setattr(
+        invoker,
+        "review_claude_runner",
+        _build_claude_seam(call_log, configuration),
+    )
+    monkeypatch.setattr(
+        chain_runner,
+        "chain_subprocess_runner",
+        _build_subprocess_seam(call_log),
+    )
+
+
+def install_seams(
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    host_profile: str = HOST_PROFILE_CLAUDE,
+    claude_outcome: ChainInvocationOutcome | BaseException | None = None,
+    should_dirty_tree_on_chain: bool = False,
+    working_directory: Path | None = None,
+) -> SeamCallLog:
+    call_log = SeamCallLog()
+    configuration = _SeamConfiguration(
+        host_profile=host_profile,
+        claude_outcome=claude_outcome,
+        should_dirty_tree_on_chain=should_dirty_tree_on_chain,
+        working_directory=working_directory,
+    )
+    _apply_seams(monkeypatch, call_log, configuration)
+    return call_log
+
+
+EFFORT_LOW = "low"
+REJECTED_ULTRA_EFFORT = "ultra"
+SINGLE_PASS_CAP = 1
+MISSING_STORE_FILE_NAME = "code_review_stamp_store_absent.py"
+SURFACE_SOURCE = "def add(left: int, right: int) -> int:\n    return left + right\n"
+SURFACE_CHANGE_SOURCE = (
+    "def add(left: int, right: int) -> int:\n    return left - right\n"
+)
+
+
+def _make_repo_with_change_surface(tmp_path: Path) -> Path:
+    origin_directory = tmp_path / "origin.git"
+    work_directory = tmp_path / "work"
+    _run_git(
+        "init",
+        "--bare",
+        "--initial-branch",
+        PINNED_INITIAL_BRANCH,
+        str(origin_directory),
+    )
+    _initialize_repository(work_directory)
+    (work_directory / "app.py").write_text(SURFACE_SOURCE, encoding="utf-8")
+    _run_git("add", "-A", working_directory=work_directory)
+    _run_git("commit", "-m", "base", working_directory=work_directory)
+    _run_git(
+        "remote",
+        "add",
+        "origin",
+        str(origin_directory),
+        working_directory=work_directory,
+    )
+    _run_git(
+        "push", "-u", "origin", PINNED_INITIAL_BRANCH, working_directory=work_directory
+    )
+    (work_directory / "app.py").write_text(SURFACE_CHANGE_SOURCE, encoding="utf-8")
+    return work_directory
+
+
+def _isolate_home(monkeypatch: pytest.MonkeyPatch, fake_home: Path) -> None:
+    home_text = str(fake_home)
+    monkeypatch.setenv("HOME", home_text)
+    monkeypatch.setenv("USERPROFILE", home_text)
+    monkeypatch.delenv("HOMEDRIVE", raising=False)
+    monkeypatch.delenv("HOMEPATH", raising=False)
+
+
+def prepared_surface_repo(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> Path:
+    fake_home = tmp_path / "home"
+    fake_home.mkdir()
+    _isolate_home(monkeypatch, fake_home)
+    return _make_repo_with_change_surface(tmp_path)
+
+
+def _chain_clean_outcome() -> invoker.CodeReviewOutcome:
+    return invoker.CodeReviewOutcome(
+        mode=invoker.MODE_CHAIN,
+        served_command=FIXTURE_SERVED_COMMAND,
+        returncode=FIXTURE_CHAIN_RETURNCODE,
+        is_dirty_tree=True,
+    )
+
+
+def stable_clean_review(**_review_keywords: object) -> invoker.CodeReviewOutcome:
+    return _chain_clean_outcome()
+
+
+def surface_changing_review(
+    *, working_directory: Path, **_review_keywords: object
+) -> invoker.CodeReviewOutcome:
+    write_dirty_tree(working_directory)
+    return _chain_clean_outcome()
+
+
+class DriftingReview:
+    def __init__(self) -> None:
+        self.pass_count = 0
+
+    def __call__(
+        self, *, working_directory: Path, **_review_keywords: object
+    ) -> invoker.CodeReviewOutcome:
+        self.pass_count += 1
+        drift_path = working_directory / f"fix_{self.pass_count}.txt"
+        drift_path.write_text(str(self.pass_count), encoding="utf-8")
+        return _chain_clean_outcome()

package/scripts/claude_chain_runner.py

@@ -40,6 +40,7 @@ import io
 import json
 import subprocess
 import sys
+import tempfile
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass
 from pathlib import Path
@@ -58,6 +59,7 @@ from dev_env_scripts_constants.claude_chain_constants import (
     ATTEMPT_STATUS_USAGE_LIMITED,
     ATTEMPT_SUMMARY_ENTRY_TEMPLATE,
     ATTEMPT_SUMMARY_JOIN_SEPARATOR,
+    CARRIAGE_RETURN,
     CHAIN_CONFIG_ERROR_EXIT_CODE,
     CHAIN_EXHAUSTED_EXIT_CODE,
     CHAIN_EXHAUSTED_MESSAGE_TEMPLATE,
@@ -82,13 +84,151 @@ from dev_env_scripts_constants.claude_chain_constants import (
     CONFIG_MISSING_MESSAGE_TEMPLATE,
     CONFIG_NOT_OBJECT_REASON,
     CONFIG_UNREADABLE_MESSAGE_TEMPLATE,
+    CRLF_NEWLINE,
     DEFAULT_TIMEOUT_SECONDS,
     EXAMPLE_CONFIG_FILENAME,
+    LINE_FEED,
     NO_COMPLETED_PROCESS_RETURN_CODE,
     UTF8_ENCODING,
 )
 
 
+def _decode_captured_stream(raw_bytes: bytes, encoding: str, errors: str) -> str:
+    """Decode captured *raw_bytes* with ``text=True`` universal-newline semantics.
+
+    Spool capture writes binary temp files, so a bare ``.decode`` leaves CRLF and
+    bare CR intact. ``subprocess.run(..., text=True)`` normalized those to LF;
+    this helper restores that contract for Windows children that emit ``\\r\\n``.
+    """
+    decoded_text = raw_bytes.decode(encoding, errors)
+    return decoded_text.replace(CRLF_NEWLINE, LINE_FEED).replace(
+        CARRIAGE_RETURN, LINE_FEED
+    )
+
+
+class _SpooledByteStream(Protocol):
+    """Binary spool with seek/read — TemporaryFile wrappers and BufferedIO."""
+
+    def seek(self, target: int, whence: int = 0, /) -> int: ...
+
+    def read(self, size: int | None = -1, /) -> bytes: ...
+
+
+def _decoded_spooled_streams(
+    stdout_file: _SpooledByteStream,
+    stderr_file: _SpooledByteStream,
+    encoding: str,
+    errors: str,
+) -> tuple[str, str]:
+    """Seek both spool files to the start and decode their full contents."""
+    stdout_file.seek(0)
+    stderr_file.seek(0)
+    return (
+        _decode_captured_stream(stdout_file.read(), encoding, errors),
+        _decode_captured_stream(stderr_file.read(), encoding, errors),
+    )
+
+
+def _attach_partial_timeout_streams(
+    timeout_error: subprocess.TimeoutExpired,
+    stdout_file: _SpooledByteStream,
+    stderr_file: _SpooledByteStream,
+    encoding: str,
+    errors: str,
+) -> None:
+    """Decode partial spool contents onto *timeout_error* before re-raise."""
+    captured_stdout, captured_stderr = _decoded_spooled_streams(
+        stdout_file, stderr_file, encoding, errors
+    )
+    timeout_error.stdout = captured_stdout
+    timeout_error.stderr = captured_stderr
+
+
+# Capturing a large-output child through OS pipes (``capture_output=True``)
+# deadlocks on Windows: the child buffers its whole response and flushes it at
+# once, the pipe buffer fills before the parent drains it, and both sides block.
+# Redirecting each stream to a temporary file removes the pipe, so the child
+# writes freely; the files are then read back and decoded the way a pipe capture
+# would. ``capture_output``, ``text``, and ``env`` are ignored in favor of file
+# redirection and the parent environment; ``timeout``, ``check``, ``cwd``,
+# ``stdin``, ``input``, ``encoding``, and ``errors`` are honored. On timeout,
+# partial stdout/stderr are decoded from the temp files and attached to the
+# raised ``TimeoutExpired``. When ``check=True`` and the child exits non-zero,
+# ``CalledProcessError.stdout`` / ``.stderr`` stay unset (temp files are not
+# attached to that raised error).
+def _run_captured_subprocess(
+    all_invocation_tokens: list[str],
+    **all_subprocess_options: object,
+) -> subprocess.CompletedProcess[str]:
+    """Run *all_invocation_tokens*, spooling stdout and stderr to temp files."""
+    encoding = str(all_subprocess_options.get("encoding") or UTF8_ENCODING)
+    errors = str(all_subprocess_options.get("errors") or CODEC_ERROR_STRATEGY)
+    input_bytes = _captured_stdin_bytes(all_subprocess_options, encoding, errors)
+    working_directory = all_subprocess_options.get("cwd")
+    timeout_seconds = all_subprocess_options.get("timeout")
+    with (
+        tempfile.TemporaryFile() as stdout_file,
+        tempfile.TemporaryFile() as stderr_file,
+    ):
+        try:
+            completion = subprocess.run(
+                all_invocation_tokens,
+                stdout=stdout_file,
+                stderr=stderr_file,
+                cwd=working_directory if isinstance(working_directory, str) else None,
+                check=bool(all_subprocess_options.get("check", False)),
+                timeout=(
+                    float(timeout_seconds)
+                    if isinstance(timeout_seconds, (int, float))
+                    else None
+                ),
+                input=input_bytes,
+            )
+        except subprocess.TimeoutExpired as timeout_error:
+            _attach_partial_timeout_streams(
+                timeout_error, stdout_file, stderr_file, encoding, errors
+            )
+            raise
+        captured_stdout, captured_stderr = _decoded_spooled_streams(
+            stdout_file, stderr_file, encoding, errors
+        )
+        return subprocess.CompletedProcess(
+            all_invocation_tokens,
+            completion.returncode,
+            captured_stdout,
+            captured_stderr,
+        )
+
+
+def _captured_stdin_bytes(
+    all_subprocess_options: dict[str, object], encoding: str, errors: str
+) -> bytes | None:
+    """Return the bytes to feed the child's stdin for a spooled run.
+
+    ::
+
+        stdin=<open prompt file>  -> the file's bytes
+        stdin=subprocess.DEVNULL  -> b"" (an immediate EOF)
+        input="charter text"      -> the encoded text
+
+    A wrapper hands the runner a ``stdin`` stream or a ``DEVNULL`` sentinel; the
+    spooled run reads from an ``input`` pipe rather than the caller's handle, so
+    the stream is read into bytes here to deliver the same stdin a direct pipe
+    would. When no ``stdin`` is given, the ``input`` text is encoded instead.
+    """
+    stdin_source = all_subprocess_options.get("stdin")
+    if isinstance(stdin_source, io.TextIOBase):
+        return stdin_source.read().encode(encoding, errors)
+    if isinstance(stdin_source, (io.RawIOBase, io.BufferedIOBase)):
+        return stdin_source.read() or b""
+    if isinstance(stdin_source, int):
+        return b""
+    input_text = all_subprocess_options.get("input")
+    if input_text is None:
+        return None
+    return str(input_text).encode(encoding, errors)
+
+
 class ChainConfigurationError(Exception):
     """Raised when the chain configuration is missing, unreadable, or malformed."""
 
@@ -138,7 +278,7 @@ class WeeklyUsageAccountReport(Protocol):
     command: str
 
 
-chain_subprocess_runner = subprocess.run
+chain_subprocess_runner = _run_captured_subprocess
 
 
 def _load_chain_usage_module() -> ModuleType: