feat(gix): resolve revisions and repository metadata natively

Handle verified revisions and repository metadata exposed by GixPython.
Keep Git's initial repository validation and unsupported discovery options.
Message searches, dirty suffixes and describe-shaped names fall back because
the native grammar differs in regex handling and exact-tag precedence
(`GIX-14`/`GIX-17`).

GixPython's native configuration identifies `extensions.refStorage`; accessing
`HEAD` in either a SHA-1 or SHA-256 reftable repository raises `gix.Error` with
an unsupported-storage cause. The bindings currently flatten the native error
kind. Add a direct regression for this signal, without manufacturing an
`Unsupported` exception in Python.

Keep `rev-parse --show-ref-format` on Git because it also validates repository
extensions. Even with strict configuration and trust options, Gix accepts an
unknown version-1 extension and successfully reads `HEAD` where Git rejects the
repository. Add that regression too. A reference-format getter is not the
prerequisite: compatible extension validation is. The remaining query costs one
CLI invocation after wrapper initialization; this amendment does not reduce it.

Validation: affected backend and revision tests passed with Gix first
(30 passed in 20.22s), then CLI (22 passed, 1 skipped in 21.26s).
Ruff lint/format and `git diff --check` passed.

Author: codex

git/_backend.py

@@ -124,7 +124,29 @@ def object_data(command: Any, ref: bytes, *, stream: bool = False) -> Any:
     return result
 
 
-_HANDLERS: Dict[str, Callable[[Any, List[str], Dict[str, Any]], bytes]] = {}
+def _rev_parse(repo: Any, args: List[str], kwargs: Dict[str, Any]) -> bytes:
+    if args == ["--path-format=absolute", "--git-common-dir"]:
+        return os.fsencode(os.path.abspath(repo.common_dir())) + b"\n"
+    if args == ["--is-bare-repository"]:
+        return b"true\n" if repo.is_bare() else b"false\n"
+    if args == ["--show-object-format"]:
+        return str(repo.object_hash()).encode("ascii") + b"\n"
+    if args == ["--show-ref-format"]:
+        # Config identifies reftable and HEAD reports it as unsupported, but
+        # neither validates unknown repository extensions as Git's query does.
+        raise _Unsupported("reference storage format query (GIX-1)")
+    if args == ["--show-toplevel"] and repo.workdir() is not None:
+        return os.fsencode(os.path.abspath(repo.workdir())) + b"\n"
+    if args[:1] != ["--verify"] or args[-2:-1] != ["--end-of-options"]:
+        raise _Unsupported("discovery or revision options")
+    if args[:-2] not in (["--verify"], ["--verify", "--quiet"]):
+        raise _Unsupported("revision options")
+    return str(_oid(repo, args[-1])).encode("ascii") + b"\n"
+
+
+_HANDLERS: Dict[str, Callable[[Any, List[str], Dict[str, Any]], bytes]] = {
+    "rev_parse": _rev_parse,
+}
 
 
 def dispatch(

test/test_gix_backend.py

@@ -7,6 +7,7 @@
 import pytest
 
 from git import Git, Repo, _backend
+from git.exc import InvalidGitRepositoryError
 from gitdb import IStream
 
 gix = pytest.importorskip("gix")
@@ -18,6 +19,27 @@ def repo(request, tmp_path):
         yield repo
 
 
+def test_reftable_head_reports_unsupported_storage(repo, tmp_path):
+    with Repo.init(tmp_path / "reftable", object_format=repo.object_format, ref_format="reftable") as reftable:
+        options = gix.OpenOptions().open_path_as_is(True).bail_if_untrusted(True).strict_config(True)
+        native = gix.open_opts(reftable.git_dir, options)
+        assert native.config_snapshot().string("extensions.refStorage") == b"reftable"
+        # The Rust Unsupported cause is flattened into gix.Error by the bindings.
+        with pytest.raises(gix.Error, match="unsupported storage backend"):
+            native.head()
+        assert reftable.ref_format == "reftable"
+
+
+def test_native_head_does_not_validate_repository_extensions(repo):
+    repo.git.config("core.repositoryFormatVersion", "1")
+    repo.git.config("extensions.unknown", "true")
+    options = gix.OpenOptions().open_path_as_is(True).bail_if_untrusted(True).strict_config(True)
+    assert gix.open_opts(repo.git_dir, options).head().is_unborn()
+    # Git's format query also validates extensions; HEAD alone cannot replace it.
+    with pytest.raises(InvalidGitRepositoryError):
+        Repo(repo.git_dir)
+
+
 def test_unknown_command_and_storage_environment_use_cli(repo):
     before = _backend.statistics()
     assert repo.git._call_process_safe("status", "--porcelain") == ""
@@ -30,7 +52,8 @@ def test_unknown_command_and_storage_environment_use_cli(repo):
         assert repo.git._call_process_safe("for_each_ref", "--format=%(refname)", "--", "refs/*") == "fallback"
         with repo.git.custom_environment(GIT_INDEX_FILE=".git/index"):
             assert repo.git._call_process_safe("ls_files", "--stage", "-v", "-z", "--full-name") == "fallback"
-        assert cli.call_count == 2
+        assert repo.git._call_process_safe("rev_parse", "--show-ref-format") == "fallback"
+        assert cli.call_count == 3
 
 
 def test_partial_native_stream_does_not_corrupt_next_read(repo):