claude-dev-env 8.69.0 → 8.70.0

package/hooks/advisory/refactor_guard.py

@@ -1,385 +0,0 @@
-#!/usr/bin/env python3
-"""Warn about refactors that reach beyond the current Edit change surface."""
-
-from __future__ import annotations
-
-import json
-import os
-import re
-import subprocess
-import sys
-from collections import Counter
-from pathlib import Path
-
-_subprocess_window_hooks_directory = str(Path(__file__).resolve().parents[2] / "hooks")
-if _subprocess_window_hooks_directory not in sys.path:
-    sys.path.append(_subprocess_window_hooks_directory)
-
-from hooks_constants.subprocess_window import hidden_window_creation_flags
-
-try:
-    hooks_root_directory = str(Path(__file__).resolve().parent.parent)
-    if hooks_root_directory not in sys.path:
-        sys.path.insert(0, hooks_root_directory)
-
-    from hooks_constants.multi_edit_reconstruction import edits_for_tool
-    from hooks_constants.refactor_guard_constants import (
-        ALL_PYTHON_KEYWORDS,
-        CHANGED_SURFACE_MATCH_RATIO,
-        GIT_COMMAND_TIMEOUT_SECONDS,
-        GIT_EXECUTABLE_TOKEN,
-        MAXIMUM_REFACTOR_LINE_DELTA,
-        REFACTOR_LINE_DELTA_DIVISOR,
-    )
-except ImportError as import_error:
-    raise ImportError(
-        "refactor_guard: cannot import its sibling modules; "
-        "ensure the hooks directory is importable."
-    ) from import_error
-
-
-REFACTOR_BYPASS_TOKEN_PATH = Path.home() / ".claude" / ".refactor-bypass-token"
-identifier_join_separator = ", "
-
-
-def _git_query_context(file_path: str) -> tuple[str, str]:
-    """Keep lexical path ownership while Git resolves repository metadata."""
-    target_path = Path(file_path).absolute()
-    return str(target_path.parent), str(target_path)
-
-
-def _git_environment() -> dict[str, str]:
-    return {
-        each_environment_name: each_environment_value
-        for each_environment_name, each_environment_value in os.environ.items()
-        if not each_environment_name.startswith("GIT_")
-    }
-
-
-def _read_added_lines_from_git(all_git_arguments: tuple[str, ...], file_path: str) -> list[str]:
-    """Return added lines from one Git diff command."""
-    working_directory, absolute_file_path = _git_query_context(file_path)
-    try:
-        completed_process = subprocess.run(
-            [*all_git_arguments, "--", absolute_file_path],
-            check=False,
-            capture_output=True,
-            text=True,
-            timeout=GIT_COMMAND_TIMEOUT_SECONDS,
-            cwd=working_directory,
-            env=_git_environment(),
-            creationflags=hidden_window_creation_flags(),
-        )
-    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
-        return []
-    if completed_process.returncode != 0:
-        return []
-    return [
-        each_line[1:].strip()
-        for each_line in completed_process.stdout.splitlines()
-        if each_line.startswith("+") and not each_line.startswith("+++")
-    ]
-
-
-def _get_added_line_occurrences(file_path: str) -> list[str]:
-    all_added_lines = _read_added_lines_from_git((GIT_EXECUTABLE_TOKEN, "diff"), file_path)
-    all_added_lines.extend(
-        _read_added_lines_from_git((GIT_EXECUTABLE_TOKEN, "diff", "--cached"), file_path)
-    )
-    return all_added_lines
-
-
-def get_git_diff_added_lines(file_path: str) -> set[str]:
-    """Return staged and unstaged added lines for a tracked file."""
-    return set(_get_added_line_occurrences(file_path))
-
-
-def is_new_file(file_path: str) -> bool:
-    """Return whether Git reports the file as untracked."""
-    working_directory, absolute_file_path = _git_query_context(file_path)
-    try:
-        completed_process = subprocess.run(
-            [
-                GIT_EXECUTABLE_TOKEN,
-                "ls-files",
-                "--others",
-                "--exclude-standard",
-                "--",
-                absolute_file_path,
-            ],
-            check=False,
-            capture_output=True,
-            text=True,
-            timeout=GIT_COMMAND_TIMEOUT_SECONDS,
-            cwd=working_directory,
-            env=_git_environment(),
-            creationflags=hidden_window_creation_flags(),
-        )
-    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
-        return False
-    return completed_process.returncode == 0 and bool(completed_process.stdout.strip())
-
-
-def is_hook_infrastructure(file_path: str) -> bool:
-    """Return whether a path belongs to the installed Claude hook tree."""
-    normalized_path = file_path.lower().replace("\\", "/")
-    return "/.claude/" in normalized_path
-
-
-def extract_identifiers(code: str) -> set[str]:
-    """Return meaningful Python identifiers from a code fragment."""
-    all_identifiers = set(re.findall(r"\b([a-zA-Z_][a-zA-Z0-9_]{2,})\b", code))
-    return all_identifiers - ALL_PYTHON_KEYWORDS
-
-
-def _have_similar_words(old_identifier: str, new_identifier: str) -> bool:
-    all_old_words = set(re.findall(r"[a-z]+|[A-Z][a-z]*", old_identifier))
-    all_new_words = set(re.findall(r"[a-z]+|[A-Z][a-z]*", new_identifier))
-    return (
-        bool(all_old_words and all_new_words)
-        and len(all_old_words & all_new_words) >= len(all_old_words) * CHANGED_SURFACE_MATCH_RATIO
-    )
-
-
-def _describe_identifier_changes(
-    all_removed_identifiers: set[str], all_added_identifiers: set[str]
-) -> str | None:
-    all_renamed_identifiers: list[str] = []
-    for each_old_identifier in sorted(all_removed_identifiers):
-        for each_new_identifier in sorted(all_added_identifiers):
-            is_same_spelling = each_old_identifier.lower().replace(
-                "_", ""
-            ) == each_new_identifier.lower().replace("_", "")
-            if is_same_spelling or _have_similar_words(each_old_identifier, each_new_identifier):
-                all_renamed_identifiers.append(f"{each_old_identifier} -> {each_new_identifier}")
-                break
-    if all_renamed_identifiers:
-        return f"Renaming detected: {identifier_join_separator.join(all_renamed_identifiers[:3])}"
-    if len(all_removed_identifiers) > 1 and len(all_added_identifiers) > 1:
-        return (
-            "Multiple identifiers changed with same structure: "
-            f"removed {sorted(all_removed_identifiers)[:3]}, "
-            f"added {sorted(all_added_identifiers)[:3]}"
-        )
-    return None
-
-
-def is_refactor_edit(old_string: str, new_string: str) -> str | None:
-    """Return a description when an edit preserves structure and changes names."""
-    all_old_lines = [
-        each_line.strip() for each_line in old_string.strip().splitlines() if each_line.strip()
-    ]
-    all_new_lines = [
-        each_line.strip() for each_line in new_string.strip().splitlines() if each_line.strip()
-    ]
-    if not all_old_lines or not all_new_lines:
-        return None
-    if abs(len(all_old_lines) - len(all_new_lines)) > max(
-        len(all_old_lines) // REFACTOR_LINE_DELTA_DIVISOR, MAXIMUM_REFACTOR_LINE_DELTA
-    ):
-        return None
-    all_old_identifiers = extract_identifiers(old_string)
-    all_new_identifiers = extract_identifiers(new_string)
-    all_removed_identifiers = all_old_identifiers - all_new_identifiers
-    all_added_identifiers = all_new_identifiers - all_old_identifiers
-    if not all_removed_identifiers or not all_added_identifiers:
-        return None
-    all_identifiers = all_old_identifiers | all_new_identifiers
-    old_structure = re.sub(r"\s+", " ", _replace_identifiers(old_string, all_identifiers).strip())
-    new_structure = re.sub(r"\s+", " ", _replace_identifiers(new_string, all_identifiers).strip())
-    if old_structure != new_structure:
-        return None
-    return _describe_identifier_changes(all_removed_identifiers, all_added_identifiers)
-
-
-def _replace_identifiers(code: str, all_identifiers: set[str]) -> str:
-    normalized_code = code
-    for each_identifier in all_identifiers:
-        normalized_code = normalized_code.replace(each_identifier, "ID")
-    return normalized_code
-
-
-def _nonempty_stripped_lines(text: str) -> list[str]:
-    return [each_line.strip() for each_line in text.splitlines() if each_line.strip()]
-
-
-def _lines_within_changed_surface(old_string: str, all_added_lines: list[str]) -> bool:
-    """Return whether at least half of the edited lines are current additions."""
-    all_old_lines = _nonempty_stripped_lines(old_string)
-    if not all_old_lines or not all_added_lines:
-        return False
-    all_old_line_counts = Counter(all_old_lines)
-    all_added_line_counts = Counter(all_added_lines)
-    matched_occurrence_count = sum(
-        min(each_count, all_added_line_counts[each_line])
-        for each_line, each_count in all_old_line_counts.items()
-    )
-    edited_occurrence_count = sum(all_old_line_counts.values())
-    return matched_occurrence_count / edited_occurrence_count >= CHANGED_SURFACE_MATCH_RATIO
-
-
-def is_edit_within_changed_surface(file_path: str, old_string: str) -> bool:
-    """Return whether at least half of the edited lines are current additions."""
-    all_added_lines = _get_added_line_occurrences(file_path)
-    return _lines_within_changed_surface(old_string, all_added_lines)
-
-
-def _is_existing_edit_target(file_path: str) -> bool:
-    if not file_path or is_hook_infrastructure(file_path):
-        return False
-    return not is_new_file(file_path)
-
-
-def find_refactor_advisory_description(
-    file_path: str, old_string: str, new_string: str
-) -> str | None:
-    """Return an advisory description for a refactor outside changed lines."""
-    if not _is_existing_edit_target(file_path):
-        return None
-    refactor_description = is_refactor_edit(old_string, new_string)
-    if refactor_description is None:
-        return None
-    if is_edit_within_changed_surface(file_path, old_string):
-        return None
-    return refactor_description
-
-
-def is_refactor_eligible(file_path: str, old_string: str, new_string: str) -> bool:
-    """Return whether an Edit is eligible for the refactor advisory."""
-    return find_refactor_advisory_description(file_path, old_string, new_string) is not None
-
-
-def is_bypass_approved() -> bool:
-    """Consume the one-use bypass token when the user approved a refactor."""
-    if not REFACTOR_BYPASS_TOKEN_PATH.exists():
-        return False
-    try:
-        REFACTOR_BYPASS_TOKEN_PATH.unlink()
-    except OSError:
-        return False
-    return True
-
-
-def build_refactor_advisory_context(refactor_description: str, file_path: str) -> str:
-    """Build guidance that names the Edit stage and changed-surface rule."""
-    return (
-        f"[HOOK ADVISORY] Refactor guard — {refactor_description} in {file_path}. "
-        "Edit-stage guidance: This edit went through, and it changes lines outside the "
-        "current git diff. Keep further edits to lines the task already changes, and ask "
-        "the user before refactoring code outside them."
-    )
-
-
-def build_refactor_advisory_payload(refactor_description: str, file_path: str) -> dict[str, object]:
-    """Build the standalone allow payload used by the Edit advisory hook."""
-    advisory_context = build_refactor_advisory_context(refactor_description, file_path)
-    return {
-        "systemMessage": advisory_context,
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "permissionDecision": "allow",
-            "additionalContext": advisory_context,
-        },
-    }
-
-
-def _read_hook_input() -> dict[str, object] | None:
-    try:
-        parsed_input = json.load(sys.stdin)
-    except (json.JSONDecodeError, TypeError):
-        return None
-    if not isinstance(parsed_input, dict):
-        return None
-    return parsed_input
-
-
-def _read_edit_fields(payload_by_key: dict[str, object]) -> tuple[str, str, str, str]:
-    raw_tool_name = payload_by_key.get("tool_name")
-    tool_name = raw_tool_name if isinstance(raw_tool_name, str) else ""
-    raw_tool_input = payload_by_key.get("tool_input")
-    if not isinstance(raw_tool_input, dict):
-        return tool_name, "", "", ""
-    file_path_field = raw_tool_input.get("file_path")
-    old_string_field = raw_tool_input.get("old_string")
-    new_string_field = raw_tool_input.get("new_string")
-    if not isinstance(file_path_field, str):
-        return tool_name, "", "", ""
-    if not isinstance(old_string_field, str):
-        return tool_name, "", "", ""
-    if not isinstance(new_string_field, str):
-        return tool_name, "", "", ""
-    return tool_name, file_path_field, old_string_field, new_string_field
-
-
-def _refactor_advisory_description_within_surface(
-    all_added_lines: list[str],
-    old_string: str,
-    new_string: str,
-) -> str | None:
-    """Return an advisory description for one edit, given the file's added lines."""
-    refactor_description = is_refactor_edit(old_string, new_string)
-    if refactor_description is None:
-        return None
-    if _lines_within_changed_surface(old_string, all_added_lines):
-        return None
-    return refactor_description
-
-
-def _multi_edit_refactor_advisory_description(
-    payload_by_key: dict[str, object],
-) -> tuple[str, str] | None:
-    """Return the (file_path, description) pair for the first eligible edit in a MultiEdit."""
-    raw_tool_input = payload_by_key.get("tool_input")
-    if not isinstance(raw_tool_input, dict):
-        return None
-    file_path_field = raw_tool_input.get("file_path")
-    file_path = file_path_field if isinstance(file_path_field, str) else ""
-    if not file_path:
-        return None
-    if not _is_existing_edit_target(file_path):
-        return None
-    all_added_lines = _get_added_line_occurrences(file_path)
-    for each_edit in edits_for_tool("MultiEdit", raw_tool_input):
-        if not isinstance(each_edit, dict):
-            continue
-        old_string_field = each_edit.get("old_string")
-        new_string_field = each_edit.get("new_string")
-        if not isinstance(old_string_field, str) or not isinstance(new_string_field, str):
-            continue
-        refactor_description = _refactor_advisory_description_within_surface(
-            all_added_lines, old_string_field, new_string_field
-        )
-        if refactor_description is not None:
-            return file_path, refactor_description
-    return None
-
-
-def _emit_advisory(file_path: str, refactor_description: str) -> None:
-    advisory_payload = build_refactor_advisory_payload(refactor_description, file_path)
-    sys.stdout.write(json.dumps(advisory_payload))
-    sys.stdout.flush()
-
-
-def main() -> None:
-    """Emit an Edit-stage advisory for eligible out-of-surface refactors."""
-    payload_by_key = _read_hook_input()
-    if payload_by_key is None:
-        return
-    tool_name, file_path, old_string, new_string = _read_edit_fields(payload_by_key)
-    if is_bypass_approved():
-        return
-    if tool_name == "MultiEdit":
-        multi_edit_result = _multi_edit_refactor_advisory_description(payload_by_key)
-        if multi_edit_result is not None:
-            _emit_advisory(*multi_edit_result)
-        return
-    if tool_name != "Edit":
-        return
-    refactor_description = find_refactor_advisory_description(file_path, old_string, new_string)
-    if refactor_description is None:
-        return
-    _emit_advisory(file_path, refactor_description)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/advisory/refactor_guard_test_support.py

