Streamline Code Commits: AI-Powered Git Message Generation

In today's fast-paced software development landscape, streamlining processes is key to maximizing productivity. One often overlooked aspect is the creation of Git commit messages. Clear, concise, and informative commit messages are crucial for code maintainability and collaboration. This article delves into the world of AI-powered Git commit message generation, focusing on tools and techniques that leverage large language models to automate and enhance this critical task.

The Challenge of Writing Effective Commit Messages

Crafting effective Git commit messages can be surprisingly time-consuming. Developers often struggle to articulate the purpose and impact of their code changes in a succinct and understandable manner. This can lead to commit histories that are difficult to navigate and understand, hindering collaboration and code maintainability. Incomplete or vague commit messages make it harder to understand the evolution of the codebase, creating a challenge for developers who might need to debug old issues or understand why certain decisions were made.

A well-crafted commit message should answer these key questions:

• What problem does this commit address?
• What changes were made to resolve the problem?
• What is the impact of these changes on the overall system?

Traditional methods of writing commit messages often involve manual effort and can be prone to inconsistencies. This is where AI-powered solutions come in, offering a way to automate and improve the process.

The Power of Large Language Models in Code Analysis

Large Language Models (LLMs) have demonstrated remarkable capabilities in understanding and generating human-like text. These models can be trained on vast amounts of code and documentation, enabling them to analyze code changes and automatically generate Meaningful commit messages. By leveraging LLMs, developers can free up their time to focus on coding, while ensuring that their commit messages are comprehensive and insightful.

LLMs can analyze the diff output of Git, which highlights the exact changes made to the code. This allows the AI to understand the modifications and generate commit messages that accurately reflect the changes. The large models can understand relationships between different parts of the code and what those changes imply.

Key Benefits of Using LLMs for Commit Messages:

• Increased Efficiency: Automates the process of writing commit messages, saving developers time and effort.
• Improved Consistency: Ensures that commit messages adhere to a consistent style and level of detail.
• Enhanced Clarity: Generates commit messages that are clear, concise, and easy to understand.
• Better Code Maintainability: Facilitates easier navigation and understanding of commit histories.

AI-Commit: A Command-Line Application for Offline Commit Message Generation

Many cloud-Based ai tools exist, but sometimes offline functionality is desired. AI-Commit provides a command-line interface (CLI) application leverages local large language models to generate commit messages offline. This means developers don't need an internet connection and don't need to be concerned with privacy implications of sending local changes to a 3rd party.

AI-Commit works by analyzing the staged changes in a Git repository and then using this information to provide instructions to the LLM. It can be run from your local machine, directly from the command line.

Currently, AI-Commit has the following core functionality:

• Git Repository Verification
• Clear Command Line Interface.
• Commit command generation.

The 'run_command' Function

