git-commit-msg-ai 1.5.0__tar.gz → 1.6.0__tar.gz

{git_commit_msg_ai-1.5.0 → git_commit_msg_ai-1.6.0}/PKG-INFO

@@ -1,137 +1,161 @@
-Metadata-Version: 2.4
-Name: git-commit-msg-ai
-Version: 1.5.0
-Summary: AI-powered git commit message generator following Conventional Commits
-License-Expression: MIT
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: anthropic
-Provides-Extra: dev
-Requires-Dist: mypy; extra == "dev"
-Requires-Dist: ruff; extra == "dev"
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: build; extra == "dev"
-Requires-Dist: twine; extra == "dev"
-
-# git-commit-msg-ai
-
-AI-powered git commit message generator that follows the [Conventional Commits](https://www.conventionalcommits.org/) specification.
-
-## Prerequisites
-
-- Python 3.10+
-- An Anthropic API key set as an environment variable:
-
-  ```sh
-  export ANTHROPIC_API_KEY=sk-ant-...   # macOS/Linux
-  ```
-
-  ```powershell
-  [System.Environment]::SetEnvironmentVariable('ANTHROPIC_API_KEY', 'sk-ant-...', 'User')   # Windows
-  ```
-
-## Development Setup
-
-Clone the repository, create a virtual environment, and install the project in editable mode with all dev dependencies:
-
-```sh
-python -m venv .venv
-```
-
-Activate the virtual environment:
-
-```sh
-# macOS/Linux
-source .venv/bin/activate
-
-# Windows PowerShell
-.venv\Scripts\Activate.ps1
-```
-
-Install the project and dev dependencies:
-
-```sh
-pip install -e ".[dev]"
-```
-
-After activation the `git-commit-msg-ai` entry-point is on your PATH. You can also run the dev toolchain:
-
-```sh
-pytest          # run tests with coverage
-ruff check .    # lint
-mypy .          # type-check
-```
-
-## Installation
-
-```sh
-pip install git-commit-msg-ai
-```
-
-## Usage
-
-Stage your changes, then run the tool from inside any git repository:
-
-```sh
-git add <files>
-git-commit-msg-ai
-```
-
-The tool will:
-1. Read your staged diff
-2. Generate a commit message using Claude AI
-3. Print the message and prompt you to choose:
-
-```
-[a]ccept / [e]dit / [r]eject:
-```
-
-- **a** - commits immediately with the generated message
-- **e** - opens the message in your `$EDITOR` (defaults to `notepad` on Windows, `vi` on Linux/macOS), lets you modify it, then commits
-- **r** - exits without committing
-
-## Commit message format
-
-Generated messages follow the Conventional Commits specification:
-
-```
-<type>(<optional scope>): <short subject>
-
-- Bullet explaining why this change was made
-- Another reason if applicable
-```
-
-For breaking changes, the subject line gets a `!` and a footer is added:
-
-```
-feat(api)!: remove deprecated endpoint
-
-- Endpoint was unused and blocking the new auth rollout
-
-BREAKING CHANGE: /v1/legacy is no longer available
-```
-
-Supported types: `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`
-
-## Debugging
-
-By default the tool produces no diagnostic output. To enable logging, set the `GIT_COMMIT_AI_LOG_LEVEL` environment variable before running the command. Logs are written to **stderr** and do not interfere with the generated commit message on **stdout**.
-
-Valid values: `DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`
-
-```sh
-# macOS/Linux - show all internal diagnostic messages
-GIT_COMMIT_AI_LOG_LEVEL=DEBUG git-commit-msg-ai
-
-# Windows PowerShell
-$env:GIT_COMMIT_AI_LOG_LEVEL = 'DEBUG'
-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 |
-| `WARNING` | no staged changes found |
-| `ERROR` | git not found, API failures, editor errors |
+Metadata-Version: 2.4
+Name: git-commit-msg-ai
+Version: 1.6.0
+Summary: AI-powered git commit message generator following Conventional Commits
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: anthropic
+Provides-Extra: dev
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+# git-commit-msg-ai
+
+AI-powered git commit message generator that follows the [Conventional Commits](https://www.conventionalcommits.org/) specification.
+
+## Prerequisites
+
+- Python 3.10+
+- An Anthropic API key set as an environment variable:
+
+  ```sh
+  export ANTHROPIC_API_KEY=sk-ant-...   # macOS/Linux
+  ```
+
+  ```powershell
+  [System.Environment]::SetEnvironmentVariable('ANTHROPIC_API_KEY', 'sk-ant-...', 'User')   # Windows
+  ```
+
+## Development Setup
+
+Clone the repository, create a virtual environment, and install the project in editable mode with all dev dependencies:
+
+```sh
+python -m venv .venv
+```
+
+Activate the virtual environment:
+
+```sh
+# macOS/Linux
+source .venv/bin/activate
+
+# Windows PowerShell
+.venv\Scripts\Activate.ps1
+```
+
+Install the project and dev dependencies:
+
+```sh
+pip install -e ".[dev]"
+```
+
+After activation the `git-commit-msg-ai` entry-point is on your PATH. You can also run the dev toolchain:
+
+```sh
+pytest          # run tests with coverage
+ruff check .    # lint
+mypy .          # type-check
+```
+
+## Installation
+
+```sh
+pip install git-commit-msg-ai
+```
+
+## Usage
+
+Stage your changes, then run the tool from inside any git repository:
+
+```sh
+git add <files>
+git-commit-msg-ai
+```
+
+The tool will:
+1. Read your staged diff
+2. Generate a commit message using Claude AI
+3. Print the message and prompt you to choose:
+
+```
+[a]ccept / [e]dit / [r]eject:
+```
+
+- **a** - commits immediately with the generated message
+- **e** - opens the message in your `$EDITOR` (defaults to `notepad` on Windows, `vi` on Linux/macOS), lets you modify it, then commits
+- **r** - exits without committing
+
+## Commit message format
+
+Generated messages follow the Conventional Commits specification:
+
+```
+<type>(<optional scope>): <short subject>
+
+- Bullet explaining why this change was made
+- Another reason if applicable
+```
+
+For breaking changes, the subject line gets a `!` and a footer is added:
+
+```
+feat(api)!: remove deprecated endpoint
+
+- Endpoint was unused and blocking the new auth rollout
+
+BREAKING CHANGE: /v1/legacy is no longer available
+```
+
+Supported types: `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`
+
+## CI/CD
+
+Every push to `main` and every pull request runs the full CI pipeline (lint, type-check, tests, build).
+
+Pushing a version tag (e.g. `v1.5.2`) triggers the CD pipeline:
+
+1. Tests are re-run as a gate
+2. The tag version is verified to match the version in `pyproject.toml`
+3. The package is built and published to [PyPI](https://pypi.org/project/git-commit-msg-ai/)
+4. A GitHub Release is created with release notes generated by Claude Haiku from the commit log
+
+**Releasing a new version:**
+
+```powershell
+# 1. Bump the version in pyproject.toml
+# 2. Commit and push
+git add pyproject.toml
+git commit -m "chore: bump version to 1.5.2"
+git push origin main
+# 3. Tag and push — this triggers the CD pipeline
+git tag v1.5.2
+git push origin v1.5.2
+```
+
+## Debugging
+
+By default the tool produces no diagnostic output. To enable logging, set the `GIT_COMMIT_AI_LOG_LEVEL` environment variable before running the command. Logs are written to **stderr** and do not interfere with the generated commit message on **stdout**.
+
+Valid values: `DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`
+
+```sh
+# macOS/Linux - show all internal diagnostic messages
+GIT_COMMIT_AI_LOG_LEVEL=DEBUG git-commit-msg-ai
+
+# Windows PowerShell
+$env:GIT_COMMIT_AI_LOG_LEVEL = 'DEBUG'
+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 |
+| `WARNING` | no staged changes found |
+| `ERROR` | git not found, API failures, editor errors |

{git_commit_msg_ai-1.5.0 → git_commit_msg_ai-1.6.0}/README.md

@@ -98,6 +98,30 @@ BREAKING CHANGE: /v1/legacy is no longer available
 
 Supported types: `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`
 
+## CI/CD
+
+Every push to `main` and every pull request runs the full CI pipeline (lint, type-check, tests, build).
+
+Pushing a version tag (e.g. `v1.5.2`) triggers the CD pipeline:
+
+1. Tests are re-run as a gate
+2. The tag version is verified to match the version in `pyproject.toml`
+3. The package is built and published to [PyPI](https://pypi.org/project/git-commit-msg-ai/)
+4. A GitHub Release is created with release notes generated by Claude Haiku from the commit log
+
+**Releasing a new version:**
+
+```powershell
+# 1. Bump the version in pyproject.toml
+# 2. Commit and push
+git add pyproject.toml
+git commit -m "chore: bump version to 1.5.2"
+git push origin main
+# 3. Tag and push — this triggers the CD pipeline
+git tag v1.5.2
+git push origin v1.5.2
+```
+
 ## Debugging
 
 By default the tool produces no diagnostic output. To enable logging, set the `GIT_COMMIT_AI_LOG_LEVEL` environment variable before running the command. Logs are written to **stderr** and do not interfere with the generated commit message on **stdout**.

{git_commit_msg_ai-1.5.0 → git_commit_msg_ai-1.6.0}/git_commit_msg_ai/ai_client.py

@@ -16,7 +16,7 @@ SYSTEM_PROMPT: Final[str] = textwrap.dedent("""\
     - If there is a breaking change, add a blank line after the body followed by "BREAKING CHANGE: <description of what breaks and why>
     Types: feat, fix, docs, style, refactor, test, chore""")
 
-MODEL: Final[str] = 'claude-haiku-4-5-20251001'
+MODEL: Final[str] = "claude-haiku-4-5-20251001"
 MAX_TOKENS: Final[int] = 1024
 
 
@@ -24,29 +24,29 @@ 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("Calling Anthropic API: model=%s max_tokens=%d", MODEL, MAX_TOKENS)
         anthropic_api_response = anthropic_client.messages.create(
             model=MODEL,
             max_tokens=MAX_TOKENS,
             system=SYSTEM_PROMPT,
-            messages=[{'role': 'user', 'content': diff}],
+            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.')
+        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.')
+        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.')
+        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}.')
+        logger.error("Anthropic API status error: %s", error.status_code)
+        raise AIError(f"Anthropic API returned an error: {error.status_code}.")
 
     anthropic_api_response_message = anthropic_api_response.content[0]
     commit_message = cast(anthropic.types.TextBlock, anthropic_api_response_message).text.strip()
 
-    logger.info('Commit message generated: %d chars', len(commit_message))
+    logger.info("Commit message generated: %d chars", len(commit_message))
 
     return commit_message

{git_commit_msg_ai-1.5.0 → git_commit_msg_ai-1.6.0}/git_commit_msg_ai/cli.py

@@ -6,20 +6,20 @@ 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_ENV_VAR: Final[str] = 'GIT_COMMIT_AI_LOG_LEVEL'
+LOG_LEVEL_ENV_VAR: Final[str] = "GIT_COMMIT_AI_LOG_LEVEL"
 
 
 def main() -> None:
-    log_level_name = os.environ.get(LOG_LEVEL_ENV_VAR, 'WARNING').upper()
+    log_level_name = os.environ.get(LOG_LEVEL_ENV_VAR, "WARNING").upper()
     numeric_log_level = getattr(logging, log_level_name, None)
 
     if not isinstance(numeric_log_level, int):
         numeric_log_level = logging.WARNING
 
-    logging.basicConfig(level=numeric_log_level, format='%(levelname)s:%(name)s:%(message)s', stream=sys.stderr)
+    logging.basicConfig(level=numeric_log_level, format="%(levelname)s:%(name)s:%(message)s", stream=sys.stderr)
 
     if not isinstance(getattr(logging, log_level_name, None), int):
-        logging.warning('Invalid %s value %r, defaulting to WARNING', LOG_LEVEL_ENV_VAR, log_level_name)
+        logging.warning("Invalid %s value %r, defaulting to WARNING", LOG_LEVEL_ENV_VAR, log_level_name)
 
     try:
         diff = git_ops.get_staged_diff()
@@ -27,25 +27,25 @@ def main() -> None:
         print(commit_message)
 
         print()
-        user_selection = input('[a]ccept / [e]dit / [r]eject: ').strip().lower()
+        user_selection = input("[a]ccept / [e]dit / [r]eject: ").strip().lower()
 
-        if user_selection == 'a':
+        if user_selection == "a":
             git_ops.commit(commit_message)
-        elif user_selection == 'e':
+        elif user_selection == "e":
             updated_commit_message = editor.open_in_editor(commit_message)
             git_ops.commit(updated_commit_message)
-        elif user_selection == 'r':
-            print('User rejected the generated commit message. No commit made.')
+        elif user_selection == "r":
+            print("User rejected the generated commit message. No commit made.")
         else:
-            print('Invalid selection.')
+            print("Invalid selection.")
             sys.exit(1)
     except GitCommitAIError as error:
         print(str(error))
         sys.exit(1)
     except (KeyboardInterrupt, EOFError):
-        print('Aborted.')
+        print("Aborted.")
         sys.exit(1)
 
 
-if __name__ == '__main__':  # pragma: no cover
+if __name__ == "__main__":  # pragma: no cover
     main()

{git_commit_msg_ai-1.5.0 → git_commit_msg_ai-1.6.0}/git_commit_msg_ai/editor.py

@@ -11,49 +11,49 @@ logger = logging.getLogger(__name__)
 
 def get_default_editor() -> str:
     current_platform = platform.system()
-    is_windows = current_platform == 'Windows'
+    is_windows = current_platform == "Windows"
 
-    return 'notepad' if is_windows else 'vi'
+    return "notepad" if is_windows else "vi"
 
 
 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=".txt", mode="w", 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.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("Temporary file created: %s", temp_file_path)
 
     platform_default_editor = get_default_editor()
-    editor_command = os.environ.get('EDITOR', platform_default_editor)
+    editor_command = os.environ.get("EDITOR", platform_default_editor)
 
-    logger.debug('Selected editor: %s', editor_command)
+    logger.debug("Selected editor: %s", editor_command)
 
     try:
         try:
-            logger.debug('Opening editor: %s %s', editor_command, temp_file_path)
+            logger.debug("Opening editor: %s %s", editor_command, temp_file_path)
             subprocess.run([editor_command, temp_file_path], check=True)
         except FileNotFoundError:
-            logger.error('Editor not found: %s', editor_command)
+            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)
+            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')
+        logger.debug("Editor closed, reading edited content")
 
         try:
             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.')
+            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("Edited text read: %d chars", len(edited_text))
 
     return edited_text

git_commit_msg_ai-1.6.0/git_commit_msg_ai/git_ops.py

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