commitai 0.1.16__py3-none-any.whl → 1.0.5__py3-none-any.whl

commitai/__init__.py

@@ -0,0 +1,10 @@
+# File: commitai/__init__.py
+# -*- coding: utf-8 -*-
+
+# This __version__ string is read by hatchling during the build process
+# Make sure to update it for new releases.
+__version__ = "0.3.0"
+
+# The importlib.metadata approach is generally for reading the version
+# of an *already installed* package at runtime. We don't need it here
+# for defining the package's own version during build.

commitai/cli.py

@@ -1,10 +1,23 @@
+# File: commitai/cli.py
 # -*- coding: utf-8 -*-
+
 import os
+from typing import Optional, Tuple, cast
 
 import click
 from langchain_anthropic import ChatAnthropic
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_ollama import ChatOllama
 from langchain_openai import ChatOpenAI
 
+# Keep SecretStr import in case it's needed elsewhere or for future refinement
+
+# Conditional import for Google Generative AI
+try:
+    from langchain_google_genai import ChatGoogleGenerativeAI
+except ImportError:
+    ChatGoogleGenerativeAI = None  # type: ignore
+
 from commitai.git import (
     create_commit,
     get_commit_template,
@@ -22,8 +35,133 @@ from commitai.template import (
 )
 
 
-@click.group(context_settings=dict(help_option_names=["-h", "--help"]))
-def cli():
+def _get_google_api_key() -> Optional[str]:
+    """Gets the Google API key from environment variables in priority order."""
+    return (
+        os.getenv("GOOGLE_API_KEY")
+        or os.getenv("GEMINI_API_KEY")
+        or os.getenv("GOOGLE_GENERATIVE_AI_API_KEY")
+    )
+
+
+def _initialize_llm(model: str) -> BaseChatModel:
+    """Initializes and returns the LangChain chat model based on the model name."""
+    google_api_key_str = _get_google_api_key()
+
+    try:
+        if model.startswith("gpt-"):
+            api_key = os.getenv("OPENAI_API_KEY")
+            if not api_key:
+                raise click.ClickException(
+                    "Error: OPENAI_API_KEY environment variable not set."
+                )
+            return ChatOpenAI(model=model, api_key=api_key, temperature=0.7)
+
+        elif model.startswith("claude-"):
+            api_key = os.getenv("ANTHROPIC_API_KEY")
+            if not api_key:
+                raise click.ClickException(
+                    "Error: ANTHROPIC_API_KEY environment variable not set."
+                )
+            return ChatAnthropic(model_name=model, api_key=api_key, temperature=0.7)
+
+        elif model.startswith("gemini-"):
+            if ChatGoogleGenerativeAI is None:
+                raise click.ClickException(
+                    "Error: 'langchain-google-genai' is not installed. "
+                    "Run 'pip install commitai[test]' or "
+                    "'pip install langchain-google-genai'"
+                )
+            if not google_api_key_str:
+                raise click.ClickException(
+                    "Error: Google API Key not found. Set GOOGLE_API_KEY, "
+                    "GEMINI_API_KEY, or GOOGLE_GENERATIVE_AI_API_KEY."
+                )
+            return ChatGoogleGenerativeAI(
+                model=model,
+                google_api_key=google_api_key_str,
+                temperature=0.7,
+                convert_system_message_to_human=True,
+            )
+        elif model.startswith("llama"):
+            # Ollama models (e.g., llama2, llama3)
+            return cast(BaseChatModel, ChatOllama(model=model, temperature=0.7))
+        else:
+            raise click.ClickException(f"🚫 Unsupported model: {model}")
+
+    except Exception as e:
+        raise click.ClickException(f"Error initializing AI model: {e}") from e
+
+
+def _prepare_context() -> str:
+    diff = get_staged_changes_diff()
+    if not diff:
+        raise click.ClickException("⚠️ Warning: No staged changes found. Exiting.")
+
+    repo_name = get_repository_name()
+    branch_name = get_current_branch_name()
+    return f"{repo_name}/{branch_name}\n\n{diff}"
+
+
+def _build_prompt(
+    explanation: str, formatted_diff: str, template: Optional[str]
+) -> str:
+    system_message = default_system_message
+    if template:
+        system_message += adding_template
+        system_message += template
+
+    if explanation:
+        diff_message = build_user_message(explanation, formatted_diff)
+    else:
+        diff_message = formatted_diff
+
+    return f"{system_message}\n\n{diff_message}"
+
+
+def _handle_commit(commit_message: str, commit_flag: bool) -> None:
+    repo_path = get_repository_name()
+    git_dir = os.path.join(repo_path, ".git")
+    try:
+        os.makedirs(git_dir, exist_ok=True)
+    except OSError as e:
+        raise click.ClickException(f"Error creating .git directory: {e}") from e
+
+    commit_msg_path = os.path.join(git_dir, "COMMIT_EDITMSG")
+
+    try:
+        with open(commit_msg_path, "w") as f:
+            f.write(commit_message)
+    except IOError as e:
+        raise click.ClickException(f"Error writing commit message file: {e}") from e
+
+    final_commit_message = commit_message
+    if not commit_flag:
+        try:
+            click.edit(filename=commit_msg_path)
+            with open(commit_msg_path, "r") as f:
+                final_commit_message = f.read().strip()
+        except click.UsageError as e:
+            click.secho(f"Could not open editor: {e}", fg="yellow")
+            click.secho(f"Using generated message:\n\n{commit_message}\n", fg="yellow")
+        except IOError as e:
+            raise click.ClickException(
+                f"Error reading commit message file after edit: {e}"
+            ) from e
+
+    if not final_commit_message:
+        raise click.ClickException("Aborting commit due to empty commit message.")
+
+    create_commit(final_commit_message)
+    click.secho(
+        f"\n\n✅ Committed message:\n\n{final_commit_message}\n\n",
+        fg="green",
+        bold=True,
+    )
+
+
+@click.group(context_settings={"help_option_names": ["-h", "--help"]})
+def cli() -> None:
     pass
 
 
@@ -39,7 +177,9 @@ def cli():
     "--template",
     "-t",
     default=None,
-    help="Specify a commit message template",
+    help=(
+        "Specify a commit message template (DEPRECATED: Use env var or create-template)"
+    ),
 )
 @click.option(
     "--add",
@@ -50,18 +190,24 @@ def cli():
 @click.option(
     "--model",
     "-m",
-    default="claude-opus",
-    help="Set the engine model to be used",
+    default="gemini-2.5-pro-preview-03-25",
+    help=(
+        "Set the engine model (e.g., 'gpt-4', 'claude-3-opus-20240229', "
+        "'gemini-2.5-pro-preview-03-25'). Ensure API key env var is set "
+        "(OPENAI_API_KEY, ANTHROPIC_API_KEY, "
+        "GOOGLE_API_KEY/GEMINI_API_KEY/GOOGLE_GENERATIVE_AI_API_KEY)."
+    ),
 )
-def generate_message(description, commit, template, add, model):
+def generate_message(
+    description: Tuple[str, ...],
+    commit: bool,
+    template: Optional[str],
+    add: bool,
+    model: str,
+) -> None:
     explanation = " ".join(description)
-    if model == "gpt-4":
-        llm = ChatOpenAI(model_name="gpt-4")
-    elif model == "claude-opus":
-        llm = ChatAnthropic(model="claude-3-opus-20240229")
-    else:
-        click.secho(f"🚫 Unsupported model: {model}", fg="red", bold=True)
-        return
+
+    llm = _initialize_llm(model)
 
     if add:
         stage_all_changes()
@@ -71,82 +217,59 @@ def generate_message(description, commit, template, add, model):
         fg="blue",
         bold=True,
     )
