feat(gix): list worktree metadata natively

Build the managed porcelain inventory from native main/linked repositories,
including branch, detached, unborn and lock metadata. Keep prunable entries on
Git for its diagnostics.

Support worktrees of bare main repositories using Gix's actual worktree path.
`Repository.is_bare()` intentionally reflects configuration and can be true
alongside a linked worktree. A record is bare only when that configuration has
no native worktree. The available metadata is sufficient; no upstream
classification fix or Python filesystem inference is needed.

Gix's `main_repo()` can retain `worktrees/linked/../..` in its Git-directory
path. Reopen that repository through Gix on a canonical input path, preserving
its native open options, instead of returning repaired metadata. This helper
can also handle gitfile targets. The SHA-1/SHA-256 regression compares locked,
unborn linked worktree inventories from both main and linked repositories.

Each supported inventory now avoids one CLI launch, including bare-main
inventories that previously required one. The regression forbids CLI execution
after setup and executable validation.

Validation: worktree/reftable/extension selection passed with Gix first
(10 passed, 1 skipped in 2.97s), then CLI (4 passed, 2 skipped in 2.47s).
Ruff lint/format and `git diff --check` passed.

Author: codex

git/_backend.py

@@ -86,6 +86,13 @@ def _repository(command: Any, env: Dict[str, Any], *, query_config: bool = False
     return repo
 
 
+def _canonical_repository(repo: Any) -> Any:
+    """Have Gix resolve repository metadata again from a canonical input path."""
+    path = os.fspath(repo.git_dir())
+    canonical = os.path.realpath(path)
+    return gix.open_opts(canonical, repo.open_options()) if path != canonical else repo
+
+
 def _oid(repo: Any, ref: Any) -> Any:
     ref = safe_decode(ref) if isinstance(ref, bytes) else str(ref)
     if re.fullmatch(r"[a-fA-F0-9]{40}|[a-fA-F0-9]{64}", ref):
@@ -202,12 +209,46 @@ def _config(repo: Any, args: List[str], kwargs: Dict[str, Any]) -> bytes:
     raise _Unsupported("config file parsing, enumeration, or mutation (GIX-12)")
 
 
+def _worktree(repo: Any, args: List[str], kwargs: Dict[str, Any]) -> bytes:
+    if args != ["list", "--porcelain", "-z"] or not hasattr(repo, "worktrees"):
+        raise _Unsupported("worktree operation or feature disabled")
+    proxies = repo.worktrees()
+    if any(proxy.is_prunable() for proxy in proxies):
+        raise _Unsupported("prunable worktree diagnostics")
+    main = _canonical_repository(repo.main_repo())
+
+    def describe(local: Any) -> List[bytes]:
+        workdir = local.workdir()
+        fields = [b"worktree " + os.fsencode(workdir or local.git_dir())]
+        # Gix's is_bare() reflects configuration, even for a linked worktree.
+        if local.is_bare() and workdir is None:
+            fields.append(b"bare")
+        else:
+            head = local.head()
+            oid = head.id()
+            fields.append(
+                b"HEAD " + (str(oid).encode("ascii") if oid is not None else b"0" * local.object_hash().len_in_hex())
+            )
+            fields.append(b"detached" if head.is_detached() else b"branch " + head.referent_name())
+        return fields
+
+    records = [b"\0".join(describe(main)) + b"\0\0"]
+    for proxy in sorted(proxies, key=lambda proxy: os.fsencode(proxy.base())):
+        fields = describe(proxy.into_repo())
+        if proxy.is_locked():
+            reason = proxy.lock_reason()
+            fields.append(b"locked" + (b" " + reason if reason else b""))
+        records.append(b"\0".join(fields) + b"\0\0")
+    return b"".join(records)
+
+
 _HANDLERS: Dict[str, Callable[[Any, List[str], Dict[str, Any]], bytes]] = {
     "rev_parse": _rev_parse,
     "ls_tree": _ls_tree,
     "symbolic_ref": _symbolic_ref,
     "for_each_ref": _for_each_ref,
     "config": _config,
+    "worktree": _worktree,
 }
 
 

test/test_gix_backend.py

@@ -40,6 +40,19 @@ def test_native_head_does_not_validate_repository_extensions(repo):
         Repo(repo.git_dir)
 
 
+def test_native_worktree_inventory_includes_bare_main(repo, tmp_path):
+    with Repo.init(tmp_path / "bare", bare=True, object_format=repo.object_format) as bare:
+        linked_path = tmp_path / "linked"
+        bare.git.worktree("add", "--orphan", "-b", "linked", str(linked_path))
+        bare.git.worktree("lock", "--reason", "keep", str(linked_path))
+        with Repo(linked_path) as linked:
+            for current in (bare, linked):
+                with patch.object(_backend, "gix", None):
+                    expected = current.git._call_process_safe("worktree", "list", "--porcelain", "-z")
+                with patch.object(Git, "execute", side_effect=AssertionError("unexpected CLI call")):
+                    assert current.git._call_process_safe("worktree", "list", "--porcelain", "-z") == expected
+
+
 def test_unknown_command_and_storage_environment_use_cli(repo):
     before = _backend.statistics()
     assert repo.git._call_process_safe("status", "--porcelain") == ""