Choose your language / Escolha o idioma:

• 🇺🇸 English
• 🇧🇷 Português

Gitai is a Python project that serves as an automation tool for managing Git commits. It is designed to analyze projects written in various programming languages, including Node.js, Python, Java, Go, and PHP.

The application analyzes the changes made in a project, identifies the programming language used, and based on that, generates a detailed commit message following the Conventional Commits standard. This standard is widely adopted to make commit messages more descriptive and useful.

Additionally, Gitai automates the commit process by adding all changes to the Git staging area, committing with the generated message, and optionally pushing the changes to the remote repository.

For generating the commit message, you can choose between the advanced language models from OpenAI or Groq.

The project also uses the libraries openai, groq, python-dotenv, and pyinstaller to create an executable that includes the dependencies of the virtual environment and reads environment variables from a .env file located in the same folder as the executable.

Click the image below to watch the video tutorial about Gitai:

After generating the .pkg file, you can follow the steps below to install the application on your Mac:

1. Navigate to the location where the .pkg file was saved.
2. Double-click the .pkg file to launch the installer.
3. Follow the on-screen instructions to install the application. You may be required to enter your administrator password.
4. After installation, the application will be available in your Applications directory.

Remember that after installation, you must configure the .env file with the necessary environment variables for the application to function correctly.

Gitai supports three AI providers for generating commit messages: OpenAI, Groq, and Anthropic.

Each has its own characteristics, costs, and usage limits.

All providers are highly capable, but your choice may depend on your specific needs and available budget.

If you need high processing power and can cover the costs, OpenAI is an excellent option. If you prefer a free service and can manage within usage limits, Groq is a viable alternative. For advanced reasoning and large context windows, Anthropic Claude offers cutting-edge capabilities.

Below is detailed information about each provider to help you choose the best one for your needs.

OpenAI is a paid service that offers advanced language models.

The most efficient available model is gpt-4o, which has a context window of 128K tokens.

• Cost:
  • $2.50 per 1M tokens for Input
  • $10.00 per 1M tokens for Output
• Website: OpenAI

Groq is a free service, but with usage limits.

The recommended model is mixtral-8x7b-32768, which offers a context window of 32,768 tokens.

• Usage Limits:
  • Requests per Minute: 30
  • Requests per Day: 14,400
  • Tokens per Minute: 5,000
• Website: Groq

Anthropic is a paid service that offers advanced AI models with excellent reasoning capabilities.

The recommended model is claude-3-5-sonnet-20241022, which has a context window of 200K tokens.

• Cost:
  • $3.00 per 1M tokens for Input
  • $15.00 per 1M tokens for Output
• Features: Advanced reasoning, large context window, excellent code understanding
• Website: Anthropic

Before running the application, you need to configure the .env file in the dist folder or in the folder where Gitai was installed. This file contains the environment variables required for the application to function correctly.

You can choose to use OpenAI, Groq, or Anthropic providers.

Open the .env file in a text editor and fill in the environment variables.

PROVIDER=openai
API_KEY=your_openai_api_key
MODEL=gpt-4o
LANGUAGE=en

PROVIDER=groq
API_KEY=your_groq_api_key
MODEL=mixtral-8x7b-32768
LANGUAGE=en

PROVIDER=anthropic
API_KEY=your_anthropic_api_key
MODEL=claude-3-5-sonnet-20241022
LANGUAGE=en

To make the application available in the terminal, you need to add the application directory to your system's PATH. The PATH is an environment variable that specifies a list of directories where executable commands are searched for.

You can add the application's directory to the PATH by appending the following line to your .bash_profile or .zshrc file (depending on the shell you are using) in your home directory:

export PATH="$PATH:/Applications/Gitai/"

After adding this line, you need to execute the source command to load the changes:

source ~/.bash_profile  # If you are using bash
source ~/.zshrc  # If you are using zsh

Now, you should be able to run the application from the terminal.

After installing and configuring Gitai, you can start using it to automatically generate commit messages for your project.

