Claude Code Masterkurs – KI-gestuetztes Programmieren lernen mit Anthropics Coding-Agent

. tig - Terminal Git Browser

Tool-Lektion | 30 Minuten

tig ist ein ncurses-basierter Text-Interface Git-Browser, der eine elegante Alternative zur Kommandozeile für Git-Exploration bietet. Es kombiniert die Effizienz von Terminal-Workflows mit der Übe

Lernziele

. tig - Terminal Git Browser

Berechtigung

tig ist ein ncurses-basierter Text-Interface Git-Browser, der eine elegante Alternative zur Kommandozeile für Git-Exploration bietet. Es kombiniert die Effizienz von Terminal-Workflows mit der Übersichtlichkeit einer GUI.

Warum tig seine Berechtigung hat:

Statistiken:

🚀 Claude Code Relevanz: tig gibt dir den visuellen Ueberblick ueber deine Git-Historie, bevor du Claude Code fuer Refactoring oder Code-Analyse einsetzt -- so erkennst du Patterns, Blame-Informationen und Commit-Zusammenhaenge auf einen Blick.

Zwecke

tig ist primaer ein Betrachtungs-Tool -- es glaenzt beim Inspizieren von Git-Historie, Blame-Informationen und Branch-Strukturen, waehrend interaktive Operationen eher lazygit vorbehalten sind.

Haupteinsatzgebiete:

Verwendung

Von der Installation ueber die ersten Schritte bis zu Custom-Konfigurationen und fortgeschrittenen Workflows.

Installation

tig ist in allen gaengigen Paketmanagern verfuegbar oder kann aus dem Quellcode kompiliert werden:

macOS (Homebrew)

Die schnellste Installation auf macOS:

brew install tig

Ubuntu/Debian

apt-get install tig

Arch Linux

pacman -S tig

From Source

git clone https://github.com/jonas/tig.git
cd tig
make
sudo make install
💡 Tipp: Erstelle direkt nach der Installation eine ~/.tigrc mit Vim-like Keybindings (g/G fuer Anfang/Ende) -- das macht die Navigation deutlich intuitiver.

Verifizierung

tig --version
# Output: tig version 2.5.8

which tig
# Output: /usr/local/bin/tig

Quick Start

Die Grundbefehle oeffnen verschiedene Ansichten -- vom Commit-Log ueber Blame bis zum Stash.

Basis-Usage

tig kann mit verschiedenen Argumenten gestartet werden, um direkt die gewuenschte Ansicht zu oeffnen:

# Öffne tig im aktuellen Repo
tig

# Specific File-History
tig src/app.js

# Blame-View für File
tig blame src/app.js

# Commit-Details anzeigen
tig show HEAD

# Stash-View
tig stash

Die Navigation in tig orientiert sich an Vim. Diese Keybindings funktionieren in allen Views:

Navigation (Standard-Keybindings)

q         - Quit/Close View
h         - Help anzeigen
k/j       - Auf/Ab navigieren
Enter     - Details öffnen
<         - Previous View
Tab       - Next View
R         - Refresh
/         - Search
n/N       - Next/Previous Search-Result

tig bietet verschiedene Views fuer unterschiedliche Git-Informationen. Jeder View wird durch einen eigenen Befehl gestartet:

Views

# Main View (Commit-Log)
tig

# Refs View (Branches/Tags)
tig refs

# Status View (git status)
tig status

# Grep View (git grep)
tig grep <pattern>

# Blame View
tig blame <file>

# Tree View (git ls-tree)
tig tree

Advanced Usage

Erweiterte Konfiguration mit Custom Keybindings, Filtern und interaktiven Git-Operationen direkt aus tig heraus.

Custom Commands

In der ~/.tigrc definierst du eigene Keybindings und Befehle, die tig deutlich maechtige machen:

# ~/.tigrc Configuration

# Keybindings
bind generic g move-first-line      # g = go to top
bind generic G move-last-line       # G = go to bottom
bind generic <Ctrl-f> scroll-page-down
bind generic <Ctrl-b> scroll-page-up

# Custom Commands
bind main C !git cherry-pick %(commit)
bind status P !git push origin %(repo:head)

# Colors
color cursor black green bold
color title-focus black blue bold

Filtering & Searching

