Generating Git Commits Messages

Managing commits is a crucial part of any development workflow, and combining the power of AI-generated messages with an efficient editor like Lunarvim can save you valuable time. In this guide, you’ll learn how to generate a commit message using Avante and execute a Git commit right from Lunarvim.

Overview

Avante is designed to help you integrate natural language generation into your coding workflow. With its provider setup (in our case using Deepseek), you can prompt it to generate text based on your needs. In this guide, we’ll focus on using Avante to create commit messages automatically. We will then configure Lunarvim to run a Git commit command with that generated message.

The basic workflow will be:

Generate a Commit Message: Trigger Avante to generate a commit message based on your changes.
Commit Your Changes: Automatically add and commit your project changes with the generated message.
Review and Iterate: Optionally, review the generated message before confirming the commit.

Prerequisites

Before proceeding, make sure:

You have Lunarvim set up with Avante (as seen in your provided configuration).
Git is installed and properly configured in your system.
Your project is already initialized as a Git repository.

Your current Lunarvim configuration already includes Avante among other plugins. We’re going to build on that and add a custom command to automate the commit process.

Configuring the Workflow

1. Avante Setup Recap

In your Lunarvim configuration, Avante is configured with the Deepseek provider. This ensures that you can generate text (commit messages in our case) using AI. Verify that you have the necessary API key and endpoint settings, as shown in your config snippet:

{
  "yetone/avante.nvim",
  event = "VeryLazy",
  lazy = false,
  version = false, -- update as needed
  opts = {
    provider = "deepseek",
    vendors = {
      deepseek = {
        __inherited_from = "openai",
        api_key_name = "DEEPSEEK_API_KEY",
        endpoint = "https://api.deepseek.com",
        model = "deepseek-coder",
      },
    },
  },
  build = "make BUILD_FROM_SOURCE=true",
  dependencies = { ... },
}

This setup allows you to use Avante’s functionalities within Lunarvim.

2. Creating a Custom Commit Command

We want to create a custom Lunarvim command—let’s call it :AvanteCommit—that does the following:

Step A: Uses Avante to generate a commit message.
Tip: You could prompt Avante with something like “Generate a concise Git commit message for the following changes: …”. How you pass context can be as simple as using a placeholder or even prompting the user for additional context.
Step B: Adds all changes and executes a Git commit with the generated message.

Here’s an example Lua function that you can add to your Lunarvim configuration. This example demonstrates the concept; you may wish to adapt it to trigger Avante’s text generation if you have a dedicated function or command for that:

-- Function to generate a commit message.
local function generate_commit_message()
  -- Replace this with your integration call to Avante's API.
  -- For demo purposes, we prompt the user to enter a prompt for Avante.
  local prompt = vim.fn.input("Enter context for commit message: ")
  
  -- Here you would normally call the Avante API with your prompt.
  -- For example, using a hypothetical function `avante.generate(prompt)`
  -- local commit_msg = avante.generate(prompt)
  -- For now, we'll simulate it:
  local commit_msg = "Auto-generated commit: " .. prompt
  return commit_msg
end
 
-- Function to add changes and commit using the generated message.
local function auto_commit()
  local commit_msg = generate_commit_message()
 
  -- Review the generated commit message
  local confirm = vim.fn.input("Commit message:\n" .. commit_msg .. "\nCommit changes? (y/n): ")
  if confirm:lower() ~= "y" then
    print("Commit cancelled")
    return
  end
 
  -- Run the Git add & commit command. Adjust the command as needed.
  os.execute("git add .")
  os.execute("git commit -m '" .. commit_msg .. "'")
  print("Changes committed with message: " .. commit_msg)
end
 
-- Create a custom command in Lunarvim
vim.api.nvim_create_user_command("AvanteCommit", auto_commit, { desc = "Generate commit message via Avante and commit changes" })

3. Integrating the Custom Command in Lunarvim

Place the above Lua code snippet somewhere in your Lunarvim configuration file (for example, in your config.lua or a dedicated Lua module that you load). This command will allow you to execute :AvanteCommit from within Lunarvim.

When you run the command:

You’ll be prompted for additional context (if desired) to help Avante generate a commit message.
A commit message is generated (in the example it is a concatenation, but you can replace it with an actual call to Avante’s generator).
You get a chance to review the commit message before confirming.
If confirmed, Lunarvim will add all changes and commit them using the generated message.

4. Fine-Tuning Your Workflow

Depending on your needs, consider the following enhancements:

Contextual Generation: Integrate Avante to analyze your changes (perhaps by reading Git diff output) to create a more accurate commit message.
Selective Commits: Modify the command to commit only specific files rather than all changes.
Error Handling: Expand the Lua function to handle potential errors (e.g., if Git is not initialized or if the commit fails).
Integration with Other Plugins: Combine this functionality with Git-related plugins such as vim-fugitive for a more feature-rich experience.

Erick Santana

Explorer