claude-dev-env 2.11.0 → 2.13.0

package/scripts/_code_review_test_support.py

@@ -35,7 +35,6 @@ 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,
@@ -108,19 +107,6 @@ def write_dirty_tree(working_directory: Path) -> None:
     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,
@@ -327,84 +313,3 @@ def install_seams(
 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/dev_env_scripts_constants/code_review_constants.py

@@ -9,22 +9,14 @@
         ok: ("blocker", "high", "medium", "low", "nit")
     ALL_LOOP_TERMINALS
         ok: ("clean", "nits_fixed", "advisor_blocked")
-    RECORD_STAMP_FLAG
-        ok: "--record-stamp"
-
-Effort tokens re-export the hooks enforcement constants (single source).
-Scalar flags, JSON keys, mint-loop messages, finding severity vocabulary,
+Effort tokens, scalar flags, JSON keys, finding severity vocabulary,
 reviewed-head counting, and loop terminal resolution live here.
 """
 
 from __future__ import annotations
 
-import importlib.util
 import os
-import sys
 from collections.abc import Mapping, Sequence
-from pathlib import Path
-from types import ModuleType
 
 ROOT_EFFECTIVE_USER_ID: int = 0
 """Effective user id the review binary treats as root."""
@@ -51,47 +43,14 @@ IS_ROOT_CALLER: bool = _read_effective_user_id() == ROOT_EFFECTIVE_USER_ID
 """Whether this process runs as root, which limits the permission modes."""
 
 
-def _load_enforcement_constants_module() -> ModuleType:
-    """Load the hooks enforcement constants by explicit file path.
-
-    Binds a private module name so a foreign ``config`` package on
-    ``sys.path`` cannot win the import and drift the effort token set.
-    """
-    package_root_directory = Path(__file__).resolve().parent.parent.parent
-    constants_file_path = (
-        package_root_directory
-        / "hooks"
-        / "blocking"
-        / "config"
-        / "code_review_enforcement_constants.py"
-    )
-    module_name = "_code_review_enforcement_constants_for_scripts"
-    cached_module = sys.modules.get(module_name)
-    if cached_module is not None:
-        return cached_module
-    module_spec = importlib.util.spec_from_file_location(
-        module_name,
-        constants_file_path,
-    )
-    if module_spec is None or module_spec.loader is None:
-        raise ImportError(
-            f"could not load code-review enforcement constants from {constants_file_path}"
-        )
-    constants_module = importlib.util.module_from_spec(module_spec)
-    sys.modules[module_name] = constants_module
-    module_spec.loader.exec_module(constants_module)
-    return constants_module
-
-
-_ENFORCEMENT_CONSTANTS = _load_enforcement_constants_module()
-
 ALL_EFFORT_TOKENS_IN_ASCENDING_ORDER: tuple[str, ...] = (
-    _ENFORCEMENT_CONSTANTS.ALL_EFFORT_TOKENS_IN_ASCENDING_ORDER
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
 )
-"""Effort tokens ordered low to max; single source from enforcement constants."""
-
-RECORD_STAMP_FLAG: str = _ENFORCEMENT_CONSTANTS.SANCTIONED_STAMP_MINTER_FLAG
-"""CLI flag that forces chain mode and mints a clean stamp on a stable pass."""
+"""Effort tokens ordered from the lowest supported effort to the highest."""
 
 DEFAULT_CODE_REVIEW_EFFORT: str = "high"
 """Default effort when the caller omits the positional effort token."""
@@ -114,8 +73,7 @@ PERMISSION_MODE_BYPASS: str = "bypassPermissions"
 PERMISSION_MODE_ACCEPT_EDITS: str = "acceptEdits"
 """Permission mode asked for when the caller is root.
 
-The review binary refuses ``bypassPermissions`` outright for a root caller,
-so asking for it there means no review runs and no stamp is ever minted.
+The review binary refuses ``bypassPermissions`` outright for a root caller.
 """
 
 REVIEW_PERMISSION_MODE: str = (
@@ -160,16 +118,7 @@ HOST_PROFILE_ERROR_RETURNCODE: int = 1
 """Return code when host-profile detection raises ValueError at the CLI boundary."""
 
 SUCCESSFUL_REVIEW_RETURNCODE: int = 0
-"""Return code required before a clean stamp may advance past CODE_REVIEW."""
-
-RESULT_KEY_STAMP_MINTED: str = "stamp_minted"
-"""JSON result key holding whether a clean stamp was written this run."""
-
-RESULT_KEY_PASS_COUNT: str = "pass_count"
-"""JSON result key holding how many review passes the mint loop ran."""
-
-RESULT_KEY_BOUND_HASH: str = "bound_hash"
-"""JSON result key holding the surface hash bound into a minted stamp, or null."""
+"""Return code for a successful review invocation."""
 
 CLI_EFFORT_METAVAR: str = "effort"
 """Argparse metavar for the positional effort token."""
@@ -180,21 +129,9 @@ CLI_EFFORT_HELP: str = (
 )
 """Help text for the positional effort argument."""
 
-CLI_RECORD_STAMP_HELP: str = (
-    "Force chain mode, loop a capped number of review passes, and mint a "
-    "clean stamp only when a pass exits 0 with a stable surface hash."
-)
-"""Help text for the --record-stamp flag."""
-
 INVALID_EFFORT_RETURNCODE: int = 2
 """Return code when the caller passes an unknown or unsupported effort token."""
 
-STAMP_DID_NOT_CONVERGE_RETURNCODE: int = 1
-"""Return code when the mint loop hits its pass cap without a stable clean pass."""
-
-MAXIMUM_STAMP_MINT_PASSES: int = 3
-"""Cap on review passes under --record-stamp before the invoker gives up."""
-
 EFFORT_TOKEN_LIST_SEPARATOR: str = ", "
 """Separator used when listing allowed effort tokens in error messages."""
 
@@ -204,32 +141,6 @@ INVALID_EFFORT_MESSAGE: str = (
 )
 """Stderr template when the caller supplies an unknown or ultra effort token."""
 
-STAMP_DID_NOT_CONVERGE_MESSAGE: str = (
-    "code-review stamp minting did not converge after {pass_count} passes "
-    "(surface kept changing or review return codes stayed non-zero); no stamp written"
-)
-"""Stderr template when the mint loop hits the pass cap without minting."""
-
-STAMP_STORE_IMPORT_FAILURE_MESSAGE: str = (
-    "code-review stamp store could not be imported for --record-stamp: {error}"
-)
-"""Stderr template when --record-stamp cannot load the stamp store module."""
-
-STAMP_STORE_MODULE_FILE_NAME: str = "code_review_stamp_store.py"
-"""File name of the stamp store module under hooks/blocking."""
-
-STAMP_STORE_MODULE_NAME: str = "code_review_stamp_store"
-"""Import name of the stamp store module."""
-
-STAMP_STORE_LIVE_SURFACE_HASH_NAME: str = "live_surface_hash"
-"""Attribute name of the live surface-hash helper on the stamp store module."""
-
-STAMP_STORE_RECORD_CLEAN_STAMP_NAME: str = "record_clean_stamp"
-"""Attribute name of the stamp-mint helper on the stamp store module."""
-
-STAMP_STORE_RESOLVE_REPO_ROOT_NAME: str = "resolve_repo_root"
-"""Attribute name of the repo-root resolver on the stamp store module."""
-
 SEVERITY_BLOCKER: str = "blocker"
 """Finding severity for a release-blocking defect."""
 

package/scripts/dev_env_scripts_constants/test_code_review_constants.py

@@ -1,52 +1,9 @@
-"""Behavioral tests for the host-aware code-review invoker constants module.
-
-These assert the single-source wiring: the effort tokens and the record-stamp
-flag the invoker exposes are the exact values the hooks enforcement module
-holds, so a threshold change in one place cannot drift the other.
-"""
+"""Behavioral tests for the host-aware code-review invoker constants module."""
 
 from __future__ import annotations
 
-import importlib.util
-from pathlib import Path
-from types import ModuleType
-
 from dev_env_scripts_constants import code_review_constants as review_constants
 
-_PACKAGE_ROOT = Path(__file__).resolve().parent.parent.parent
-_ENFORCEMENT_CONSTANTS_PATH = (
-    _PACKAGE_ROOT
-    / "hooks"
-    / "blocking"
-    / "config"
-    / "code_review_enforcement_constants.py"
-)
-
-
-def _load_enforcement_module() -> ModuleType:
-    module_spec = importlib.util.spec_from_file_location(
-        "code_review_enforcement_constants_under_test", _ENFORCEMENT_CONSTANTS_PATH
-    )
-    assert module_spec is not None
-    assert module_spec.loader is not None
-    enforcement_module = importlib.util.module_from_spec(module_spec)
-    module_spec.loader.exec_module(enforcement_module)
-    return enforcement_module
-
-
-def test_effort_tokens_reexport_the_enforcement_source() -> None:
-    enforcement_module = _load_enforcement_module()
-    assert review_constants.ALL_EFFORT_TOKENS_IN_ASCENDING_ORDER == getattr(
-        enforcement_module, "ALL_EFFORT_TOKENS_IN_ASCENDING_ORDER"
-    )
-
-
-def test_record_stamp_flag_matches_sanctioned_minter_flag() -> None:
-    enforcement_module = _load_enforcement_module()
-    assert review_constants.RECORD_STAMP_FLAG == getattr(
-        enforcement_module, "SANCTIONED_STAMP_MINTER_FLAG"
-    )
-
 
 def test_default_effort_is_a_known_token() -> None:
     assert (