To use Gitai, open the terminal in your project's root directory. This is important because Gitai needs access to your project's files to analyze the changes and generate commit messages.

Once the terminal is open in your project's root, you can run Gitai with the following command:

gitai <project_path> '<generic_message>'

Replace <project_path> with the path to your project's directory and <generic_message> with a basic description of the change you made in the project.

For example, if you have the terminal open in your project's root and the change was to add a new feature, you can simply type:

gitai . 'Added new feature'

If you wish to analyze only a specific folder or a project in another directory, for example, if you made a change in your project located at /Users/username/MyProject, you can run Gitai with the following command:

gitai /Users/username/MyProject 'Added new feature'

To automatically generate the commit and push it, you can add the --push flag to the command:

gitai . 'Added new feature' --push

The releaser.py script is used to generate release notes for any Git project. It analyzes the commits made since the last tag and generates a detailed release document.

For detailed instructions on how to use the releaser.py script, please refer to the RELEASER.md document.

• Python 3.7 or higher
• pip (Python package manager)
• git

1. Clone the repository to your local machine using git clone.

   git clone <repository-url>

2. Navigate to the project directory.

   cd <project-name>

3. Install the project dependencies.

   pip install -r requirements.txt

To build the project, run the build.sh script in the root of the project.

./build.sh

This script will generate an executable of the Python script using PyInstaller called gitai and will copy the .env.example file to the dist folder.

If you want to generate an executable for a specific platform, you can use the following commands:

To generate an installer for Windows, you need to use the Inno Setup tool.

1. Visit the official Inno Setup website at http://www.jrsoftware.org/isinfo.php.
2. Click on the "Download" link on the page.
3. Download the latest version of Inno Setup.
4. After downloading the .exe file, open it.
5. Follow the on-screen instructions to install Inno Setup.
6. After installation, Inno Setup should be available on your computer.
7. Open Inno Setup and click on "File" > "New" to create a new installation script.
8. Fill in your project details, such as name, version, and description.
9. Add the necessary files to the installer, including the executable generated by PyInstaller and the example .env file.
10. Configure the installation options, such as the installation directory and shortcuts.
11. Click on "Build" to generate the installer.
12. After building, you will have an .exe file that can be distributed and used to install your application on Windows.
13. Run the installer on the target computer to install the application.
14. After installation, the application will be available in the Start menu and in the installation directory.

To generate an installer for Linux, you need to use the Makeself tool.

1. Visit the official Makeself website at https://makeself.io/.

2. Click on the "Download" link on the page.

3. Download the latest version of Makeself.

4. After downloading the .run file, open it.

5. Follow the on-screen instructions to install Makeself.

6. After installation, Makeself should be available on your computer.

7. Open the terminal and navigate to the directory where the executable generated by PyInstaller is located.

8. Execute the following command to create the installer:

   makeself <source_directory> <installer_name> "<installer_description>" <installation_command>

   Replace <source_directory> with the directory where the executable is located, <installer_name> with the name of the installer file, <installer_description> with a description of the installer, and <installation_command> with an installation command.

   For example:

   makeself dist/ GitaiInstaller.run "Gitai Installer" "./gitai"

This will create a .run file that can be distributed and used to install your application on Linux.

To generate an installer for macOS, you need to use the Packages tool.

1. Visit the official Packages website at http://s.sudre.free.fr/Software/Packages/about.html.
2. Click on the "Download" link on the page.
3. After downloading the .dmg file, open it.
4. Drag the Packages icon to the Applications folder.

Now, Packages should be installed and ready to use on your Mac.

1. Open Packages and click on "New Project".
2. Select "Distribution" and click "Next".
3. Give your project a name and choose where to save it.
4. In the left panel, click on "Project" and fill in your project details.
5. In the left panel, click on "Settings" and configure the installation options.
6. In the left panel, click on "Scripts" and add a post-installation script that installs the necessary Python libraries.
7. In the left panel, click on "Payload" and add the executable and the example .env file to the installation directory.
8. In the "Build" menu, select "Build".

This will create a .pkg file that installs your application.

