Autovervollständigung für Bash & zsh

Autovervollständigung macht eigene Kommandozeilen‑Tools leichter nutzbar. In diesem Artikel lernst du, wie du für zsh und Bash einfache, kontextbewusste Tab‑Completion schreibst, wie du ein portables Skript baust, wie du testest und wie du Rollout und Fehlerbehebung planst.

Terminalfenster mit der Man-Page des Mutt-E-Mail-Clients unter Linux

Warum Autocomplete wichtig ist

Autovervollständigung spart Zeit, reduziert Tippfehler und erhöht die Entdeckbarkeit von Optionen und Unterbefehlen. Für eigene Skripte macht sie die Benutzeroberfläche intuitiver. Kurz gesagt: Autocomplete verbessert die Usability und verringert Support‑Aufwand.

Wichtige Begriffe (1‑Zeiler)

Tab‑Completion: Vorschläge, die beim Drücken der Tab‑Taste erscheinen.
Subcommand: Ein Unterbefehl wie “edit” oder “help”.
compadd / COMPREPLY: Funktionen/Variablen, mit denen Vorschläge an die Shell übergeben werden.

Wie Tab Completion grundsätzlich funktioniert

Autocomplete gibt es in vielen Formen. Shells wie zsh und Bash bieten ein mächtiges Ökosystem. Bei Befehlen und Dateinamen nutzt die Shell Informationen wie PATH oder das Dateisystem. Bei Argumenten und Subcommands musst du Vorschläge bereitstellen, die zur aktuellen Cursorposition passen.

Autovervollständigungsvorschläge für Befehl 'git check' zeigen check-attr, check-ignore und checkout.

Beispiel: Ein kleines “todos”‑Skript

Das folgende Minimalbeispiel verwaltet eine einfache To‑Do‑Datei. Der Inhalt ist sekundär — wir zeigen nur, wie die Completion dazu passt.

#!/usr/bin/env zsh  
  
FILE="$HOME/.local/state/todos/data"  
  
if [ "$#" -eq "1" ] && [ "$1" = "edit" ] ; then  
    "${EDITOR:-vi}" "$FILE"  
elif [ "$#" -eq "1" ] && [ "$1" = "help" ] ; then  
    echo "Usage: $(basename $0) [ edit | help ]"  
else  
    <"$FILE" grep -v ^~  
fi

Auf meinem System heißen die Befehle dann:

todos — Ausgabe der Daten, ~‑Zeilen ignorieren
todos help — Hilfe anzeigen
todos edit — Datei im Editor öffnen

Du kannst ein leeres ausführbares Skript mit dem Namen todos in den PATH legen. Die Completion funktioniert dann genauso.

Zsh: die einfache Variante

In zsh ist die minimalste Completion sehr kurz. Du definierst eine Funktion, lädst compinit und verbindest die Funktion mit deinem Befehl:

_complete_todos() {  
    compadd help edit  
}  
  
autoload -Uz compinit  
compinit  
compdef _complete_todos todos

Erläuterung:

_complete_todos ist der Handler. Er ruft compadd auf.
compadd nimmt einzelne Wörter als Vorschläge.
compinit initialisiert das Completion‑System.
compdef verknüpft Handler und Befehl.

Du kannst diesen Code in ~/.zshrc einfügen oder als Datei im fpath ablegen (Dateiname beginnt mit “_”). Für Entwicklungstests kannst du ihn einfach interaktiv ausführen.

Bash: mehr Kontrolle, mehr Arbeit

Bash verlässt sich stärker auf dich. Ein simples Beispiel:

_complete_todos_bash() {  
    COMPREPLY=(help edit)  
}  
  
complete -F _complete_todos_bash todos

Das funktioniert, listet aber immer alle Vorschläge, auch wenn schon der Anfang des Wortes eingegeben wurde:

$ todos he  
help edit

Bash liefert bei Tablevents nützliche Variablen:

COMP_WORDS: Array mit allen Wörtern der aktuellen Kommandozeile.
COMP_CWORD: Index des Wortes, in dem sich der Cursor befindet.