@@ -1,46 +0,0 @@
-"""Shared temporary-repository support for refactor guard tests."""
-
-from __future__ import annotations
-
-import subprocess
-from collections.abc import Generator
-from pathlib import Path
-
-import pytest
-
-
-@pytest.fixture
-def git_repository(tmp_path: Path) -> Generator[Path]:
-    """Create a committed temporary repository for refactor guard tests."""
-    repository_path = tmp_path / "repository"
-    repository_path.mkdir()
-    subprocess.run(["git", "init", "-q"], cwd=repository_path, check=True)
-    yield repository_path
-
-
-def commit_file(repository_path: Path, file_path: Path, file_content: str) -> None:
-    """Write and commit one file in a temporary repository."""
-    file_path.write_text(file_content, encoding="utf-8")
-    subprocess.run(["git", "add", str(file_path)], cwd=repository_path, check=True)
-    subprocess.run(
-        [
-            "git",
-            "-c",
-            "user.name=Refactor Guard Test",
-            "-c",
-            "user.email=refactor-guard@example.invalid",
-            "commit",
-            "-q",
-            "-m",
-            "baseline",
-            "--no-verify",
-        ],
-        cwd=repository_path,
-        check=True,
-    )
-
-
-def stage_file(repository_path: Path, file_path: Path, file_content: str) -> None:
-    """Write and stage one file in a temporary repository."""
-    file_path.write_text(file_content, encoding="utf-8")
-    subprocess.run(["git", "add", str(file_path)], cwd=repository_path, check=True)

