Praticamente todo meu trampo no terminal passa por git. Uso lazygit faz um tempo e é massa demais pra maioria das tarefas do dia a dia.

Pra mim, ferramentas CLI precisam ser customizáveis ou conseguir conversar com outras ferramentas via pipes, redirects ou plugins. Um programa nunca vai resolver tudo, então eles precisam trabalhar junto ou pelo menos deixar eu forçar isso a acontecer.

Não uso só lazygit. No NeoVim tenho os plugins GitSigns e Git Fugitive instalados que me mostram stats de git direto no editor, deixam eu editar hunks e executar comandos sem sair de lá. Uso pra fazer mudanças pequenas, pontuais nos arquivos que tô mexendo.

Com GitSigns consigo apertar <leader>gr pra resetar o hunk abaixo do cursor ou <leader>gR pra resetar o arquivo todo.

Git Fugitive uso principalmente pra navegar no histórico. Com <leader>gL vejo o histórico do arquivo atual, o que é extremamente útil pra sacar o que mudou e por quê.

O diff padrão do lazygit é útil mas não é muito legal de olhar, então customizei a aparência e o output. Uso delta pra um diff mais massa. Aqui tá minha configuração de ~/.config/git:

[alias]
	pf = push --force-with-lease
[pull]
	rebase = false
[fetch]
	prune = true

[diff]
    colorMoved = default
    algorithm = histogram

[merge]
    conflictstyle = zdiff3

[core]
    pager = delta

[include]
    path = /home/cacarico/ghq/github.com/catppuccin/delta/catppuccin.gitconfig

[delta]
	features = catppuccin-frappe
    keep-plus-minus-markers = true
    paging = never
    line-numbers = true
    file-style = bold "#A855F7"
    hunk-header-style = file line-number syntax

    minus-style = syntax normal
    plus-style = syntax normal

    minus-marker-style = "red bold"
    plus-marker-style  = "green bold"

E ~/.config/lazygit/config.yml:

git:
  overrideGpg: true
  pagers:
    - colorArg: always
      pager: delta --dark --paging=never --line-numbers --hyperlinks
  log:
    showGraph: always
    order: topo-order

Isso transforma a view padrão em algo bem mais palpável:

Antes:

Depois:

O syntax highlighting melhorado e as linhas numeradas fazem uma diferença gigante. Além da configuração, tenho uns keybinds customizados no lazygit pra agilizar o trampo.

Em todos os repos que contribuo tenho pre-commit instalado, então linting e testes rodam antes de eu fazer commit. Isso evita um monte de pipeline fudido no GitHub e economiza grana em execuções.

Depois de fazer mudanças e commitar, uso uns scripts pra rodar e ficar de olho nas workflow executions do GitHub. Tenho uma function em fish chamada ghrv (github run view) que abre um terminal flutuante com fzf, deixando eu escolher qual run acompanhar.

function ghrv --description 'Pick a workflow run with fzf and watch it (floating window)'
    if not set -q _GH_FLOATING
        alacritty -T floating60 -e fish -c "cd $(pwd); set -x _GH_FLOATING 1; ghrv" &
        return
    end

    # If a run ID was passed directly, skip fzf
    if test (count $argv) -gt 0
        gh run watch $argv
        return
    end

    set -l selected (
        gh run list --limit 30 --json databaseId,displayTitle,status,conclusion,workflowName 2>/dev/null |
        jq -r '.[] | [
            (.databaseId | tostring),
            .workflowName,
            .status,
            (.conclusion // "-"),
            .displayTitle
        ] | @tsv' |
        fzf --prompt="Run> " \
            --height=20 \
            --border \
            --layout=reverse \
            --delimiter='\t' \
            --with-nth=2,3,4,5
    )
    test -z "$selected" && return 0

    set -l run_id (string split \t $selected)[1]
    set -l run_status (string split \t $selected)[3]

    if test "$run_status" = "completed"
        set -l job_ids (
            gh run view "$run_id" --json jobs 2>/dev/null |
            jq -r '.jobs[].databaseId'
        )
        for job_id in $job_ids
            gh run view "$run_id" --job="$job_id"
            echo ""
        end
    else
        gh run watch "$run_id"
        set -l conclusion (gh run view "$run_id" --json conclusion -q '.conclusion' 2>/dev/null)
        notify-send "GitHub Actions" "Run finished: $conclusion" --icon=dialog-information
    end

    echo ""
    read -P "Press enter to close..."
end

Escolhendo uma workflow pra acompanhar:

Acompanhando a execução:

Isso é extremamente útil pra checker se tá passando ou fudido, e se tá fudido consigo ver os logs na hora e sacando o que deu errado.

Pra ver PRs que tô assignado ou revisor, uso gh-dash, uma extensão da CLI gh que me dá um dashboard com todas as PRs. Consigo filtrar por repo ou label sem abrir o browser.

Então o workflow todo vive no terminal. De coding a PR review a merging a acompanhar workflows, nunca preciso sair de lá.

Dito isso, ainda uso a web interface quando faz sentido. Não sou aquele hardcore que acha que “mouse é o demônio quando tá usando Vim”. É equilíbrio. Pra algumas coisas o browser é sempre superior, e pra essas eu saio do terminal. Mas pra muita coisa sou mais rápido e eficiente no terminal, então fico lá.