Gommit: menos dependências, mais consistência nos seus commits

Você termina uma alteração, revisa o código e vai fazer o commit. Então percebe que o assistente de mensagens ficou em outra versão do Node, precisa reinstalar uma ferramenta global ou carregar uma configuração que só existe naquele projeto.

O commit deveria ser a parte simples desse caminho.

Foi de uma frustração assim, envolvendo nvm e instalações de git-cz, que nasceu o Gommit: um assistente de commits escrito em Go, inspirado na experiência do Commitizen, que pode acompanhar você por diferentes repositórios sem depender de Node.js ou npm para funcionar.

O projeto é aberto e está aqui: github.com/Hangell/gommit (https://github.com/Hangell/gommit). A proposta merece uma experiência prática — e começa por uma distinção importante.

Commitizen não é o problema. O acoplamento é.

O Commitizen resolve uma necessidade real: orientar a escrita de mensagens e ajudar uma equipe a seguir convenções. Seu ecossistema de adaptadores permite ajustar essa experiência a diferentes projetos. Se ele já atende bem ao seu fluxo, existe valor em continuar usando.

Também seria injusto dizer que ele exige instalação em cada repositório: o Commitizen oferece configuração global (https://github.com/commitizen/cz-cli#conventional-commit-messages-as-a-global-utility). Instalações locais, por sua vez, ajudam a equipe a compartilhar a mesma versão.

A questão aparece quando a ferramenta de commit fica presa ao ambiente da aplicação. Você troca de versão do Node, alterna entre projetos ou trabalha em um repositório de outra linguagem, e precisa administrar esse ambiente só para registrar uma mudança.

O Gommit propõe separar essas responsabilidades: a aplicação segue com suas dependências; o assistente de commits fica disponível como um executável no seu ambiente.

Menos dependências para usar, menos configuração para repetir

Com o binário pronto, você não precisa instalar Go, Node.js, npm ou um adaptador JavaScript para usar o Gommit. Precisa do Git para trabalhar com os repositórios. A mesma instalação pode atender projetos em Go, Python, Java, JavaScript e outras linguagens.

Isso evita adicionar um package.json ou dependências de desenvolvimento apenas para ter um assistente de commits. Em projetos que já usam Node, pode simplificar essa parte do fluxo; em projetos que não usam, evita introduzir esse ambiente só por causa dos commits.

A expressão “zero dependências” merece precisão: ela descreve a experiência de executar o binário sem instalar outro runtime. O código-fonte declara módulos Go (https://github.com/Hangell/gommit/blob/main/go.mod), incluindo golang.org/x/term e golang.org/x/sys. Menos dependências operacionais é uma vantagem concreta; ausência absoluta de dependências não seria uma descrição correta.

Instale e faça o primeiro teste

O caminho mais visual é abrir a página de Releases (https://github.com/Hangell/gommit/releases), baixar o pacote correspondente ao seu sistema e arquitetura e extrair o arquivo. Há pacotes para Linux, macOS e Windows, em amd64 e arm64.

No Linux ou macOS, dentro da pasta extraída:

chmod +x ./gommit
./gommit --install

No Windows, pelo PowerShell:

.\gommit.exe --install

Reabra o terminal e confira a instalação. Depois, salve o português como idioma da interface:

gommit --version
gommit --set-language pt

O instalador coloca o executável em uma pasta do usuário: ~/.local/bin no Linux/macOS e %LOCALAPPDATA%\Programs\gommit\bin no Windows. O README em português (https://github.com/Hangell/gommit/blob/main/README.pt-BR.md) também apresenta scripts de instalação em uma linha.

Antes do primeiro commit, você pode experimentar a geração de uma mensagem dentro de um repositório Git:

gommit --dry-run --allow-empty --auto-stage=false --type feat --subject "adiciona busca por nome"

Essa combinação exibe a mensagem sem criar um commit e sem adicionar arquivos ao staging. É uma boa forma de conhecer a ferramenta antes de incorporá-la ao trabalho.

No dia a dia, duas respostas bastam

Dentro de um repositório com alterações, execute:

gommit

No modo simples, que é o padrão, você escolhe o tipo da mudança com as setas e descreve o que fez. Tipos como feat, fix, docs, test e refactor ajudam a comunicar a intenção antes mesmo de abrir o diff.

Um exemplo de mensagem gerada pela versão 0.2.0 é:

feat: 💡 adiciona busca por nome

Atenção ao comportamento do staging: quando não há nada preparado, o Gommit pode executar git add -A automaticamente. Para selecionar exatamente o que vai entrar, prepare os arquivos e desative esse comportamento:

git add caminho/do/arquivo
git diff --cached
gommit --auto-stage=false

Assim você combina a praticidade do assistente com uma revisão consciente do conteúdo do commit.

Uma mensagem curta quando basta; contexto quando precisa

Para mudanças que exigem mais explicação, use o modo completo:

gommit --mode full

Ele permite informar escopo, descrição, corpo da mensagem, mudança incompatível e referências a issues. Isso ajuda a registrar tanto o que mudou quanto o motivo, além de relacionar o trabalho a itens como Closes #123 ou Refs #45.

Se preferir esse fluxo sempre:

gommit --set-mode full

Para voltar ao modo simples:

gommit --set-mode simple

Também é possível fornecer os campos diretamente, sem percorrer o assistente:

gommit --auto-stage=false --type fix --scope api --subject "corrige validacao do token" --body "Rejeita tokens expirados antes de consultar os dados." --footer "Closes #42"

O exemplo pressupõe alterações já preparadas e cria o commit. Para apenas visualizar a mensagem, acrescente --dry-run.

Integridade: preservar o fluxo e conferir o que chega à máquina

Consistência começa pela mensagem: o Gommit exige uma descrição e limita esse campo a 72 caracteres. O resumo das alterações preparadas, habilitado por padrão, ajuda a conferir o que está prestes a ser registrado.

Ao finalizar, ele chama o git commit. Por isso, os hooks continuam participando do fluxo, inclusive validações configuradas com Husky e commit-msg. A ferramenta oferece --no-verify, mas esse desvio só ocorre quando solicitado explicitamente. Se os seus hooks dependem de Node, essa dependência continua existindo.

Há também integridade na atualização do executável. No atualizador da versão 0.2.0 (https://github.com/Hangell/gommit/blob/v0.2.0/internal/update/update.go), o pacote baixado é conferido contra SHA256SUMS.txt antes da extração e execução. A atualização falha se o checksum estiver ausente ou não corresponder ao arquivo.

gommit --update

Essa conferência detecta divergências em relação ao checksum publicado. Ela não equivale a uma assinatura independente do distribuidor e não deve ser confundida com assinatura de commits. Da mesma forma, --signoff acrescenta Signed-off-by; não cria uma assinatura criptográfica.

O assistente e a criação do commit funcionam sem conexão. Após um commit bem-sucedido, versões de release podem consultar atualizações, com cache de 24 horas. Uma falha nessa consulta não invalida o commit, e a instalação da atualização depende do comando explícito.

Compatibilidade sem promessas mágicas

O Gommit se inspira em Conventional Commits e oferece os campos que tornam o histórico mais informativo. Na versão 0.2.0, emojis também aparecem na mensagem final, como no exemplo acima. Vale conhecer esse detalhe antes de conectá-lo às regras do time.

Validadores, geradores de changelog e ferramentas de release têm suas próprias configurações. Experimente mensagens representativas — especialmente mudanças incompatíveis — no pipeline que você utiliza. O assistente ajuda a escrever; os hooks e a CI continuam responsáveis por aplicar as regras da equipe.

Por ser um executável nativo, o Gommit oferece uma forma direta de distribuir a ferramenta. O repositório não publica benchmarks comparativos, então a vantagem apresentada aqui é a simplicidade operacional, sem inventar números de desempenho.

Onde ele pode fazer diferença

• Vários repositórios: uma instalação disponível no ambiente, sem repetir a configuração do assistente em cada projeto.

• Equipes com diferentes linguagens: uma experiência de commit que não exige adotar o runtime da aplicação do colega.

• Quem está aprendendo Git: perguntas guiadas para transformar mensagens vagas em descrições úteis.

• Quem precisa de contexto: modo completo, corpo, escopo e vínculo com issues.

• Quem prefere comandos: preenchimento por flags, prévia com --dry-run, --amend e --signoff.

• Quem trabalha em português: interface traduzida, com suporte também a inglês, espanhol, hindi, russo e chinês.

Para integrar ao comando git commit, é possível configurar o Gommit como editor. Comece somente no repositório atual:

git config core.editor "gommit --as-editor"

Essa opção muda o editor usado pelo Git nesse repositório e pode afetar outros fluxos que solicitam edição. Para a maioria das pessoas, começar executando gommit diretamente já é suficiente.

Experimente, dê uma estrela e ajude a construir

O valor de uma ferramenta assim aparece na rotina: abrir outro repositório e continuar com um fluxo familiar; escrever uma mensagem que o colega entende; voltar ao histórico meses depois e encontrar contexto.

Se essa proposta resolve uma dificuldade sua, teste o Gommit em um projeto e conte como foi. Uma issue com versão, sistema operacional e passos para reproduzir um problema já é uma contribuição útil.

Também há espaço para código, testes, documentação e traduções. O guia de contribuição (https://github.com/Hangell/gommit/blob/main/CONTRIBUTING.md) explica o ambiente com Go 1.25+, as verificações com make check e o processo de pull request. Você não precisa começar por uma grande funcionalidade.

Gostou da ideia? Dê uma ⭐ no Hangell/gommit (https://github.com/Hangell/gommit), experimente no seu fluxo e participe da evolução. A estrela ajuda outras pessoas a descobrir o projeto; o uso real mostra onde ele precisa melhorar; as contribuições transformam essa experiência em uma ferramenta melhor para todos.

E no seu ambiente: o assistente de commits acompanha você entre projetos ou ainda depende da configuração de cada um?

Artigo baseado no repositório Hangell/gommit e na versão publicada 0.2.0, consultados em 6 de outubro de 2026.