Filtere die Commit-Historie nach Autor, Datum, Pfad oder Commit-Message -- so findest du schnell den gesuchten Commit:

# Log mit Path-Filter
tig -- src/

# Nur Commits von Author
tig --author="John Doe"

# Seit bestimmtem Datum
tig --since="2 weeks ago"

# Grep in Commit-Messages
tig --grep="fix"

# Kombiniert
tig --author="Jane" --since="1 month" -- src/
🚀 Beispiel: Mit tig blame src/app.js siehst du sofort, wer welche Zeile wann geschrieben hat. Durch Enter auf einer Zeile springst du direkt zum zugehoerigen Commit -- perfekt fuer Bug-Hunting.

Diese Operationen fuehrst du direkt innerhalb von tig aus, ohne in die Kommandozeile wechseln zu muessen:

Interactive Operations

# In Status-View
u         - Stage/Unstage File
!         - Run Git Command
C         - Commit (öffnet Editor)
M         - Amend Last Commit
R         - Revert Changes

# In Main-View (Log)
C         - Cherry-Pick Commit
H         - Create Branch at Commit
T         - Create Tag at Commit

# In Refs-View
C         - Checkout Branch/Tag
D         - Delete Branch

Split-Screen Usage

# In Main-View
d         - Toggle Diff-View
b         - Toggle Blame-View
f         - Toggle File-View
t         - Toggle Tree-View

# Result: Split-Screen mit Log + Diff

Integration in Claude Code Workflows

. Code-Review mit AI-Assistance

# Browse Commits, kopiere Commit-Hash
tig

# Dann mit Claude analysieren
git show <commit-hash> | \
  claude "Review this commit for potential issues"

# Oder direkt aus tig heraus:
# Bind custom command in ~/.tigrc
bind main A !git show %(commit) | claude "Analyze commit"

. Blame-Analysis für Bug-Tracking

# Öffne tig blame
tig blame src/buggy-file.js

# Identifiziere problematische Zeilen und Commits
# Kopiere Commit-Hash, dann:
git show <hash> | \
  claude "Explain what this commit was trying to achieve"

. Refactoring-History

# File-History anzeigen
tig src/component.tsx

# Mit Claude analysieren
git log --follow -p -- src/component.tsx | \
  head -500 | \
  claude "Summarize evolution of this component"

. Pre-Merge Review

# Feature-Branch in tig
tig feature/new-api

# Commits zwischen main und feature
tig main..feature/new-api

# Kompletten Diff
git diff main...feature/new-api | \
  claude "Review feature branch changes"

Best Practices

Empfohlene Konfigurationen und Workflows fuer den produktiven Einsatz von tig.

. Essenzielle ~/.tigrc Config

Diese Konfiguration verbessert die Darstellung, fuegt Vim-aehnliche Navigation hinzu und definiert Quick-Actions fuer haeufige Operationen:

# ~/.tigrc

# ===== Display =====
set main-view = id date author commit-title:graph=yes,refs=yes
set line-graphics = utf-8
set tab-size = 4
set ignore-case = true
set refresh-mode = auto

# ===== Keybindings =====
# Vim-like Navigation
bind generic g move-first-line
bind generic G move-last-line
bind generic <Ctrl-u> scroll-half-page-up
bind generic <Ctrl-d> scroll-half-page-down

# Quick Actions
bind main C !git cherry-pick %(commit)
bind main ! !git revert %(commit)
bind status A !git add -A
bind status R !git reset HEAD %(file)

# ===== Colors =====
color cursor black green bold
color title-focus black blue
color diff-add green default
color diff-del red default

. Aliase für häufige Tasks

Kurze Aliase fuer die verschiedenen tig-Views sparen Tipparbeit im Alltag:

# ~/.bashrc oder ~/.zshrc
alias tigs='tig status'
alias tigr='tig refs'
alias tigg='tig grep'
alias tigb='tig blame'
alias tigt='tig stash'
⚠️ Warnung: tig ist primaer ein Browser/Viewer -- fuer interaktive Git-Operationen wie Rebase oder komplexes Staging ist lazygit besser geeignet. Nutze tig zum Inspizieren und lazygit zum Ausfuehren.

. Integration mit lazygit

