Zum Hauptinhalt springen
Machen Sie Claude Code zu Ihrem eigenen mit einer benutzerdefinierten Statuszeile, die am unteren Rand der Claude Code-Oberfläche angezeigt wird, ähnlich wie Terminal-Eingabeaufforderungen (PS1) in Shells wie Oh-my-zsh funktionieren.

​
Erstellen Sie eine benutzerdefinierte Statuszeile

Sie können entweder:
  • /statusline ausführen, um Claude Code um Hilfe bei der Einrichtung einer benutzerdefinierten Statuszeile zu bitten. Standardmäßig wird versucht, die Eingabeaufforderung Ihres Terminals zu reproduzieren, aber Sie können Claude Code zusätzliche Anweisungen zum gewünschten Verhalten geben, z. B. /statusline show the model name in orange
  • Fügen Sie direkt einen statusLine-Befehl zu Ihrer .claude/settings.json hinzu: 
{
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh",
    "padding": 0 // Optional: auf 0 setzen, damit die Statuszeile bis zur Kante geht
  }
}

​
Wie es funktioniert

  • Die Statuszeile wird aktualisiert, wenn die Konversationsnachrichten aktualisiert werden
  • Aktualisierungen werden höchstens alle 300 ms ausgeführt
  • Die erste Zeile der Standardausgabe Ihres Befehls wird zum Text der Statuszeile
  • ANSI-Farbcodes werden zur Formatierung Ihrer Statuszeile unterstützt
  • Claude Code übergibt kontextbezogene Informationen über die aktuelle Sitzung (Modell, Verzeichnisse usw.) als JSON über stdin an Ihr Skript

​
JSON-Eingabestruktur

Ihr Statuszeilen-Befehl empfängt strukturierte Daten über stdin im JSON-Format: 
{
  "hook_event_name": "Status",
  "session_id": "abc123...",
  "transcript_path": "/path/to/transcript.json",
  "cwd": "/current/working/directory",
  "model": {
    "id": "claude-opus-4-1",
    "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,
    "current_usage": {
      "input_tokens": 8500,
      "output_tokens": 1200,
      "cache_creation_input_tokens": 5000,
      "cache_read_input_tokens": 2000
    }
  }
}

​
Beispielskripte

​
Einfache Statuszeile

#!/bin/bash
# JSON-Eingabe von stdin lesen
input=$(cat)

# Werte mit jq extrahieren
MODEL_DISPLAY=$(echo "$input" | jq -r '.model.display_name')
CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir')

echo "[$MODEL_DISPLAY] 📁 ${CURRENT_DIR##*/}"

​
Git-bewusste Statuszeile

#!/bin/bash
# JSON-Eingabe von stdin lesen
input=$(cat)

# Werte mit jq extrahieren
MODEL_DISPLAY=$(echo "$input" | jq -r '.model.display_name')
CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir')

# Git-Branch anzeigen, falls in einem Git-Repository
GIT_BRANCH=""
if git rev-parse --git-dir > /dev/null 2>&1; then
    BRANCH=$(git branch --show-current 2>/dev/null)
    if [ -n "$BRANCH" ]; then
        GIT_BRANCH=" | 🌿 $BRANCH"
    fi
fi

echo "[$MODEL_DISPLAY] 📁 ${CURRENT_DIR##*/}$GIT_BRANCH"

​
Python-Beispiel

#!/usr/bin/env python3
import json
import sys
import os

# JSON von stdin lesen
data = json.load(sys.stdin)

# Werte extrahieren
model = data['model']['display_name']
current_dir = os.path.basename(data['workspace']['current_dir'])

# Auf Git-Branch prüfen
git_branch = ""
if os.path.exists('.git'):
    try:
        with open('.git/HEAD', 'r') as f:
            ref = f.read().strip()
            if ref.startswith('ref: refs/heads/'):
                git_branch = f" | 🌿 {ref.replace('ref: refs/heads/', '')}"
    except:
        pass

print(f"[{model}] 📁 {current_dir}{git_branch}")

​
Node.js-Beispiel

#!/usr/bin/env node

const fs = require('fs');
const path = require('path');

