claude-dev-env 2.36.0 → 4.1.0

package/hooks/git-hooks/post_commit.py

@@ -1,241 +0,0 @@
-#!/usr/bin/env python3
-"""
-Git post-commit hook: Auto-update parent repos when committing in a submodule.
-
-When you commit in a submodule, this hook:
-1. Detects if current repo is a submodule of a parent
-2. Stages the submodule update in the parent
-3. Creates a commit in the parent pointing to the new submodule commit
-
-This prevents the "lost work" issue where submodule commits aren't tracked by parent.
-"""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-from enum import StrEnum
-from pathlib import Path
-
-from git_hooks_constants import (
-    GH_EXECUTABLE_NAME,
-    GH_PR_VIEW_ARGUMENTS,
-    GH_PR_VIEW_TIMEOUT_SECONDS,
-    GIT_COMMAND_SUCCESS_EXIT_CODE,
-    GIT_EXECUTABLE_NAME,
-)
-from pull_request_handoff import build_pull_request_reminder
-
-
-class ParentPointerStatus(StrEnum):
-    """States returned by a parent pointer update."""
-
-    UPDATED = "updated"
-    UNCHANGED = "unchanged"
-    FAILED = "failed"
-
-
-ParentPointerUpdate = tuple[ParentPointerStatus, str]
-
-
-def execute_git(
-    *arguments: str,
-    cwd: Path,
-) -> subprocess.CompletedProcess[str]:
-    """Run a Git command and return its completed process."""
-    try:
-        return subprocess.run(
-            [GIT_EXECUTABLE_NAME, *arguments],
-            cwd=cwd,
-            check=False,
-            capture_output=True,
-            text=True,
-        )
-    except OSError as error:
-        return subprocess.CompletedProcess(
-            [GIT_EXECUTABLE_NAME, *arguments],
-            1,
-            "",
-            str(error),
-        )
-
-
-def run_git(*arguments: str, cwd: Path) -> str:
-    """Run a successful Git command and return its trimmed standard output."""
-    command_result = execute_git(*arguments, cwd=cwd)
-    if command_result.returncode != GIT_COMMAND_SUCCESS_EXIT_CODE:
-        return ""
-    return command_result.stdout.strip()
-
-
-def run_git_from_current_directory(*arguments: str) -> str:
-    """Run a successful Git command from the hook's current directory."""
-    return run_git(*arguments, cwd=Path.cwd())
-
-
-def find_parent_repo(repo_dir: Path) -> Path | None:
-    """Return the Git superproject that owns the current repository."""
-    parent_path_text = run_git(
-        "rev-parse",
-        "--show-superproject-working-tree",
-        cwd=repo_dir,
-    )
-    if not parent_path_text:
-        return None
-
-    parent_path = Path(parent_path_text).resolve()
-    if not parent_path.is_dir():
-        return None
-    return parent_path
-
-
-def find_submodule_path(parent_repo: Path, repo_dir: Path) -> Path | None:
-    """Return the submodule path relative to its parent repository."""
-    try:
-        return repo_dir.resolve().relative_to(parent_repo.resolve())
-    except ValueError:
-        return None
-
-
-def build_literal_pathspec(submodule_path: Path) -> str:
-    """Build a Git pathspec that treats every path character literally."""
-    return f":(literal){submodule_path.as_posix()}"
-
-
-def get_git_failure_diagnostic(
-    command_result: subprocess.CompletedProcess[str],
-) -> str:
-    """Return the most useful diagnostic from a failed Git command."""
-    return command_result.stderr.strip() or command_result.stdout.strip()
-
-
-def build_parent_commit_message(
-    repo_name: str,
-    commit_hash: str,
-    commit_message: str,
-) -> str:
-    """Build the parent commit message for a submodule pointer update."""
-    return (
-        f"chore: update {repo_name} submodule to {commit_hash}\n\n"
-        f"Submodule commit: {commit_message}\n\n"
-        "Co-Authored-By: Claude <noreply@anthropic.com>"
-    )
-
-
-def update_parent_pointer(
-    parent_repo: Path,
-    repo_dir: Path,
-    commit_hash: str,
-    commit_message: str,
-) -> ParentPointerUpdate:
-    """Commit the current submodule pointer in its parent repository."""
-    submodule_path = find_submodule_path(parent_repo, repo_dir)
-    if submodule_path is None:
-        return ParentPointerStatus.FAILED, "could not resolve the submodule path"
-
-    submodule_reference = build_literal_pathspec(submodule_path)
-    add_result = execute_git("add", "--", submodule_reference, cwd=parent_repo)
-    if add_result.returncode != GIT_COMMAND_SUCCESS_EXIT_CODE:
-        return ParentPointerStatus.FAILED, get_git_failure_diagnostic(add_result)
-
-    staged_difference = execute_git(
-        "diff",
-        "--cached",
-        "--quiet",
-        "--",
-        submodule_reference,
-        cwd=parent_repo,
-    )
-    if staged_difference.returncode == GIT_COMMAND_SUCCESS_EXIT_CODE:
-        return ParentPointerStatus.UNCHANGED, ""
-    if staged_difference.returncode != 1:
-        return ParentPointerStatus.FAILED, get_git_failure_diagnostic(staged_difference)
-
-    parent_commit_message = build_parent_commit_message(
-        repo_dir.name,
-        commit_hash,
-        commit_message,
-    )
-    commit_result = execute_git(
-        "commit",
-        "--only",
-        "-m",
-        parent_commit_message,
-        "--",
-        submodule_reference,
-        cwd=parent_repo,
-    )
-    if commit_result.returncode != GIT_COMMAND_SUCCESS_EXIT_CODE:
-        return ParentPointerStatus.FAILED, get_git_failure_diagnostic(commit_result)
-    return ParentPointerStatus.UPDATED, ""
-
-
-def print_pull_request_reminder(repo_dir: Path) -> None:
-    """Print a reminder when the committed repository has an open pull request."""
-    try:
-        result = subprocess.run(
-            [GH_EXECUTABLE_NAME, *GH_PR_VIEW_ARGUMENTS],
-            cwd=repo_dir,
-            check=False,
-            capture_output=True,
-            text=True,
-            timeout=GH_PR_VIEW_TIMEOUT_SECONDS,
-        )
-    except (OSError, subprocess.TimeoutExpired):
-        return
-    pull_request_url = result.stdout.strip()
-    if result.returncode == 0 and pull_request_url:
-        print(build_pull_request_reminder(pull_request_url))
-
-
-def main() -> int:
-    """Update a parent repository after a submodule commit."""
-    repo_path_text = run_git_from_current_directory("rev-parse", "--show-toplevel")
-    if not repo_path_text:
-        return 0
-
-    repo_dir = Path(repo_path_text).resolve()
-    parent_repo = find_parent_repo(repo_dir)
-    if parent_repo is None:
-        print_pull_request_reminder(repo_dir)
-        return 0
-
-    commit_msg = run_git("log", "-1", "--pretty=%s", cwd=repo_dir)
-    commit_hash = run_git("rev-parse", "HEAD", cwd=repo_dir)
-    short_commit_hash = run_git("rev-parse", "--short", "HEAD", cwd=repo_dir)
-    if not commit_hash or not short_commit_hash:
-        print_pull_request_reminder(repo_dir)
-        return 0
-
-    print()
-    print("=== Submodule Parent Update ===")
-    print(f"Submodule: {repo_dir.name} @ {short_commit_hash}")
-    print(f"Parent:    {parent_repo}")
-
-    parent_pointer_status, parent_pointer_diagnostic = update_parent_pointer(
-        parent_repo,
-        repo_dir,
-        commit_hash,
-        commit_msg,
-    )
-    if parent_pointer_status is ParentPointerStatus.FAILED:
-        print("Parent update failed.")
-        if parent_pointer_diagnostic:
-            print(f"Git diagnostic: {parent_pointer_diagnostic}")
-        print_pull_request_reminder(repo_dir)
-        return 0
-    if parent_pointer_status is ParentPointerStatus.UNCHANGED:
-        print("Parent already up to date.")
-        print_pull_request_reminder(repo_dir)
-        return 0
-
-    print("Parent updated successfully.")
-    print("================================")
-    print()
-    print_pull_request_reminder(repo_dir)
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/hooks/git-hooks/test_post_commit.py

