🩹 fix(version): fix typo: reclusive -> recursive

Author: Jannchie

pyproject.toml

@@ -112,6 +112,7 @@ exclude_lines = [
     "if __name__ == .__main__.:",
     "class .*\\bProtocol\\):",
     "@(abc\\.)?abstractmethod",
+    "if TYPE_CHECKING:",
 ]
 
 [dependency-groups]

tests/integration/test_version_integration.py

@@ -127,7 +127,7 @@ def test_update_version_files_package_json(self, tmp_path):
         next_version = Version(major=1, minor=1, patch=0)
 
         # Update version files
-        update_version_files(args, next_version, verbose=0, reclusive=False)
+        update_version_files(args, next_version, verbose=0, recursive=False)
 
         # Verify update
         updated_content = json.loads(package_json.read_text())
@@ -171,7 +171,7 @@ def test_update_version_files_pyproject_toml(self, tmp_path):
         next_version = Version(major=2, minor=0, patch=0)
 
         # Update version files
-        update_version_files(args, next_version, verbose=0, reclusive=False)
+        update_version_files(args, next_version, verbose=0, recursive=False)
 
         # Verify update
         updated_content = pyproject_toml.read_text()
@@ -208,7 +208,7 @@ def test_update_version_files_multiple_files(self, tmp_path):
         next_version = Version(major=1, minor=0, patch=1)
 
         # Update version files
-        update_version_files(args, next_version, verbose=0, reclusive=False)
+        update_version_files(args, next_version, verbose=0, recursive=False)
 
         # Verify updates
         updated_package_json = json.loads(package_json.read_text())
@@ -251,7 +251,7 @@ def test_update_version_files_recursive(self, tmp_path):
         next_version = Version(major=1, minor=1, patch=0)
 
         # Update version files
-        update_version_files(args, next_version, verbose=0, reclusive=True)
+        update_version_files(args, next_version, verbose=0, recursive=True)
 
         # Verify updates in both directories
         root_content = json.loads(root_package_json.read_text())
@@ -295,7 +295,7 @@ def test_update_version_files_ignore_node_modules(self, tmp_path):
         next_version = Version(major=2, minor=0, patch=0)
 
         # Update version files
-        update_version_files(args, next_version, verbose=0, reclusive=True)
+        update_version_files(args, next_version, verbose=0, recursive=True)
 
         # Verify root package.json was updated
         root_content = json.loads(root_package_json.read_text())
@@ -418,7 +418,7 @@ def test_version_workflow_with_git_repo(self, temp_git_repo):
 
         # Update version files
         next_version = Version(major=1, minor=0, patch=1)
-        update_version_files(args, next_version, verbose=0, reclusive=False)
+        update_version_files(args, next_version, verbose=0, recursive=False)
 
         # Verify version was updated
         updated_content = json.loads(package_json.read_text())

tests/unit/test_changelog_coverage.py

@@ -0,0 +1,78 @@
+from unittest.mock import Mock, patch
+
+import pytest
+from tgit.changelog import (
+    get_changelog_by_range,
+    get_commits,
+    prepare_changelog_segments,
+)
+
+
+class TestChangelogCoverage:
+    """Additional tests to increase coverage for changelog.py."""
+
+    @patch("tgit.changelog.commit_pattern")
+    def test_get_commits_bytes_message(self, mock_pattern):
+        """Test get_commits with bytes message."""
+        repo = Mock()
+        commit = Mock()
+        commit.message = b"feat: bytes message"
+        repo.iter_commits.return_value = [commit]
+        
+        mock_pattern.match.return_value = None  # Just to avoid further processing
+        
+        get_commits(repo, "HEAD~1", "HEAD")
+        
+        # Verify message was decoded
+        # Since we mocked match to return None, we can't verify the result list,
+        # but we can verify that no error occurred during decoding.
+
+    @patch("tgit.changelog.commit_pattern")
+    def test_get_commits_non_string_message(self, mock_pattern):
+        """Test get_commits with non-string message."""
+        repo = Mock()
+        commit = Mock()
+        commit.message = 12345
+        repo.iter_commits.return_value = [commit]
+        
+        mock_pattern.match.return_value = None
+        
+        get_commits(repo, "HEAD~1", "HEAD")
+
+    def test_prepare_changelog_segments_with_latest_tag_in_file(self):
+        """Test prepare_changelog_segments with latest_tag_in_file."""
+        repo = Mock()
+        tag1 = Mock()
+        tag1.name = "v1.0.0"
+        tag1.commit.hexsha = "hash1"
+        tag1.commit.committed_datetime = 1000
+        
+        tag2 = Mock()
+        tag2.name = "v1.1.0"
+        tag2.commit.hexsha = "hash2"
+        tag2.commit.committed_datetime = 2000
+        
+        repo.tags = [tag1, tag2]
+        repo.iter_commits.return_value = [Mock(hexsha="init")]
+        
+        # Mock get_first_commit_hash
+        with patch("tgit.changelog.get_first_commit_hash", return_value="init"):
+            segments = prepare_changelog_segments(repo, latest_tag_in_file="v1.0.0")
+            
+            assert len(segments) == 1
+            assert segments[0].from_name == "v1.0.0"
+            assert segments[0].to_name == "v1.1.0"
+
+    @patch("tgit.changelog.get_commits")
+    @patch("tgit.changelog.group_commits_by_type")
+    @patch("tgit.changelog.generate_changelog")
+    def test_get_changelog_by_range_no_remote(self, mock_gen, mock_group, mock_get_commits):
+        """Test get_changelog_by_range when remote is missing."""
+        repo = Mock()
+        repo.remote.side_effect = ValueError("No remote")
+        
+        with pytest.warns(UserWarning, match="Origin not found"):
+            get_changelog_by_range(repo, "HEAD~1", "HEAD")
+            
+        mock_gen.assert_called_once()
+        assert mock_gen.call_args[0][3] is None  # remote_uri should be None

