Git Alias ile Terminal İş Akışını Hızlandırın

Terminalde geçirdiğiniz zamanın büyük bir kısmı aynı komutları tekrar tekrar yazmakla geçiyor olabilir. git status, git add ., git commit -m, git push origin main… Bu döngü günde onlarca kez tekrarlanıyor ve sizi yavaşlatıyor. Git’in alias sistemi ve özel komut mekanizmaları tam da bu sorunu çözmek için tasarlanmış. Bugün bu araçları gerçek dünya senaryolarıyla birlikte ele alacağız.

Git Alias Nedir ve Neden Önemlidir

Git alias, uzun ve karmaşık git komutlarını kısaltmanın resmi yoludur. .gitconfig dosyasına eklenen bu tanımlamalar, hem kişisel üretkenliğinizi artırır hem de ekip içinde standart iş akışları oluşturmanıza yardımcı olur.

Alias’lar iki seviyede tanımlanabilir:

Global seviye: ~/.gitconfig dosyasında tanımlanır, tüm projeler için geçerlidir
Proje seviyesi: .git/config dosyasında tanımlanır, yalnızca o proje için geçerlidir

Çoğu zaman global tanımlamalar tercih edilir çünkü iş akışı alışkanlıklarınız projeden projeye büyük ölçüde değişmez. Proje seviyesi alias’lar ise ekibe özel standartlar için kullanışlıdır.

Temel Alias Tanımlama Yöntemleri

Git alias tanımlamanın iki yolu vardır. Birincisi terminal üzerinden komut çalıştırmak:

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.cm commit

İkincisi .gitconfig dosyasını doğrudan düzenlemek. Ben her zaman ikinci yöntemi tercih ederim çünkü tüm alias’larınızı tek bir yerde görüp düzenleyebiliyorsunuz:

# ~/.gitconfig dosyasını açın
nano ~/.gitconfig

Dosyanın içine [alias] bloğu ekleyin:

[alias]
    st = status
    co = checkout
    br = branch
    cm = commit -m
    aa = add --all
    ps = push
    pl = pull
    lg = log --oneline --graph --decorate
    df = diff
    rb = rebase

Bu kadar basit tanımlamalar bile günde yüzlerce tuş vuruşu kazandırır. git status yerine git st, git checkout yerine git co yazmak küçük görünebilir ama haftalık bazda ciddi bir zaman tasarrufu sağlar.

Gerçek Dünya Senaryosu: Sabah Rutini

Diyelim ki sabah işe geldiniz, birkaç farklı projede çalışıyorsunuz ve her birinin durumunu kontrol etmeniz gerekiyor. Normalde her proje için:

cd /projeler/api-servisi
git status
git log --oneline -10
git branch -a

Yazmak zorunda kalıyorsunuz. Bu işlemi aşağıdaki alias’larla dramatik biçimde kısaltabilirsiniz:

[alias]
    # Projenin genel durumunu tek bakışta göster
    info = "!git st && echo '---BRANCHES---' && git br -a && echo '---RECENT COMMITS---' && git lg -10"
    
    # Sabah güncellemesi: pull + submodule update + durum raporu
    morning = "!git pull --rebase && git submodule update --init --recursive && git info"

Artık sabah git morning yazıp kahvenizi alabilirsiniz. Komut hem güncel kodu çekiyor hem de submodule’leri güncelliyor hem de size bir durum raporu sunuyor.

Güçlü Log Alias’ları

Git log’un varsayılan çıktısı oldukça okunaksızdır. Bunu düzelten alias’lar en çok değer üretenler arasındadır:

[alias]
    # Renkli, grafik gösterimli kompakt log
    lg = log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit
    
    # Son N commit'i göster
    last = log -1 HEAD --stat
    
    # Belirli bir dosyanın geçmişini göster
    flog = log --follow -p
    
    # Bugün kim ne yaptı
    standup = log --since='yesterday' --author='$(git config user.email)' --pretty=format:'%Cred%h%Creset - %s %Cgreen(%cr)%Creset'
    
    # Tüm branchların son commit'lerini göster
    branches = branch -v --sort=-committerdate