Der beste Workflow: tig zum Inspizieren der Historie, lazygit zum Ausfuehren von Aktionen:

# Nutze tig für History-Browse, lazygit für Ops
alias t='tig'
alias lg='lazygit'

# Als Workflow:
# 1. tig: Commits inspizieren
# 2. lazygit: Interaktive Ops (rebase, etc.)

. Custom Views erstellen

Custom Views in tig ermoeglicht es dir, haeufig genutzte Filteransichten per Tastendruck aufzurufen. Statt jedes Mal lange Kommandozeilen-Flags zu tippen, definierst du die Filter einmalig in der .tigrc und rufst sie mit einem Tastendruck auf. Stell dir vor, du willst taeglich schnell sehen, was du heute committet hast, was dein Teamkollege gemacht hat, oder nur die letzten 50 Commits -- jede dieser Ansichten ist einen Tastendruck entfernt. Die !sh -c Syntax fuhrt einen Shell-Befehl aus und oeffnet das Ergebnis in einer neuen tig-Instanz.

# ~/.tigrc

# View: Recent Changes (last 50 commits)
bind generic R !sh -c "tig --max-count=50"

# View: My Commits
bind generic M !sh -c "tig --author=$(git config user.name)"

# View: Today's Work
bind generic T !sh -c "tig --since=today"

. Performance für große Repos

Bei Repositories mit Hunderttausenden von Commits kann tig spuerbar langsamer werden, da es die gesamte Historie laden muss. Diese Optimierungen begrenzen die Commit-Anzahl, deaktivieren das aufwaendige Graph-Rendering und nutzen bei Bedarf Shallow Clones. Stell dir vor, du arbeitest am Linux-Kernel-Repository mit ueber einer Million Commits -- ohne Limit wuerde tig beim Start mehrere Sekunden oder sogar Minuten brauchen. Mit --max-count=500 siehst du nur die letzten 500 Commits, was fuer die taegliche Arbeit voellig ausreichend ist. Die Graph-Deaktivierung spart weitere Rechenzeit, da das Zeichnen der Branch-Linien bei vielen parallelen Branches aufwaendig ist.

# Limit Commit-Count
tig --max-count=500

# Disable Graph für Speed
set main-view = id date author commit-title:graph=no

# Shallow Clone für Testing
git clone --depth 100 <repo>
tig

Beispiele

. Feature-Branch Review

# Check out Feature Branch
git checkout feature/new-auth

# Öffne tig
tig

# Navigation:
# - j/k zum Navigieren durch Commits
# - Enter auf Commit → Diff-View
# - Tab → Cycle durch Views
# - d → Toggle Diff unten

# Workflow:
# 1. Scrolle durch alle Commits
# 2. Enter auf verdächtigen Commit
# 3. Prüfe Diff im Detail
# 4. b für Blame falls unklar
# 5. q zurück zu Main-View

. Bug-Hunt mit Blame

# File mit Bug öffnen
tig blame src/auth/login.js

# Navigation durch Zeilen
# - j/k um Zeilen zu durchsuchen
# - Zeile mit Bug identifizieren
# - Enter auf Zeile → Commit-Details
# - Prüfe Message: "Why was this changed?"

# Wenn Commit unklar:
# - Kopiere Commit-Hash (markieren & Ctrl+Shift+C)
# - Exit tig (q)
# - git show <hash> | claude "Explain this commit"

. Merge-Conflict Resolution History

# Alle Merges anzeigen
tig --merges

# Oder mit grep
tig --grep="Merge"

# Workflow:
# 1. Identifiziere problematischen Merge
# 2. Enter → Details
# 3. Prüfe Parents (shows "Merge: abc def")
# 4. Exit mit q
# 5. git show <merge-hash> --stat

. Reflog-Browse nach Force-Push

# Reflog öffnen
tig reflog

# oder
tig -g

# Navigation:
# - Scrolle durch reflog-Einträge
# - Identifiziere "old" State vor force-push
# - Enter → Details
# - Kopiere Commit-Hash

# Recovery:
git reset --hard <hash>
# oder
git cherry-pick <hash>

. Stash-Management

# Öffne Stash-View
tig stash

# Navigation:
# - Liste aller Stashes
# - Enter → Stash-Details & Diff
# - ! → Run command

