[Proposal] Automate Commit Messages with OpenAI

[sorcererxw]

I am a huge fan of lazygit and use it almost every day. I am wondering if there is any plans to integrate lazygit with OpenAI/ChatGPT for automatically generating commit messages? This would be a fantastic feature that could make lazygit even lazier!

My idea for implementing this feature would be:
1.Set the OpenAI token in the lazygit config file.
2.lazygit would read the stashed files and request OpenAI to generate a commit message.
3.If the commit textarea is empty, display the generated commit message in the commit textarea with dimmed hint text.
4.Press TAB to use the generated commit message.

If there hasn’t been any progress on this front, I would be honored to offer my help.

[mark2185]

This sounds like a perfect use case for a custom command, not really something that needs to be integrated into lazygit :)

[jesseduffield]

I'm open to the idea of integrating it into lazygit if it's really good. To be clear, a good commit message has a summary of what's changing along with a description of why the change is being made and additional context you can't get from just looking at the diff. So GPT is only going to be able to help with the summary line, and the question is whether it can reliably produce a summary line that would be what the developer themselves would have come up with if they gave sufficient thought.

I'm not actually sure how reliable GPT is at doing that. Have people elsewhere used a tool that generated commit messages based on diffs and found the results were good? All I'm seeing about such tools on hacker news is derision about the idea itself, but I haven't seen much from people who actually use it (correctly) and like it.

[zhangddjs]

what's going on about this issue, is it possible for integrate automate commit messages? it looks like fugitive.nvim plugin already integrated. Looking forward to the integrate of lazygit and openai haha

[sangdth]

Recently I try the GitButler and to be honest, I addicted to the autogenerate commit messages. There are many cases that we do not need it to be fine tuned, so I would love to see this feature in lazygit too. Because, well, it's for lazy people, right?

https://gitbutler.com/

[Chaitanya-Shahare]

I would love to have this feature in lazygit. After I used it in GitButler, it has raised my expectations from a git client.

[deepanchal]

#3212 (comment)

https://github.com/chhoumann/bunnai

[deepanchal]

Here's my custom command with aichat (https://github.com/sigoden/aichat) using modified template from https://github.com/chhoumann/bunnai/blob/af4b78efa24dce6940bb6576ad3f9f579f995111/src/template.ts

