fix(scripts): skip ci-precheck in the pre-push hook when a push only deletes refs (#4702)

## Description

The pre-push hook that `make install-git-hooks` writes runs the full
`make ci-precheck` (cargo fmt, clippy and the workspace tests, plus the
Python suite) even when a push only deletes branches. Its loop over the
refs on stdin skips deleted refs with `continue`, but the precheck runs
after the loop regardless, so `git push origin --delete <branch>` waits
several minutes for checks on code it doesn't send.

This PR tracks whether any ref in the push is an update, and exits 0
when none is.

No tracking issue.

## Type of Change

- [x] Bug fix (non-breaking change that fixes an issue)
- [ ] New feature (non-breaking change that adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update
- [ ] Performance improvement
- [ ] Code refactoring (no functional changes)

## Changes Made

- `scripts/install-git-hooks.sh` (the generated pre-push hook): set
`has_update=1` for every non-delete ref and `exit 0` after the loop when
no ref was an update. A push that mixes a delete with an update still
runs the precheck.
- The delete check now matches an all-zero sha of any length (`^0+$`),
so SHA-256 repositories (64-zero null id) are also recognised. The old
check compared against exactly 40 zeros.
- Removed the hook comment about gating only "main tracking branches";
the hook has no such pattern.
- `tests/test_install_git_hooks_script.py`: three end-to-end tests that
install the hooks into a temp repo and push to a bare remote with `make`
stubbed to log its calls. A branch update runs `make ci-precheck`; a
delete-only push does not (and the remote branch is gone); a push that
mixes a delete and an update runs it once.

## Testing

- [x] Unit tests pass (`pytest`)
- [x] Linting passes (`ruff check .`)
- [ ] Type checking passes (`mypy headroom`) (not run: no `headroom/`
code changed; the pre-commit mypy hook passed on the changed test file)
- [x] New tests added for new functionality
- [x] Manual testing performed

### Test Output

```text
$ pytest -q tests/test_install_git_hooks_script.py            # this branch
.......                                                         [100%]
7 passed in 3.97s

$ pytest -q tests/test_install_git_hooks_script.py            # same tests, origin/main's script
E   AssertionError: assert ['ci-precheck'] == []
FAILED tests/test_install_git_hooks_script.py::test_pre_push_skips_ci_precheck_for_a_delete_only_push
1 failed, 6 passed in 3.40s

$ ruff check tests/test_install_git_hooks_script.py
All checks passed!
$ ruff format --check tests/test_install_git_hooks_script.py
1 file already formatted
$ shellcheck -s bash scripts/install-git-hooks.sh
(no output)
$ npx commitlint --from origin/main --to HEAD
(exit 0)
```

pre-commit (ruff, ruff format, mypy, commitlint) passed on the commit.

## Real Behavior Proof

- Environment: macOS 27.2 arm64, git 2.x, bash 5; hooks installed by
each version of `scripts/install-git-hooks.sh` into a throwaway repo
with a bare remote; `make` stubbed to print instead of running the
precheck.
- Exact command / steps: install the hooks, push a `feature` branch with
`--no-verify`, then run `git push origin --delete feature` and `git push
origin HEAD:refs/heads/feature`, once with origin/main's script
(bb8d18a56) and once with this branch's.
- Observed result: origin/main runs `make ci-precheck` for the delete;
this branch skips it and still runs it for the branch push:

```text
== origin/main bb8d18a56
$ git push origin --delete feature
  [make ci-precheck] would run the full Rust + Python precheck
$ git push origin HEAD:refs/heads/feature
── pre-push: running 'make ci-precheck' before pushing HEAD → refs/heads/feature
  [make ci-precheck] would run the full Rust + Python precheck
== this branch
$ git push origin --delete feature
$ git push origin HEAD:refs/heads/feature
── pre-push: running 'make ci-precheck' before pushing HEAD → refs/heads/feature
  [make ci-precheck] would run the full Rust + Python precheck
```

- Not tested: a SHA-256 repository end to end (the regex change is
covered by reading only); Windows (the hook test module skips without
bash and git, as before); the full `make ci-precheck` itself (pushed
with `--no-verify`, since this PR changes only the hook script and its
test, and the precheck's `pip install -e .` would overwrite the local
venv used for the tests above).

## Runtime Rollout Safety

- Rollout-managed feature(s): none; contributor git hook only.
- Minimum rollout channel: N/A (not shipped in the package).
- Stable/default behavior changed: only for delete-only pushes, which no
longer run `make ci-precheck`. Every push that sends commits behaves as
before.
- Kill switch / disable path: N/A; contributors re-run `make
install-git-hooks` to pick up the change.
- Unsafe override required: no.
- Qualification impact: none; CI does not use this hook.
- Rollback path: revert this commit and re-run `make install-git-hooks`.

## Review Readiness

- [x] I have performed a self-review
- [x] This PR is ready for human review

## Checklist

- [x] My code follows the project's style guidelines
- [x] I have performed a self-review of my code
- [x] I have commented my code, particularly in hard-to-understand areas
- [ ] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] New and existing unit tests pass locally with my changes
- [x] I did **not** edit `CHANGELOG.md` — it is generated by
release-please from my Conventional Commit PR title (a CI guard enforces
this)

## Screenshots (if applicable)

N/A

## Additional Notes

Documentation: N/A. `CONTRIBUTING.md` says the pre-push hook runs
ci-precheck "on every push"; a push that only deletes branches sends no
code, so I left that wording alone. Happy to add a note if you prefer.

The three existing shellcheck SC2034 warnings in the hook body
(`remote`, `url`, `remote_sha` unused) are unchanged by this PR.

<!-- devin-review-badge-begin -->

---

<a href="https://app.devin.ai/review/headroomlabs-ai/headroom/pull/4702"
target="_blank"><picture><source media="(prefers-color-scheme: dark)"
srcset="https://static.devin.ai/assets/gh-devin-review-dark.svg?v=4"><img
src="https://static.devin.ai/assets/gh-devin-review-light.svg?v=4"
alt="Devin Review"></picture></a>
<!-- devin-review-badge-end -->

Co-authored-by: Kenneth Wong <17061293+KennethWKZ@users.noreply.github.com>
This commit is contained in:
Kenneth Wong
2026-11-09 12:24:49 -06:00
committed by GitHub
co-authored by Kenneth Wong
parent 2649835a51
commit cbcf8d8d9b
2 changed files with 71 additions and 5 deletions
+9 -5
View File
@@ -51,20 +51,24 @@ cat > "$HOOK_PATH" <<'HOOK_EOF'
set -euo pipefail
# Skip the hook entirely when push goes to a ref that is not on the main
# tracking branches we gate. Adjust the pattern below if more branches
# need gating.
remote="$1"
url="$2"
# git passes one line per ref on stdin. An all-zero local sha is a delete
# (`git push --delete`): it sends no commits, so there is nothing to check.
has_update=0
while IFS=' ' read -r local_ref local_sha remote_ref remote_sha; do
# Empty local_sha means a delete; nothing to verify.
if [[ "$local_sha" == "0000000000000000000000000000000000000000" ]]; then
if [[ "$local_sha" =~ ^0+$ ]]; then
continue
fi
has_update=1
echo "── pre-push: running 'make ci-precheck' before pushing $local_ref → $remote_ref"
done
if [[ "$has_update" -eq 0 ]]; then
exit 0
fi
if [[ -z "${VIRTUAL_ENV:-}" ]]; then
if [[ -f .venv/bin/activate ]]; then
# shellcheck disable=SC1091
+62
View File
@@ -117,6 +117,68 @@ def test_refuses_a_source_copy_nested_in_another_repository(tmp_path: Path) -> N
assert _hooks(parent / ".git") == set()
def _push_setup(tmp_path: Path) -> tuple[Path, dict[str, str], Path]:
"""A checkout with the hooks installed, a bare remote, and a fake ``make``
that logs each call instead of running ci-precheck."""
repo = _checkout(tmp_path / "repo")
env = _env(tmp_path)
assert _run(repo, env).returncode == 0
make_log = tmp_path / "make.log"
fake_make = tmp_path / "fake-bin" / "make"
fake_make.write_text(f'#!/bin/sh\necho "$*" >> "{make_log}"\n')
fake_make.chmod(0o755)
remote = tmp_path / "remote.git"
_git(tmp_path, "init", "-q", "--bare", str(remote))
_git(repo, "remote", "add", "origin", str(remote))
return repo, env, make_log
def _push(repo: Path, env: dict[str, str], *args: str) -> subprocess.CompletedProcess[str]:
return subprocess.run(
["git", "push", "-q", "origin", *args],
cwd=repo,
env=env,
capture_output=True,
text=True,
)
def _make_calls(make_log: Path) -> list[str]:
return make_log.read_text().splitlines() if make_log.exists() else []
def test_pre_push_runs_ci_precheck_for_a_branch_update(tmp_path: Path) -> None:
repo, env, make_log = _push_setup(tmp_path)
result = _push(repo, env, "HEAD:refs/heads/feature")
assert result.returncode == 0, result.stderr
assert _make_calls(make_log) == ["ci-precheck"]
def test_pre_push_skips_ci_precheck_for_a_delete_only_push(tmp_path: Path) -> None:
repo, env, make_log = _push_setup(tmp_path)
_git(repo, "push", "-q", "--no-verify", "origin", "HEAD:refs/heads/feature")
result = _push(repo, env, "--delete", "feature")
assert result.returncode == 0, result.stderr
assert _make_calls(make_log) == []
assert _git(repo, "ls-remote", "--heads", "origin", "feature") == ""
def test_pre_push_runs_ci_precheck_when_a_push_mixes_a_delete_and_an_update(
tmp_path: Path,
) -> None:
repo, env, make_log = _push_setup(tmp_path)
_git(repo, "push", "-q", "--no-verify", "origin", "HEAD:refs/heads/old")
result = _push(repo, env, ":old", "HEAD:refs/heads/new")
assert result.returncode == 0, result.stderr
assert _make_calls(make_log) == ["ci-precheck"]
def test_refuses_a_directory_outside_git(tmp_path: Path) -> None:
loose = tmp_path / "loose"
(loose / "scripts").mkdir(parents=True)