fix(scripts): resolve hooks dir via git so install-git-hooks works in linked worktrees (#4176)

## Description

`make install-git-hooks` fails in a linked Git worktree because
`scripts/install-git-hooks.sh` checks for a literal `.git/hooks`
directory. In a worktree `.git` is a file and the hooks live in the
shared common dir, so the script exits before installing anything. The
script now asks Git for the effective hooks directory (`git rev-parse
--git-path hooks`) and writes the pre-push hook there. `pre-commit
install` already handles worktrees.

Closes #4161

## Type of Change

- [x] Bug fix (non-breaking change that fixes an issue)

## Changes Made

- Resolve `HOOKS_DIR` with `git rev-parse --git-path hooks` instead of
assuming `.git/hooks`; fail clearly when not in a git checkout.
- Write `pre-push` to `$HOOKS_DIR` and print the real installed paths.
- Ordinary checkouts are unchanged (still `.git/hooks`, same output).

## Testing

- [x] Manual testing performed
- [ ] Unit tests / ruff / mypy: N/A, shell-only change with no Python
touched

### Test Output

```text
# linked worktree, before
$ ./scripts/install-git-hooks.sh
error: .git/hooks/ not found — run from a git checkout root

# linked worktree, after
✅ installed: /…/co/.git/hooks/pre-push
pre-commit installed at /…/co/.git/hooks/pre-commit
pre-commit installed at /…/co/.git/hooks/commit-msg

# ordinary checkout, after (unchanged)
✅ installed: .git/hooks/pre-push
✅ installed: .git/hooks/pre-commit (repo pre-commit checks via pre-commit)

# outside a git checkout
error: not inside a git checkout — run from a Headroom git checkout
```

## Real Behavior Proof

- Environment: Linux x86_64, git 2.43.0, pre-commit from a venv
- Exact command / steps: `git worktree add <dir> HEAD`, then
`./scripts/install-git-hooks.sh` from the worktree; repeated in the main
checkout and outside any repo
- Observed result: hooks install into the shared common dir; a commit
made in the worktree runs the pre-commit hooks (ruff/mypy hooks ran)
- Not tested: macOS; a repo with `core.hooksPath` set (pre-commit
refuses that config regardless)

## Runtime Rollout Safety

- Rollout-managed feature(s): None. Developer tooling only
(`scripts/install-git-hooks.sh`); no runtime code changes.
- Minimum rollout channel: Stable.
- Stable/default behavior changed: No. Proxy, library, and CLI behavior
are untouched; ordinary checkouts install hooks to the same `.git/hooks`
paths as before.
- Kill switch / disable path: Not applicable.
- Unsafe override required: No.
- Qualification impact: None.
- Rollback path: Revert this commit.

## Review Readiness

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

## Checklist

- [x] I have performed a self-review of my code
- [x] I did **not** edit `CHANGELOG.md`

## Additional Notes

No hook bypass: the same pre-commit, commit-msg and pre-push hooks are
installed.
<!-- devin-review-badge-begin -->

---

<a href="https://app.devin.ai/review/headroomlabs-ai/headroom/pull/4176"
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: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: JD Davis <mxjerrett@gmail.com>
This commit is contained in:
aftabkh4n
2026-11-03 21:43:33 -06:00
committed by GitHub
co-authored by Claude Opus 5.5 JD Davis
parent 93279f3208
commit 0f4275f8b3
2 changed files with 144 additions and 7 deletions
+16 -7
View File
@@ -13,24 +13,33 @@
# import-order violations because the ruff pre-commit hook in
# .pre-commit-config.yaml was never installed for contributors.
#
# Idempotent. Re-running is safe. Skips installation if `.git/hooks/` is
# missing (e.g. running outside a git checkout).
# Idempotent. Re-running is safe. Exits with an error when run outside a git
# checkout. Works from linked worktrees too: there `.git` is a file, so the
# hooks directory is resolved through git rather than assumed to be
# `.git/hooks/`.
set -euo pipefail
cd "$(dirname "$0")/.."
if [[ ! -d .git/hooks ]]; then
echo "error: .git/hooks/ not found — run from a git checkout root" >&2
# Install only into the checkout this script belongs to. A source copy nested
# inside another repository would otherwise resolve that repository's hooks.
if [[ "$(git rev-parse --show-toplevel 2>/dev/null)" != "$(pwd -P)" ]]; then
echo "error: $(pwd -P) is not the root of a git checkout — run from a Headroom git checkout" >&2
exit 1
fi
# Ask git for the effective hooks directory. In a linked worktree `.git` is a
# file and hooks live in the shared common dir, so `.git/hooks` doesn't exist.
HOOKS_DIR="$(git rev-parse --git-path hooks)"
mkdir -p "$HOOKS_DIR"
if ! command -v npx &>/dev/null; then
echo "error: npx not found — install Node 18+ before installing Headroom's git hooks." >&2
exit 1
fi
HOOK_PATH=".git/hooks/pre-push"
HOOK_PATH="$HOOKS_DIR/pre-push"
cat > "$HOOK_PATH" <<'HOOK_EOF'
#!/usr/bin/env bash
@@ -96,8 +105,8 @@ fi
if [[ -n "$PRE_COMMIT_BIN" ]]; then
"$PRE_COMMIT_BIN" install
"$PRE_COMMIT_BIN" install --hook-type commit-msg
echo "✅ installed: .git/hooks/pre-commit (repo pre-commit checks via pre-commit)"
echo "✅ installed: .git/hooks/commit-msg (conventional commit enforcement via commitlint)"
echo "✅ installed: $HOOKS_DIR/pre-commit (repo pre-commit checks via pre-commit)"
echo "✅ installed: $HOOKS_DIR/commit-msg (conventional commit enforcement via commitlint)"
else
echo "error: pre-commit not found — run 'pip install -e .[dev]' first, then re-run this script." >&2
exit 1
+128
View File
@@ -0,0 +1,128 @@
"""scripts/install-git-hooks.sh: install into the checkout that owns the script.
The script runs for real against temporary repositories, with fake
``pre-commit`` and ``npx`` on PATH, so ordinary checkouts, linked worktrees,
a source copy nested inside another repository, and a directory outside git
are exercised end to end without touching real hooks.
"""
from __future__ import annotations
import os
import shutil
import subprocess
import sys
from pathlib import Path
import pytest
ROOT = Path(__file__).resolve().parents[1]
SCRIPT = ROOT / "scripts" / "install-git-hooks.sh"
pytestmark = pytest.mark.skipif(
sys.platform == "win32" or not (shutil.which("bash") and shutil.which("git")),
reason="needs bash and git",
)
FAKE_PRE_COMMIT = """#!/usr/bin/env bash
hooks="$(git rev-parse --git-path hooks)"
case "$*" in
install) echo "#!/bin/sh" > "$hooks/pre-commit" ;;
"install --hook-type commit-msg") echo "#!/bin/sh" > "$hooks/commit-msg" ;;
esac
"""
def _git(cwd: Path, *args: str) -> str:
return subprocess.run(
["git", *args], cwd=cwd, check=True, capture_output=True, text=True
).stdout.strip()
def _checkout(path: Path) -> Path:
"""A repository containing scripts/install-git-hooks.sh and one commit."""
(path / "scripts").mkdir(parents=True)
shutil.copy(SCRIPT, path / "scripts" / "install-git-hooks.sh")
_git(path, "init", "-q")
_git(path, "add", ".")
_git(path, "-c", "user.name=t", "-c", "user.email=t@t", "commit", "-qm", "init")
return path
def _env(tmp_path: Path) -> dict[str, str]:
bin_dir = tmp_path / "fake-bin"
bin_dir.mkdir(exist_ok=True)
for name, body in (("pre-commit", FAKE_PRE_COMMIT), ("npx", "#!/bin/sh\n")):
tool = bin_dir / name
tool.write_text(body)
tool.chmod(0o755)
env = {k: v for k, v in os.environ.items() if not k.startswith("GIT_")}
env.pop("VIRTUAL_ENV", None)
env["PATH"] = f"{bin_dir}{os.pathsep}{env['PATH']}"
env["GIT_CEILING_DIRECTORIES"] = str(tmp_path)
return env
def _run(script_root: Path, env: dict[str, str]) -> subprocess.CompletedProcess[str]:
return subprocess.run(
["bash", str(script_root / "scripts" / "install-git-hooks.sh")],
cwd=script_root,
env=env,
capture_output=True,
text=True,
)
def _hooks(common_dir: Path) -> set[str]:
return {
p.name
for p in (common_dir / "hooks").iterdir()
if p.name in {"pre-push", "pre-commit", "commit-msg"}
}
def test_installs_hooks_in_an_ordinary_checkout(tmp_path: Path) -> None:
repo = _checkout(tmp_path / "repo")
result = _run(repo, _env(tmp_path))
assert result.returncode == 0, result.stderr
assert _hooks(repo / ".git") == {"pre-push", "pre-commit", "commit-msg"}
def test_installs_shared_hooks_from_a_linked_worktree(tmp_path: Path) -> None:
repo = _checkout(tmp_path / "repo")
worktree = tmp_path / "worktree"
_git(repo, "worktree", "add", "-q", str(worktree))
assert (worktree / ".git").is_file()
result = _run(worktree, _env(tmp_path))
assert result.returncode == 0, result.stderr
assert _hooks(repo / ".git") == {"pre-push", "pre-commit", "commit-msg"}
def test_refuses_a_source_copy_nested_in_another_repository(tmp_path: Path) -> None:
parent = tmp_path / "parent"
parent.mkdir()
_git(parent, "init", "-q")
nested = parent / "vendor" / "headroom"
(nested / "scripts").mkdir(parents=True)
shutil.copy(SCRIPT, nested / "scripts" / "install-git-hooks.sh")
result = _run(nested, _env(tmp_path))
assert result.returncode == 1
assert "not the root of a git checkout" in result.stderr
assert _hooks(parent / ".git") == set()
def test_refuses_a_directory_outside_git(tmp_path: Path) -> None:
loose = tmp_path / "loose"
(loose / "scripts").mkdir(parents=True)
shutil.copy(SCRIPT, loose / "scripts" / "install-git-hooks.sh")
result = _run(loose, _env(tmp_path))
assert result.returncode == 1
assert "not the root of a git checkout" in result.stderr