feat(gix): count reachable commits natively

Add a closable native history helper and use it for `Commit.count`, including skip, limit and first-parent selection. Counting does not depend on the known general walk-order difference. Keep path filters and other revision options on Git; iteration errors preserve the public Git command error type.

The staged version passes Ruff and Python syntax checks. Its SHA-1/SHA-256 native smoke and focused pytest selection pass: 5 passed in 1.01s.

Author: codex

git/_backend.py

@@ -8,11 +8,12 @@
 from collections import Counter
 from importlib import import_module
 import io
+from itertools import islice
 import logging
 import os
 import re
 from threading import Lock
-from typing import Any, Callable, Dict, List, Sequence, Tuple
+from typing import Any, Callable, Dict, Iterator, List, Sequence, Tuple
 
 from git.compat import safe_decode
 from git.exc import GitCommandError
@@ -261,6 +262,59 @@ def _merge_base(repo: Any, args: List[str], kwargs: Dict[str, Any]) -> bytes:
     return b"" if ancestor else b"".join(str(oid).encode("ascii") + b"\n" for oid in ids)
 
 
+def _walk(repo: Any, rev: str, options: Dict[str, Any]) -> Iterator[str]:
+    if not hasattr(repo, "rev_walk"):
+        raise _Unsupported("revision feature disabled")
+    if options.keys() - {"max_count", "skip", "first_parent"}:
+        raise _Unsupported("history options or ordering (GIX-8)")
+    if options.get("first_parent") not in (None, True, False):
+        raise _Unsupported("history options")
+    start, count = options.get("skip", 0), options.get("max_count")
+    if type(start) is not int or start < 0 or (count is not None and (type(count) is not int or count < 0)):
+        raise _Unsupported("history limits")
+    tip = repo.find_object(_oid(repo, rev)).peel_to_commit().id
+    platform = repo.rev_walk([tip])
+    if options.get("first_parent"):
+        platform = platform.first_parent_only()
+    cursor = platform.all()
+
+    def iterate() -> Iterator[str]:
+        try:
+            with cursor:
+                for item in islice(cursor, start, None if count is None else start + count):
+                    yield str(item.id)
+        except gix.Error as exc:
+            raise GitCommandError(["gix", "rev-list", rev], 128, str(exc)) from exc
+
+    return iterate()
+
+
+def history(command: Any, rev: str, paths: Any, options: Dict[str, Any], *, count: bool = False) -> Any:
+    """Count reachable commits, or lazily walk the first-parent chain."""
+    if gix is None:
+        return NotImplemented
+    method = "Commit.count" if count else "Commit.iter_items"
+    command._require_version()
+    try:
+        if paths:
+            raise _Unsupported("history path filtering")
+        if (
+            not count
+            and not options.get("first_parent")
+            and not (options.get("max_count") == 1 and not options.get("skip"))
+        ):
+            raise _Unsupported("Git history ordering (GIX-8)")
+        iterator = _walk(_repository(command, {}), rev, options)
+        result = sum(1 for _ in iterator) if count else iterator
+    except _Unsupported as exc:
+        return _fallback(method, str(exc))
+    except gix.Error as exc:
+        _logger.debug("%s native preparation: %s", method, exc)
+        return _fallback(method, "native preparation diagnostics")
+    record(method, "native")
+    return result
+
+
 _HANDLERS: Dict[str, Callable[[Any, List[str], Dict[str, Any]], bytes]] = {
     "rev_parse": _rev_parse,
     "ls_tree": _ls_tree,

git/objects/commit.py

@@ -16,6 +16,7 @@
 import tempfile
 
 
+from git import _backend
 from git.cmd import Git
 from git.exc import GitCommandError, UnsafeOptionError
 from git.diff import Diffable
@@ -321,6 +322,9 @@ def count(
 
         # Yes, it makes a difference whether empty paths are given or not in our case as
         # the empty paths version will ignore merge commits for some reason.
+        native = _backend.history(self.repo.git, self.hexsha, paths, kwargs, count=True)
+        if native is not NotImplemented:
+            return native
         if paths:
             return len(self.repo.git._call_process_safe("rev_list", self.hexsha, "--", paths, **kwargs).splitlines())
         return len(self.repo.git._call_process_safe("rev_list", self.hexsha, **kwargs).splitlines())