# Custom Command in tig:
# Enter → dann in Command-Zeile:
!git stash apply stash@{0}

# Oder bind in ~/.tigrc:
bind stash A !git stash apply %(stash)
bind stash P !git stash pop %(stash)
bind stash D !git stash drop %(stash)
💡 Tipp: Nutze tig --author=$(git config user.name) --since=yesterday als schnellen Standup-Report -- du siehst sofort alle deine Commits seit gestern in einer uebersichtlichen Darstellung.

. Cross-Branch Comparison

# Vergleiche zwei Branches
tig main..feature

# Zeigt nur Commits in feature, nicht in main

# Reverse
tig feature..main

# Oder Combined (beidseitige Diff)
tig main...feature

# Workflow:
# - Enter auf Commits
# - Prüfe was unterschiedlich ist
# - Identifiziere Conflicts

. Git Grep mit tig

# Suche nach Pattern im gesamten Repo
tig grep "API_KEY"

# Mit Context
tig grep -C 3 "TODO"

# Case-insensitive
tig grep -i "password"

# Workflow:
# - Liste aller Matches
# - Enter → File an Position
# - / → Search weiter im File

. Tag & Release Management

# Alle Tags anzeigen
tig refs

# Oder
tig show-ref --tags

# Navigiere zu Tag:
# - j/k durch Liste
# - Enter → Tag-Details & Commit
# - t → Create Tag at Commit

# Workflow für Release-Notes:
# 1. tig v1.0.0..v2.0.0
# 2. Scrolle durch alle Changes
# 3. Kopiere relevante Commits
# 4. Generiere Notes mit Claude

. Author-Contribution Analysis

# Alle Commits von Author
tig --author="Jane Doe"

# Combined mit Time-Range
tig --author="Jane" --since="1 month ago"

# Count Commits (außerhalb tig)
git log --author="Jane" --since="1 month" --oneline | wc -l

# Mit tig für Details:
tig --author="Jane" --since="1 month" --stat

. Interactive Rebase Planning

# Letzte 10 Commits anzeigen
tig HEAD~10..HEAD

# Workflow:
# 1. Identifiziere Commits für Squash
# 2. Notiere Hashes
# 3. Exit tig
# 4. git rebase -i HEAD~10
# 5. Squash die identifizierten Commits

# Oder mit lazygit:
# tig → Identifiziere
# lazygit → Rebase durchführen

Claude Code Integration

Workflow 1: Claude Code Commits reviewen

Wenn Claude Code Commits mit Co-Author-Zeilen erstellt, kannst du mit tig alle AI-generierten Commits gezielt filtern und reviewen. Der --grep Filter durchsucht Commit-Messages nach dem angegebenen Pattern und zeigt nur passende Commits an. Stell dir vor, du willst am Ende der Woche pruefen, welche Aenderungen Claude Code vorgenommen hat -- dieser Befehl zeigt dir alle Claude-Commits in der uebersichtlichen tig-Ansicht. Du kannst dann mit Enter in jeden Commit hineinschauen und den vollstaendigen Diff inspizieren. Das ist besonders wichtig fuer Code-Quality-Reviews von AI-generiertem Code.

# Alle Commits mit Claude Co-Author anzeigen
tig --grep="Co-Authored-By: Claude"

Workflow 2: Branch-Vergleich vor Merge

Bevor du einen Feature-Branch in main mergst, solltest du alle Commits zwischen den Branches pruefen. Dieser Befehl zeigt nur die Commits an, die im Feature-Branch existieren, aber nicht in main -- also genau die Aenderungen, die durch den Merge hinzukommen wuerden. Stell dir vor, ein Kollege bittet dich, seinen Feature-Branch zu reviewen, bevor er gemergt wird -- in tig siehst du alle Commits chronologisch, kannst in jeden Commit reinschauen und die Aenderungen im Detail pruefen. Das ist deutlich uebersichtlicher als git log und schneller als ein PR-Review im Browser.

tig main..feature-branch

Workflow 3: File-History nach Claude Code Aenderungen