Mit compgen kannst du aus einer Liste nur die passenden Vorschläge erzeugen:

$ compgen -W "one two three" o  
one  
$ compgen -W "one two three" t  
two  
three

Vollständiges Bash‑Beispiel:

_complete_todos_bash() {  
    COMPREPLY=( $( compgen -W "edit help" -- "${COMP_WORDS[$COMP_CWORD]}" ) )  
}  
  
complete -F _complete_todos_bash todos

Portables Skript, das in beiden Shells funktioniert

Für wiederverwendbare Skripte lohnt sich eine kurze Abstraktion. Dieses Beispiel erkennt die Shell und registriert die passende Completion:

SUBCOMMANDS=(help edit halt)  
  
_complete_todos_zsh() {  
    compadd $SUBCOMMANDS  
}  
  
_complete_todos_bash() {  
    COMPREPLY=( $( compgen -W "${SUBCOMMANDS[*]}" -- "${COMP_WORDS[$COMP_CWORD]}" ) )  
}  
  
if [ -n "${ZSH_VERSION:-}" ]; then  
    autoload -Uz compinit  
    compinit  
    compdef _complete_todos_zsh todos  
elif [ -n "${BASH_VERSION:-}" ]; then  
    complete -F _complete_todos_bash todos  
fi

Hinweis: Entscheidend ist die Shell, in der die Completion ausgeführt wird — also die Shell, in der der Nutzer Tab drückt.

Erweiterte Zsh‑Techniken

Zsh bietet zusätzliche Funktionen:

Muster‑ und Glob‑Vervollständigung.
Description‑Strings neben Vorschlägen (mit compadd -d oder Hilfe durch _describe).
Kontextabhängige Completion für Optionen (z.B. unterschiedliche Vorschläge nach einem bestimmten Flag).

Beispiel für beschriebene Vorschläge:

_complete_colors() {  
    compadd "red:Warnfarbe" "green:Erfolgsfarbe" "blue:Infofarbe"  
}

Das zeigt neben jedem Vorschlag eine kurze Beschreibung.

Erweiterte Bash‑Techniken

Für komplexe Bash‑Completions gibt es Bibliotheken (z.B. bash‑completion). Wichtige Praktiken:

Verwende compgen für Dateinamen, Prozesse, Funktionen usw.
Arbeite mit COMP_WORDS und COMP_CWORD, um Kontext zu berücksichtigen.
Achte auf IFS und korrekte Quoting‑Regeln, wenn du Arrays und Strings mischst.

Beispiel: Dateiname‑Vorschläge ergänzen:

_complete_open() {  
    COMPREPLY=( $( compgen -f -- "${COMP_WORDS[$COMP_CWORD]}" ) )  
}  
complete -F _complete_open open

Debugging und Tests

Tipps zum Testen und Debuggen von Completion:

Führe Handler interaktiv aus (in zsh einfach die Funktion aufrufen).
Aktiviere set -x für Bash‑Handler, um Variablen zu sehen.
Simuliere die Eingabe mit COMP_WORDS und COMP_CWORD in einer Testumgebung.
Schreibe kleine Unit‑Tests: setze Variablen, rufe die Funktion auf und überprüfe COMPREPLY.

Beispiel‑Testskript für Bash:

COMP_WORDS=(todos he)  
COMP_CWORD=1  
_complete_todos_bash  
if [[ " ${COMPREPLY[*]} " == *help* ]]; then  
    echo "OK"  
else  
    echo "Fehler"  
fi

Sicherheitsaspekte und Privatsphäre

Verarbeite keine sensiblen Daten zur Laufzeit in Vorschlägen, wenn das Skript von mehreren Benutzern genutzt wird.
Sei vorsichtig beim Ausführen von externen Programmen oder Skripten zur Generierung von Vorschlägen.
Verifiziere, welche Pfade oder Umgebungsvariablen du liest, um keine Informationen und Leaks zu erzeugen.

