fix(git): refuse to commit when nothing is staged

repo.index.commit() writes a tree from the index unconditionally, so
git_commit returned "Changes committed successfully with hash ..." even
when the index matched HEAD. A caller that edited files and skipped
git_add got a hash back, reported the work as committed, and left the
working tree dirty with an empty commit on top.

The message could not be false, so nothing downstream could tell a real
commit from an empty one.

Mirrors git commit, which refuses this without --allow-empty: raises when
the index matches HEAD, while still allowing the first commit on an
unborn branch and an empty merge commit when MERGE_HEAD is present.

Author: ConnorMoss02

src/git/src/mcp_server_git/server.py

@@ -125,7 +125,28 @@ def git_diff(repo: git.Repo, target: str, context_lines: int = DEFAULT_CONTEXT_L
     repo.rev_parse(target)  # Validates target is a real git ref, throws BadName if not
     return repo.git.diff(f"--unified={context_lines}", target)
 
+def _has_staged_changes(repo: git.Repo) -> bool:
+    """Whether the index holds anything git would record as a commit.
+
+    Mirrors `git commit`, which refuses to create an empty commit unless
+    --allow-empty is given, but permits one while a merge is in progress.
+    """
+    if (Path(repo.git_dir) / "MERGE_HEAD").exists():
+        return True
+    if not repo.head.is_valid():
+        # Unborn branch: the first commit, so anything in the index counts.
+        return bool(repo.index.entries)
+    return bool(repo.index.diff(repo.head.commit))
+
 def git_commit(repo: git.Repo, message: str) -> str:
+    # repo.index.commit() writes a tree unconditionally, so without this check
+    # a caller that forgot to stage gets a hash back for an empty commit and no
+    # way to tell it apart from a real one.
+    if not _has_staged_changes(repo):
+        raise ValueError(
+            "No changes staged for commit. Use git_add to stage changes first; "
+            "git_status shows what is currently staged."
+        )
     commit = repo.index.commit(message)
     return f"Changes committed successfully with hash {commit.hexsha}"
 

src/git/tests/test_server.py

@@ -198,6 +198,81 @@ def test_git_commit(test_repository):
     latest_commit = test_repository.head.commit
     assert latest_commit.message.strip() == "test commit message"
 
+def test_git_commit_refuses_when_nothing_is_staged(test_repository):
+    """repo.index.commit() writes a tree unconditionally, so an unstaged edit
+    used to come back as a hash for an empty commit while the working tree
+    stayed dirty and the edit stayed uncommitted."""
+    head_before = test_repository.head.commit.hexsha
+    file_path = Path(test_repository.working_dir) / "test.txt"
+    file_path.write_text("edited but never staged")
+
+    with pytest.raises(ValueError, match="No changes staged for commit"):
+        git_commit(test_repository, "should not be created")
+
+    assert test_repository.head.commit.hexsha == head_before
+    assert test_repository.is_dirty()
+
+def test_git_commit_refuses_on_a_clean_tree(test_repository):
+    head_before = test_repository.head.commit.hexsha
+
+    with pytest.raises(ValueError, match="No changes staged for commit"):
+        git_commit(test_repository, "nothing to record")
+
+    assert test_repository.head.commit.hexsha == head_before
+
+def test_git_commit_refuses_when_only_untracked_files_exist(test_repository):
+    head_before = test_repository.head.commit.hexsha
+    Path(test_repository.working_dir, "untracked.txt").write_text("never added")
+
+    with pytest.raises(ValueError, match="No changes staged for commit"):
+        git_commit(test_repository, "should not be created")
+
+    assert test_repository.head.commit.hexsha == head_before
+
+def test_git_commit_records_a_staged_deletion(test_repository):
+    """A deletion leaves no file behind, so it must not read as an empty index."""
+    test_repository.git.rm("test.txt")
+
+    result = git_commit(test_repository, "remove test.txt")
+
+    assert "Changes committed successfully with hash" in result
+    assert "test.txt" not in test_repository.head.commit.tree
+
+def test_git_commit_allows_the_first_commit_on_an_unborn_branch(tmp_path: Path):
+    repo = git.Repo.init(tmp_path / "unborn")
+    Path(repo.working_dir, "first.txt").write_text("first")
+    repo.index.add(["first.txt"])
+
+    result = git_commit(repo, "initial commit")
+
+    assert "Changes committed successfully with hash" in result
+    assert repo.head.commit.message.strip() == "initial commit"
+
+def test_git_commit_allows_an_empty_merge_commit(test_repository):
+    """git itself permits an empty commit while a merge is in progress, so a
+    conflict resolved back to HEAD's content must still be committable."""
+    test_repository.git.checkout("-b", "side")
+    Path(test_repository.working_dir, "test.txt").write_text("side")
+    test_repository.git.add("test.txt")
+    test_repository.index.commit("side change")
+
+    test_repository.git.checkout("-")
+    Path(test_repository.working_dir, "test.txt").write_text("mainline")
+    test_repository.git.add("test.txt")
+    test_repository.index.commit("mainline change")
+
+    with pytest.raises(git.GitCommandError):
+        test_repository.git.merge("side")
+
+    # Resolve to HEAD's own content, so the index matches HEAD exactly.
+    Path(test_repository.working_dir, "test.txt").write_text("mainline")
+    test_repository.git.add("test.txt")
+    assert not test_repository.index.diff(test_repository.head.commit)
+
+    result = git_commit(test_repository, "merge side")
+
+    assert "Changes committed successfully with hash" in result
+
 def test_git_reset(test_repository):
     file_path = Path(test_repository.working_dir) / "reset_test.txt"
     file_path.write_text("content to reset")