Die File-History zeigt dir alle Commits, die eine bestimmte Datei betreffen, in chronologischer Reihenfolge. Das ist besonders wertvoll nach einer Claude Code Session, in der eine Datei mehrfach geaendert wurde. Stell dir vor, Claude hat eine Komponente in drei Schritten refactored und du willst nachvollziehen, was in jedem Schritt passiert ist -- tig zeigt dir jeden Commit mit seinem Diff. Du kannst mit Enter in jeden Commit hineinschauen und die genauen Aenderungen sehen. So verstehst du die Entwicklungsgeschichte einer Datei, ohne alle Commits einzeln aufrufen zu muessen.

tig -- src/components/Header.tsx
💡 Tipp: Nutze tig um die von Claude Code erstellten Commits visuell zu reviewen bevor du sie pushst.

Troubleshooting

Die meisten tig-Probleme betreffen fehlende Git-Repos, Darstellungsprobleme oder Performance bei grossen Historien.

Problem: tig startet nicht

tig benoetigt ein Git-Repository im aktuellen oder einem uebergeordneten Verzeichnis. Ohne Git-Repo verweigert es den Start.

Symptom: Fehlermeldung beim Start

tig
# Error: Not a git repository

Lösung: In Git-Repo navigieren

# Check ob Git-Repo
git status

# Oder init
git init

# Oder in Repo navigieren
cd /path/to/repo
tig

Problem: Keybindings funktionieren nicht

Die Standard-Keybindings von tig sind nicht Vim-aehnlich. g/G zum Springen an Anfang/Ende muss erst in der ~/.tigrc konfiguriert werden.

Symptom: Vim-Keys (g, G) funktionieren nicht

# In tig: g drücken → nichts passiert

Lösung: ~/.tigrc konfigurieren

# ~/.tigrc erstellen
cat > ~/.tigrc << 'EOF'
bind generic g move-first-line
bind generic G move-last-line
EOF

# tig neustarten

Problem: Zu viele Commits (Performance)

Bei Repositories mit Hunderttausenden Commits muss tig die gesamte Historie laden, was entsprechend lange dauert.

Symptom: tig lädt ewig bei riesigem Repo

tig  # Dauert >10 Sekunden

Lösung: Limit setzen

# Max Commits limitieren
tig --max-count=200

# Oder in ~/.tigrc
set main-view-commit-limit = 200

# Shallow Clone verwenden
git clone --depth 500 <repo>

Problem: UTF-8 Encoding Issues

Falsche Locale-Einstellungen fuehren dazu, dass Umlaute und Sonderzeichen als Fragezeichen oder Kauderwelsch angezeigt werden.

Symptom: Weird characters in tig

tig  # Zeigt � statt Umlaute

Lösung: Locale korrekt setzen

# Check Locale
locale

# In ~/.bashrc
export LANG=en_US.UTF-8
export LC_ALL=en_US.UTF-8

# In ~/.tigrc
set line-graphics = utf-8

Problem: Colors sehen falsch aus

Das Standard-Farbschema von tig kann je nach Terminal-Hintergrund schlecht lesbar sein, z.B. dunkler Text auf dunklem Hintergrund.

Symptom: Unlesbare Farben im Terminal

tig  # Schwarzer Text auf schwarzem Hintergrund

Lösung: Color-Scheme anpassen

# ~/.tigrc
color cursor black green bold
color title-focus white blue bold
color diff-add green default
color diff-del red default
color author yellow default bold

# Oder Terminal-Colors prüfen
echo $TERM
# Sollte: xterm-256color oder screen-256color

Problem: Remote-Branches nicht sichtbar

tig zeigt nur die lokal bekannten Referenzen. Ohne vorheriges git fetch fehlen neue Remote-Branches.

Symptom: Nur lokale Branches in tig refs

tig refs  # Fehlen origin/* Branches

Lösung: Fetch und View-Config

# Remote-Branches fetchen
git fetch --all

# In ~/.tigrc - Remote Refs anzeigen
set main-view = date author commit-title:graph=yes,refs=yes

# Oder in refs-View
# Drücke R für Refresh

Vergleich: tig vs. Alternativen