Gitai will analyze the changes made in your project, identify the programming language used, and based on that, generate a detailed commit message following the Conventional Commits standard. Then, it will add all changes to the Git staging area and commit with the generated message.

• Generate release for Mac
• Generate release for Windows
• Generate release for Linux
• Update the documentation to include installation instructions for Windows and Linux
• Add the possibility of using the GROQ API to generate commit messages
• Translate the documentation to English
• Translate prompts to English
• Add support for more programming languages
• Automatically add the executable binary to the PATH
• Add automated tests

We appreciate your interest in contributing to Gitai! Here are some guidelines to help you through the process:

1. Fork the Repository: Fork the Gitai repository to your GitHub account. This means you will have a copy of the repository in your own account, allowing you to make changes without affecting the original project.
2. Clone the Repository: Clone the repository to your local machine so that you can make changes.
3. Create a Branch: Create a new branch in your fork for your changes. This helps separate your changes from others that may be happening simultaneously.
4. Make Your Changes: Make the changes that you believe will improve the project. This can be adding a new feature, fixing a bug, or improving the documentation.
5. Test Your Changes: Ensure that your changes do not break anything and that the code still works as expected.
6. Submit a Pull Request: Submit a pull request to the original repository proposing your changes. Make sure to provide a detailed description of your changes so that the project maintainers can understand what you did and why.

We ask that all contributors follow our code of conduct. Mutual respect is essential for a healthy collaborative environment. Please be professional and respectful to all contributors.

If you have any questions or issues, please open an issue. We will do our best to help you.

If you wish to contact the project maintainers, please send an email to: [email protected]

Thank you for your interest in our project. We look forward to your contributions!

Leandro Silva Ferreira

• GitHub: @leandrosilvaferreira
• Twitter: @leandrosfer
• Email: [email protected]
• LinkedIn: Leandro Ferreira

Thanks to these amazing contributors

This project is licensed under the MIT License. This means you are free to copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the software, provided that you give appropriate credit to the original author and reproduce the license in all copies or substantial portions of the software.

For more details, see the LICENSE file in the repository.

Gitai é um projeto Python que serve como uma ferramenta de automação para gerenciamento de commits no Git. Ele é projetado para analisar projetos escritos em várias linguagens de programação, incluindo Node.js, Python, Java, Go e PHP.

A aplicação analisa as alterações feitas em um projeto, identifica a linguagem de programação usada e, com base nisso, gera uma mensagem de commit detalhada seguindo o padrão Conventional Commits. Este padrão é amplamente adotado para tornar as mensagens de commit mais descritivas e úteis.

Além disso, Gitai automatiza o processo de commit, adicionando todas as alterações ao índice do Git, realizando o commit com a mensagem gerada e, opcionalmente, fazendo push das alterações para o repositório remoto.

Para a geração da mensagem de commit, é possível escolher entre os modelos de linguagem avançados da OpenAI ou Groq.

O projeto também utiliza as bibliotecas openai, groq, python-dotenv e pyinstaller para criar um executável que inclui as dependências do ambiente virtual e que lê as variáveis de ambiente de um arquivo .env na mesma pasta que o executável.

Clique na imagem abaixo para assistir ao tutorial em vídeo sobre o Gitai:

Depois de gerar o arquivo .pkg, você pode seguir os passos abaixo para instalar a aplicação no seu Mac:

1. Navegue até o local onde o arquivo .pkg foi salvo.
2. Dê um duplo clique no arquivo .pkg para iniciar o instalador.
3. Siga as instruções na tela para instalar a aplicação. Você pode precisar inserir sua senha de administrador.
4. Após a instalação, a aplicação estará disponível no seu diretório de Aplicativos.

Lembre-se de que, após a instalação, você deve configurar o arquivo .env com as variáveis de ambiente necessárias para a aplicação funcionar corretamente.

O Gitai oferece suporte a três provedores de IA para gerar mensagens de commit: OpenAI, Groq e Anthropic.

Cada um tem suas características, custos e limites de utilização.