-
     if not run_pre_commit_hook():
-        click.secho(
-            "🚫 Pre-commit hook failed. Aborting commit.",
-            fg="red",
-            bold=True,
-        )
-        return
+        raise click.ClickException("🚫 Pre-commit hook failed. Aborting commit.")
 
-    diff = get_staged_changes_diff()
-    if not diff:
+    formatted_diff = _prepare_context()
+
+    if template:
         click.secho(
-            "⚠️ Warning: No staged changes found. Exiting.",
+            "⚠️ Warning: The --template/-t option is deprecated. Use environment "
+            "variable TEMPLATE_COMMIT or `commitai-create-template` command.",
             fg="yellow",
-            bold=True,
         )
-        return
+    final_template = template or get_commit_template()
 
-    # Clear the terminal using click
-    click.clear()
-
-    repo_name = get_repository_name()
-    branch_name = get_current_branch_name()
-    formatted_diff = f"{repo_name}/{branch_name}\n\n{diff}"
-
-    if not template:
-        template = get_commit_template()
-    system_message: str = ""
-    if template:
-        system_message += default_system_message
-        system_message += adding_template
-        system_message += template
-
-    if explanation:
-        diff = build_user_message(explanation, formatted_diff)
+    input_message = _build_prompt(explanation, formatted_diff, final_template)
 