tests/unit/test_commit_coverage.py

@@ -0,0 +1,74 @@
+from unittest.mock import Mock, patch
+
+import pytest
+from tgit.commit import (
+    CommitArgs,
+    _supports_reasoning,
+    get_ai_command,
+    get_file_change_sizes,
+    handle_commit,
+)
+
+
+class TestCommitCoverage:
+    """Additional tests to increase coverage for commit.py."""
+
+    def test_supports_reasoning_empty(self):
+        """Test _supports_reasoning with empty model."""
+        assert _supports_reasoning("") is False
+        assert _supports_reasoning(None) is False
+
+    def test_get_file_change_sizes_value_error(self):
+        """Test get_file_change_sizes with invalid numstat."""
+        repo = Mock()
+        # Simulate a case where numstat returns invalid integer
+        repo.git.diff.return_value = "invalid\tinvalid\timage.png"
+        
+        sizes = get_file_change_sizes(repo)
+        assert sizes["image.png"] == 0
+
+    @patch("tgit.commit.git.Repo")
+    @patch("tgit.commit.get_filtered_diff_files")
+    def test_get_ai_command_no_diff(self, mock_filter, mock_repo):
+        """Test get_ai_command when there is no diff after filtering."""
+        repo = Mock()
+        mock_repo.return_value = repo
+        
+        # Return some files to pass the first check
+        mock_filter.return_value = (["file.txt"], [])
+        
+        # But make git diff return empty string
+        repo.git.diff.return_value = ""
+        repo.active_branch.name = "main"
+        
+        assert get_ai_command() is None
+
+    @patch("tgit.commit.git.Repo")
+    @patch("tgit.commit.get_filtered_diff_files")
+    @patch("tgit.commit._generate_commit_with_ai")
+    def test_get_ai_command_ai_failure(self, mock_gen, mock_filter, mock_repo):
+        """Test get_ai_command when AI generation fails."""
+        repo = Mock()
+        mock_repo.return_value = repo
+        mock_filter.return_value = (["file.txt"], [])
+        repo.git.diff.return_value = "diff content"
+        repo.active_branch.name = "main"
+        
+        mock_gen.return_value = None
+        
+        assert get_ai_command() is None
+
+    @patch("tgit.commit.get_ai_command")
+    def test_handle_commit_ai_command_none(self, mock_get_ai):
+        """Test handle_commit when get_ai_command returns None."""
+        mock_get_ai.return_value = None
+        
+        args = CommitArgs(
+            message=["feat"],
+            emoji=False,
+            breaking=False,
+            ai=False,
+        )
+        
+        handle_commit(args)
+        # Should return without error and without running command

tests/unit/test_utils_coverage.py

@@ -0,0 +1,120 @@
+import json
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+import pytest
+from click.testing import CliRunner
+from tgit.cli import app
+from tgit.utils import (
+    load_global_settings,
+    load_workspace_settings,
+    set_global_settings,
+)
+
+
+class TestUtilsCoverage:
+    """Additional tests to increase coverage for utils and cli."""
+
+    def test_load_global_settings_empty_json(self, tmp_path):
+        """Test load_global_settings with empty JSON (returns None)."""
+        settings_path = tmp_path / ".tgit" / "settings.json"
+        settings_path.parent.mkdir(parents=True)
+        settings_path.write_text("null")
+        
+        with patch("tgit.utils.Path.home", return_value=tmp_path):
+            settings = load_global_settings()
+            assert settings == {}
+
+    def test_load_workspace_settings_empty_json(self, tmp_path):
+        """Test load_workspace_settings with empty JSON (returns None)."""
+        settings_path = tmp_path / ".tgit" / "settings.json"
+        settings_path.parent.mkdir(parents=True)
+        settings_path.write_text("null")
+        
+        with patch("tgit.utils.Path.cwd", return_value=tmp_path):
+            settings = load_workspace_settings()
+            assert settings == {}
+
+    def test_set_global_settings(self, tmp_path):
+        """Test set_global_settings."""
+        with patch("tgit.utils.Path.home", return_value=tmp_path):
+            set_global_settings("test_key", "test_value")
+            
+            settings_path = tmp_path / ".tgit" / "settings.json"
+            assert settings_path.exists()
+            content = json.loads(settings_path.read_text())
+            assert content["test_key"] == "test_value"
+            
+            # Test updating existing settings
+            set_global_settings("test_key_2", "test_value_2")
+            content = json.loads(settings_path.read_text())
+            assert content["test_key"] == "test_value"
+            assert content["test_key_2"] == "test_value_2"
+
+    def test_set_global_settings_with_null_file(self, tmp_path):
+        """Test set_global_settings when file exists but is null."""
+        settings_path = tmp_path / ".tgit" / "settings.json"
+        settings_path.parent.mkdir(parents=True)
+        settings_path.write_text("null")
+        
+        with patch("tgit.utils.Path.home", return_value=tmp_path):
+            set_global_settings("test_key", "test_value")
+            
+            content = json.loads(settings_path.read_text())
+            assert content["test_key"] == "test_value"
+
+    def test_load_global_settings_missing_file(self, tmp_path):
+        """Test load_global_settings when file is missing."""
+        with patch("tgit.utils.Path.home", return_value=tmp_path):
+            settings = load_global_settings()
+            assert settings == {}
+
+    def test_load_workspace_settings_missing_file(self, tmp_path):
+        """Test load_workspace_settings when file is missing."""
+        with patch("tgit.utils.Path.cwd", return_value=tmp_path):
+            settings = load_workspace_settings()
+            assert settings == {}
+
+    @patch("tgit.cli.threading.Thread")
+    def test_cli_app_import_openai(self, mock_thread):
+        """Test cli app triggers openai import."""
+        # Mock Thread to run target immediately
+        def run_target(target=None, **kwargs):
+            target()
+            return Mock()
+            
+        mock_thread.side_effect = run_target
+        
+        runner = CliRunner()
+        # Invoke with a subcommand to ensure group function runs
+        # We use a non-existent command to trigger group execution before error?
+        # Or use 'version' command if available.
+        # Let's use 'settings' command which is added.
+        result = runner.invoke(app, ["settings", "--help"])
+        
+        assert result.exit_code == 0
+        mock_thread.assert_called()
+
+    @patch("tgit.cli.threading.Thread")
+    def test_cli_app_import_openai_exception(self, mock_thread):
+        """Test cli app handles openai import exception."""
+        def run_target(target=None, **kwargs):
+            # Mock import to raise exception
+            with patch("builtins.__import__", side_effect=ImportError("fail")):
+                target()
+            return Mock()
+            
+        mock_thread.side_effect = run_target
+        
+        runner = CliRunner()
+        result = runner.invoke(app, ["settings", "--help"])
+        
+        assert result.exit_code == 0
+        mock_thread.assert_called()
+
+    def test_version_callback(self):
+        """Test version callback."""
+        runner = CliRunner()
+        result = runner.invoke(app, ["--version"])
+        assert result.exit_code == 0
+        assert "TGIT - ver." in result.output

tests/unit/test_version.py

@@ -2186,7 +2186,7 @@ def test_update_version_files_verbose_mode(self, mock_console, mock_get_detected
         )
         next_version = Version(2, 0, 0)
 
-        update_version_files(args, next_version, 1, reclusive=True)
+        update_version_files(args, next_version, 1, recursive=True)
 
         # Check verbose output
         mock_console.print.assert_any_call("Current path: [cyan bold]/test")