claude-dev-env 4.0.0 → 4.2.0

package/hooks/blocking/test_es_exe_path_rewriter.py

@@ -1,447 +0,0 @@
-"""Tests for es_exe_path_rewriter — PreToolUse hook that rewrites es.exe paths."""
-
-import json
-import sys
-from io import StringIO
-from pathlib import Path
-from unittest.mock import patch
-
-import pytest
-
-_BLOCKING_DIR = Path(__file__).resolve().parent
-_HOOKS_ROOT = _BLOCKING_DIR.parent
-for each_sys_path_entry in (str(_BLOCKING_DIR), str(_HOOKS_ROOT)):
-    if each_sys_path_entry not in sys.path:
-        sys.path.insert(0, each_sys_path_entry)
-
-import es_exe_path_rewriter as rewriter
-
-
-def test_rewriter_does_not_redefine_dynamic_stderr_handler_locally() -> None:
-    """Pin PR #230 round 3 DRY fix: handler is imported from the shared module.
-
-    Both project_paths_reader and es_exe_path_rewriter previously defined
-    identical `_DynamicStderrHandler` classes. This test fails if the
-    duplicate class reappears in es_exe_path_rewriter.
-    """
-    assert not hasattr(rewriter, "_DynamicStderrHandler")
-
-
-REGISTRY_WITH_ONE_REPO = {"my-repo": "Y:\\Projects\\my-repo"}
-REGISTRY_WITH_TWO_REPOS = {
-    "my-repo": "Y:\\Projects\\my-repo",
-    "other-repo": "C:\\Dev\\other-repo",
-}
-ABSOLUTE_PATH_ARGUMENT = "Y:\\Projects\\already-absolute\\file.py"
-KNOWN_REPO_NAME = "my-repo"
-KNOWN_REPO_PATH = "Y:\\Projects\\my-repo"
-OTHER_REPO_NAME = "other-repo"
-OTHER_REPO_PATH = "C:\\Dev\\other-repo"
-
-
-def _run_main_with_stdin_text(stdin_text: str) -> tuple[str, str, int]:
-    """Return (stdout, stderr, exit_code) from running main() with the given stdin text."""
-    captured_stdout = StringIO()
-    captured_stderr = StringIO()
-    exit_code = 0
-    try:
-        with (
-            patch("sys.stdin", StringIO(stdin_text)),
-            patch("sys.stdout", captured_stdout),
-            patch("sys.stderr", captured_stderr),
-        ):
-            rewriter.main()
-    except SystemExit as e:
-        exit_code = e.code or 0
-    return captured_stdout.getvalue(), captured_stderr.getvalue(), exit_code
-
-
-def _run_main_with_input(hook_input: dict) -> tuple[str, str, int]:
-    """Return (stdout, stderr, exit_code) from running main() with the given hook input."""
-    return _run_main_with_stdin_text(json.dumps(hook_input))
-
-
-def _make_bash_input(command: str, description: str = "search files") -> dict:
-    return {
-        "tool_name": "Bash",
-        "tool_input": {"command": command, "description": description},
-    }
-
-
-class TestTriggerRegex:
-    def test_matches_bare_es_exe(self) -> None:
-        assert rewriter.command_invokes_es_exe("es.exe my-repo")
-
-    def test_matches_everything_forward_slash_path(self) -> None:
-        assert rewriter.command_invokes_es_exe("Everything/es.exe my-repo")
-
-    def test_matches_everything_backslash_path(self) -> None:
-        assert rewriter.command_invokes_es_exe("Everything\\es.exe my-repo")
-
-    def test_does_not_match_unrelated_command(self) -> None:
-        assert not rewriter.command_invokes_es_exe("git status")
-
-    def test_does_not_match_es_exe_inside_longer_word(self) -> None:
-        assert not rewriter.command_invokes_es_exe("not_es.exe_here")
-
-    def test_matches_case_insensitively(self) -> None:
-        assert rewriter.command_invokes_es_exe("ES.EXE my-repo")
-
-
-class TestRewriteCommand:
-    def test_bare_token_rewrite_substitutes_registry_path(self) -> None:
-        rewritten = rewriter.rewrite_command(
-            "es.exe my-repo config.py", REGISTRY_WITH_ONE_REPO
-        )
-        assert rewritten == f'es.exe "{KNOWN_REPO_PATH}" config.py'
-
-    def test_placeholder_token_rewrite_substitutes_registry_path(self) -> None:
-        rewritten = rewriter.rewrite_command(
-            'es.exe "{my-repo}" config.py', REGISTRY_WITH_ONE_REPO
-        )
-        assert rewritten == f'es.exe "{KNOWN_REPO_PATH}" config.py'
-
-    def test_single_quoted_placeholder_rewrite_substitutes_registry_path(self) -> None:
-        rewritten = rewriter.rewrite_command(
-            "es.exe '{my-repo}' config.py", REGISTRY_WITH_ONE_REPO
-        )
-        assert rewritten == f'es.exe "{KNOWN_REPO_PATH}" config.py'
-
-    def test_placeholder_without_quotes_rewrite_substitutes_registry_path(self) -> None:
-        rewritten = rewriter.rewrite_command(
-            "es.exe {my-repo} config.py", REGISTRY_WITH_ONE_REPO
-        )
-        assert rewritten == f'es.exe "{KNOWN_REPO_PATH}" config.py'
-
-    def test_absolute_path_argument_is_never_modified(self) -> None:
-        command = f'es.exe "{ABSOLUTE_PATH_ARGUMENT}" config.py'
-        rewritten = rewriter.rewrite_command(command, REGISTRY_WITH_ONE_REPO)
-        assert rewritten == command
-
-    def test_unknown_token_is_never_touched(self) -> None:
-        command = "es.exe unknown-name config.py"
-        rewritten = rewriter.rewrite_command(command, REGISTRY_WITH_ONE_REPO)
-        assert rewritten == command
-
-    def test_multiple_tokens_all_rewrite(self) -> None:
-        command = "es.exe my-repo other-repo config.py"
-        rewritten = rewriter.rewrite_command(command, REGISTRY_WITH_TWO_REPOS)
-        assert rewritten == f'es.exe "{KNOWN_REPO_PATH}" "{OTHER_REPO_PATH}" config.py'
-
-    def test_empty_registry_returns_unchanged_command(self) -> None:
-        command = "es.exe my-repo config.py"
-        rewritten = rewriter.rewrite_command(command, {})
-        assert rewritten == command
-
-    def test_double_spaces_inside_quoted_arg_pass_through_unchanged_on_no_registry_hit(
-        self,
-    ) -> None:
-        command = 'es.exe "foo  bar" baz'
-        rewritten = rewriter.rewrite_command(command, REGISTRY_WITH_ONE_REPO)
-        assert rewritten == command
-
-    def test_tab_separator_is_preserved_when_bare_token_is_rewritten(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = "es.exe my-repo\tconfig.py"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == f'es.exe "Y:\\Projects\\my-repo"\tconfig.py'
-
-    def test_multiple_substitutions_preserve_all_inter_token_whitespace(self) -> None:
-        command = "es.exe my-repo  other-repo   config.py"
-        rewritten = rewriter.rewrite_command(command, REGISTRY_WITH_TWO_REPOS)
-        assert rewritten == f'es.exe "{KNOWN_REPO_PATH}"  "{OTHER_REPO_PATH}"   config.py'
-
-
-class TestEmittedJsonShape:
-    def test_emitted_json_has_correct_hook_event_name(self) -> None:
-        hook_input = _make_bash_input(f"es.exe {KNOWN_REPO_NAME} config.py")
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        emitted = json.loads(stdout)
-        assert emitted["hookSpecificOutput"]["hookEventName"] == "PreToolUse"
-
-    def test_emitted_json_has_allow_permission_decision(self) -> None:
-        hook_input = _make_bash_input(f"es.exe {KNOWN_REPO_NAME} config.py")
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        emitted = json.loads(stdout)
-        assert emitted["hookSpecificOutput"]["permissionDecision"] == "allow"
-
-    def test_emitted_json_has_rewritten_command(self) -> None:
-        hook_input = _make_bash_input(f"es.exe {KNOWN_REPO_NAME} config.py")
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        emitted = json.loads(stdout)
-        updated_command = emitted["hookSpecificOutput"]["updatedInput"]["command"]
-        assert updated_command == f'es.exe "{KNOWN_REPO_PATH}" config.py'
-
-    def test_description_field_round_trips_unchanged(self) -> None:
-        original_description = "my special search description"
-        hook_input = _make_bash_input(
-            f"es.exe {KNOWN_REPO_NAME} config.py", original_description
-        )
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        emitted = json.loads(stdout)
-        assert (
-            emitted["hookSpecificOutput"]["updatedInput"]["description"]
-            == original_description
-        )
-
-    def test_additional_unknown_fields_pass_through_into_updated_input(self) -> None:
-        hook_input = {
-            "tool_name": "Bash",
-            "tool_input": {
-                "command": f"es.exe {KNOWN_REPO_NAME} config.py",
-                "description": "search",
-                "extra_field": "extra_value",
-            },
-        }
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        emitted = json.loads(stdout)
-        assert (
-            emitted["hookSpecificOutput"]["updatedInput"]["extra_field"]
-            == "extra_value"
-        )
-
-    def test_no_code_path_returns_deny_decision(self) -> None:
-        for command in [
-            f"es.exe {KNOWN_REPO_NAME} config.py",
-            "es.exe unknown-token config.py",
-            "git status",
-        ]:
-            hook_input = _make_bash_input(command)
-            with patch(
-                "es_exe_path_rewriter.load_registry",
-                return_value=REGISTRY_WITH_ONE_REPO,
-            ):
-                stdout, _, _ = _run_main_with_input(hook_input)
-            if stdout.strip():
-                emitted = json.loads(stdout)
-                decision = emitted.get("hookSpecificOutput", {}).get(
-                    "permissionDecision", ""
-                )
-                assert decision != "deny", f"deny returned for command: {command!r}"
-
-
-class TestStdinParsingRobustness:
-    def test_empty_stdin_exits_zero_without_stdout_or_stderr(self) -> None:
-        stdout, stderr, exit_code = _run_main_with_stdin_text("")
-        assert exit_code == 0
-        assert stdout.strip() == ""
-        assert stderr.strip() == ""
-
-    def test_whitespace_only_stdin_exits_zero_without_stdout_or_stderr(self) -> None:
-        stdout, stderr, exit_code = _run_main_with_stdin_text("  \n\t ")
-        assert exit_code == 0
-        assert stdout.strip() == ""
-        assert stderr.strip() == ""
-
-    def test_invalid_json_stdin_exits_zero_without_stdout_or_stderr(self) -> None:
-        stdout, stderr, exit_code = _run_main_with_stdin_text("{not valid")
-        assert exit_code == 0
-        assert stdout.strip() == ""
-        assert stderr.strip() == ""
-
-
-class TestMalformedHookPayloadTypes:
-    def test_null_tool_input_exits_zero_without_stdout_or_stderr(self) -> None:
-        hook_input = {
-            "tool_name": "Bash",
-            "tool_input": None,
-        }
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, stderr, exit_code = _run_main_with_input(hook_input)
-        assert exit_code == 0
-        assert stdout.strip() == ""
-        assert stderr.strip() == ""
-
-    def test_list_tool_input_exits_zero_without_stdout_or_stderr(self) -> None:
-        hook_input = {
-            "tool_name": "Bash",
-            "tool_input": ["es.exe", KNOWN_REPO_NAME],
-        }
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, stderr, exit_code = _run_main_with_input(hook_input)
-        assert exit_code == 0
-        assert stdout.strip() == ""
-        assert stderr.strip() == ""
-
-    def test_string_tool_input_exits_zero_without_stdout_or_stderr(self) -> None:
-        hook_input = {
-            "tool_name": "Bash",
-            "tool_input": f"es.exe {KNOWN_REPO_NAME}",
-        }
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, stderr, exit_code = _run_main_with_input(hook_input)
-        assert exit_code == 0
-        assert stdout.strip() == ""
-        assert stderr.strip() == ""
-
-    def test_non_string_command_exits_zero_without_stdout_or_stderr(self) -> None:
-        hook_input = {
-            "tool_name": "Bash",
-            "tool_input": {"command": 12345, "description": "search"},
-        }
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, stderr, exit_code = _run_main_with_input(hook_input)
-        assert exit_code == 0
-        assert stdout.strip() == ""
-        assert stderr.strip() == ""
-
-
-class TestNoOutputCases:
-    def test_non_es_exe_command_produces_no_output(self) -> None:
-        hook_input = _make_bash_input("git status")
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        assert stdout.strip() == ""
-
-    def test_empty_registry_produces_no_output(self) -> None:
-        hook_input = _make_bash_input(f"es.exe {KNOWN_REPO_NAME} config.py")
-        with patch("es_exe_path_rewriter.load_registry", return_value={}):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        assert stdout.strip() == ""
-
-    def test_unchanged_command_produces_no_output(self) -> None:
-        hook_input = _make_bash_input("es.exe unknown-token config.py")
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        assert stdout.strip() == ""
-
-    def test_malformed_registry_produces_no_output_and_one_stderr_line(self) -> None:
-        hook_input = _make_bash_input(f"es.exe {KNOWN_REPO_NAME} config.py")
-        with patch(
-            "es_exe_path_rewriter.load_registry",
-            side_effect=Exception("simulated read error"),
-        ):
-            stdout, stderr, _ = _run_main_with_input(hook_input)
-        assert stdout.strip() == ""
-        assert stderr.strip() != ""
-        assert stderr.strip().count("\n") == 0
-
-    def test_non_bash_tool_produces_no_output(self) -> None:
-        hook_input = {
-            "tool_name": "Write",
-            "tool_input": {"command": f"es.exe {KNOWN_REPO_NAME}"},
-        }
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        assert stdout.strip() == ""
-
-
-class TestQuoteAwareTokenizer:
-    def test_double_quoted_multiword_arg_with_registry_key_prefix_is_not_substituted(
-        self,
-    ) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = 'es.exe "my-repo foo" baz'
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == command
-
-    def test_single_quoted_multiword_arg_with_registry_key_prefix_is_not_substituted(
-        self,
-    ) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = "es.exe 'my-repo baz' config.py"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == command
-
-    def test_bare_token_matching_registry_key_is_rewritten(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = "es.exe my-repo config.py"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == f'es.exe "Y:\\Projects\\my-repo" config.py'
-
-    def test_whitespace_between_bare_tokens_is_preserved_after_rewrite(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo", "other-repo": "C:\\Dev\\other"}
-        command = "es.exe my-repo  other-repo   config.py"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == f'es.exe "Y:\\Projects\\my-repo"  "C:\\Dev\\other"   config.py'
-
-    def test_tab_separator_is_preserved_when_bare_token_is_rewritten(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = "es.exe my-repo\tconfig.py"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == f'es.exe "Y:\\Projects\\my-repo"\tconfig.py'
-
-
-class TestQuotedSingleWordRewrite:
-    def test_double_quoted_single_word_registry_key_is_rewritten(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = 'es.exe "my-repo" config.py'
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == f'es.exe "Y:\\Projects\\my-repo" config.py'
-
-    def test_single_quoted_single_word_registry_key_is_rewritten(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = "es.exe 'my-repo' config.py"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == f'es.exe "Y:\\Projects\\my-repo" config.py'
-
-
-class TestPlaceholderBoundaryEnforcement:
-    def test_placeholder_inside_flag_argument_is_not_rewritten(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = "es.exe --regex=^{my-repo}$"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == command
-
-    def test_placeholder_embedded_in_token_is_not_rewritten(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = "es.exe foo{my-repo}bar"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == command
-
-    def test_standalone_placeholder_is_still_rewritten(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = "es.exe {my-repo} config.py"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == f'es.exe "Y:\\Projects\\my-repo" config.py'
-
-
-class TestAbsolutePathDetection:
-    def test_windows_drive_letter_path_detected_as_absolute(self) -> None:
-        assert rewriter._token_is_absolute_path("C:\\Users\\x")
-
-    def test_windows_drive_letter_path_with_forward_slashes_detected_as_absolute(
-        self,
-    ) -> None:
-        assert rewriter._token_is_absolute_path("Y:/Projects/foo")
-
-    def test_unc_path_detected_as_absolute(self) -> None:
-        assert rewriter._token_is_absolute_path("\\\\server\\share\\path")
-
-    def test_posix_absolute_path_detected_as_absolute(self) -> None:
-        assert rewriter._token_is_absolute_path("/etc/hosts")
-
-    def test_relative_path_not_detected_as_absolute(self) -> None:
-        assert not rewriter._token_is_absolute_path("./foo")
-
-    def test_bare_registry_token_not_detected_as_absolute(self) -> None:
-        assert not rewriter._token_is_absolute_path("my-repo")

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())