claude-dev-env 8.74.0 → 8.74.1

package/hooks/followup_ledger.py

@@ -25,10 +25,15 @@ if _hooks_directory not in sys.path:
 from hooks_constants.followup_ledger_constants import (
     ABSENT_ORIGIN_COMMIT,
     ALL_FOLLOWUP_LEDGER_PATH_SEGMENTS,
-    ALL_GIT_HEAD_PATH_SEGMENTS,
     CHECK_ID_KEY,
     FILE_PATH_KEY,
+    GIT_COMMON_DIRECTORY_FILE_NAME,
+    GIT_DIRECTORY_FILE_PREFIX,
     GIT_DIRECTORY_NAME,
+    GIT_HEAD_FILE_NAME,
+    GIT_PACKED_REFERENCES_COMMENT_PREFIX,
+    GIT_PACKED_REFERENCES_FILE_NAME,
+    GIT_PACKED_REFERENCES_PEELED_PREFIX,
     GIT_REFERENCE_PREFIX,
     LEDGER_APPEND_MODE,
     LEDGER_ENCODING,
@@ -267,7 +272,10 @@ def head_commit(repository_root: Path) -> str:
 
         .git/HEAD holding "ref: refs/heads/main" -> the sha in refs/heads/main
         .git/HEAD holding a sha                  -> that sha
-        no .git directory                        -> ""
+        .git file holding "gitdir: <path>"       -> the same reads in <path>,
+                                                    branches from its commondir
+        branch only in packed-refs               -> the sha packed-refs lists
+        no .git entry                            -> ""
 
     The revision comes from the files git writes rather than from a git
     process, so recording a finding starts no subprocess.
@@ -278,16 +286,73 @@ def head_commit(repository_root: Path) -> str:
     Returns:
         The checked-out revision, or an empty string when none can be read.
     """
-    head_path = repository_root.joinpath(*ALL_GIT_HEAD_PATH_SEGMENTS)
-    head_text = _file_text(head_path)
+    git_directory = _git_directory(repository_root)
+    head_text = _file_text(git_directory / GIT_HEAD_FILE_NAME)
     if head_text is None:
         return ABSENT_ORIGIN_COMMIT
     if not head_text.startswith(GIT_REFERENCE_PREFIX):
         return head_text
-    reference_path = repository_root / GIT_DIRECTORY_NAME / head_text[
-        len(GIT_REFERENCE_PREFIX) :
-    ]
-    return _file_text(reference_path) or ABSENT_ORIGIN_COMMIT
+    reference_name = head_text[len(GIT_REFERENCE_PREFIX) :]
+    for each_reference_directory in (git_directory, _common_directory(git_directory)):
+        loose_commit = _file_text(each_reference_directory / reference_name)
+        if loose_commit:
+            return loose_commit
+    return _packed_reference_commit(_common_directory(git_directory), reference_name)
+
+
+def _git_directory(repository_root: Path) -> Path:
+    """Locate the git directory, following a linked worktree's .git file.
+
+    Args:
+        repository_root: The repository whose git directory to locate.
+
+    Returns:
+        The directory git keeps HEAD in for this checkout.
+    """
+    git_entry = repository_root / GIT_DIRECTORY_NAME
+    if not git_entry.is_file():
+        return git_entry
+    entry_text = _file_text(git_entry) or ""
+    if not entry_text.startswith(GIT_DIRECTORY_FILE_PREFIX):
+        return git_entry
+    return repository_root / entry_text[len(GIT_DIRECTORY_FILE_PREFIX) :]
+
+
+def _common_directory(git_directory: Path) -> Path:
+    """Locate the directory holding the branches shared by every worktree.
+
+    Args:
+        git_directory: The checkout's own git directory.
+
+    Returns:
+        The commondir target, or git_directory itself when none is named.
+    """
+    common_text = _file_text(git_directory / GIT_COMMON_DIRECTORY_FILE_NAME)
+    if not common_text:
+        return git_directory
+    return git_directory / common_text
+
+
+def _packed_reference_commit(common_directory: Path, reference_name: str) -> str:
+    """Find one reference's sha in packed-refs.
+
+    Args:
+        common_directory: The git directory holding packed-refs.
+        reference_name: The full reference name, such as refs/heads/main.
+
+    Returns:
+        The packed sha, or an empty string when packed-refs lacks the reference.
+    """
+    packed_text = _file_text(common_directory / GIT_PACKED_REFERENCES_FILE_NAME) or ""
+    for each_line in packed_text.splitlines():
+        if each_line.startswith(
+            (GIT_PACKED_REFERENCES_COMMENT_PREFIX, GIT_PACKED_REFERENCES_PEELED_PREFIX)
+        ):
+            continue
+        commit_and_name = each_line.split(maxsplit=1)
+        if len(commit_and_name) == 2 and commit_and_name[1] == reference_name:
+            return commit_and_name[0]
+    return ABSENT_ORIGIN_COMMIT
 
 
 def _file_text(file_path: Path) -> str | None:

package/hooks/hooks_constants/followup_ledger_constants.py

@@ -15,7 +15,12 @@ __all__ = [
     "SEVERITY_KEY",
     "ORIGIN_COMMIT_KEY",
     "ABSENT_ORIGIN_COMMIT",
-    "ALL_GIT_HEAD_PATH_SEGMENTS",
+    "GIT_HEAD_FILE_NAME",
+    "GIT_DIRECTORY_FILE_PREFIX",
+    "GIT_COMMON_DIRECTORY_FILE_NAME",
+    "GIT_PACKED_REFERENCES_FILE_NAME",
+    "GIT_PACKED_REFERENCES_COMMENT_PREFIX",
+    "GIT_PACKED_REFERENCES_PEELED_PREFIX",
     "GIT_DIRECTORY_NAME",
     "GIT_REFERENCE_PREFIX",
     "SEVERITY_BREAKING",
@@ -38,7 +43,12 @@ ORIGIN_COMMIT_KEY: str = "origin_commit"
 
 ABSENT_ORIGIN_COMMIT: str = ""
 GIT_DIRECTORY_NAME: str = ".git"
-ALL_GIT_HEAD_PATH_SEGMENTS: tuple[str, ...] = (GIT_DIRECTORY_NAME, "HEAD")
+GIT_HEAD_FILE_NAME: str = "HEAD"
+GIT_DIRECTORY_FILE_PREFIX: str = "gitdir: "
+GIT_COMMON_DIRECTORY_FILE_NAME: str = "commondir"
+GIT_PACKED_REFERENCES_FILE_NAME: str = "packed-refs"
+GIT_PACKED_REFERENCES_COMMENT_PREFIX: str = "#"
+GIT_PACKED_REFERENCES_PEELED_PREFIX: str = "^"
 GIT_REFERENCE_PREFIX: str = "ref: "
 
 SEVERITY_BREAKING: str = "breaking"

package/hooks/test_followup_ledger.py

@@ -191,6 +191,83 @@ def test_head_commit_is_empty_outside_a_repository(tmp_path: Path) -> None:
     assert head_commit(tmp_path) == ""
 
 
+def _committed_repository(repository_root: Path) -> str:
+    subprocess.run(["git", "init", "--quiet", str(repository_root)], check=True)
+    subprocess.run(
+        [
+            "git",
+            "-C",
+            str(repository_root),
+            "-c",
+            "user.name=t",
+            "-c",
+            "user.email=t@t",
+            "commit",
+            "--quiet",
+            "--allow-empty",
+            "-m",
+            "start",
+        ],
+        check=True,
+    )
+    return subprocess.run(
+        ["git", "-C", str(repository_root), "rev-parse", "HEAD"],
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+
+
+def test_head_commit_reads_a_linked_worktree_branch(tmp_path: Path) -> None:
+    main_root = tmp_path / "main"
+    worktree_root = tmp_path / "linked"
+    expected_commit = _committed_repository(main_root)
+    subprocess.run(
+        [
+            "git",
+            "-C",
+            str(main_root),
+            "worktree",
+            "add",
+            "--quiet",
+            "-b",
+            "feature",
+            str(worktree_root),
+        ],
+        check=True,
+    )
+
+    assert head_commit(worktree_root) == expected_commit
+
+
+def test_head_commit_reads_a_packed_branch_from_a_linked_worktree(
+    tmp_path: Path,
+) -> None:
+    main_root = tmp_path / "main"
+    worktree_root = tmp_path / "linked"
+    expected_commit = _committed_repository(main_root)
+    subprocess.run(
+        [
+            "git",
+            "-C",
+            str(main_root),
+            "worktree",
+            "add",
+            "--quiet",
+            "-b",
+            "feature",
+            str(worktree_root),
+        ],
+        check=True,
+    )
+    subprocess.run(
+        ["git", "-C", str(main_root), "pack-refs", "--all"], check=True
+    )
+
+    assert not (main_root / ".git" / "refs" / "heads" / "feature").exists()
+    assert head_commit(worktree_root) == expected_commit
+
+
 def test_deduplicated_lines_keeps_the_first_of_each_exact_line_in_order() -> None:
     assert deduplicated_lines(["a", "b", "a", "c", "b"]) == ["a", "b", "c"]
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.74.0",
+    "version": "8.74.1",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {