git-commit-msg-ai 1.7.0__tar.gz → 2.0.0__tar.gz

{git_commit_msg_ai-1.7.0 → git_commit_msg_ai-2.0.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: git-commit-msg-ai
-Version: 1.7.0
+Version: 2.0.0
 Summary: AI-powered git commit message generator following Conventional Commits
 License-Expression: MIT
-Requires-Python: >=3.10
+Requires-Python: >=3.14
 Description-Content-Type: text/markdown
 Requires-Dist: anthropic
 Provides-Extra: dev
@@ -20,7 +20,7 @@ AI-powered git commit message generator that follows the [Conventional Commits](
 
 ## Prerequisites
 
-- Python 3.10+
+- Python 3.14+
 - An Anthropic API key set as an environment variable:
 
   ```sh
@@ -156,6 +156,6 @@ git-commit-msg-ai
 | Level | What you see |
 |---|---|
 | `DEBUG` | git commands run, API model/token params, temp file paths, char counts |
-| `INFO` | commit message generated, commit created |
+| `INFO` | commit message generated (with char count), commit created |
 | `WARNING` | no staged changes found |
 | `ERROR` | git not found, API failures, editor errors |

{git_commit_msg_ai-1.7.0 → git_commit_msg_ai-2.0.0}/README.md

@@ -4,7 +4,7 @@ AI-powered git commit message generator that follows the [Conventional Commits](
 
 ## Prerequisites
 
-- Python 3.10+
+- Python 3.14+
 - An Anthropic API key set as an environment variable:
 
   ```sh
@@ -140,6 +140,6 @@ git-commit-msg-ai
 | Level | What you see |
 |---|---|
 | `DEBUG` | git commands run, API model/token params, temp file paths, char counts |
-| `INFO` | commit message generated, commit created |
+| `INFO` | commit message generated (with char count), commit created |
 | `WARNING` | no staged changes found |
 | `ERROR` | git not found, API failures, editor errors |

{git_commit_msg_ai-1.7.0 → git_commit_msg_ai-2.0.0}/git_commit_msg_ai/ai_client.py

@@ -1,6 +1,6 @@
 import logging
 import textwrap
-from typing import Final, cast
+from typing import Final
 
 import anthropic
 
@@ -24,7 +24,7 @@ def generate_commit_message(diff: str) -> str:
     try:
         anthropic_client = anthropic.Anthropic()
 
-        logger.debug("Calling Anthropic API: model=%s max_tokens=%d", MODEL, MAX_TOKENS)
+        logger.debug(f"Calling Anthropic API: model={MODEL} max_tokens={MAX_TOKENS}")
         anthropic_api_response = anthropic_client.messages.create(
             model=MODEL,
             max_tokens=MAX_TOKENS,
@@ -32,21 +32,19 @@ def generate_commit_message(diff: str) -> str:
             messages=[{"role": "user", "content": diff}],
         )
     except anthropic.AuthenticationError:
-        logger.error("Anthropic authentication error")
         raise AIError("Anthropic API key is missing or invalid. Set the ANTHROPIC_API_KEY environment variable.")
     except anthropic.RateLimitError:
-        logger.error("Anthropic rate limit error")
         raise AIError("Anthropic API rate limit reached. Wait a moment and try again.")
     except anthropic.APIConnectionError:
-        logger.error("Anthropic API connection error")
         raise AIError("Could not reach the Anthropic API. Check your network connection.")
-    except anthropic.APIStatusError as error:
-        logger.error("Anthropic API status error: %s", error.status_code)
-        raise AIError(f"Anthropic API returned an error: {error.status_code}.")
+    except anthropic.APIStatusError as api_status_error:
+        raise AIError(f"Anthropic API returned an error: {api_status_error.status_code}.")
 
     anthropic_api_response_message = anthropic_api_response.content[0]
-    commit_message = cast(anthropic.types.TextBlock, anthropic_api_response_message).text.strip()
+    if not isinstance(anthropic_api_response_message, anthropic.types.TextBlock):
+        raise AIError("Unexpected response format from Anthropic API.")
+    commit_message = anthropic_api_response_message.text.strip()
 
-    logger.info("Commit message generated: %d chars", len(commit_message))
+    logger.info(f"Commit message generated: {len(commit_message)} chars")
 
     return commit_message

git_commit_msg_ai-2.0.0/git_commit_msg_ai/cli.py

@@ -0,0 +1,59 @@
+import logging
+import os
+import sys
+from typing import Final
+
+from git_commit_msg_ai import ai_client, editor, git_ops
+from git_commit_msg_ai.exceptions import GitCommitAIError
+
+LOG_LEVEL_ENVIRONMENT_VARIABLE: Final[str] = "GIT_COMMIT_AI_LOG_LEVEL"
+DEFAULT_LOG_LEVEL: Final[str] = "WARNING"
+LOG_FORMAT: Final[str] = "%(levelname)s:%(name)s:%(message)s"
+SELECTION_PROMPT: Final[str] = "[a]ccept / [e]dit / [r]eject: "
+SELECTION_ACCEPT: Final[str] = "a"
+SELECTION_EDIT: Final[str] = "e"
+SELECTION_REJECT: Final[str] = "r"
+REJECTED_MESSAGE: Final[str] = "User rejected the generated commit message. No commit made."
+INVALID_SELECTION_MESSAGE: Final[str] = "Invalid selection."
+ABORTED_MESSAGE: Final[str] = "Aborted."
+
+
+def main() -> None:
+    log_level_name = os.environ.get(LOG_LEVEL_ENVIRONMENT_VARIABLE, DEFAULT_LOG_LEVEL).upper()
+    numeric_log_level = getattr(logging, log_level_name, None)
+    valid_log_level = isinstance(numeric_log_level, int)
+    effective_log_level = numeric_log_level if valid_log_level else logging.WARNING
+
+    if not valid_log_level:
+        logging.warning(f"Invalid {LOG_LEVEL_ENVIRONMENT_VARIABLE} value {log_level_name!r}, defaulting to {DEFAULT_LOG_LEVEL}")
+
+    logging.basicConfig(level=effective_log_level, format=LOG_FORMAT, stream=sys.stderr)
+
+    try:
+        diff = git_ops.get_staged_diff()
+        commit_message = ai_client.generate_commit_message(diff)
+        print(commit_message)
+
+        print()
+        user_selection = input(SELECTION_PROMPT).strip().lower()
+
+        if user_selection == SELECTION_ACCEPT:
+            git_ops.commit(commit_message)
+        elif user_selection == SELECTION_EDIT:
+            updated_commit_message = editor.open_in_editor(commit_message)
+            git_ops.commit(updated_commit_message)
+        elif user_selection == SELECTION_REJECT:
+            print(REJECTED_MESSAGE)
+        else:
+            print(INVALID_SELECTION_MESSAGE)
+            sys.exit(1)
+    except GitCommitAIError as error:
+        logging.error(str(error))
+        sys.exit(1)
+    except KeyboardInterrupt, EOFError:
+        print(ABORTED_MESSAGE)
+        sys.exit(1)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

{git_commit_msg_ai-1.7.0 → git_commit_msg_ai-2.0.0}/git_commit_msg_ai/editor.py

@@ -3,44 +3,49 @@ import os
 import platform
 import subprocess
 import tempfile
+from typing import Final
 
 from git_commit_msg_ai.exceptions import EditorError
 
 logger = logging.getLogger(__name__)
 
+_WINDOWS_PLATFORM: Final[str] = "Windows"
+WINDOWS_EDITOR: Final[str] = "notepad"
+FALLBACK_EDITOR: Final[str] = "vi"
+_EDITOR_ENVIRONMENT_VARIABLE: Final[str] = "EDITOR"
+_TEMP_FILE_SUFFIX: Final[str] = ".txt"
+_TEMP_FILE_MODE: Final[str] = "w"
+
 
 def get_default_editor() -> str:
     current_platform = platform.system()
-    is_windows = current_platform == "Windows"
+    is_windows = current_platform == _WINDOWS_PLATFORM
 
-    return "notepad" if is_windows else "vi"
+    return WINDOWS_EDITOR if is_windows else FALLBACK_EDITOR
 
 
 def open_in_editor(initial_text: str) -> str:
     try:
-        with tempfile.NamedTemporaryFile(suffix=".txt", mode="w", delete=False) as temp_file:
+        with tempfile.NamedTemporaryFile(suffix=_TEMP_FILE_SUFFIX, mode=_TEMP_FILE_MODE, delete=False) as temp_file:
             temp_file.write(initial_text)
             temp_file_path = temp_file.name
     except OSError:
-        logger.error("Could not create temporary file")
         raise EditorError("Could not create a temporary file.")
 
-    logger.debug("Temporary file created: %s", temp_file_path)
+    logger.debug(f"Temporary file created: {temp_file_path}")
 
     platform_default_editor = get_default_editor()
-    editor_command = os.environ.get("EDITOR", platform_default_editor)
+    editor_command = os.environ.get(_EDITOR_ENVIRONMENT_VARIABLE, platform_default_editor)
 
-    logger.debug("Selected editor: %s", editor_command)
+    logger.debug(f"Selected editor: {editor_command}")
 
     try:
         try:
-            logger.debug("Opening editor: %s %s", editor_command, temp_file_path)
+            logger.debug(f"Opening editor: {editor_command} {temp_file_path}")
             subprocess.run([editor_command, temp_file_path], check=True)
         except FileNotFoundError:
-            logger.error("Editor not found: %s", editor_command)
             raise EditorError(f'Editor "{editor_command}" was not found. Set the EDITOR environment variable to a valid editor.')
         except subprocess.CalledProcessError:
-            logger.error("Editor exited with error: %s", editor_command)
             raise EditorError(f'Editor "{editor_command}" exited with an error.')
 
         logger.debug("Editor closed, reading edited content")
@@ -49,11 +54,10 @@ def open_in_editor(initial_text: str) -> str:
             with open(temp_file_path) as temp_file:
                 edited_text = temp_file.read().strip()
         except OSError:
-            logger.error("Could not read temporary file: %s", temp_file_path)
             raise EditorError("Could not read the edited commit message from the temporary file.")
     finally:
         os.unlink(temp_file_path)
 
-    logger.debug("Edited text read: %d chars", len(edited_text))
+    logger.debug(f"Edited text read: {len(edited_text)} chars")
 
     return edited_text

git_commit_msg_ai-2.0.0/git_commit_msg_ai/git_ops.py

@@ -0,0 +1,41 @@
+import logging
+import subprocess
+from typing import Final
+
+from git_commit_msg_ai.exceptions import GitError
+
+GIT_COMMAND: Final[str] = "git"
+
+logger = logging.getLogger(__name__)
+
+
+def get_staged_diff() -> str:
+    try:
+        logger.debug(f"Running: {GIT_COMMAND} diff --cached")
+        raw_diff_bytes = subprocess.check_output([GIT_COMMAND, "diff", "--cached"])
+        staged_diff = raw_diff_bytes.decode("utf-8")
+    except FileNotFoundError:
+        raise GitError("git is not installed or not on PATH.")
+    except subprocess.CalledProcessError:
+        raise GitError("Failed to get staged diff. Are you inside a git repository?")
+    except UnicodeDecodeError:
+        raise GitError("Staged diff contains bytes that could not be decoded as UTF-8.")
+
+    logger.debug(f"Staged diff received: {len(staged_diff)} chars")
+
+    if not staged_diff:
+        raise GitError("No staged changes found. Stage files with git add before running.")
+
+    return staged_diff
+
+
+def commit(message: str) -> None:
+    try:
+        logger.debug(f"Running: {GIT_COMMAND} commit -m <message>")
+        subprocess.run([GIT_COMMAND, "commit", "-m", message], check=True)
+    except FileNotFoundError:
+        raise GitError("git is not installed or not on PATH.")
+    except subprocess.CalledProcessError:
+        raise GitError("git commit failed.")
+
+    logger.info("Commit created successfully")

{git_commit_msg_ai-1.7.0 → git_commit_msg_ai-2.0.0}/git_commit_msg_ai.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: git-commit-msg-ai
-Version: 1.7.0
+Version: 2.0.0
 Summary: AI-powered git commit message generator following Conventional Commits
 License-Expression: MIT
-Requires-Python: >=3.10
+Requires-Python: >=3.14
 Description-Content-Type: text/markdown
 Requires-Dist: anthropic
 Provides-Extra: dev
@@ -20,7 +20,7 @@ AI-powered git commit message generator that follows the [Conventional Commits](
 
 ## Prerequisites
 
-- Python 3.10+
+- Python 3.14+
 - An Anthropic API key set as an environment variable:
 
   ```sh
@@ -156,6 +156,6 @@ git-commit-msg-ai
 | Level | What you see |
 |---|---|
 | `DEBUG` | git commands run, API model/token params, temp file paths, char counts |
-| `INFO` | commit message generated, commit created |
+| `INFO` | commit message generated (with char count), commit created |
 | `WARNING` | no staged changes found |
 | `ERROR` | git not found, API failures, editor errors |

{git_commit_msg_ai-1.7.0 → git_commit_msg_ai-2.0.0}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "git-commit-msg-ai"
-version = "1.7.0"
+version = "2.0.0"
 description = "AI-powered git commit message generator following Conventional Commits"
 readme = "README.md"
 license = "MIT"
-requires-python = ">=3.10"
+requires-python = ">=3.14"
 dependencies = ["anthropic"]
 
 [project.scripts]
@@ -18,14 +18,14 @@ git-commit-msg-ai = "git_commit_msg_ai.cli:main"
 dev = ["mypy", "ruff", "pytest", "pytest-cov", "build", "twine"]
 
 [tool.ruff]
-target-version = "py310"
+target-version = "py314"
 line-length = 320
 
 [tool.ruff.lint]
 select = ["E", "F", "I"]
 
 [tool.mypy]
-python_version = "3.10"
+python_version = "3.14"
 strict = true
 
 [tool.pytest.ini_options]

git_commit_msg_ai-2.0.0/tests/test_ai_client.py

@@ -0,0 +1,95 @@
+from contextlib import ExitStack
+from unittest.mock import MagicMock, patch
+
+import anthropic
+import pytest
+
+from git_commit_msg_ai.ai_client import generate_commit_message
+from git_commit_msg_ai.exceptions import AIError
+
+
+def _make_api_response(text: str) -> MagicMock:
+    mock_text_block = MagicMock(spec=anthropic.types.TextBlock)
+    mock_text_block.text = text
+
+    mock_response = MagicMock(spec=anthropic.types.Message)
+    mock_response.content = [mock_text_block]
+
+    return mock_response
+
+
+def _make_status_error(exception_class: type[anthropic.APIStatusError], status_code: int) -> anthropic.APIStatusError:
+    mock_response = MagicMock()
+    mock_response.status_code = status_code
+
+    return exception_class("error", response=mock_response, body={})
+
+
+class TestGenerateCommitMessage:
+    def test_generate_commit_message_returns_stripped_message(self) -> None:
+        with ExitStack() as stack:
+            mock_anthropic_class = stack.enter_context(patch("git_commit_msg_ai.ai_client.anthropic.Anthropic"))
+            mock_client = MagicMock()
+            mock_client.messages.create.return_value = _make_api_response("  feat: add feature  ")
+            mock_anthropic_class.return_value = mock_client
+
+            result = generate_commit_message("diff content")
+
+        assert result == "feat: add feature"
+
+    def test_generate_commit_message_raises_ai_error_on_authentication_error(self) -> None:
+        with ExitStack() as stack:
+            mock_anthropic_class = stack.enter_context(patch("git_commit_msg_ai.ai_client.anthropic.Anthropic"))
+            mock_client = MagicMock()
+            mock_client.messages.create.side_effect = _make_status_error(anthropic.AuthenticationError, 401)
+            mock_anthropic_class.return_value = mock_client
+
+            with pytest.raises(AIError, match="ANTHROPIC_API_KEY"):
+                generate_commit_message("diff content")
+
+    def test_generate_commit_message_raises_ai_error_on_rate_limit_error(self) -> None:
+        with ExitStack() as stack:
+            mock_anthropic_class = stack.enter_context(patch("git_commit_msg_ai.ai_client.anthropic.Anthropic"))
+            mock_client = MagicMock()
+            mock_client.messages.create.side_effect = _make_status_error(anthropic.RateLimitError, 429)
+            mock_anthropic_class.return_value = mock_client
+
+            with pytest.raises(AIError, match="rate limit"):
+                generate_commit_message("diff content")
+
+    def test_generate_commit_message_raises_ai_error_on_api_connection_error(self) -> None:
+        mock_request = MagicMock()
+
+        with ExitStack() as stack:
+            mock_anthropic_class = stack.enter_context(patch("git_commit_msg_ai.ai_client.anthropic.Anthropic"))
+            mock_client = MagicMock()
+            mock_client.messages.create.side_effect = anthropic.APIConnectionError(request=mock_request)
+            mock_anthropic_class.return_value = mock_client
+
+            with pytest.raises(AIError, match="network"):
+                generate_commit_message("diff content")
+
+    def test_generate_commit_message_raises_ai_error_on_api_status_error_with_status_code(self) -> None:
+        with ExitStack() as stack:
+            mock_anthropic_class = stack.enter_context(patch("git_commit_msg_ai.ai_client.anthropic.Anthropic"))
+            mock_client = MagicMock()
+            mock_client.messages.create.side_effect = _make_status_error(anthropic.APIStatusError, 500)
+            mock_anthropic_class.return_value = mock_client
+
+            with pytest.raises(AIError, match="500"):
+                generate_commit_message("diff content")
+
+    def test_generate_commit_message_raises_ai_error_on_non_text_block_response(self) -> None:
+        mock_non_text_block = MagicMock()  # no spec=TextBlock → isinstance check fails
+
+        mock_response = MagicMock(spec=anthropic.types.Message)
+        mock_response.content = [mock_non_text_block]
+
+        with ExitStack() as stack:
+            mock_anthropic_class = stack.enter_context(patch("git_commit_msg_ai.ai_client.anthropic.Anthropic"))
+            mock_client = MagicMock()
+            mock_client.messages.create.return_value = mock_response
+            mock_anthropic_class.return_value = mock_client
+
+            with pytest.raises(AIError, match="Unexpected response format"):
+                generate_commit_message("diff content")