@@ -1,298 +0,0 @@
-from __future__ import annotations
-
-import os
-import subprocess
-from pathlib import Path
-
-import post_commit
-import pytest
-from git_hooks_constants import GIT_EXECUTABLE_NAME
-
-
-def build_fixture_git_environment() -> dict[str, str]:
-    """Copy the process environment without inherited Git state overrides."""
-    return {
-        each_name: each_value
-        for each_name, each_value in os.environ.items()
-        if not each_name.upper().startswith("GIT_")
-    }
-
-
-def clear_inherited_git_environment(monkeypatch: pytest.MonkeyPatch) -> None:
-    """Remove inherited Git state overrides from the current test process."""
-    for each_name in list(os.environ):
-        if each_name.upper().startswith("GIT_"):
-            monkeypatch.delenv(each_name, raising=False)
-
-
-def test_fixture_git_environment_preserves_process_execution_path(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """The fixture environment keeps PATH while removing Git overrides."""
-    monkeypatch.setenv("PATH", "fixture-execution-path")
-    monkeypatch.setenv("GIT_DIR", "unrelated-repository")
-
-    fixture_environment = build_fixture_git_environment()
-
-    assert fixture_environment["PATH"] == "fixture-execution-path"
-    assert all(not each_name.upper().startswith("GIT_") for each_name in fixture_environment)
-
-
-def run_fixture_git(repository_path: Path, *arguments: str) -> str:
-    """Run Git in a fixture repository and return standard output."""
-    completed_process = subprocess.run(
-        [GIT_EXECUTABLE_NAME, *arguments],
-        cwd=repository_path,
-        check=False,
-        capture_output=True,
-        text=True,
-        env=build_fixture_git_environment(),
-    )
-    assert completed_process.returncode == 0, completed_process.stderr
-    return completed_process.stdout.strip()
-
-
-def configure_fixture_identity(repository_path: Path) -> None:
-    """Configure a stable identity for a fixture repository."""
-    run_fixture_git(repository_path, "config", "user.name", "Fixture User")
-    run_fixture_git(
-        repository_path,
-        "config",
-        "user.email",
-        "fixture@example.invalid",
-    )
-    run_fixture_git(repository_path, "config", "commit.gpgsign", "false")
-    fixture_hooks_directory = repository_path / ".fixture-hooks"
-    fixture_hooks_directory.mkdir(exist_ok=True)
-    run_fixture_git(
-        repository_path,
-        "config",
-        "core.hooksPath",
-        str(fixture_hooks_directory),
-    )
-
-
-def initialize_fixture_repository(repository_path: Path) -> None:
-    """Create and configure a fixture Git repository."""
-    repository_path.mkdir()
-    run_fixture_git(repository_path, "init", "-b", "main")
-    configure_fixture_identity(repository_path)
-
-
-def test_native_submodule_commit_records_parent_pointer(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """A real submodule commit creates the matching parent pointer commit."""
-    unrelated_repository = tmp_path / "unrelated-repository"
-    initialize_fixture_repository(unrelated_repository)
-    monkeypatch.setenv("GIT_DIR", str(unrelated_repository / ".git"))
-
-    source_repository = tmp_path / "source-repository"
-    parent_repository = tmp_path / "parent-repository"
-    initialize_fixture_repository(source_repository)
-    (source_repository / "README.md").write_text("fixture source\n", encoding="utf-8")
-    run_fixture_git(source_repository, "add", "README.md")
-    run_fixture_git(source_repository, "commit", "-m", "Create fixture source")
-
-    initialize_fixture_repository(parent_repository)
-    (parent_repository / "README.md").write_text("fixture parent\n", encoding="utf-8")
-    run_fixture_git(parent_repository, "add", "README.md")
-    run_fixture_git(parent_repository, "commit", "-m", "Create fixture parent")
-    run_fixture_git(
-        parent_repository,
-        "-c",
-        "protocol.file.allow=always",
-        "submodule",
-        "add",
-        str(source_repository),
-        "nested/sub[module]",
-    )
-    run_fixture_git(parent_repository, "commit", "-am", "Add fixture submodule")
-
-    submodule_repository = parent_repository / "nested" / "sub[module]"
-    configure_fixture_identity(submodule_repository)
-    (parent_repository / "staged-note.txt").write_text("keep staged\n", encoding="utf-8")
-    run_fixture_git(parent_repository, "add", "staged-note.txt")
-    (submodule_repository / "change.txt").write_text("fixture change\n", encoding="utf-8")
-    run_fixture_git(submodule_repository, "add", "change.txt")
-    run_fixture_git(submodule_repository, "commit", "-m", "Record fixture change")
-    clear_inherited_git_environment(monkeypatch)
-    monkeypatch.chdir(submodule_repository)
-    assert post_commit.main() == 0
-
-    submodule_commit_hash = run_fixture_git(submodule_repository, "rev-parse", "HEAD")
-    parent_commit_subject = run_fixture_git(parent_repository, "log", "-1", "--pretty=%s")
-    parent_commit_body = run_fixture_git(parent_repository, "log", "-1", "--pretty=%B")
-    recorded_pointer_hash = run_fixture_git(
-        parent_repository,
-        "rev-parse",
-        "HEAD:nested/sub[module]",
-    )
-
-    assert recorded_pointer_hash == submodule_commit_hash
-    assert parent_commit_subject == (
-        f"chore: update sub[module] submodule to {submodule_commit_hash}"
-    )
-    assert "Submodule commit: Record fixture change" in parent_commit_body
-    assert run_fixture_git(parent_repository, "status", "--short") == "A  staged-note.txt"
-
-
-def test_parent_update_returns_git_diagnostic_for_failed_add(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """A failed parent add returns the Git diagnostic and literal pathspec."""
-    parent_repository = tmp_path / "parent-repository"
-    submodule_repository = parent_repository / "sub[module]"
-    submodule_repository.mkdir(parents=True)
-    recorded_commands: list[tuple[str, ...]] = []
-
-    def fail_git_add(*arguments: str, cwd: Path) -> subprocess.CompletedProcess[str]:
-        recorded_commands.append(arguments)
-        return subprocess.CompletedProcess(
-            ["git", *arguments],
-            1,
-            "",
-            "fatal: fixture add failure",
-        )
-
-    monkeypatch.setattr(post_commit, "execute_git", fail_git_add)
-
-    parent_update = post_commit.update_parent_pointer(
-        parent_repository,
-        submodule_repository,
-        "a" * 40,
-        "Fixture commit",
-    )
-
-    assert parent_update == (
-        post_commit.ParentPointerStatus.FAILED,
-        "fatal: fixture add failure",
-    )
-    assert recorded_commands == [("add", "--", ":(literal)sub[module]")]
-
-
-def test_main_prints_git_failure_diagnostic(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-) -> None:
-    """The hook prints the Git diagnostic when the parent update fails."""
-    submodule_repository = tmp_path / "submodule"
-    parent_repository = tmp_path / "parent"
-    submodule_repository.mkdir()
-    parent_repository.mkdir()
-    monkeypatch.setattr(
-        post_commit,
-        "run_git_from_current_directory",
-        lambda *arguments: str(submodule_repository),
-    )
-    monkeypatch.setattr(post_commit, "find_parent_repo", lambda repo: parent_repository)
-    monkeypatch.setattr(post_commit, "run_git", lambda *arguments, cwd: "a" * 40)
-    monkeypatch.setattr(
-        post_commit,
-        "update_parent_pointer",
-        lambda *arguments: (
-            post_commit.ParentPointerStatus.FAILED,
-            "fatal: fixture commit failure",
-        ),
-    )
-
-    assert post_commit.main() == 0
-    assert "Git diagnostic: fatal: fixture commit failure" in capsys.readouterr().out
-
-
-@pytest.mark.parametrize(
-    "completed_process",
-    [
-        subprocess.CompletedProcess(["gh"], 1, "", "no pull request"),
-        subprocess.CompletedProcess(["gh"], 1, "", "auth failed"),
-    ],
-)
-def test_pull_request_reminder_is_silent_without_successful_url(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-    completed_process: subprocess.CompletedProcess[str],
-) -> None:
-    monkeypatch.setattr(post_commit.subprocess, "run", lambda *args, **kwargs: completed_process)
-
-    post_commit.print_pull_request_reminder(tmp_path)
-
-    assert capsys.readouterr().out == ""
-
-
-def test_pull_request_reminder_prints_url(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-) -> None:
-    monkeypatch.setattr(
-        post_commit.subprocess,
-        "run",
-        lambda *args, **kwargs: subprocess.CompletedProcess(
-            ["gh"], 0, "https://github.com/example/repo/pull/1\n", ""
-        ),
-    )
-
-    post_commit.print_pull_request_reminder(tmp_path)
-
-    output = capsys.readouterr().out
-    assert output.startswith("Review this pull request: https://github.com/example/repo/pull/1\n")
-    assert "<PR link>" not in output
-    assert "Do not use the branch name, commit message, labels, current title" in output
-    assert (
-        "Before writing, inventory every independently observable behavior in the full diff."
-        in output
-        and "Lead with the central behavior for readability, then give every other behavior its own short paragraph or bullet."
-        in output
-        and "For each behavior, state the trigger or observer, the Before -> After result" in output
-        and "OVERRIDE:" not in output
-    )
-    assert "gh pr edit https://github.com/example/repo/pull/1" in output
-    assert output.rstrip().endswith("Report the saved result.")
-
-
-@pytest.mark.parametrize("exception", [FileNotFoundError(), subprocess.TimeoutExpired("gh", 5)])
-def test_pull_request_reminder_ignores_missing_gh_and_timeout(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-    exception: Exception,
-) -> None:
-    def raise_exception(*args: object, **kwargs: object) -> None:
-        raise exception
-
-    monkeypatch.setattr(post_commit.subprocess, "run", raise_exception)
-
-    post_commit.print_pull_request_reminder(tmp_path)
-
-    assert capsys.readouterr().out == ""
-
-
-def test_main_runs_pull_request_reminder_after_parent_update(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    events: list[str] = []
-    repo = tmp_path / "repo"
-    parent = tmp_path / "parent"
-    repo.mkdir()
-    parent.mkdir()
-    monkeypatch.setattr(post_commit, "run_git_from_current_directory", lambda *args: str(repo))
-    monkeypatch.setattr(post_commit, "find_parent_repo", lambda repo_dir: parent)
-    monkeypatch.setattr(post_commit, "run_git", lambda *args, cwd: "a" * 40)
-    monkeypatch.setattr(
-        post_commit,
-        "update_parent_pointer",
-        lambda *args: events.append("parent") or (post_commit.ParentPointerStatus.UPDATED, ""),
-    )
-    monkeypatch.setattr(
-        post_commit,
-        "print_pull_request_reminder",
-        lambda repo_dir: events.append("reminder"),
-    )
-
-    assert post_commit.main() == 0
-    assert events == ["parent", "reminder"]