fix(odb): restore the legacy GitDB backend selector

Aider-chat 0.86.2 opens every repository with `Repo(..., odbt=git.GitDB)`.
Removing that public name blocks all 21 unchanged upstream repository tests
with `AttributeError`, before diffs, commits, attribution or tracked-file
queries can run. The same full selection passes with released GitPython 3.2.1.
Aider uses the name only as a constructor selector and does not rely on gitdb's
Python storage implementation or specialized object-database methods.

Export `GitDB` from `git` and `git.db` as an alias for `GitCmdObjectDB`. Legacy
selectors now choose the same managed Git/Gix backend as the default, without
restoring independent Python object storage, widening accepted custom backend
types, or changing native/fallback decisions. Document that the selector survives
while the old implementation's specialized interfaces remain unsupported.

Add a regression across SHA-1/SHA-256 and files/reftable storage that verifies
both exports, repository construction and actual managed object header/stream
queries. All four cases fail before the alias. The regression plus adjacent
repository and safety suites pass 173 tests, two skips and 14 subtests on each
backend, CLI first. Aider's full 21-test repository suite now passes on both
backends against the editable checkout. Ruff lint/format, mypy for changed
production modules and `git diff --check` pass with Python 3.12.15, Git 2.53.0
and GixPython 0.2.0. The broader second downstream audit remains in progress.

Author: codex

doc/gix-backend.md

@@ -45,6 +45,14 @@ fallbacks.
 
 ## Index and object metadata lifecycle
 
+`git.GitDB` and `git.db.GitDB` remain compatibility aliases for
+`GitCmdObjectDB`, so legacy `Repo(..., odbt=GitDB)` selectors use the same
+managed backend. Aider 0.86.2 uses that selector for every repository open.
+This does not restore gitdb's Python object database or its specialized APIs.
+Object queries continue through `object_data()` and the supported
+`Repository.try_find_header()`/`find_object()` APIs, with the existing large-object
+and diagnostic CLI fallbacks. Storage uses the existing `hash_object` dispatch.
+
 `IndexFile` queries immutable entry records; it does not retain a parsed index.
 The compatibility `entries` property projects those queries into a read-only
 snapshot keyed by path and stage, preserving readers in dlt and Renku. It uses

doc/source/changes.rst

@@ -54,9 +54,11 @@ API changes
 * ``GitCmdObjectDB`` no longer inherits ``LooseObjectDB``. Its object reads,
   writes, existence checks, and enumeration use Git, including packed objects.
   Precompressed input streams and custom object-output writers are unsupported.
-  ``GitDB`` exports and backend selection are removed. ``odbt`` accepts only
-  ``GitCmdObjectDB`` and its subclasses, rejecting unsupported types before
-  initialization or cloning. Remove ``odbt=GitDB`` or select ``GitCmdObjectDB``.
+  ``GitDB`` remains exported as a compatibility alias for ``GitCmdObjectDB``;
+  ``odbt=GitDB`` selects the same managed Git/Gix backend. It no longer selects
+  gitdb's Python storage implementation or supports that implementation's
+  specialized interfaces. ``odbt`` accepts ``GitCmdObjectDB`` and its subclasses,
+  rejecting unsupported types before initialization or cloning.
   ``gitdb`` remains a dependency for shared types and utilities.
 * ``Repo.object_format`` and ``Repo.ref_format`` report Git's storage formats.
   ``Repo.alternates`` is read-only and reports effective absolute alternate

git/__init__.py

@@ -29,6 +29,7 @@
     "GitCommandError",
     "GitCommandNotFound",
     "GitConfigParser",
+    "GitDB",
     "GitError",
     "HEAD",
     "Head",
@@ -146,7 +147,7 @@
         DiffIndex,
         Diffable,
     )
-    from git.db import GitCmdObjectDB  # @NoMove
+    from git.db import GitCmdObjectDB, GitDB  # @NoMove
     from git.cmd import Git  # @NoMove
     from git.repo import Repo  # @NoMove
     from git.remote import FetchInfo, PushInfo, Remote, RemoteProgress  # @NoMove

git/db.py

@@ -3,7 +3,7 @@
 
 """Git's object database, accessed exclusively through the Git command."""
 
-__all__ = ["GitCmdObjectDB"]
+__all__ = ["GitCmdObjectDB", "GitDB"]
 
 import tempfile
 from typing import Iterator, TYPE_CHECKING
@@ -107,3 +107,8 @@ def partial_to_complete_sha_hex(self, partial_hexsha: str) -> bytes:
             return hex_to_bin(hexsha)
         except (GitCommandError, ValueError) as exc:
             raise BadObject(partial_hexsha) from exc
+
+
+# Preserve the public object-backend selector used by downstream applications.
+# Storage remains owned by Git/Gix; this does not restore gitdb's Python backend.
+GitDB = GitCmdObjectDB

test/test_downstream_compatibility.py

@@ -4,9 +4,27 @@
 
 import pytest
 
+import git
+import git.db
+
 from test.lib.fixtures import fixture_repo
 
 
+@pytest.mark.parametrize("object_format", ["sha1", "sha256"])
+@pytest.mark.parametrize("ref_format", ["files", "reftable"])
+def test_legacy_gitdb_selector_uses_the_managed_object_backend(object_format, ref_format):
+    assert git.GitDB is git.db.GitDB is git.GitCmdObjectDB
+    with fixture_repo("downstream-index.sh", object_format, ref_format) as fixture:
+        with git.Repo(fixture.working_tree_dir, odbt=git.GitDB) as repo:
+            assert isinstance(repo.odb, git.GitCmdObjectDB)
+            blob = repo.head.commit.tree["tracked"]
+            assert repo.odb.has_object(blob.binsha)
+            info = repo.odb.info(blob.binsha)
+            assert info.binsha == blob.binsha
+            assert info.type == b"blob"
+            assert repo.odb.stream(blob.binsha).read() == blob.data_stream.read()
+
+
 @pytest.mark.parametrize("object_format", ["sha1", "sha256"])
 @pytest.mark.parametrize("ref_format", ["files", "reftable"])
 def test_index_entries_readers_retain_pending_and_published_snapshots(object_format, ref_format):