| Feature | tig | lazygit | gitk | GitKraken |
|---------|-----|---------|------|-----------|
| Interface | ncurses | ncurses | Tk GUI | Electron GUI |
| Performance | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐ |
| SSH-Friendly | ✅ | ✅ | ❌ | ❌ |
| Interactive Ops | ⚠️ Limited | ✅ Full | ❌ | ✅ Full |
| History-Browse | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ |
| Blame-View | ✅ | ✅ | ✅ | ✅ |
| Diff-View | ✅ | ✅ Delta | ⚠️ Basic | ✅ |
| Resource-Usage | Minimal | Low | Medium | High |
| Learning Curve | Medium | Low | Low | Very Low |
| Customizable | ✅ tigrc | ⚠️ Limited | ❌ | ⚠️ |

Wann welches Tool?

tig:

lazygit:

gitk:

GitKraken:

Links & Ressourcen

Offizielle Dokumentation

Tutorials & Guides

Configuration Examples

Integration

Pro-Tipps

. Nutze tig als git-log Replacement

Wenn du tig als Ersatz fuer git log verwendest, hast du sofort eine interaktive, navigierbare Ansicht statt statischem Text-Output. Diese Aliase machen tig zu deinem Standard-Tool fuer Git-Historie, Refs und Status. Stell dir vor, du tippst gewohnheitsmaessig gl statt git log -- du bekommst sofort die tig-Ansicht mit Navigation, Diff-View und Blame-Zugriff. Der Git-Alias git t integriert tig direkt in die Git-Befehlsstruktur, was sich fuer Team-Mitglieder natuerlich anfuehlt, die tig noch nicht kennen.

# In ~/.bashrc
alias gl='tig'
alias gla='tig --all'
alias gls='tig status'
alias glr='tig refs'

# Oder als Git-Alias
git config --global alias.t '!tig'
# Usage: git t

. Custom View für Daily-Standup

Diese Konfiguration bindet Shift+S in tig an eine gefilterte Ansicht, die nur deine eigenen Commits seit gestern zeigt. Das ist perfekt als schneller Standup-Report: Ein Tastendruck zeigt dir alle Aufgaben, an denen du seit gestern gearbeitet hast. Stell dir vor, du bist im Daily-Standup und musst berichten, was du gestern gemacht hast -- statt muehsam zu ueberlegen, drueckst du Shift+S in tig und siehst alle deine Commits mit Details. Die Bindung nutzt git config user.name automatisch, sodass du den Alias nicht anpassen musst, wenn du ihn auf verschiedenen Maschinen nutzt.

# ~/.tigrc
bind generic S !sh -c "tig --author=$(git config user.name) --since=yesterday"

# In tig: Drücke Shift+S
# → Zeigt alle eigenen Commits seit gestern

. Kombiniere mit tmux für Power-Workflow

Die Kombination von tig und tmux Split-Screen ist einer der produktivsten Git-Workflows. Links laeuft tig fuer die visuelle Navigation durch die Git-Historie, rechts der Editor fuer sofortige Aenderungen. Stell dir vor, du findest in tig eine fehlerhafte Codezeile per Blame -- statt tig zu verlassen, den Dateinamen zu merken und den Editor zu oeffnen, kopierst du den Dateinamen ueber den tmux Copy Mode und oeffnest ihn direkt im rechten Pane. Dieser Workflow eliminiert den staendigen Kontextwechsel zwischen Git-Historie und Editor und spart pro Code-Review-Session mehrere Minuten.

# Setup tmux-Split
tmux split-window -h

# Links: tig
# Rechts: Editor

# Workflow:
# 1. tig: Browse & identifiziere File
# 2. Copy filename (visual mode in tmux)
# 3. Rechts: vim <filename>

. Quick-Diff Funktion

Diese Konfiguration bindet die Taste D in der Main-View an einen Diff mit delta-Syntax-Highlighting. Normalerweise zeigt tig Diffs in seinem eingebauten Viewer, der kein Syntax-Highlighting hat. Mit dieser Bindung wird der Diff stattdessen durch delta geleitet und im Terminal angezeigt. Stell dir vor, du navigierst durch die Commit-Historie und willst bei einem bestimmten Commit die Aenderungen mit vollem Syntax-Highlighting sehen -- drueckst du D, oeffnet sich der delta-View mit farbigen Diffs. Der Ausdruck %(commit)~ %(commit) vergleicht den Commit mit seinem Vorgaenger, was exakt dem Diff des Commits entspricht.

# ~/.tigrc
bind main D !sh -c "git diff %(commit)~ %(commit) | delta"

