feat(gix): check repository dirtiness natively

Use native tree/index/worktree status for `Repo.is_dirty`, preserving its flags, pathspecs, untracked selection and configured submodule checks. Do not write native status refreshes back to the index. Add CLI parity and no-subprocess checks for status, ignores, untracked files and dirty submodules.

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

Author: codex

git/_backend.py

@@ -247,6 +247,52 @@ def _worktree_root(command: Any, repo: Any) -> str:
     return os.fspath(root)
 
 
+def is_dirty(command: Any, index: bool, working_tree: bool, untracked: bool, submodules: bool, path: Any) -> Any:
+    if gix is None:
+        return NotImplemented
+    method = "Repo.is_dirty"
+    command._require_version()
+    try:
+        repo = _repository(command, {})
+        _worktree_root(command, repo)
+        if not hasattr(repo, "status"):
+            raise _Unsupported("status feature disabled")
+        patterns = [os.fspath(path)] if path else []
+        if any("\0" in pattern for pattern in patterns):
+            raise _Unsupported("invalid pathspec")
+        status = (
+            repo.status()
+            .index(_index(repo, {"env": command.environment()}))
+            .untracked_files("files" if untracked else "none")
+            .tree_index_track_renames(None)
+            .index_worktree_rewrites(None)
+            .index_worktree_submodules("configured" if submodules else "all", check_dirty=submodules)
+        )
+        dirty = False
+        with status.into_iter(patterns) as entries:
+            for item in entries:
+                if item.summary() is None:
+                    continue
+                if item.kind == "TreeIndex":
+                    if index and (submodules or item.details["entry_mode"] != 0o160000):
+                        dirty = True
+                        break
+                elif item.details["kind"] == "DirectoryContents":
+                    if untracked and item.details["entry"]["status"] == "Untracked":
+                        dirty = True
+                        break
+                elif working_tree:
+                    dirty = True
+                    break
+    except _Unsupported as exc:
+        return _fallback(method, str(exc))
+    except gix.Error as exc:
+        _logger.debug("is_dirty native read: %s", exc)
+        return _fallback(method, "native read diagnostics")
+    record(method, "native")
+    return dirty
+
+
 def untracked_files(command: Any, args: Tuple[Any, ...], options: Dict[str, Any]) -> Any:
     if gix is None:
         return NotImplemented

git/repo/base.py

@@ -1096,6 +1096,10 @@ def is_dirty(
             # always considered to be clean.
             return False
 
+        native = _backend.is_dirty(self.git, index, working_tree, untracked_files, submodules, path)
+        if native is not NotImplemented:
+            return native
+
         # Start from the one which is fastest to evaluate.
         default_args = ["--raw", "--no-ext-diff", "--no-textconv"]
         if not submodules:

test/test_gix_backend.py

@@ -246,6 +246,49 @@ def test_native_raw_diff_matches_cli(repo):
             assert native == before.diff(after, **options)
 
 
+def test_native_status_and_ignore_match_cli_without_writing_index(repo):
+    root = Path(repo.working_dir)
+    (root / ".gitignore").write_text("*.log\nignored/\n")
+    (root / "tracked.log").write_text("tracked even though ignored\n")
+    repo.index.add([".gitignore", "tracked.log"])
+    repo.index.commit("initial", skip_hooks=True)
+    (root / "ignored").mkdir()
+    (root / "ignored/file").write_text("ignored")
+    (root / "untracked\nfile").write_text("untracked")
+    (root / "tracked.log").write_text("changed")
+    Repo.init(root / "nested").close()
+    paths = ["ignored", "ignored/file", "new.log", "tracked.log", "untracked\nfile"]
+    index_before = Path(repo.index.path).read_bytes()
+    options = [{}, {"working_tree": False}, {"index": False, "untracked_files": True}, {"path": "ignored"}]
+    with patch.object(Git, "execute", side_effect=AssertionError("unexpected CLI call")):
+        untracked = repo.untracked_files
+        ignored = repo.ignored(*paths)
+        dirty = [repo.is_dirty(**option) for option in options]
+    assert Path(repo.index.path).read_bytes() == index_before
+    with patch.object(_backend, "gix", None):
+        assert untracked == repo.untracked_files
+        assert ignored == repo.ignored(*paths)
+        assert dirty == [repo.is_dirty(**option) for option in options]
+
+
+def test_native_status_tracks_submodule_dirtiness(repo):
+    root = Path(repo.working_dir)
+    with Repo.init(root.parent / "source", object_format=repo.git.rev_parse("--show-object-format")) as source:
+        Path(source.working_dir, "file").write_text("initial")
+        source.index.add(["file"])
+        source.index.commit("initial", skip_hooks=True)
+        module = repo.create_submodule("module", "module", source.working_dir)
+    repo.index.commit("add submodule", skip_hooks=True)
+    with module.module() as child:
+        Path(child.working_dir, "file").write_text("modified")
+    options = [{}, {"submodules": False}, {"working_tree": False}, {"index": False}]
+    with patch.object(Git, "execute", side_effect=AssertionError("unexpected CLI call")):
+        dirty = [repo.is_dirty(**option) for option in options]
+    assert dirty == [True, False, False, True]
+    with patch.object(_backend, "gix", None):
+        assert dirty == [repo.is_dirty(**option) for option in options]
+
+
 def test_native_commit_statistics_match_cli(repo):
     root = Path(repo.working_dir)
     for name, content in (("file", b"one\ntwo\n"), ("binary", b"a\0b"), ("old", b"gone\n"), ("link", b"text")):