Rollout‑ und Betriebsscheckliste (Rollout)

Prüfe Kompatibilität mit Zsh und Bash.
Lege Installationsort fest: ~/.bashrc, ~/.zshrc oder systemweite Completion‑Verzeichnisse.
Stelle sicher, dass das Skript ausführbar ist und in PATH liegt.
Schreibe kurze Anleitungen für Benutzer.
Füge einfache Tests in CI ein, wenn du das Skript in ein Repo packst.

Wann Autocomplete nicht sinnvoll ist (Gegenbeispiele)

Sehr selten genutzte interne Skripte mit wenigen Anwendern: Aufwand > Nutzen.
Wenn Vorschläge sensible Daten offenlegen.
Bei extrem dynamischen Umgebungen, in denen Vorschläge ständig fehlinformiert sind.

Best Practices / Playbook

Definiere die Menge der Vorschläge (statisch oder dynamisch).
Implementiere Handler für beide Shells oder nutze vorhandene Bibliotheken.
Füge Kontext‑Logik hinzu (prüfe COMP_WORDS/COMP_CWORD oder benutze zsh?_context).
Schreibe Tests für häufige Fälle und Grenzfälle.
Dokumentiere Installation und Deinstallation.

Akzeptanzkriterien

Tab zeigt passende Vorschläge für Top‑Level‑Subcommands.
Teilt der Benutzer bereits ein Teilwort mit, sind Vorschläge darauf begrenzt.
Installation per Source der Datei in .bashrc/.zshrc funktioniert ohne Fehler.
Keine vertraulichen Daten werden als Vorschlag angezeigt.

Entscheidungshilfe (Mermaid)

flowchart TD
  A[Start: Willst du Completion verbreiten?] --> B{Nur du oder mehrere Nutzer?}
  B -->|Nur du| C[Einfach: in .zshrc/.bashrc einfügen]
  B -->|Mehrere| D{Systemweit oder per Repo?}
  D -->|Systemweit| E[In systemweite Completion‑Ordner installieren]
  D -->|Repo| F[Repo mit Install‑Script & CI‑Tests]
  C --> G[Testen]
  E --> G
  F --> G
  G --> H[Rollout & Dokumentation]

Tests und Akzeptanzfälle (Beispiele)

Eingabe: “todos ” → Vorschläge: help, edit, halt
Eingabe: “todos he” → Vorschlag: help
Eingabe: “todos e” → Vorschlag: edit
Installationstest: sourcing der Datei fügt Completion hinzu ohne Fehler

Rolle‑basierte Checkliste

Entwickler: Implementieren Handler, Tests, CI.
DevOps: Systemweiter Installationspfad, Berechtigungen prüfen.
Dokumentation: Kurze Anleitung, Beispiele, Deinstallationsschritte.
QA: Testfälle für Edge‑Cases, Regressionstests.

Kompatibilität und Migrationshinweise

Zsh‑Funktionen (compadd, compdef) sind zsh‑spezifisch. Bash nutzt complete und COMPREPLY.
Für portable Pakete: immer Shell‑Erkennung einbauen (ZSH_VERSION / BASH_VERSION).
Wenn du Nutzer mit älteren Shells hast, teste auf 3.x‑zsh bzw. bash 4.x.

Kurze Glossar‑Liste

compadd: zsh‑Funktion zum Hinzufügen von Vorschlägen.
compinit: Initialisiert zsh Completion‑System.
complete: Bash‑Builtin, registriert Completion‑Funktionen.
compgen: Bash‑Tool zum Generieren von Vorschlägen aus Listen.

Fazit

Autovervollständigung erhöht die Produktivität und macht eigene Skripte benutzerfreundlicher. Beginne mit einer einfachen, statischen Liste; erweitere dann kontextabhängig für robustere Erfahrungen. Teste, dokumentiere und schütze sensible Daten.

Wichtig: Plane Installation und Updates so, dass Nutzer möglichst wenig manuell tun müssen.

Autovervollständigung für Bash- und zsh-Skripte