Passen Sie Ihre Statuszeile an

• Die Kontextfensternutzung während der Arbeit überwachen möchten
• Sitzungskosten verfolgen müssen
• Über mehrere Sitzungen hinweg arbeiten und diese unterscheiden müssen
• Git-Branch und Status immer sichtbar haben möchten

​

Richten Sie eine Statuszeile ein

​

Verwenden Sie den /statusline Befehl

/statusline show model name and context percentage with a progress bar

​

Statuszeile manuell konfigurieren

{
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh",
    "padding": 2
  }
}

{
  "statusLine": {
    "type": "command",
    "command": "jq -r '\"[\\(.model.display_name)] \\(.context_window.used_percentage // 0)% context\"'"
  }
}

​

Deaktivieren Sie die Statuszeile

​

Erstellen Sie eine Statuszeile Schritt für Schritt

#!/bin/bash
# Read JSON data that Claude Code sends to stdin
input=$(cat)

# Extract fields using jq
MODEL=$(echo "$input" | jq -r '.model.display_name')
DIR=$(echo "$input" | jq -r '.workspace.current_dir')
# The "// 0" provides a fallback if the field is null
PCT=$(echo "$input" | jq -r '.context_window.used_percentage // 0' | cut -d. -f1)

# Output the status line - ${DIR##*/} extracts just the folder name
echo "[$MODEL] 📁 ${DIR##*/} | ${PCT}% context"

chmod +x ~/.claude/statusline.sh

{
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh"
  }
}

​

Wie Statuszeilen funktionieren