package/hooks/advisory/test_refactor_guard.py

@@ -1,148 +0,0 @@
-"""Unit tests for refactor_guard's MultiEdit reconstruction, run in-process.
-
-test_refactor_guard_advisory.py and test_refactor_guard_eligibility.py already
-cover this hook end to end through real git fixtures; these tests exercise
-``_multi_edit_refactor_advisory_description`` directly against a target path
-outside any git repository, where the underlying git commands fail closed and
-return no added lines, so a qualifying rename is eligible without fixture setup.
-"""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-from pathlib import Path
-
-import pytest
-
-try:
-    _ADVISORY_DIRECTORY = Path(__file__).resolve().parent
-    if str(_ADVISORY_DIRECTORY) not in sys.path:
-        sys.path.insert(0, str(_ADVISORY_DIRECTORY))
-
-    import refactor_guard
-except ImportError as import_error:
-    raise ImportError(
-        "test_refactor_guard: cannot import its sibling modules; "
-        "ensure the advisory directory is importable."
-    ) from import_error
-
-
-WINDOWS_NO_WINDOW_FLAG = 0x08000000
-EXPECTED_HIDDEN_WINDOW_FLAGS = WINDOWS_NO_WINDOW_FLAG if sys.platform == "win32" else 0
-
-
-def _multi_edit_payload(file_path: str, all_edits: list[dict[str, str]]) -> dict[str, object]:
-    return {
-        "tool_name": "MultiEdit",
-        "tool_input": {"file_path": file_path, "edits": all_edits},
-    }
-
-
-def test_multi_edit_reports_the_first_eligible_rename(tmp_path: Path) -> None:
-    """A rename in the second edit is reported, even though the first edit is ordinary."""
-    target_path = str(tmp_path / "module.py")
-    payload = _multi_edit_payload(
-        target_path,
-        [
-            {"old_string": "return amount", "new_string": "return amount + 1"},
-            {
-                "old_string": "def calculate_total(amount):\n    return amount",
-                "new_string": "def compute_total(amount):\n    return amount",
-            },
-        ],
-    )
-
-    result = refactor_guard._multi_edit_refactor_advisory_description(payload)
-
-    assert result is not None
-    reported_path, description = result
-    assert reported_path == target_path
-    assert "calculate_total" in description
-    assert "compute_total" in description
-
-
-def test_multi_edit_scans_past_two_ordinary_edits_to_the_third(tmp_path: Path) -> None:
-    """The loop over edit pairs reaches the third pair, not only the first two."""
-    target_path = str(tmp_path / "module.py")
-    payload = _multi_edit_payload(
-        target_path,
-        [
-            {"old_string": "return amount", "new_string": "return amount + 1"},
-            {"old_string": "return amount + 1", "new_string": "return amount + 2"},
-            {
-                "old_string": "def calculate_total(amount):\n    return amount + 2",
-                "new_string": "def compute_total(amount):\n    return amount + 2",
-            },
-        ],
-    )
-
-    result = refactor_guard._multi_edit_refactor_advisory_description(payload)
-
-    assert result is not None
-    _reported_path, description = result
-    assert "compute_total" in description
-
-
-def test_multi_edit_returns_none_when_no_edit_qualifies(tmp_path: Path) -> None:
-    target_path = str(tmp_path / "module.py")
-    payload = _multi_edit_payload(
-        target_path,
-        [{"old_string": "return amount", "new_string": "return amount + 1"}],
-    )
-
-    assert refactor_guard._multi_edit_refactor_advisory_description(payload) is None
-
-
-def _record_creation_flags(
-    monkeypatch: pytest.MonkeyPatch, standard_output: str
-) -> dict[str, object]:
-    all_recorded_keyword_arguments: dict[str, object] = {}
-
-    def _record(*args: object, **kwargs: object) -> subprocess.CompletedProcess[str]:
-        del args
-        all_recorded_keyword_arguments.update(kwargs)
-        return subprocess.CompletedProcess([], 0, stdout=standard_output, stderr="")
-
-    monkeypatch.setattr(refactor_guard.subprocess, "run", _record)
-    return all_recorded_keyword_arguments
-
-
-def test_git_diff_should_start_without_a_console_window(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    all_recorded_keyword_arguments = _record_creation_flags(monkeypatch, "+added line\n")
-
-    refactor_guard.get_git_diff_added_lines(str(tmp_path / "module.py"))
-
-    assert all_recorded_keyword_arguments["creationflags"] == EXPECTED_HIDDEN_WINDOW_FLAGS
-
-
-def test_untracked_probe_should_start_without_a_console_window(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    all_recorded_keyword_arguments = _record_creation_flags(monkeypatch, "module.py\n")
-
-    assert refactor_guard.is_new_file(str(tmp_path / "module.py")) is True
-    assert all_recorded_keyword_arguments["creationflags"] == EXPECTED_HIDDEN_WINDOW_FLAGS
-
-
-def test_the_git_query_carries_the_advisory_s_own_executable_and_timeout(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    """refactor_guard_constants supplies both names the git call is built from."""
-    all_calls: list[tuple[list[str], object]] = []
-
-    def record_call(
-        command: list[str], **keyword_arguments: object
-    ) -> subprocess.CompletedProcess[str]:
-        all_calls.append((command, keyword_arguments["timeout"]))
-        return subprocess.CompletedProcess(command, 1, "", "")
-
-    monkeypatch.setattr(refactor_guard.subprocess, "run", record_call)
-
-    refactor_guard.is_new_file(str(tmp_path / "module.py"))
-
-    command, timeout = all_calls[0]
-    assert command[:2] == ["git", "ls-files"]
-    assert timeout == refactor_guard.GIT_COMMAND_TIMEOUT_SECONDS