// JSON von stdin lesen
let input = '';
process.stdin.on('data', chunk => input += chunk);
process.stdin.on('end', () => {
    const data = JSON.parse(input);
    
    // Werte extrahieren
    const model = data.model.display_name;
    const currentDir = path.basename(data.workspace.current_dir);
    
    // Auf Git-Branch prüfen
    let gitBranch = '';
    try {
        const headContent = fs.readFileSync('.git/HEAD', 'utf8').trim();
        if (headContent.startsWith('ref: refs/heads/')) {
            gitBranch = ` | 🌿 ${headContent.replace('ref: refs/heads/', '')}`;
        }
    } catch (e) {
        // Kein Git-Repository oder HEAD kann nicht gelesen werden
    }
    
    console.log(`[${model}] 📁 ${currentDir}${gitBranch}`);
});

​
Hilfsfunktions-Ansatz

Für komplexere Bash-Skripte können Sie Hilfsfunktionen erstellen: 
#!/bin/bash
# JSON-Eingabe einmal lesen
input=$(cat)

# Hilfsfunktionen für häufige Extraktionen
get_model_name() { echo "$input" | jq -r '.model.display_name'; }
get_current_dir() { echo "$input" | jq -r '.workspace.current_dir'; }
get_project_dir() { echo "$input" | jq -r '.workspace.project_dir'; }
get_version() { echo "$input" | jq -r '.version'; }
get_cost() { echo "$input" | jq -r '.cost.total_cost_usd'; }
get_duration() { echo "$input" | jq -r '.cost.total_duration_ms'; }
get_lines_added() { echo "$input" | jq -r '.cost.total_lines_added'; }
get_lines_removed() { echo "$input" | jq -r '.cost.total_lines_removed'; }
get_input_tokens() { echo "$input" | jq -r '.context_window.total_input_tokens'; }
get_output_tokens() { echo "$input" | jq -r '.context_window.total_output_tokens'; }
get_context_window_size() { echo "$input" | jq -r '.context_window.context_window_size'; }

# Hilfsfunktionen verwenden
MODEL=$(get_model_name)
DIR=$(get_current_dir)
echo "[$MODEL] 📁 ${DIR##*/}"

​
Kontextfenster-Nutzung

Zeigen Sie den Prozentsatz des verbrauchten Kontextfensters an. Das context_window-Objekt enthält:
  • total_input_tokens / total_output_tokens: Kumulative Gesamtwerte über die gesamte Sitzung
  • current_usage: Aktuelle Kontextfenster-Nutzung aus dem letzten API-Aufruf (kann null sein, wenn noch keine Nachrichten vorhanden sind)
    • input_tokens: Eingabe-Token im aktuellen Kontext
    • output_tokens: Generierte Ausgabe-Token
    • cache_creation_input_tokens: In den Cache geschriebene Token
    • cache_read_input_tokens: Aus dem Cache gelesene Token
Für einen genauen Kontextprozentsatz verwenden Sie current_usage, das den tatsächlichen Kontextfenster-Status widerspiegelt: 
#!/bin/bash
input=$(cat)

MODEL=$(echo "$input" | jq -r '.model.display_name')
CONTEXT_SIZE=$(echo "$input" | jq -r '.context_window.context_window_size')
USAGE=$(echo "$input" | jq '.context_window.current_usage')

if [ "$USAGE" != "null" ]; then
    # Aktuellen Kontext aus current_usage-Feldern berechnen
    CURRENT_TOKENS=$(echo "$USAGE" | jq '.input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens')
    PERCENT_USED=$((CURRENT_TOKENS * 100 / CONTEXT_SIZE))
    echo "[$MODEL] Context: ${PERCENT_USED}%"
else
    echo "[$MODEL] Context: 0%"
fi

​
Tipps

  • Halten Sie Ihre Statuszeile prägnant - sie sollte auf eine Zeile passen
  • Verwenden Sie Emojis (falls Ihr Terminal diese unterstützt) und Farben, um Informationen leicht erfassbar zu machen
  • Verwenden Sie jq für JSON-Parsing in Bash (siehe Beispiele oben)
  • Testen Sie Ihr Skript, indem Sie es manuell mit Mock-JSON-Eingabe ausführen: echo '{"model":{"display_name":"Test"},"workspace":{"current_dir":"/test"}}' | ./statusline.sh
  • Erwägen Sie das Caching teurer Operationen (wie Git-Status), falls erforderlich

​
Fehlerbehebung

  • Wenn Ihre Statuszeile nicht angezeigt wird, überprüfen Sie, dass Ihr Skript ausführbar ist (chmod +x)
  • Stellen Sie sicher, dass Ihr Skript auf stdout ausgibt (nicht auf stderr)