• Mehrere Zeilen: Jede echo oder print Anweisung wird als separate Zeile angezeigt. Siehe das mehrzeilige Beispiel.
• Farben: Verwenden Sie ANSI-Escape-Codes wie \033[32m für Grün (Terminal muss diese unterstützen). Siehe das Git-Status-Beispiel.
• Links: Verwenden Sie OSC 8 Escape-Sequenzen, um Text anklickbar zu machen (Cmd+Klick auf macOS, Strg+Klick auf Windows/Linux). Erfordert ein Terminal, das Hyperlinks wie iTerm2, Kitty oder WezTerm unterstützt. Siehe das anklickbare Links-Beispiel.

​

Verfügbare Daten

{
  "cwd": "/current/working/directory",
  "session_id": "abc123...",
  "transcript_path": "/path/to/transcript.jsonl",
  "model": {
    "id": "claude-opus-4-6",
    "display_name": "Opus"
  },
  "workspace": {
    "current_dir": "/current/working/directory",
    "project_dir": "/original/project/directory"
  },
  "version": "1.0.80",
  "output_style": {
    "name": "default"
  },
  "cost": {
    "total_cost_usd": 0.01234,
    "total_duration_ms": 45000,
    "total_api_duration_ms": 2300,
    "total_lines_added": 156,
    "total_lines_removed": 23
  },
  "context_window": {
    "total_input_tokens": 15234,
    "total_output_tokens": 4521,
    "context_window_size": 200000,
    "used_percentage": 8,
    "remaining_percentage": 92,
    "current_usage": {
      "input_tokens": 8500,
      "output_tokens": 1200,
      "cache_creation_input_tokens": 5000,
      "cache_read_input_tokens": 2000
    }
  },
  "exceeds_200k_tokens": false,
  "vim": {
    "mode": "NORMAL"
  },
  "agent": {
    "name": "security-reviewer"
  },
  "worktree": {
    "name": "my-feature",
    "path": "/path/to/.claude/worktrees/my-feature",
    "branch": "worktree-my-feature",
    "original_cwd": "/path/to/project",
    "original_branch": "main"
  }
}

​

Kontextfenster-Felder

• Kumulative Summen (total_input_tokens, total_output_tokens): Summe aller Token über die gesamte Sitzung, nützlich zur Verfolgung des Gesamtverbrauchs
• Aktuelle Nutzung (current_usage): Token-Zählungen aus dem letzten API-Aufruf, verwenden Sie dies für einen genauen Kontextprozentsatz, da er den tatsächlichen Kontextzustand widerspiegelt

• input_tokens: Eingabe-Token im aktuellen Kontext
• output_tokens: generierte Ausgabe-Token
• cache_creation_input_tokens: Token, die in den Cache geschrieben wurden
• cache_read_input_tokens: Token, die aus dem Cache gelesen wurden

​

Beispiele

1. Speichern Sie das Skript in einer Datei wie ~/.claude/statusline.sh (oder .py/.js)
2. Machen Sie es ausführbar: chmod +x ~/.claude/statusline.sh
3. Fügen Sie den Pfad zu Ihren Einstellungen hinzu

​

Kontextfensternutzung

#!/bin/bash
# Read all of stdin into a variable
input=$(cat)

# Extract fields with jq, "// 0" provides fallback for null
MODEL=$(echo "$input" | jq -r '.model.display_name')
PCT=$(echo "$input" | jq -r '.context_window.used_percentage // 0' | cut -d. -f1)

# Build progress bar: printf -v creates a run of spaces, then
# ${var// /▓} replaces each space with a block character
BAR_WIDTH=10
FILLED=$((PCT * BAR_WIDTH / 100))
EMPTY=$((BAR_WIDTH - FILLED))
BAR=""
[ "$FILLED" -gt 0 ] && printf -v FILL "%${FILLED}s" && BAR="${FILL// /▓}"
[ "$EMPTY" -gt 0 ] && printf -v PAD "%${EMPTY}s" && BAR="${BAR}${PAD// /░}"

echo "[$MODEL] $BAR $PCT%"

​

Git-Status mit Farben

#!/bin/bash
input=$(cat)

MODEL=$(echo "$input" | jq -r '.model.display_name')
DIR=$(echo "$input" | jq -r '.workspace.current_dir')

GREEN='\033[32m'
YELLOW='\033[33m'
RESET='\033[0m'

if git rev-parse --git-dir > /dev/null 2>&1; then
    BRANCH=$(git branch --show-current 2>/dev/null)
    STAGED=$(git diff --cached --numstat 2>/dev/null | wc -l | tr -d ' ')
    MODIFIED=$(git diff --numstat 2>/dev/null | wc -l | tr -d ' ')

    GIT_STATUS=""
    [ "$STAGED" -gt 0 ] && GIT_STATUS="${GREEN}+${STAGED}${RESET}"
    [ "$MODIFIED" -gt 0 ] && GIT_STATUS="${GIT_STATUS}${YELLOW}~${MODIFIED}${RESET}"

    echo -e "[$MODEL] 📁 ${DIR##*/} | 🌿 $BRANCH $GIT_STATUS"
else
    echo "[$MODEL] 📁 ${DIR##*/}"
fi

​

Kosten- und Dauer-Verfolgung

#!/bin/bash
input=$(cat)

MODEL=$(echo "$input" | jq -r '.model.display_name')
COST=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
DURATION_MS=$(echo "$input" | jq -r '.cost.total_duration_ms // 0')

COST_FMT=$(printf '$%.2f' "$COST")
DURATION_SEC=$((DURATION_MS / 1000))
MINS=$((DURATION_SEC / 60))
SECS=$((DURATION_SEC % 60))

echo "[$MODEL] 💰 $COST_FMT | ⏱️ ${MINS}m ${SECS}s"

​

Mehrere Zeilen anzeigen

#!/bin/bash
input=$(cat)

MODEL=$(echo "$input" | jq -r '.model.display_name')
DIR=$(echo "$input" | jq -r '.workspace.current_dir')
COST=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
PCT=$(echo "$input" | jq -r '.context_window.used_percentage // 0' | cut -d. -f1)
DURATION_MS=$(echo "$input" | jq -r '.cost.total_duration_ms // 0')

CYAN='\033[36m'; GREEN='\033[32m'; YELLOW='\033[33m'; RED='\033[31m'; RESET='\033[0m'

# Pick bar color based on context usage
if [ "$PCT" -ge 90 ]; then BAR_COLOR="$RED"
elif [ "$PCT" -ge 70 ]; then BAR_COLOR="$YELLOW"
else BAR_COLOR="$GREEN"; fi

FILLED=$((PCT / 10)); EMPTY=$((10 - FILLED))
printf -v FILL "%${FILLED}s"; printf -v PAD "%${EMPTY}s"
BAR="${FILL// /█}${PAD// /░}"

MINS=$((DURATION_MS / 60000)); SECS=$(((DURATION_MS % 60000) / 1000))

BRANCH=""
git rev-parse --git-dir > /dev/null 2>&1 && BRANCH=" | 🌿 $(git branch --show-current 2>/dev/null)"

echo -e "${CYAN}[$MODEL]${RESET} 📁 ${DIR##*/}$BRANCH"
COST_FMT=$(printf '$%.2f' "$COST")
echo -e "${BAR_COLOR}${BAR}${RESET} ${PCT}% | ${YELLOW}${COST_FMT}${RESET} | ⏱️ ${MINS}m ${SECS}s"

​

Anklickbare Links

#!/bin/bash
input=$(cat)

MODEL=$(echo "$input" | jq -r '.model.display_name')

# Convert git SSH URL to HTTPS
REMOTE=$(git remote get-url origin 2>/dev/null | sed 's/[email protected]:/https:\/\/github.com\//' | sed 's/\.git$//')

if [ -n "$REMOTE" ]; then
    REPO_NAME=$(basename "$REMOTE")
    # OSC 8 format: \e]8;;URL\a then TEXT then \e]8;;\a
    # printf %b interprets escape sequences reliably across shells
    printf '%b' "[$MODEL] 🔗 \e]8;;${REMOTE}\a${REPO_NAME}\e]8;;\a\n"
else
    echo "[$MODEL]"
fi

​

Teure Operationen zwischenspeichern

#!/bin/bash
input=$(cat)

MODEL=$(echo "$input" | jq -r '.model.display_name')
DIR=$(echo "$input" | jq -r '.workspace.current_dir')

CACHE_FILE="/tmp/statusline-git-cache"
CACHE_MAX_AGE=5  # seconds

cache_is_stale() {
    [ ! -f "$CACHE_FILE" ] || \
    # stat -f %m is macOS, stat -c %Y is Linux
    [ $(($(date +%s) - $(stat -f %m "$CACHE_FILE" 2>/dev/null || stat -c %Y "$CACHE_FILE" 2>/dev/null || echo 0))) -gt $CACHE_MAX_AGE ]
}

if cache_is_stale; then
    if git rev-parse --git-dir > /dev/null 2>&1; then
        BRANCH=$(git branch --show-current 2>/dev/null)
        STAGED=$(git diff --cached --numstat 2>/dev/null | wc -l | tr -d ' ')
        MODIFIED=$(git diff --numstat 2>/dev/null | wc -l | tr -d ' ')
        echo "$BRANCH|$STAGED|$MODIFIED" > "$CACHE_FILE"
    else
        echo "||" > "$CACHE_FILE"
    fi
fi

IFS='|' read -r BRANCH STAGED MODIFIED < "$CACHE_FILE"

if [ -n "$BRANCH" ]; then
    echo "[$MODEL] 📁 ${DIR##*/} | 🌿 $BRANCH +$STAGED ~$MODIFIED"
else
    echo "[$MODEL] 📁 ${DIR##*/}"
fi

​

Windows-Konfiguration

{
  "statusLine": {
    "type": "command",
    "command": "powershell -NoProfile -File C:/Users/username/.claude/statusline.ps1"
  }
}

{
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh"
  }
}