-    input_message = f"{system_message}\n\n{diff}"
+    click.clear()
     click.secho(
         "\n\n🧠 Analyzing the changes and generating a commit message...\n\n",
         fg="blue",
         bold=True,
-    ),
-    ai_message = llm.invoke(input=input_message)
-    commit_message = ai_message.content
-
-    repo_path = get_repository_name()
-    commit_msg_path = os.path.join(repo_path, ".git", "COMMIT_EDITMSG")
-    with open(commit_msg_path, "w") as f:
-        f.write(commit_message)
+    )
+    try:
+        assert llm is not None
+        ai_message = llm.invoke(input=input_message)
+        commit_message = ai_message.content
+        if not isinstance(commit_message, str):
+            commit_message = str(commit_message)
 
-    if not commit:
-        click.edit(filename=commit_msg_path)
+    except Exception as e:
+        raise click.ClickException(f"Error during AI generation: {e}") from e
 
-    with open(commit_msg_path, "r") as f:
-        final_commit_message = f.read().strip()
-
-    create_commit(final_commit_message)
-    click.secho(
-        f"\n\n✅ Committed message:\n\n{final_commit_message}\n\n",
-        fg="green",
-        bold=True,
-    )
+    _handle_commit(commit_message, commit)
 
 
 @cli.command(name="create-template")
 @click.argument("template_content", nargs=-1, type=click.UNPROCESSED)
-def create_template_command(template_content):
-    template_content = " ".join(template_content)
-    if template_content:
-        save_commit_template(template_content)
+def create_template_command(template_content: Tuple[str, ...]) -> None:
+    """Saves a repository-specific commit template."""
+    content = " ".join(template_content)
+    if content:
+        save_commit_template(content)
         click.secho("📝 Template saved successfully.", fg="green")
     else:
         click.secho("❗ Please provide the template content.", fg="red")
 
 
-@click.command(name="commitai")
+# --- Alias Commands ---
+
+
+@click.command(
+    name="commitai",
+    context_settings={"ignore_unknown_options": True},
+)
 @click.argument("description", nargs=-1, type=click.UNPROCESSED)
 @click.option(
     "--add",
@@ -160,27 +283,38 @@ def create_template_command(template_content):
     is_flag=True,
     help="Commit the changes with the generated message",
 )
+@click.option(
+    "--model",
+    "-m",
+    default="gemini-2.5-pro-preview-03-25",
+    help="Set the engine model to be used.",
+)
 @click.pass_context