Todos os provedores são altamente capazes, mas sua escolha pode depender de suas necessidades específicas e do orçamento disponível.

Se você precisa de uma grande capacidade de processamento e pode arcar com os custos, OpenAI é uma excelente opção. Se você prefere um serviço sem custo e pode gerenciar dentro dos limites de utilização, Groq é uma alternativa viável. Para raciocínio avançado e grandes janelas de contexto, Anthropic Claude oferece capacidades de ponta.

Abaixo estão as informações detalhadas sobre cada provedor para ajudá-lo a escolher o melhor para suas necessidades.

OpenAI é um serviço pago que oferece modelos de linguagem avançados.

O modelo mais eficiente disponível é o gpt-4o, que tem uma janela de contexto de 128K tokens.

• Custo:
  • $2.50 por 1M tokens para Input
  • $10.00 por 1M tokens para Output
• Site: OpenAI

Groq é um serviço gratuito, mas com limites de utilização.

O modelo recomendado é o mixtral-8x7b-32768, que oferece uma janela de contexto de 32,768 tokens.

• Limites de Utilização:
  • Requests por Minuto: 30
  • Requests por Dia: 14,400
  • Tokens por Minuto: 5,000
• Site: Groq

Anthropic é um serviço pago que oferece modelos de IA avançados com excelentes capacidades de raciocínio.

O modelo recomendado é o claude-3-5-sonnet-20241022, que tem uma janela de contexto de 200K tokens.

• Custo:
  • $3.00 por 1M tokens para Input
  • $15.00 por 1M tokens para Output
• Características: Raciocínio avançado, grande janela de contexto, excelente compreensão de código
• Site: Anthropic

Antes de executar o aplicativo, você precisa configurar o arquivo .env na pasta dist ou na pasta onde o GITAI foi instalado. Este arquivo contém as variáveis de ambiente que o aplicativo precisa para funcionar corretamente.

Você pode escolher entre usar o provedor OpenAI, Groq ou Anthropic.

Abra o arquivo .env em um editor de texto e preencha as variáveis de ambiente.

PROVIDER=openai
API_KEY=your_openai_api_key
MODEL=gpt-4o
LANGUAGE=en

PROVIDER=groq
API_KEY=your_groq_api_key
MODEL=mixtral-8x7b-32768
LANGUAGE=en

PROVIDER=anthropic
API_KEY=your_anthropic_api_key
MODEL=claude-3-5-sonnet-20241022
LANGUAGE=en

Para tornar o aplicativo disponível no terminal, você precisa adicionar o diretório do aplicativo ao PATH do sistema. O PATH é uma variável de ambiente que especifica uma lista de diretórios onde os comandos executáveis são procurados.

Você pode adicionar o diretório do aplicativo ao PATH adicionando a seguinte linha ao arquivo .bash_profile ou .zshrc (dependendo do shell que você está usando) no diretório inicial do usuário:

export PATH="$PATH:/Applications/Gitai/"

Depois de adicionar essa linha, você precisa executar o comando source para carregar as alterações:

source ~/.bash_profile  # Se você estiver usando bash
source ~/.zshrc  # Se você estiver usando zsh

Agora, você deve ser capaz de executar o aplicativo a partir do terminal.

Depois de instalar e configurar o Gitai, você pode começar a usá-lo para gerar mensagens de commit automaticamente para o seu projeto.

Para usar o Gitai, você precisa abrir o terminal na raiz do seu projeto. Isso é importante porque o Gitai precisa ter acesso aos arquivos do seu projeto para analisar as alterações e gerar as mensagens de commit.

Uma vez que o terminal esteja aberto na raiz do seu projeto, você pode executar o Gitai com o seguinte comando:

gitai <caminho_do_projeto> '<mensagem_genérica>'

Substitua <caminho_do_projeto> pelo caminho do diretório do seu projeto e <mensagem_genérica> por uma descrição básica da mudança que você fez no projeto.

Se você estiver com o terminal aberto na raiz do seu projeto e a mudança foi para adicionar uma nova funcionalidade, você pode simplesmente digitar:

gitai . 'Adicionada nova funcionalidade'

Se você deseja analisar somente uma pasta específica ou um projeto em outra pasta, por exemplo, se você fez uma alteração no seu projeto localizado em /Users/username/MeuProjeto, você pode executar o Gitai com o seguinte comando:

gitai /Users/username/MeuProjeto 'Adicionada nova funcionalidade'

Para gerar o commit e fazer push de forma automática, você pode adicionar a flag --push ao comando:

gitai . 'Adicionada nova funcionalidade' --push

O script releaser.py é usado para gerar notas de lançamento para qualquer projeto Git. Ele analisa os commits feitos desde a última tag e gera um documento de lançamento detalhado.

Para instruções detalhadas sobre como usar o script releaser.py, consulte o documento RELEASER.md.

• Python 3.7 ou superior
• pip (gerenciador de pacotes do Python)
• git

1. Clone o repositório para a sua máquina local usando git clone.

git clone <url-do-repositorio>

2. Navegue até o diretório do projeto.

cd <nome-do-projeto>

3. Instale as dependências do projeto.

pip install -r requirements.txt

Para executar o build do projeto, execute o script build.sh na raiz do projeto.

./build.sh

Este script irá gerar um executável do script Python usando o PyInstaller chamado gitai e copiará o arquivo .env.example para a pasta dist.

Caso você queira gerar um executável para uma plataforma específica, você pode usar os seguintes comandos:

Para gerar um instalador para Windows, você precisa usar a ferramenta Inno Setup.

1. Acesse o site oficial do Inno Setup em http://www.jrsoftware.org/isinfo.php
2. Clique no link "Download" na página.
3. Baixe a versão mais recente do Inno Setup.
4. Após o download do arquivo .exe, abra-o.
5. Siga as instruções na tela para instalar o Inno Setup.
6. Após a instalação, o Inno Setup deve estar disponível no seu computador.
7. Abra o Inno Setup e clique em "File" > "New" para criar um novo script de instalação.
8. Preencha os detalhes do seu projeto, como nome, versão e descrição.
9. Adicione os arquivos necessários ao instalador, incluindo o executável gerado pelo PyInstaller e o arquivo .env de exemplo.
10. Configure as opções de instalação, como o diretório de instalação e os atalhos.
11. Clique em "Build" para gerar o instalador.
12. Após a compilação, você terá um arquivo .exe que pode ser distribuído e usado para instalar o seu aplicativo no Windows.
13. Execute o instalador no computador de destino para instalar o aplicativo.
14. Após a instalação, o aplicativo estará disponível no menu Iniciar e no diretório de instalação.

Para gerar um instalador para Linux, você precisa usar a ferramenta Makeself.

1. Acesse o site oficial do Makeself em https://makeself.io/
2. Clique no link "Download" na página.
3. Baixe a versão mais recente do Makeself.
4. Após o download do arquivo .run, abra-o.
5. Siga as instruções na tela para instalar o Makeself.
6. Após a instalação, o Makeself deve estar disponível no seu computador.
7. Abra o terminal e navegue até o diretório onde o executável gerado pelo PyInstaller está localizado.
8. Execute o seguinte comando para criar o instalador:

makeself <diretório_de_origem> <nome_do_instalador> "<descrição_do_instalador>" <comando_de_instalação>

Substitua <diretório_de_origem> pelo diretório onde o executável gerado pelo PyInstaller está localizado, <nome_do_instalador> pelo nome do arquivo do instalador, <descrição_do_instalador> por uma descrição do instalador e <comando_de_instalação> por um comando de instalação.

Por exemplo:

makeself dist/ GitaiInstaller.run "Instalador do Gitai" "./gitai"

Isso irá criar um arquivo .run que pode ser distribuído e usado para instalar o seu aplicativo no Linux.

Para gerar um instalador para macOS, você precisa usar a ferramenta Packages.