​

Tipps

• Mit Mock-Eingabe testen: echo '{"model":{"display_name":"Opus"},"context_window":{"used_percentage":25}}' | ./statusline.sh
• Ausgabe kurz halten: Die Statusleiste hat begrenzte Breite, daher kann lange Ausgabe abgeschnitten oder unangenehm umgebrochen werden
• Langsame Operationen zwischenspeichern: Ihr Skript wird während aktiver Sitzungen häufig ausgeführt, daher können Befehle wie git status zu Verzögerungen führen. Siehe das Caching-Beispiel für die Handhabung.

​

Fehlerbehebung

• Überprüfen Sie, dass Ihr Skript ausführbar ist: chmod +x ~/.claude/statusline.sh
• Überprüfen Sie, dass Ihr Skript auf stdout ausgibt, nicht auf stderr
• Führen Sie Ihr Skript manuell aus, um zu überprüfen, dass es Ausgabe erzeugt
• Wenn disableAllHooks in Ihren Einstellungen auf true gesetzt ist, ist die Statuszeile auch deaktiviert. Entfernen Sie diese Einstellung oder setzen Sie sie auf false, um sie erneut zu aktivieren.
• Führen Sie claude --debug aus, um den Exit-Code und stderr aus der ersten Statuszeilen-Invokation in einer Sitzung zu protokollieren
• Bitten Sie Claude, Ihre Einstellungsdatei zu lesen und den statusLine Befehl direkt auszuführen, um Fehler zu finden