-def commitai(ctx, description, add, commit):
-    if add:
-        stage_all_changes()
-    ctx.invoke(
-        generate_message,
-        description=description,
-        add=add,
-        commit=commit,
+def commitai_alias(
+    ctx: click.Context,
+    description: Tuple[str, ...],
+    add: bool,
+    commit: bool,
+    model: str,
+) -> None:
+    """Alias for the 'generate' command."""
+    ctx.forward(
+        generate_message, description=description, add=add, commit=commit, model=model
     )
 
 
 @click.command(name="commitai-create-template")
 @click.argument("template_content", nargs=-1, type=click.UNPROCESSED)
 @click.pass_context
-def commitai_create_template(ctx, template_content):
-    ctx.invoke(create_template_command, template_content=template_content)
+def commitai_create_template_alias(
+    ctx: click.Context, template_content: Tuple[str, ...]
+) -> None:
+    """Alias for the 'create-template' command."""
+    ctx.forward(create_template_command, template_content=template_content)
 
 
-cli.add_command(commitai)
-cli.add_command(commitai_create_template)
+cli.add_command(commitai_alias)
+cli.add_command(commitai_create_template_alias)
 
 
 if __name__ == "__main__":

commitai/template.py

@@ -14,12 +14,12 @@ default_system_message = (
     "Footer can contain references to issues, pull requests, or breaking changes."
     "Avoid generic messages like 'update', 'fix bugs', or 'improve code'."
     "Focus on the specific changes made and their impact."
+    "Don't wrap the text in the commit message, or anything like that this text is a commit message directed sent to the user editor in commit process"
+    "Don't include codeblock on the response as ``` or anything like that we need raw git message as raw txt"
 )
 
 adding_template = " The message should follow this template: "
 
 
 def build_user_message(explanation, diff):
-    return (
-        f"Here is a high-level explanation of the commit: {explanation}" f"\n\n{diff}"
-    )
+    return f"Here is a high-level explanation of the commit: {explanation}\n\n{diff}"

commitai-1.0.5.dist-info/METADATA

@@ -0,0 +1,316 @@
+Metadata-Version: 2.4
+Name: commitai
+Version: 1.0.5
+Summary: Commitai helps you generate git commit messages using AI
+Project-URL: Bug Tracker, https://github.com/lguibr/commitai/issues
+Project-URL: Documentation, https://github.com/lguibr/commitai/blob/main/README.md
+Project-URL: Source Code, https://github.com/lguibr/commitai
+Author-email: Luis Guilherme <lgpelin92@gmail.com>
+License: # File: LICENSE
+        MIT License
+        
+        Copyright (c) 2024 Luis Guilherme
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Requires-Dist: click<9.0,>=8.0
+Requires-Dist: langchain-anthropic<=0.3.12,>=0.1.0
+Requires-Dist: langchain-community<=0.3.23,>=0.0.20
+Requires-Dist: langchain-core<=0.3.58,>=0.1.0
+Requires-Dist: langchain-google-genai~=2.1.4
+Requires-Dist: langchain-ollama~=0.3.2
+Requires-Dist: langchain-openai<=0.3.16,>=0.1.0
+Requires-Dist: langchain<=0.3.25,>=0.1.0
+Requires-Dist: pydantic<3.0,>=2.0
+Provides-Extra: test
+Requires-Dist: langchain-google-genai~=2.1.4; extra == 'test'
+Requires-Dist: mypy>=1.9.0; extra == 'test'
+Requires-Dist: pytest-cov>=3.0; extra == 'test'
+Requires-Dist: pytest>=7.0; extra == 'test'
+Requires-Dist: ruff==0.4.4; extra == 'test'
+Requires-Dist: types-setuptools; extra == 'test'
+Description-Content-Type: text/markdown
+
+# CommitAi - Your AI-Powered Commit Assistant
+
+[![CI and Publish](https://github.com/lguibr/commitai/actions/workflows/main.yml/badge.svg)](https://github.com/lguibr/commitai/actions/workflows/main.yml)
+[![codecov](https://codecov.io/gh/lguibr/commitai/graph/badge.svg?token=MXZKCXO6LA)](https://codecov.io/gh/lguibr/commitai) <!-- Added Codecov Badge -->
+[![PyPI](https://img.shields.io/pypi/v/CommitAi.svg)](https://pypi.org/project/CommitAi/)
+[![Python Version](https://img.shields.io/pypi/pyversions/CommitAi.svg)](https://pypi.org/project/CommitAi/)
+[![License](https://img.shields.io/pypi/l/CommitAi.svg)](https://github.com/lguibr/CommitAi/blob/main/LICENSE)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+
+<img
+  src="https://raw.githubusercontent.com/lguibr/commitai/main/bitmap.png"
+  alt="screenshot"
+  width="400"
+/>
+
+
+**Tired of writing Git commit messages? Let AI do the heavy lifting!**
+
+**CommitAi** streamlines your Git workflow by leveraging powerful AI models (OpenAI's GPT, Anthropic's Claude, Google's Gemini) to automatically generate clear, concise, and conventional commit messages based on your staged changes.
+
+Simply stage your files and run `commitai`. It analyzes the diff, optionally takes your high-level explanation, and crafts a commit message adhering to the [Conventional Commits](https://www.conventionalcommits.org/) standard. Review the message in your default Git editor, make any tweaks, save, and you're done!
+
+## Table of Contents
+
+- [CommitAi - Your AI-Powered Commit Assistant](#commitai---your-ai-powered-commit-assistant)
+  - [Table of Contents](#table-of-contents)
+  - [Features](#features)
+  - [Demo](#demo)
+  - [Installation](#installation)
+  - [Configuration](#configuration)
+    - [API Keys](#api-keys)
+    - [Commit Templates (Optional)](#commit-templates-optional)
+  - [Usage](#usage)
+    - [Basic Workflow](#basic-workflow)
+    - [Command-Line Options](#command-line-options)
+    - [Creating Repository Templates](#creating-repository-templates)
+  - [Examples](#examples)
+  - [Contributing](#contributing)
+  - [License](#license)
+
+## Features
+
+*   🧠 **Intelligent Commit Generation**: Analyzes staged code differences (`git diff --staged`) using state-of-the-art AI models (GPT, Claude, Gemini) to create meaningful commit messages.
+*   📄 **Conventional Commits**: Automatically formats messages according to the Conventional Commits specification (e.g., `feat(auth): add JWT authentication`). This improves readability and enables automated changelog generation.
+*   📝 **Optional Explanations**: Provide a high-level description of your changes as input to guide the AI, or let it infer the context solely from the code diff.
+*   ✅ **Pre-commit Hook Integration**: Automatically runs your existing native Git pre-commit hook (`.git/hooks/pre-commit`) before generating the message, ensuring code quality and style checks pass.
+*   🔧 **Customizable Prompts via Templates**: Add custom instructions or context to the AI prompt using global environment variables or repository-specific template files.
+*   🤖 **Multiple AI Provider Support**: Choose your preferred AI model from OpenAI, Anthropic, Google or local AI models with Ollama.
+*   ⚙️ **Flexible Workflow**:
+    *   Stages all changes automatically (`-a` flag).
+    *   Reviews message in your default Git editor (default behavior).
+    *   Commits directly without editor review (`-c` flag).
+*   ✨ **Modern Tooling**: Built with `pyproject.toml` and formatted/linted with `ruff`.
+
+## Demo
+
+![CommitAi Demo](./assets/commitaai.gif)
+
+*(Demo shows generating a commit message using Claude 3 Opus without providing an explicit explanation)*
+
+## Installation
+
+Ensure you have Python 3.8+ and Git installed.
+
+Install **CommitAi** directly from PyPI:
+
+```bash
+pip install commitai
+```
+
+## Configuration
+
+### API Keys
+
+CommitAi requires API keys for the AI provider you intend to use. Set these as environment variables:
+
+*   **OpenAI (GPT models):**
+    ```bash
+    export OPENAI_API_KEY="your_openai_api_key_here"
+    ```
+
+*   **Anthropic (Claude models):**
+    ```bash
+    export ANTHROPIC_API_KEY="your_anthropic_api_key_here"
+    ```
+
+*   **Google (Gemini models):**
+    Set **one** of the following (CommitAi checks in this priority order):
+    1.  `GOOGLE_API_KEY` (Recommended)
+    2.  `GEMINI_API_KEY`
+    3.  `GOOGLE_GENERATIVE_AI_API_KEY`
+
+    Example:
+    ```bash
+    export GOOGLE_API_KEY="your_google_api_key_here"
+    ```
+
+You only need to set the key for the provider corresponding to the model you select (or the default, Gemini).
+
+### Ollama
+
+CommitAi can also work with Ollama models:
+```bash
+export OLLAMA_HOST="your_ollama_base_url"
+```
+
+
+### Commit Templates (Optional)
+
+You can add custom instructions to the default system prompt used by the AI. This is useful for enforcing project-specific guidelines (e.g., mentioning ticket numbers).
+
+*   **Global Template:** Set an environment variable. This applies to all repositories unless overridden locally.
+    ```bash
+    # Example: Always ask the AI to reference a JIRA ticket format
+    export TEMPLATE_COMMIT="Ensure the commit footer includes a JIRA reference like 'Refs: PROJECT-123'."
+    ```
+
+*   **Repository-Specific Template:** Use the `commitai-create-template` command within your repository. This creates a `.git/commit_template.txt` file and overrides the global `TEMPLATE_COMMIT` variable for this repo only.
+    ```bash
+    # Example: Instruct the AI to focus on UI changes for this specific repo
+    commitai-create-template "Focus the commit message body on user-facing UI changes."
+    ```
+
+**Note:** These templates *add* to the default system prompt, which already instructs the AI to follow Conventional Commits format. You are providing supplementary instructions.
+
+## Usage
+
+### Basic Workflow
+
+1.  **Make your code changes.**
+2.  **Stage the changes** you want to include in the commit:
+    ```bash
+    git add <file1> <file2> ...
+    # or stage all changes in tracked files
+    git add .
+    # or stage all changes including untracked files
+    git add --all
+    ```
+3.  **Run `commitai`:**
+    ```bash
+    # Option 1: Let CommitAi infer the message from the diff
+    commitai
+
+    # Option 2: Provide a high-level explanation to guide the AI
+    commitai "Refactor user authentication to use JWT tokens"
+    ```
+4.  **Review & Edit:** CommitAi runs pre-commit hooks, generates the message, and opens it in your default Git editor (e.g., Vim, Nano, VS Code). Review the message, make any necessary edits.
+5.  **Save & Close:** Save the file and close the editor. CommitAi will then create the commit with the final message. If you close without saving or clear the message, the commit will be aborted.
+
+### Command-Line Options
+
+The `commitai` command (which is an alias for `commitai generate`) accepts the following options:
+
+*   `-a`, `--add`:
+    *   Automatically stages *all* unstaged changes (`git add --all`) before generating the commit message.
+    *   Useful for quickly committing everything in the working directory.
+    *   Example: `commitai -a "Implement user profile page"`
+
+*   `-c`, `--commit`:
+    *   Skips opening the Git editor for review. The generated message is used to create the commit directly.
+    *   **Use with caution!** Reviewing AI-generated messages is recommended.
+    *   Example: `commitai -c "Fix typo in documentation"` (for minor changes)
+    *   Can be combined with `-a`: `commitai -a -c "Quick fix and commit all"`
+
+*   `-m <model_name>`, `--model <model_name>`:
+    *   Specifies which AI model to use.
+    *   Defaults to `gemini-2.5-pro-preview-03-25`.
+    *   Ensure the corresponding API key environment variable is set.
+    *   Examples:
+        *   `commitai -m gpt-4 "Use OpenAI's GPT-4"`
+        *   `commitai -m claude-3-opus-20240229 "Use Anthropic's Claude 3 Opus"`
+        *   `commitai -m gemini-2.5-flash-preview-04-17 "Use Google's Gemini 1.5 Flash"`
+
+### Creating Repository Templates
+
+The `commitai-create-template` command sets a repository-specific template instruction.
+
+```bash
+commitai-create-template "Add a 'Co-authored-by:' line if applicable."
+```
+
+This creates/overwrites the `.git/commit_template.txt` file in the current repository.
+
+## Examples
+
+**1. Simple commit, inferred message:**
+
+```bash
+# Stage changes
+git add src/utils.py tests/test_utils.py
+
+# Run commitai - AI infers message from diff
+commitai
+```
+*(Editor opens with a message like `feat(utils): add helper function for data validation`)*
+
+**2. Commit with explanation:**
+
+```bash
+# Stage changes
+git add src/auth.py
+
+# Run commitai with explanation
+commitai "Implement password reset functionality using email tokens"
+```
+*(Editor opens with a message like `feat(auth): implement password reset via email token`)*
+
+**3. Stage all and commit directly (no editor):**
+
+```bash
+# Stage all changes and commit immediately using GPT-4
+commitai -a -c -m gpt-4 "Minor refactoring and cleanup"
+```
+*(Commit is created directly)*
+
+**4. Using a Template:**
+
+*   First, set a template:
+    ```bash
+    commitai-create-template "Mention the related issue number from GitHub, e.g., Fixes #123."
+    ```
+*   Then, run commitai:
+    ```bash
+    git add src/parser.py
+    commitai "Fix bug in CSV parsing logic"
+    ```
+*(Editor opens with a message potentially like `fix(parser): correct handling of quoted commas\n\nFixes #123`)*
+
+## Contributing
+
+Contributions are highly welcome! Please follow these steps:
+
+1.  Fork the repository on GitHub.
+2.  Clone your fork locally: `git clone <your-fork-url>`
+3.  Navigate to the project directory: `cd commitai`
+4.  Create a virtual environment: `python -m venv .venv && source .venv/bin/activate` (or `.\.venv\Scripts\activate` on Windows)
+5.  Install dependencies, including development tools: `pip install -e ".[test]"`
+6.  **(Optional but Recommended)** Set up pre-commit hooks: `pre-commit install`
+7.  Create a new branch for your feature or bug fix: `git checkout -b my-feature-branch`
+8.  Make your changes.
+9.  Run checks locally before committing:
+    *   Format code: `ruff format .`
+    *   Lint code: `ruff check .`
+    *   Run type checks: `mypy commitai tests`
+    *   Run tests: `pytest`
+10. Commit your changes (you can use `commitai`!).
+11. Push your branch to your fork: `git push origin my-feature-branch`
+12. Open a pull request on the main `lguibr/commitai` repository.
+
+The CI pipeline will automatically run all checks on your pull request.
+
+## License
+
+**CommitAi** is open-source software licensed under the MIT License. See the [LICENSE](https://github.com/lguibr/CommitAi/blob/main/LICENSE) file for more details.

commitai-1.0.5.dist-info/RECORD

@@ -0,0 +1,9 @@
+commitai/__init__.py,sha256=Z5hB8NLKlfi7oPDRcDSQmtPSo_arLjoa6jwjFt3Pb9o,388
+commitai/cli.py,sha256=ClIF6hLekc4gRg9IAUDK9d-y4ee7kvJcZuTt9NCfFRg,9732
+commitai/git.py,sha256=XWAloZWQuLrFHUyfh3SkOgLsL4kfKRtgj3fzuJjcL2A,1649
+commitai/template.py,sha256=q4AO64hKhJP2y9DCc5-ePFoRZfOQBkbkB6vt8CnoMh8,1379
+commitai-1.0.5.dist-info/METADATA,sha256=_wO_IflHPj969OHjwzuQ-kCgV0DPgJ9ChPi8qPjBJPs,13710
+commitai-1.0.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+commitai-1.0.5.dist-info/entry_points.txt,sha256=qzWJQdPoR38mjQgRPRCB3tA7Kojtj3WrozlFWR4KhLY,128
+commitai-1.0.5.dist-info/licenses/LICENSE,sha256=wVkmSz0UMpGw0xYxk4AmkPLd_tVFcuszTdNIoq02tJA,1087
+commitai-1.0.5.dist-info/RECORD,,

{commitai-0.1.16.dist-info → commitai-1.0.5.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

{commitai-0.1.16.dist-info → commitai-1.0.5.dist-info}/entry_points.txt

@@ -1,3 +1,3 @@
 [console_scripts]
-commitai = commitai.cli:commitai
-commitai-create-template = commitai.cli:commitai_create_template
+commitai = commitai.cli:commitai_alias
+commitai-create-template = commitai.cli:commitai_create_template_alias

commitai-1.0.5.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+# File: LICENSE
+MIT License
+
+Copyright (c) 2024 Luis Guilherme
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

commitai-0.1.16.dist-info/METADATA

@@ -1,119 +0,0 @@
-Metadata-Version: 2.1
-Name: commitai
-Version: 0.1.16
-Summary: Commitai helps you generate git commit messages using AI
-Home-page: https://github.com/lguibr/commitai
-Author: Luis Guilherme
-Author-email: lgpelin92@gmail.com
-Project-URL: Bug Tracker, https://github.com/lguibr/commitai/issues
-Project-URL: Documentation, https://github.com/lguibr/commitai/blob/main/README.md
-Project-URL: Source Code, https://github.com/lguibr/commitai
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Requires-Dist: langchain
-Requires-Dist: click
-Requires-Dist: langchain-community
-Requires-Dist: langchain-anthropic
-Requires-Dist: langchain-openai
-Requires-Dist: setuptools
-
-# CommitAi - Your AI-Powered Commit Assistant
-
-[![CI](https://github.com/lguibr/commitai/workflows/CI/badge.svg)](https://github.com/lguibr/commitai/actions)
-[![codecov](https://codecov.io/gh/lguibr/commitai/graph/badge.svg?token=MXZKCXO6LA)](https://codecov.io/gh/lguibr/commitai)
-[![PyPI](https://img.shields.io/pypi/v/CommitAi.svg)](https://pypi.org/project/CommitAi/)
-[![Python Version](https://img.shields.io/pypi/pyversions/CommitAi.svg)](https://pypi.org/project/CommitAi/)
-[![License](https://img.shields.io/pypi/l/CommitAi.svg)](https://github.com/lguibr/CommitAi/blob/main/LICENSE)
-
-**CommitAi** simplifies the Git commit message creation process by leveraging AI technologies, including GPT-4 and Claude. Designed for developers who value clarity and precision in commit histories, **CommitAi** offers a streamlined workflow that transforms your staged changes and high-level explanations into informative commit messages. Enhance your project documentation and streamline your development process with commit messages that truly reflect your changes.
-
-## Demo
-
-![CommitAi Demo](./assets/commitaai.gif)
-
-This demo GIF shows CommitAi in action, demonstrating how it generates a commit without any additional input, using Claude 3 Opus.
-
-## Features
-
-- **Intelligent Commit Generation**: Leverages state-of-the-art AI models to generate meaningful commit messages from your changes.
-- **Pre-commit Checks**: Automatically runs configured pre-commit hooks to ensure quality and consistency before generating messages.
-- **Template Support**: Utilizes both global and repository-specific commit message templates to maintain a consistent style across your projects.
-- **AI Model Integration**: Supports multiple AI models, including GPT-4 by OpenAI and Claude by Anthropic, ensuring versatility in natural language processing capabilities.
-
-## Getting Started
-
-### Prerequisites
-
-- Python 3.6 or later
-- API keys for GPT-4 and Claude, as required
-
-### Installation
-
-Install **CommitAi** directly from PyPI:
-
-```bash
-pip install commitai
-```
-
-### Configuration
-
-#### API Keys
-
-Set the necessary API keys as environment variables:
-
-```bash
-export OPENAI_API_KEY="your_openai_api_key"
-export ANTHROPIC_API_KEY="your_anthropic_api_key"
-```
-
-#### Commit Templates
-
-Set a global commit template environment variable:
-
-```bash
-export TEMPLATE_COMMIT="My global custom template: {message}"
-```
-
-Or, create a repository-specific template using:
-
-```bash
-commitai-create-template "My repository-specific template: {message}"
-```
-
-This creates a hidden template file within the `.git` directory of your repository.
-
-## Usage
-
-To generate a commit message, provide a high-level explanation of your changes:
-
-```bash
-commitai "This is a high-level explanation of my commit"
-```
-
-#### Options
-
-- `-a, --add`: Stage all changes before generating the commit message.
-- `-c, --commit`: Automatically create the commit using the generated message.
-- `-t, --template`: Specify a commit template. Defaults to the global template if available.
-- `-m, --model`: Choose the AI model (`gpt-4` by default).
-
-### Additional Commands
-
-- `commitai-create-template`: Set a custom template specific to your repository.
-
-## Contributing
-
-Contributions are welcome! Feel free to fork the repository, push your changes to a branch, and open a pull request. For bugs, questions, or feature requests, please open an issue through the GitHub issue tracker.
-
-## License
-
-**CommitAi** is open-source software licensed under the MIT License. See the [LICENSE](https://github.com/lguibr/CommitAi/blob/main/LICENSE) file for more details.

commitai-0.1.16.dist-info/RECORD

@@ -1,9 +0,0 @@
-commitai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-commitai/cli.py,sha256=e6AxBnTBRW4yjl8lmzYBYWaVDdpZQ97UV3k81IvjLzY,4766
-commitai/git.py,sha256=XWAloZWQuLrFHUyfh3SkOgLsL4kfKRtgj3fzuJjcL2A,1649
-commitai/template.py,sha256=KlAhYUgea1rXpih6TyFeZ2rU8qN1H-VfZpMt7Wi8dZA,1137
-commitai-0.1.16.dist-info/METADATA,sha256=b4NT4tsnKlVFoyH3SrJyjeHG2ctwJdms7H9ngh2xvvM,4711
-commitai-0.1.16.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-commitai-0.1.16.dist-info/entry_points.txt,sha256=KS-RBWo8XGrU1a11k6FgRCIwjGq8X5Zs-OuY8ri9BYU,116
-commitai-0.1.16.dist-info/top_level.txt,sha256=X76OfoBOic7IkaMkIgobuZxsVlsmcY_WMtBrtXtfn_w,9
-commitai-0.1.16.dist-info/RECORD,,

commitai-0.1.16.dist-info/top_level.txt

@@ -1 +0,0 @@
-commitai