feat(gix): resolve supported committer identities through Gix

Use `Repository.committer()` for `GIT_COMMITTER_IDENT` and format the returned
native signature. Keep unsupported normalization, empty identities, and
per-command identity overrides on the CLI; Python must not fill missing fields
or manufacture a resolved identity.

Gix supports in-memory overrides for `committer.name`, `committer.email`, and
`gitoxide.commit.committerDate`. Applying them to the retained repository would
expose operation-specific identity to other threads. GixPython 0.1.0 binds no
cheap independent repository clone: `copy.copy` and `copy.deepcopy` raise
`TypeError`, while the binding's internal Rust `RepoHandle::clone()` shares its
`Arc` state. Upstream should bind an independent native clone, with isolated
configuration and native identity resolution (`GIX-21`). Reopening would isolate
state but repeats repository setup. Keep the existing fallback until this is
available; do not change the process environment or the shared snapshot.

A supported process/config identity avoids one CLI invocation. A command
override retains one. Native query parity uses a fixed process identity, and
regressions compare partial and complete overrides with Git. The reference
format query retains its repository-extension validation fallback (`GIX-1`).

Original validation: backend and commit tests passed with Gix first (65 passed
in 10.42s), then CLI (37 passed, 1 skipped in 10.97s), plus Ruff lint/format and
`git diff --check`. This follow-up only clarifies the commit message; direct
GixPython 0.1.0 probes verified native snapshot overrides and the absent copy API.

Author: codex

git/_backend.py

@@ -632,6 +632,26 @@ def _signature(env: Dict[str, Any], role: str) -> Any:
     return _checked_signature(gix.Signature(name, email, int(seconds), offset))
 
 
+def _committer(repo: Any, env: Dict[str, Any]) -> Any:
+    for field in ("NAME", "EMAIL", "DATE"):
+        key = "GIT_COMMITTER_" + field
+        if key in env and env[key] != os.environ.get(key):
+            raise _Unsupported("per-command committer identity (GIX-21)")
+        if os.environ.get(key) == "":
+            raise _Unsupported("empty identity")
+    signature = repo.committer()
+    if signature is None:
+        raise _Unsupported("identity resolution")
+    return _checked_signature(signature)
+
+
+def _var(repo: Any, args: List[str], kwargs: Dict[str, Any]) -> bytes:
+    if args != ["GIT_COMMITTER_IDENT"]:
+        raise _Unsupported("Git variable")
+    signature = _committer(repo, kwargs.get("env", {}))
+    return signature.name + b" <" + signature.email + b"> " + _date(signature) + b"\n"
+
+
 def _commit_tree(repo: Any, args: List[str], kwargs: Dict[str, Any]) -> bytes:
     if len(args) < 2 or args[0] != "--no-gpg-sign" or args[2::2] != ["-p"] * len(args[2::2]):
         raise _Unsupported("commit options")
@@ -671,6 +691,7 @@ def _commit_tree(repo: Any, args: List[str], kwargs: Dict[str, Any]) -> bytes:
     "read_tree": _read_tree,
     "commit_tree": _commit_tree,
     "reflog": _reflog,
+    "var": _var,
     "config": _config,
     "worktree": _worktree,
 }

test/test_gix_backend.py

@@ -110,6 +110,53 @@ def test_unknown_command_and_storage_environment_use_cli(repo):
         assert cli.call_count == 3
 
 
+def test_native_command_queries_match_cli(repo, monkeypatch):
+    Path(repo.working_dir, "file").write_bytes(b"content")
+    repo.index.add(["file"])
+    commit = repo.index.commit("initial", skip_hooks=True)
+    monkeypatch.setenv("GIT_COMMITTER_NAME", "Example")
+    monkeypatch.setenv("GIT_COMMITTER_EMAIL", "example@example.invalid")
+    monkeypatch.setenv("GIT_COMMITTER_DATE", "1100000000 -0430")
+    with repo.config_writer() as writer:
+        writer.set_value("test", "value", "configured")
+    queries = [
+        ("rev_parse", "--verify", "--end-of-options", "HEAD"),
+        ("rev_parse", "--path-format=absolute", "--git-common-dir"),
+        ("rev_parse", "--is-bare-repository"),
+        ("rev_parse", "--show-object-format"),
+        ("rev_parse", "--show-toplevel"),
+        ("ls_tree", "-z", "--full-tree", commit.tree.hexsha),
+        ("symbolic_ref", "--quiet", "--no-recurse", "--", "HEAD"),
+        ("for_each_ref", "--format=%(refname)", "--", "refs/heads"),
+        ("config", "--get", "test.value"),
+        ("worktree", "list", "--porcelain", "-z"),
+        ("merge_base", "--", commit.hexsha, commit.hexsha),
+        ("ls_files", "--stage", "-v", "-z", "--full-name"),
+        ("update_index", "--show-index-version"),
+        ("reflog", "exists", "--", "HEAD"),
+        ("var", "GIT_COMMITTER_IDENT"),
+    ]
+    for method, *args in queries:
+        with patch.object(Git, "execute", side_effect=AssertionError("unexpected CLI call: " + method)):
+            native = repo.git._call_process_safe(method, *args, stdout_as_string=False)
+        with patch.object(_backend, "gix", None):
+            assert native == repo.git._call_process_safe(method, *args, stdout_as_string=False)
+
+
+@pytest.mark.parametrize("fields", [("NAME",), ("EMAIL",), ("DATE",), ("NAME", "EMAIL", "DATE")])
+def test_per_command_committer_identity_uses_cli(repo, fields, monkeypatch):
+    monkeypatch.setenv("GIT_COMMITTER_NAME", "Process")
+    monkeypatch.setenv("GIT_COMMITTER_EMAIL", "process@example.invalid")
+    monkeypatch.setenv("GIT_COMMITTER_DATE", "1000000000 +0000")
+    values = {"NAME": "Override", "EMAIL": "override@example.invalid", "DATE": "1100000000 -0430"}
+    env = {"GIT_COMMITTER_" + field: values[field] for field in fields}
+    with patch.object(_backend, "gix", None):
+        expected = repo.git._call_process_safe("var", "GIT_COMMITTER_IDENT", env=env)
+    with patch.object(Git, "execute", autospec=True, side_effect=Git.execute) as cli:
+        assert repo.git._call_process_safe("var", "GIT_COMMITTER_IDENT", env=env) == expected
+        assert cli.call_count == 1
+
+
 def test_a_native_write_failure_is_not_retried(repo, monkeypatch):
     attempts = []