# Bindet 'D' in main-view
# → Zeigt Diff mit delta-coloring

. Blame + Claude Integration

Diese Funktion kombiniert tig's Blame-Ansicht mit Claude Code Analyse. Sie exportiert den Blame-Output einer Datei und laesst Claude die Patterns analysieren -- zum Beispiel welche Autoren welche Bereiche geschrieben haben, wo die meisten Aenderungen stattfinden, und welche Zeilen am aeltesten (und damit moeglicherweise veraltet) sind. Stell dir vor, du uebernimmst ein neues Projekt und willst verstehen, wer welchen Bereich des Codes besitzt und wo die meisten Aenderungen stattfinden -- diese Funktion gibt dir eine AI-generierte Analyse. Beachte, dass die Funktion den tig-Output in eine temporaere Datei schreibt, die nach der Analyse geloescht werden sollte.

# Function in ~/.bashrc
tigblame_ai() {
  local file=$1
  tig blame "$file" > /tmp/blame.txt
  cat /tmp/blame.txt | claude "Analyze git blame, identify patterns"
}

# Usage: tigblame_ai src/app.js

. Export Historie für Dokumentation

Diese Funktion generiert einen strukturierten Changelog zwischen zwei Tags oder Commits. Sie nutzt git log mit einem benutzerdefinierten Format und uebergibt das Ergebnis an Claude Code fuer die Formatierung. Stell dir vor, du bereitest ein neues Release vor und brauchst eine lesbare Liste aller Aenderungen seit dem letzten Release -- statt manuell durch Commits zu scrollen, erstellt diese Funktion einen formatierten Changelog in Sekunden. Die --reverse Option zeigt die Commits in chronologischer Reihenfolge, was fuer Changelogs natuerlicher ist. Standardmaessig vergleicht die Funktion von v1.0.0 bis HEAD, aber du kannst beliebige Tags oder Commit-Hashes uebergeben.

# Function: Generate Changelog
changelog() {
  local from=${1:-v1.0.0}
  local to=${2:-HEAD}

  git log $from..$to \
    --pretty=format:"* %s (%an, %ar)" \
    --reverse | \
    claude "Format as structured changelog"
}

. Interaktive Cherry-Pick

Diese Konfiguration fuegt zwei nuetzliche Keybindings zur Main-View hinzu: C fuer Cherry-Pick mit -x Flag (das eine "cherry picked from" Notiz hinzufuegt) und X fuer das Kopieren des Commit-Diffs in die Zwischenablage. Stell dir vor, du browsst durch die Historie eines anderen Branches und findest einen Bugfix, den du auf deinem Branch brauchst -- statt den Commit-Hash zu notieren und tig zu verlassen, drueckst du einfach C direkt auf dem Commit. Das -x Flag ist wichtig fuer die Nachvollziehbarkeit, da es dokumentiert, woher der Cherry-Pick stammt. Die X-Bindung nutzt pbcopy (macOS) und kann fuer Linux durch xclip ersetzt werden.

# ~/.tigrc
bind main C !git cherry-pick -x %(commit)
bind main X !sh -c "git show %(commit) | pbcopy"

# Workflow:
# 1. tig in source-branch
# 2. Navigate to commit
# 3. Drücke C → cherry-pick
# Oder X → copy to clipboard

Zusammenfassung

tig ist ein essentielles Tool für Git-Power-Users, die Effizienz und Übersichtlichkeit schätzen:

Kern-Vorteile:

✅ Visual Git-Historie übersichtlich dargestellt
✅ Interaktiv Vim-like Navigation, schnell & effizient
✅ SSH-Friendly Funktioniert remote ohne GUI
✅ Feature-Rich Blame, Diff, Refs, Status, Grep
✅ Customizable Powerful ~/.tigrc Configuration

Typische Use Cases:

Ergänzt perfekt:

Nächste Schritte:

Bottom Line: tig ist unverzichtbar für Git-Workflows im Terminal. Schneller als GUI, mächtiger als git log, perfekt für Remote-Work.

Weiter zu: [16. zsh - Modern Shell](./16-zsh.md) Zurück zu: [14. fd - File-Finding](./14-fd.md) Übersicht: [Tools & Extensions](../TOOLS-EXTENSIONS-INDEX.md)