git standup alias’ı özellikle scrum toplantıları için harikadır. Sabah toplantısından önce çalıştırıp dün ne yaptığınızı anında görebilirsiniz.

Shell Entegrasyonu: Ünlem İşareti ile Shell Komutları

Git alias’larının en güçlü özelliği, başına ! eklediğinizde shell komutu olarak çalışabilmesidir. Bu sayede alias’lar sadece git komutlarıyla sınırlı kalmaz, istediğiniz herhangi bir shell işlemini yapabilir.

[alias]
    # Mevcut branch ismini kopyala (macOS)
    copy-branch = "!git rev-parse --abbrev-ref HEAD | pbcopy"
    
    # Tüm değişiklikleri tek komutla commit et
    save = "!git add -A && git commit -m 'SAVEPOINT'"
    
    # Working directory'yi temizle ama takip edilmeyen dosyaları koru
    wipe = "!git add -A && git commit -qm 'WIPE SAVEPOINT' && git reset HEAD~1 --hard"
    
    # Feature branch oluştur ve geç
    feature = "!f() { git checkout -b feature/$1; }; f"
    
    # Hotfix branch oluştur
    hotfix = "!f() { git checkout main && git pull && git checkout -b hotfix/$1; }; f"

git save komutu özellikle faydalıdır. Bir şeyi denemek üzeresiniz ama mevcut durumu kaybetmek istemiyorsunuz, hızlıca git save yapıp devam ediyorsunuz.

Parametre Alan Alias’lar

Shell fonksiyonları kullanarak alias’larınıza parametre geçebilirsiniz. Bu, alias’ları gerçek mini uygulamalara dönüştürür:

[alias]
    # Belirli bir commit'e geri dön
    undo = "!f() { git reset --hard HEAD~${1:-1}; }; f"
    
    # Remote branch'ı local'e çek ve takip et
    track = "!f() { git checkout --track origin/$1; }; f"
    
    # Bir branch'taki tüm commit'leri squash et
    squash = "!f() { git rebase -i HEAD~$1; }; f"
    
    # Commit mesajında arama yap
    find = "!f() { git log --all --grep=$1; }; f"
    
    # İki branch arasındaki farkı göster
    compare = "!f() { git log --oneline ${1:-main}..${2:-HEAD}; }; f"

Kullanım örnekleri:

# Son 3 commit'i geri al
git undo 3

# upstream/feature-auth branch'ını takip et
git track feature-auth

# "login" kelimesini commit mesajlarında ara
git find "login"

# main ile mevcut branch arasındaki farkı göster
git compare main HEAD

Gerçek Dünya Senaryosu: Pull Request Hazırlığı

Bir feature branch’ı üzerinde çalıştınız ve pull request açmak üzeresiniz. Bu süreç genellikle şu adımları içerir: main’i güncellemek, kendi branch’ınızı rebase etmek, commit’leri temizlemek ve push etmek. Bunu otomatikleştirelim:

[alias]
    # PR öncesi hazırlık: main'i güncelle, rebase et, push et
    pr-ready = "!f() { 
        BRANCH=$(git rev-parse --abbrev-ref HEAD); 
        git checkout main && 
        git pull origin main && 
        git checkout $BRANCH && 
        git rebase main && 
        git push origin $BRANCH --force-with-lease; 
    }; f"
    
    # Stale branch'ları temizle
    cleanup = "!git fetch --prune && git branch -vv | grep 'origin/.*: gone]' | awk '{print $1}' | xargs git branch -d"
    
    # Merge edilmiş branch'ları listele
    merged = "!git branch --merged main | grep -v 'main\|master\|develop'"

git pr-ready yazdığınızda tüm bu işlemler sırayla gerçekleşir. --force-with-lease kullanmak --force‘a göre daha güvenlidir çünkü başkası o branch’a bir şey push ettiyse sizi uyarır.