1. Acesse o site oficial do Packages em http://s.sudre.free.fr/Software/Packages/about.html
2. Clique no link "Download" na página.
3. Após o download do arquivo .dmg, abra-o.
4. Arraste o ícone do Packages para a pasta de Aplicativos.

Agora, o Packages deve estar instalado e pronto para uso no seu Mac.

1. Abra o Packages e clique em "New Project".
2. Selecione "Distribution" e clique em "Next".
3. Dê um nome ao seu projeto e escolha onde salvá-lo.
4. No painel esquerdo, clique em "Project" e preencha os detalhes do seu projeto.
5. No painel esquerdo, clique em "Settings" e configure as opções de instalação.
6. No painel esquerdo, clique em "Scripts" e adicione um script de pós-instalação que instala as bibliotecas Python necessárias.
7. No painel esquerdo, clique em "Payload" e adicione o executável e o arquivo .env de exemplo ao diretório de instalação.
8. No menu "Build", selecione "Build".

Isso irá criar um arquivo .pkg que instala o seu aplicativo.

O Gitai irá analisar as alterações feitas no seu projeto, identificar a linguagem de programação usada e, com base nisso, gerar uma mensagem de commit detalhada seguindo o padrão Conventional Commits. Em seguida, ele irá adicionar todas as alterações ao índice do Git e realizar o commit com a mensagem gerada.

• Gerar release para Mac
• Gerar release para Windows
• Gerar release para Linux
• Atualizar a documentação para incluir instruções de instalação para Windows e Linux
• Adicionar possibilidade de utilizar a API do GROQ para gerar mensagens de commit
• Traduzir a documentação para Inglês
• Traduzir prompts para Inglês
• Adicionar suporte para mais linguagens de programação
• Adicionar binário executável automaticamente no PATH
• Adicionar testes automatizados

Agradecemos o seu interesse em contribuir para o Gitai! Aqui estão algumas diretrizes que podem ajudá-lo no processo:

1. Fork o Repositório: Faça um fork do repositório Gitai para a sua conta do GitHub. Isso significa que você terá uma cópia do repositório em sua própria conta, permitindo que você faça alterações sem afetar o projeto original.

2. Clone o Repositório: Clone o repositório para a sua máquina local para que você possa fazer alterações.

3. Crie uma Branch: Crie uma nova branch em seu fork para fazer suas alterações. Isso ajuda a separar suas alterações de outras que possam estar acontecendo simultaneamente.

4. Faça suas Alterações: Faça as alterações que você acha que melhorariam o projeto. Isso pode ser a adição de uma nova funcionalidade, a correção de um bug ou a melhoria da documentação.

5. Teste suas Alterações: Certifique-se de que suas alterações não quebram nada e que o código ainda funciona como esperado.

6. Envie um Pull Request: Envie um pull request para o repositório original propondo suas alterações. Certifique-se de dar uma descrição detalhada de suas alterações para que os mantenedores do projeto possam entender o que você fez e por quê.

Pedimos que todos os contribuintes sigam nosso código de conduta. Respeito mútuo é fundamental para um ambiente de colaboração saudável. Por favor, seja profissional e respeitoso com os outros contribuintes.

Se você tiver alguma dúvida ou problema, por favor, abra uma issue. Faremos o nosso melhor para ajudá-lo.

Se você quiser entrar em contato com os mantenedores do projeto, por favor, envie um e-mail para: [email protected]

Obrigado por seu interesse em nosso projeto. Estamos ansiosos para ver suas contribuições!

Leandro Silva Ferreira

• GitHub: @leandrosilvaferreira
• Twitter: @leandrosfer
• Email: [email protected]
• LinkedIn: Leandro Ferreira

Obrigado a estes incríveis contribuidores

Este projeto está licenciado sob a licença MIT. Isso significa que você é livre para copiar, modificar, mesclar, publicar, distribuir, sublicenciar e/ou vender cópias do software, desde que forneça o devido crédito ao autor original e reproduza a licença em todas as cópias ou partes substanciais do software.

Para mais detalhes, veja o arquivo LICENSE no repositório.