customCommands:
  - key: <c-a>
    description: Pick AI commit
    command: |
      aichat "Please suggest 10 commit messages, given the following diff:

        \`\`\`diff
        $(git diff --cached)
        \`\`\`

        **Criteria:**

        1. **Format:** Each commit message must follow the conventional commits format,
        which is \`<type>(<scope>): <description>\`.
        2. **Relevance:** Avoid mentioning a module name unless it's directly relevant
        to the change.
        3. **Enumeration:** List the commit messages from 1 to 10.
        4. **Clarity and Conciseness:** Each message should clearly and concisely convey
        the change made.

        **Commit Message Examples:**

        - fix(app): add password regex pattern
        - test(unit): add new test cases
        - style: remove unused imports
        - refactor(pages): extract common code to \`utils/wait.ts\`

        **Recent Commits on Repo for Reference:**

        \`\`\`
        $(git log -n 10 --pretty=format:'%h %s')
        \`\`\`

        **Output Template**

        Follow this output template and ONLY output raw commit messages without spacing,
        numbers or other decorations.

        fix(app): add password regex pattern
        test(unit): add new test cases
        style: remove unused imports
        refactor(pages): extract common code to \`utils/wait.ts\`

        **Instructions:**

        - Take a moment to understand the changes made in the diff.

        - Think about the impact of these changes on the project (e.g., bug fixes, new
        features, performance improvements, code refactoring, documentation updates).
        It's critical to my career you abstract the changes to a higher level and not
        just describe the code changes.

        - Generate commit messages that accurately describe these changes, ensuring they
        are helpful to someone reading the project's history.

        - Remember, a well-crafted commit message can significantly aid in the maintenance
        and understanding of the project over time.

        - If multiple changes are present, make sure you capture them all in each commit
        message.

        Keep in mind you will suggest 10 commit messages. Only 1 will be used. It's
        better to push yourself (esp to synthesize to a higher level) and maybe wrong
        about some of the 10 commits because only one needs to be good. I'm looking
        for your best commit, not the best average commit. It's better to cover more
        scenarios than include a lot of overlap.

        Write your 10 commit messages below in the format shown in Output Template section above." \
          | fzf --height 40% --border --ansi --preview "echo {}" --preview-window=up:wrap \
          | xargs -I {} bash -c '
              COMMIT_MSG_FILE=$(mktemp)
              echo "{}" > "$COMMIT_MSG_FILE"
              ${EDITOR:-vim} "$COMMIT_MSG_FILE"
              if [ -s "$COMMIT_MSG_FILE" ]; then
                  git commit -F "$COMMIT_MSG_FILE"
              else
                  echo "Commit message is empty, commit aborted."
              fi
              rm -f "$COMMIT_MSG_FILE"'
    context: files
    subprocess: true

For nix users: https://github.com/deepanchal/nixos/blob/49c9e33d5ffbe5b8f2be67b4fa658acd9ccc2f20/home/features/terminal/programs/lazygit.nix#L76-L141

Usage:

Trigger with Ctrl + A after staging files in lazygit

[tfriedel]

@deepanchal Thanks for this!
I modified it for my purpose a bit. For example it generates also a body for the commit message that is then previewed.
Here's my version:
https://github.com/tfriedel/commit-oracle

[tamas-torjek]

Hi, really don't want to spam, but I'll try my luck and leave this here as well: #3212 (my comment)

My main problem is that as far as I can see, every solution use a fixed (or a number of fixed) commit message.
What I want to achieve is a single editable commit summary AND description, same as the default commit dialog, but pre-populated from the command.

Or... is it possible to run the prepare-commit-msg hook (or another hook?) with some kind of loading indicator and populate it with the resulting commit message file's content? I have the hook set up, it works great, but I need to specifically open the editor (ctrl-o then e) to trigger it, so it's a bit inconvenient 😄

[pbek]

I tried using https://github.com/zurawiki/gptcommit to create a commit message (they are using a prepare-commit-msg git hook) and it worked when using git commit. But lazygit seems to ignore the prepare-commit-msg git hook. 🤔

[codevogel]

I felt the exact same. I got inspired after @deepanchal 's reply here, but felt it was missing some things, like easier prompt customization, and human confirmation.

That's why I built commit for me!
It generates some candidates, and then opens the commit message in your $EDITOR for review.
If you then save the file, you commit. If you leave it untouched or empty, you abort.

Demo:

Lazygit use demo:

It's a simple bash script that you can use standalone, or with lazygit integration using this custom command:

customCommands:
  - key: "<c-a>"
    description: "generate message candidates and commit using cfme"
    command: "cfme"
    context: "files"
    loadingText: "Generating commit message with cfme..."
    subprocess: true

It uses the conventional-commits standard by default (see the prompt here), but it's also VERY easy to customize to your own needs:

You just write a prompt file in markdown using template strings <__IN_THIS_FORMAT__>, and supply a variables file in YAML, which swaps out the template strings from A) literal string values from your YAML file, or B) command (sequences) defined in your YAML file.

For example, the simplest promp file could look like this:

Generate a commit message for the following changes:
<__GIT_DIFF__>
<__RESPONSE__REQUIREMENTS__>

or a more complex prompt file:

You are an expert software developer who writes clear and concise commit messages.
Your task is to generate a commit message based on the following instructions,
if present:
<__INSTRUCTIONS__>
The commit message should follow these guidelines:
<__COMMIT_MESSAGE_GUIDELINES__>
Here are the changes that need to be committed:
<__GIT_DIFF__>
Generate <__NUM_COMMIT_MESSAGES__> commit message candidates that adheres to the
above guidelines.
Here are the test results for the changes:
<__TEST_RESULTS__>
<__RESPONSE__REQUIREMENTS__>

With corresponding variable file:

vars:
  - template_string: "<__COMMIT_MESSAGE_GUIDELINES__>"
    value: |
      - Use the imperative mood in the subject line.
      - Limit the subject line to 50 characters.
      - Wrap the body at 72 characters.
      - Use the body to explain what and why vs. how.
  - template_string: "<__NUM_COMMIT_MESSAGES__>"
    value: "3"
  - template_string: "<__TEST_RESULTS__>"
    value_from: "pnpm test:unit --reporter=summary"