Ekip Çalışması İçin Standart Alias’lar

Bir ekipte çalışıyorsanız, .gitconfig alias’larınızı ekiple paylaşmak iş birliğini kolaylaştırır. Bunun için projeye bir git-aliases.sh dosyası ekleyip ekip üyelerinin çalıştırmasını isteyebilirsiniz:

#!/bin/bash
# Ekip standart git alias'larını kur
# Kullanım: bash git-aliases.sh

echo "Git alias'ları kuruluyor..."

git config --global alias.st "status -sb"
git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"
git config --global alias.aa "add --all"
git config --global alias.cm "commit -m"
git config --global alias.ps "push"
git config --global alias.pl "pull --rebase"
git config --global alias.feature "!f() { git checkout -b feature/$1; }; f"
git config --global alias.hotfix "!f() { git checkout main && git pull && git checkout -b hotfix/$1; }; f"
git config --global alias.pr-ready "!f() { BRANCH=$(git rev-parse --abbrev-ref HEAD); git checkout main && git pull origin main && git checkout $BRANCH && git rebase main && git push origin $BRANCH --force-with-lease; }; f"

echo "Tamamlandı! 'git alias' komutuyla kurulu alias'ları görebilirsiniz."

Git Alias Alternatifi: Özel Git Komutları

Git’in az bilinen bir özelliği vardır: git- prefix’iyle başlayan herhangi bir çalıştırılabilir dosya PATH‘de bulunuyorsa, git komutuyla çağrılabilir. Yani git-deploy adında bir script yazarsanız, git deploy şeklinde çağırabilirsiniz.

Bu özellik alias’lardan daha güçlüdür çünkü tam teşekküllü script’ler yazabilirsiniz:

#!/bin/bash
# /usr/local/bin/git-deploy
# Kullanım: git deploy [staging|production]

ENVIRONMENT=${1:-staging}
BRANCH=$(git rev-parse --abbrev-ref HEAD)

echo "Branch '$BRANCH' -> '$ENVIRONMENT' ortamına deploy ediliyor..."

case $ENVIRONMENT in
    staging)
        git push origin $BRANCH:staging
        echo "Staging deploy tamamlandı."
        ;;
    production)
        if [ "$BRANCH" != "main" ]; then
            echo "Hata: Production deploy sadece main branch'ından yapılabilir!"
            exit 1
        fi
        git push origin main:production
        echo "Production deploy tamamlandı."
        ;;
    *)
        echo "Hata: Geçersiz ortam. 'staging' veya 'production' kullanın."
        exit 1
        ;;
esac

# Script'i çalıştırılabilir yapın
chmod +x /usr/local/bin/git-deploy

# Artık şöyle kullanabilirsiniz
git deploy staging
git deploy production

Hata Ayıklama ve Tehlikeli İşlemler İçin Alias’lar

Bazen tehlikeli ama gerekli işlemleri güvenli hale getiren alias’lar yazarsınız:

[alias]
    # Son commit'i geri al ama değişiklikleri staged olarak tut
    uncommit = reset --soft HEAD~1
    
    # Staged değişiklikleri unstage et
    unstage = reset HEAD --
    
    # Tüm local değişiklikleri sıfırla (DİKKAT!)
    nuke = "!git reset --hard HEAD && git clean -fd"
    
    # Conflict olan dosyaları listele
    conflicts = diff --name-only --diff-filter=U
    
    # Hangi commit bir dosyayı sildi
    deleted = log --diff-filter=D --summary
    
    # Bir dosyanın hangi commit'te eklendiğini bul
    added = log --diff-filter=A --summary

git nuke gibi tehlikeli alias’ları kasıtlı olarak uzun tutmak iyi bir pratiktir. Yanlışlıkla yazmak için nuke yeterince kötü bir isim değil mi?

Productivity Boost: Alias Zincirleme

Alias’ları birbirleriyle birleştirebilirsiniz:

[alias]
    aa = add --all
    cm = commit -m
    ps = push
    
    # Tüm değişiklikleri add, commit ve push et
    acp = "!f() { git aa && git cm "$1" && git ps; }; f"
    
    # Günün sonunda tüm işi kaydet
    done = "!f() { git acp "WIP: $(date '+%Y-%m-%d %H:%M')" && echo 'Bugünlük iş kaydedildi!'; }; f"

# Tek komutla add, commit, push
git acp "feat: kullanici girisi eklendi"

# Gunu bitir
git done

.gitconfig Dosyasını Versiyon Kontrolüne Almak

Tüm bu alias’ları kaybetmemek ve farklı makinelerde kullanabilmek için .gitconfig dosyanızı bir dotfiles reposunda tutmanızı şiddetle tavsiye ederim:

# Dotfiles reposu oluştur
mkdir ~/dotfiles && cd ~/dotfiles
git init

# .gitconfig'i buraya kopyala ve symlink oluştur
cp ~/.gitconfig ~/dotfiles/gitconfig
rm ~/.gitconfig
ln -s ~/dotfiles/gitconfig ~/.gitconfig

# Versiyonla
git add .
git commit -m "dotfiles: ilk versiyon"
git remote add origin [email protected]:kullanici/dotfiles.git
git push -u origin main

Artık yeni bir makineye geçtiğinizde sadece dotfiles reponuzu clone’layıp symlink’leri kurmanız yeterli. Birçok sysadmin’in dotfiles adında public bir reposu vardır ve bunlar başlı başına ilham kaynağı olabilir.

Alias’larınızı Belgelendirin

Alias listeniz büyüdükçe neyin ne işe yaradığını unutmak kaçınılmaz hale gelir. Bu yüzden tüm alias’larınızı listeleyen bir alias tanımlayın:

[alias]
    # Tum alias'lari listele
    aliases = "!git config --get-regexp '^alias\.' | sed 's/alias\.//'"
    
    # Alias'larda arama yap
    find-alias = "!f() { git aliases | grep $1; }; f"

# Tüm alias'ları gör
git aliases

# "branch" içeren alias'ları bul
git find-alias branch

Performans İpuçları

Özellikle büyük repolar üzerinde çalışırken bazı alias’lar yavaş çalışabilir. Şu optimizasyonları .gitconfig‘e ekleyebilirsiniz:

[core]
    # Büyük repolar için dosya sistemi izlemeyi hızlandır
    untrackedCache = true
    
[fetch]
    # Paralel fetch
    parallel = 4

[alias]
    # Hızlı status: untracked dosyaları takip etme
    qst = status -uno
    
    # Sadece staged değişiklikleri göster
    staged = diff --cached

Sonuç

Git alias sistemi ve özel komutlar, terminal iş akışınızı dönüştürebilecek güçlü araçlardır. Önemli olan her şeyi bir anda uygulamaya çalışmamak. Önce günlük rutininizde en çok yazdığınız komutları belirleyin ve onları alias’a dönüştürün. git status yerine git st, git log --oneline --graph yerine git lg gibi basit başlangıçlar bile hissedilir bir fark yaratır.

Zamanla ihtiyaçlarınız netleştikçe daha karmaşık alias’lar ve özel git komutları eklersiniz. Shell fonksiyonlarıyla parametre alan alias’lar yazmayı öğrendiğinizde ise git’i kendi araç kutunuza uyacak şekilde şekillendirebilirsiniz.

Son olarak şunu söyleyeyim: Başka sysadmin’lerin dotfiles repolarına göz atın. GitHub’da dotfiles veya gitconfig diye aratırsanız onlarca ilham verici yapılandırma bulabilirsiniz. Birisinin yıllarca geliştirdiği bir alias’ı kendi rutininize dahil etmek, sıfırdan keşfetmekten çok daha verimli bir öğrenme yoludur.

Git Alias ve Özel Komutlarla Terminal İş Akışını Hızlandırma