def run_command(command: list[str] | str):
    try:
        result = subprocess.run(
            command,
            capture_output=True,
            text=True,
            check=True,
            timeout=10,
        )
        return result.stdout
    except subprocess.CalledProcessError as e:
        print(f"
Error: {e.stderr=}")
        sys.exit(1)

This function

is a core component, responsible for executing commands directly on the system's command line. It utilizes Python’s subprocess module to run external processes, capture their output, and manage potential errors.

This function’s parameters are:

• command (list[str] | str): Specifies the command to be executed, either as a list of strings (suitable for commands with multiple arguments) or as a single STRING.

The code handles error gracefully in a try...except block.

• The function then attempts to execute the given command using subprocess.run(). Several arguments are passed:
  • capture_output=True : This captures the standard output and standard error streams of the command.
  • text=True: Opens the files in text mode, the stdout and stderr streams will be strings, and encoding is handled transparently
  • check=True: If the process exits with a non-zero exit code, a CalledProcessError will be raised.
  • timeout=10: Limits the execution time of the command to 10 seconds. If the command takes longer, a TimeoutExpired exception is raised. This prevents commands from running indefinitely and hanging the application.

Command definitions

commands = {
    "is_git_repo": ["git", "rev-parse", "--is-inside-work-tree"],
    "clear_screen": ["cls"] if os.name == "nt" else ["clear"],
    "commit": ["git", "commit", "-m"],
    "get_stashed_changes": ["git", "diff", "--cached"],
}

This dictionary

stores crucial commands used throughout the AI-Commit application. By defining these commands in a centralized location, the application can easily execute them via the run_command function and adapt to different operating systems, ensuring maximum portability and flexibility.

The various commands are:

• is_git_repo: Determines whether the current directory is part of a valid Git repository. It leverages git rev-parse --is-inside-work-tree, which checks if the directory is within a Git working tree.
• clear_screen: Provides a cross-platform way to clear the terminal screen. Depending on the operating system (os.name), it uses either cls (for Windows, denoted by 'nt') or clear (for Unix-like systems).
• commit: Formats the Git commit command. It uses git commit -m, where -m specifies that the commit message will be provided directly on the command line.
• get_stashed_changes: Retrieves the differences between the staged changes and the last commit, providing input to the LLM to understand what modifications have been made. It uses git diff --cached, which shows the changes that are staged for the next commit.

LLM System Prompts

system_prompt = """
You are an expert AI commit message generator specialized in creating concise, informative commit messages that follow best practices in version control.

Your ONLY task is to generate a well-structured commit message based on the provided diff. The commit message must:
1.  Use a clear, descriptive title in the imperative mood (50 characters max)
2.  Provide a detailed explanation of changes in bullet points
3.  Focus solely on the technical changes in the code
4.  Use present tense and be specific about modifications

Key Guidelines:
-   Analyze the entire diff comprehensively
-   Capture the essence of only MAJOR changes
-   Use technical, precise languages
-   Avoid generic or vague descriptions
-   Avoid quoting any word or sentences
-   Avoid adding description for minor changes with not much context
-   Return just the commit message, no additional text
-   Don't return more bullet points than required
-   Generate a single commit message

Output Format:
Concise Title Summarizing Changes

-   Specific change description
-   Another specific change description
-   Rationale for key modifications
-   Impact of changes
"""

This system Prompt

serves as the core set of instructions provided to the language model, guiding it on how to generate the commit messages. This is where key instructions and best practices are outlined to ensure the quality and usefulness of the generated messages.

This prompt defines the AI assistant’s role as an expert in generating commit messages. It emphasizes conciseness and adherence to version control best practices, setting the tone and direction for how the AI should approach the task.

Install Build Tools

To successfully build your project into a command-line application, it is essential to install the required build tools. This ensures that your Python environment is equipped to Package and distribute your application effectively. To do so, run the following command:

pip install wheel build setuptools

Configure 'pyproject.toml'

1. Navigate to the root directory of your Python project. This is where your main application code resides and where you plan to create the pyproject.toml file.
2. Create the pyproject.toml file: If it doesn’t already exist, create a new file named pyproject.toml in the root of your project. You can typically do this using your IDE or text editor.
3. Add basic build system requirements: Open the pyproject.toml file and add the following to define that you are building with setuptools and which version you need.

[build-system]
requires = ["setuptools >= 61.0"]
build-backend = "setuptools.build_meta"

4. Define the 'AI-Commit' Command: In a new line, specify the name of your command-line application. This command is what you’ll use to run your application from the terminal.

[project.scripts]
ai-commit = "ai_commit.app:run"

• ai-commit: Is the command itself.
• ai_commit.app: The app.py is the main file
• run: Is the actual method inside of the app.py

Build and Run the Application

python -m build

Run this command from the root directory to produce the wheel and distribution archives. Now install it to your machine. Your file name in this directory will be different.

pip install dist/ai_commit-0.0.1-py3-none-any.whl

After all of this, you are now ready to run the program in the command line. Run the command ai-commit.

Local LLM Usage

Using AI-Commit with Ollama and local LLMs is entirely free after the initial setup of downloading the model. There are no subscription fees or usage-based costs. The only cost is the initial price to purchase the PC.

Automatic Commit Message Generation

AI-Commit automatically generates commit messages by analyzing the staged changes using Git diff, saving developers time and increasing efficiency.

Offline Functionality

Leverages local large language models for commit message generation, ensuring privacy and enabling usage without an internet connection.

Interactive Mode

The tool prompts users to confirm or regenerate the commit message, allowing for iterative refinement and ensuring the message accurately reflects the changes.

Git Repository Validation

Ensures that the tool is run within a valid Git repository before proceeding, preventing errors and ensuring the correct context for generating commit messages.

Streamlining Individual Workflows

For solo developers, AI-Commit can automate the tedious process of writing commit messages, ensuring consistency and helping maintain a clear and informative commit history.

Enhancing Team Collaboration

In team environments, AI-Commit promotes a uniform standard for commit messages, facilitating easier code review and collaboration by ensuring that all team members provide clear, concise descriptions of their changes.

Improving Codebase Maintainability

AI-Commit can help maintain a well-documented codebase, making it easier for developers to understand the purpose and impact of changes, which is particularly valuable for long-term projects and large codebases.