• Felder können null sein, bevor die erste API-Antwort abgeschlossen ist
• Behandeln Sie Null-Werte in Ihrem Skript mit Fallbacks wie // 0 in jq
• Starten Sie Claude Code neu, wenn Werte nach mehreren Nachrichten leer bleiben

• Verwenden Sie used_percentage für genauen Kontextzustand anstelle von kumulativen Summen
• Die total_input_tokens und total_output_tokens sind kumulativ über die Sitzung und können die Kontextfenstergröße überschreiten
• Der Kontextprozentsatz kann sich von der /context Ausgabe unterscheiden, je nachdem, wann jeder berechnet wird

• Überprüfen Sie, dass Ihr Terminal OSC 8-Hyperlinks unterstützt (iTerm2, Kitty, WezTerm)
• Terminal.app unterstützt keine anklickbaren Links
• SSH- und tmux-Sitzungen können OSC-Sequenzen je nach Konfiguration entfernen
• Wenn Escape-Sequenzen als Literaltext wie \e]8;; angezeigt werden, verwenden Sie printf '%b' anstelle von echo -e für zuverlässigere Escape-Behandlung

• Komplexe Escape-Sequenzen (ANSI-Farben, OSC 8-Links) können gelegentlich zu beschädigter Ausgabe führen, wenn sie mit anderen UI-Aktualisierungen überlappen
• Wenn Sie beschädigten Text sehen, versuchen Sie, Ihr Skript auf einfache Textausgabe zu vereinfachen
• Mehrzeilige Statuszeilen mit Escape-Codes sind anfälliger für Rendering-Probleme als einzeilige einfache Texte

• Skripte, die mit Nicht-Null-Codes beendet werden oder keine Ausgabe erzeugen, führen dazu, dass die Statuszeile leer wird
• Langsame Skripte blockieren die Statuszeilen-Aktualisierung, bis sie abgeschlossen sind. Halten Sie Skripte schnell, um veraltete Ausgabe zu vermeiden.
• Wenn eine neue Aktualisierung ausgelöst wird, während ein langsames Skript läuft, wird das laufende Skript abgebrochen
• Testen Sie Ihr Skript unabhängig mit Mock-Eingabe, bevor Sie es konfigurieren

• Systembenachrichtigungen wie MCP-Serverfehler, automatische Updates und Token-Warnungen werden auf der rechten Seite derselben Zeile wie Ihre Statuszeile angezeigt
• Das Aktivieren des ausführlichen Modus fügt einen Token-Zähler zu diesem Bereich hinzu
• Auf schmalen Terminals können diese Benachrichtigungen Ihre Statuszeilen-Ausgabe abschneiden