Build This Now
Build This Now
Raccourcis clavierGuide de la Status Line
Extension Claude Code pour VS CodeClaude Code vs Cursor en 2026OpenClaw vs Claude CodeSEO IA et optimisation GEOKeybindings Claude CodeConfiguration de la status line Claude Code
speedy_devvkoen_salo
Blog/Toolkit/Extensions/Claude Code Status Line Setup

Configuration de la status line Claude Code

Ajoute une status line Claude Code avec le modèle, la branche git, le coût de session et l'utilisation du contexte. Config settings.json, contrat JSON en entrée, scripts bash, Python, Node.

Arrêtez de configurer. Commencez à construire.

Templates SaaS avec orchestration IA.

Published Feb 24, 2026Toolkit hubExtensions index

Problème : le terminal Claude Code laisse plein d'infos utiles hors écran. Une status line personnalisée affiche le nom du modèle, la branche git, le coût de session en cours et l'utilisation du contexte juste sous l'interface de chat.

Pense à ça comme un PS1 pour Claude Code. Si tu as déjà configuré un prompt shell avec Oh-my-zsh ou Starship, le principe est exactement le même. Une ligne d'infos en temps réel qui te garde orienté pendant que tu travailles.

Ce qu'affiche la status line

La status line vit en bas de l'interface Claude Code et se rafraîchit à chaque changement de conversation. Ce que ton script affiche est rendu : le modèle actuel, la branche git active, le coût de session jusqu'ici, ou le taux de remplissage de la fenêtre de contexte.

Voici un exemple en action :

[Opus] my-project | main | $0.42 | Context: 37%

Une ligne. Modèle, dossier projet, branche git, coût de session, et le pourcentage de la fenêtre de contexte utilisé. Chaque champ se met à jour tout seul.

Configuration rapide avec /statusline

La commande /statusline est intégrée directement dans le CLI. Tape-la dans Claude Code et il génère un script pour toi.

/statusline

Le comportement par défaut crée un script de status line qui reflète ton prompt terminal. Tu peux aussi lui passer une demande précise :

/statusline show the model name in orange

/statusline display git branch and session cost

/statusline show context window percentage with color coding

C'est tout. Claude Code écrit le script, branche les paramètres, et la status line apparaît. Pour un contrôle complet, la configuration manuelle est décrite ci-dessous.

Configuration manuelle via settings.json

Pour le configurer à la main, ajoute une entrée statusLine dans le .claude/settings.json de ton projet (ou dans ton ~/.claude/settings.json global si tu veux que ça s'applique à tous les projets) :

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

Trois champs à connaître :

  • type : toujours "command" pour les status lines basées sur un script
  • command : chemin vers le script qui génère la sortie de ta status line
  • padding : nombre de lignes vides au-dessus de la status line (0 est typique)

Une fois cette entrée en place, crée le fichier script et rends-le exécutable :

touch ~/.claude/statusline.sh
chmod +x ~/.claude/statusline.sh

L'étape chmod +x est importante. Si ta status line n'apparaît jamais, une permission d'exécution manquante est presque toujours la cause.

Comment fonctionne le moteur de status line

Comprendre les mécaniques paye dès que tu débogues ou personnalises un script :

  • Déclencheur de mise à jour : la status line se rafraîchit à chaque changement de message dans la conversation
  • Limitation : les mises à jour s'exécutent au maximum toutes les 300ms pour éviter les problèmes de performance
  • Gestion de la sortie : seule la première ligne de stdout de ton script devient le texte de la status line
  • Couleurs : support complet des codes de couleur ANSI
  • Entrée : Claude Code envoie un objet JSON avec les données de session dans ton script via stdin

Ce dernier point est la clé. Ton script reçoit un payload JSON structuré sur stdin contenant le modèle actuel, les chemins de workspace, le coût de session, les statistiques de fenêtre de contexte, et plus encore. Tu le parses, tu le formates, tu affiche une ligne sur stdout.

Le JSON que ton script reçoit en entrée

À chaque mise à jour de la status line, ton script reçoit cette structure JSON sur stdin :

{
  "hook_event_name": "Status",
  "session_id": "abc123...",
  "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",
  "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": 42.5,
    "remaining_percentage": 57.5,
    "current_usage": {
      "input_tokens": 8500,
      "output_tokens": 1200,
      "cache_creation_input_tokens": 5000,
      "cache_read_input_tokens": 2000
    }
  }
}

Les champs qui font vraiment le boulot dans une status line pratique :

  • model.display_name : nom court du modèle comme "Opus" ou "Sonnet"
  • workspace.current_dir : là où tu travailles en ce moment
  • cost.total_cost_usd : coût total de la session en cours en dollars
  • cost.total_lines_added / total_lines_removed : suivi des modifications de code
  • context_window.used_percentage : utilisation du contexte pré-calculée (0-100)
  • context_window.context_window_size : capacité totale de la fenêtre de contexte

Scripts de status line prêts à copier

Voici des scripts complets et fonctionnels en plusieurs langages. Prends celui qui correspond à ton setup.

Status line Bash simple

La plus petite status line qui vaille la peine. Nom du modèle plus répertoire courant :

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir')
 
echo "[$MODEL] ${CURRENT_DIR##*/}"

Sortie : [Opus] my-project

En coulisses, ce script s'appuie sur jq pour parser le JSON. Si jq n'est pas installé, lance brew install jq sur macOS ou sudo apt install jq sur Ubuntu.

Status line Bash avec git

Les infos de branche rejoignent la ligne, ce qui est utile quand tu jongle entre branches de fonctionnalités :

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir')
 
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] ${CURRENT_DIR##*/}$GIT_BRANCH"

Sortie : [Opus] my-project | feature/auth

Status line Bash complète

Modèle, branche git, coût de session et pourcentage de contexte, tout sur une ligne :

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir')
COST=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
PERCENT_USED=$(echo "$input" | jq -r '.context_window.used_percentage // 0')
 
# Git branch
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
 
# Format cost to 2 decimal places
COST_FMT=$(printf '%.2f' "$COST")
 
# Round context percentage
PERCENT_INT=$(printf '%.0f' "$PERCENT_USED")
 
echo "[$MODEL] ${CURRENT_DIR##*/}$GIT_BRANCH | \$${COST_FMT} | Ctx: ${PERCENT_INT}%"

Sortie : [Opus] my-project | main | $0.42 | Ctx: 37%

Bash avec couleurs ANSI

Le codage couleur rend la ligne lisible d'un coup d'œil :

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir')
COST=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
PERCENT_USED=$(echo "$input" | jq -r '.context_window.used_percentage // 0')
 
# ANSI colors
ORANGE='\033[38;5;208m'
GREEN='\033[32m'
YELLOW='\033[33m'
RED='\033[31m'
CYAN='\033[36m'
RESET='\033[0m'
 
# Color context percentage based on usage
PERCENT_INT=$(printf '%.0f' "$PERCENT_USED")
if [ "$PERCENT_INT" -lt 50 ]; then
    CTX_COLOR=$GREEN
elif [ "$PERCENT_INT" -lt 80 ]; then
    CTX_COLOR=$YELLOW
else
    CTX_COLOR=$RED
fi
 
COST_FMT=$(printf '%.2f' "$COST")
 
echo -e "${ORANGE}[$MODEL]${RESET} ${CURRENT_DIR##*/} ${CYAN}\$${COST_FMT}${RESET} ${CTX_COLOR}Ctx:${PERCENT_INT}%${RESET}"

En dessous de 50%, le pourcentage de contexte est vert. Entre 50-80%, jaune. Au-dessus de 80%, rouge. Un signal visuel rapide qu'il est temps de gérer la fenêtre de contexte.

Approche avec fonctions helper pour les scripts complexes

Quand un script de status line grossit, les fonctions helper le gardent lisible :

#!/bin/bash
input=$(cat)
 
# Helper functions for clean extraction
get_model()     { echo "$input" | jq -r '.model.display_name'; }
get_dir()       { echo "$input" | jq -r '.workspace.current_dir'; }
get_cost()      { echo "$input" | jq -r '.cost.total_cost_usd // 0'; }
get_context()   { echo "$input" | jq -r '.context_window.used_percentage // 0'; }
get_added()     { echo "$input" | jq -r '.cost.total_lines_added // 0'; }
get_removed()   { echo "$input" | jq -r '.cost.total_lines_removed // 0'; }
get_version()   { echo "$input" | jq -r '.version'; }
 
MODEL=$(get_model)
DIR=$(get_dir)
COST=$(printf '%.2f' "$(get_cost)")
CTX=$(printf '%.0f' "$(get_context)")
ADDED=$(get_added)
REMOVED=$(get_removed)
 
echo "[$MODEL] ${DIR##*/} | \$$COST | Ctx:${CTX}% | +$ADDED/-$REMOVED"

Sortie : [Opus] my-project | $0.42 | Ctx:37% | +156/-23

Le +156/-23 à la fin suit les lignes ajoutées et supprimées dans la session. Un aperçu rapide de combien de code a vraiment changé.

Status line Python

Pour les utilisateurs Python plutôt que bash :

#!/usr/bin/env python3
import json
import sys
import os
import subprocess
 
data = json.load(sys.stdin)
 
model = data["model"]["display_name"]
current_dir = os.path.basename(data["workspace"]["current_dir"])
cost = data.get("cost", {}).get("total_cost_usd", 0)
ctx_pct = data.get("context_window", {}).get("used_percentage", 0)
 
# Get git branch
git_branch = ""
try:
    result = subprocess.run(
        ["git", "branch", "--show-current"],
        capture_output=True, text=True, timeout=2
    )
    if result.returncode == 0 and result.stdout.strip():
        git_branch = f" | {result.stdout.strip()}"
except Exception:
    pass
 
print(f"[{model}] {current_dir}{git_branch} | ${cost:.2f} | Ctx:{ctx_pct:.0f}%")

Status line Node.js

Pour les développeurs JavaScript :

#!/usr/bin/env node
const fs = require("fs");
const path = require("path");
const { execSync } = require("child_process");
 
let input = "";
process.stdin.on("data", (chunk) => (input += chunk));
process.stdin.on("end", () => {
  const data = JSON.parse(input);
 
  const model = data.model.display_name;
  const currentDir = path.basename(data.workspace.current_dir);
  const cost = (data.cost?.total_cost_usd || 0).toFixed(2);
  const ctxPct = Math.round(data.context_window?.used_percentage || 0);
 
  // Get git branch
  let gitBranch = "";
  try {
    const branch = execSync("git branch --show-current", {
      encoding: "utf8",
      timeout: 2000,
    }).trim();
    if (branch) gitBranch = ` | ${branch}`;
  } catch (e) {}
 
  console.log(
    `[${model}] ${currentDir}${gitBranch} | $${cost} | Ctx:${ctxPct}%`,
  );
});

Suivre l'utilisation de la fenêtre de contexte

Garder un œil sur la fenêtre de contexte est l'une des raisons les plus pratiques d'utiliser une status line. Quand elle se remplit, Claude Code compacte la conversation et des détails sont perdus. Voir où tu en es t'aide à décider quand recommencer ou compacter de ta propre initiative.

Approche simple avec le pourcentage pré-calculé :

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
PERCENT_USED=$(echo "$input" | jq -r '.context_window.used_percentage // 0')
 
echo "[$MODEL] Context: ${PERCENT_USED}%"

Approche avancée avec calcul manuel depuis les compteurs de tokens bruts :

#!/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
    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}% (${CURRENT_TOKENS}/${CONTEXT_SIZE} tokens)"
else
    echo "[$MODEL] Context: 0%"
fi

La version avancée expose les chiffres de tokens bruts en plus du pourcentage. Utile quand tu veux connaître le budget de tokens restant précis, surtout quand tu compares des modèles avec des tailles de contexte différentes.

Suivre le coût de session

cost.total_cost_usd se met à jour en temps réel. L'afficher dans la status line rend les dépenses visibles sans avoir à aller sur le dashboard :

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
COST=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
COST_FMT=$(printf '%.2f' "$COST")
 
echo "[$MODEL] Session: \$${COST_FMT}"

Pour ceux qui ont un budget ou qui suivent le coût par fonctionnalité, cette visibilité paye tout de suite. Combine ça avec des stratégies de sélection de modèles et tu changeras de modèle dès qu'une tâche ne nécessite plus le niveau Opus.

Dépannage

La status line n'apparaît pas du tout

Une permission d'exécution manquante sur le fichier script est la cause habituelle. Corrige avec :

chmod +x ~/.claude/statusline.sh

Le script tourne mais la sortie est vide

Ton script écrit peut-être sur stderr plutôt que stdout. Seule la première ligne de stdout atteint la status line. Ajoute un echo "test" rapide pour confirmer la sortie, puis construis depuis là.

Tester ton script manuellement

Tu peux tester sans lancer Claude Code en envoyant du JSON simulé directement dans le script :

echo '{"model":{"display_name":"Test"},"workspace":{"current_dir":"/test"},"cost":{"total_cost_usd":0.5},"context_window":{"used_percentage":25}}' | ~/.claude/statusline.sh

Si ça affiche la ligne attendue, le script est bon. Si rien ne sort, le problème vient du parsing.

jq introuvable

Récupère-le depuis ton gestionnaire de paquets :

# macOS
brew install jq
 
# Ubuntu/Debian
sudo apt install jq
 
# Windows (via scoop)
scoop install jq

Idées créatives de status line

Une fois les bases en place, quelques idées pour aller plus loin avec la status line :

  • Suivi des lignes modifiées : affiche +ajoutées/-supprimées pour suivre la productivité de session
  • Durée de session : dérive le temps écoulé depuis total_duration_ms
  • Affichage de l'ID modèle : expose l'identifiant complet du modèle pendant les tests de différentes configurations
  • Répertoire projet vs courant : affiche les deux quand Claude Code se déplace dans des sous-répertoires
  • Coût par minute : divise total_cost_usd par total_duration_ms et vois le vrai taux de consommation
  • Barre de fenêtre de contexte : remplace le pourcentage par une barre visuelle comme [========--]
  • Avertissements conditionnels : change de couleur quand le contexte dépasse 80% ou le coût un seuil

La status line exécute n'importe quel script que tu lui donnes. Bash, Python, Node.js, tout ce que tu peux écrire s'affichera à l'écran.

Et maintenant ?

Ta status line est en place. Les prochaines étapes naturelles :

  • Gérer le contexte de façon proactive : utilise le pourcentage de contexte avec les stratégies de gestion du buffer de contexte
  • Configurer l'environnement terminal : découvre les techniques de contrôle terminal pour un workspace Claude Code complet
  • Configurer les paramètres du projet : fixe tes bases de configuration pour que chaque session démarre avec le bon contexte

Continue in Extensions

  • SEO IA et optimisation GEO
    Un tour d'horizon de la Generative Engine Optimization : comment faire citer ton contenu dans les réponses de ChatGPT, Claude et Perplexity plutôt que simplement classé sur Google.
  • Claude Code vs Cursor en 2026
    Une comparaison côte à côte de Claude Code et Cursor en 2026 : modèles d'agents, fenêtres de contexte, niveaux de prix, et comment chaque outil s'adapte aux différents workflows des développeurs.
  • Extension Claude Code pour VS Code
    L'extension VS Code d'Anthropic intègre Claude Code dans la barre latérale de l'éditeur sous forme de panneau icône Spark, avec diffs inline, mode plan, sous-agents et support MCP.
  • Keybindings Claude Code
    Reconfigurer les raccourcis Claude Code via keybindings.json. 17 contextes, syntaxe des touches, séquences en accords, piles de modificateurs, désactivation des défauts, configs prêtes à coller.
  • OpenClaw vs Claude Code
    OpenClaw vs Claude Code : un assistant de vie branché sur les apps de messagerie face à un agent de code terminal qui lit ton dépôt. Quand chacun mérite une place dans ton workflow.

More from Toolkit

  • Raccourcis clavier
    Configurer keybindings.json dans Claude Code : 17 contextes, syntaxe des touches, séquences d'accords, combinaisons de modificateurs, et comment désactiver n'importe quel raccourci par défaut instantanément.
  • Guide de la Status Line
    Configure une status line Claude Code affichant le nom du modèle, la branche git, le coût de session et l'utilisation du contexte. Config settings.json, JSON d'entrée, scripts bash, Python, Node.js.
  • Hooks de configuration Claude Code
    Assemble scripts, agents et docs dans des hooks de configuration Claude Code. Une commande lance un script déterministe, passe la sortie à un agent de diagnostic, et journalise une doc vivante.
  • Hooks de sauvegarde de contexte pour Claude Code
    Un hook de sauvegarde de contexte Claude Code piloté par StatusLine. Écrit des snapshots structurés toutes les 10K tokens pour que la compaction automatique ne mange jamais les erreurs, signatures et décisions.

Arrêtez de configurer. Commencez à construire.

Templates SaaS avec orchestration IA.

On this page

Ce qu'affiche la status line
Configuration rapide avec /statusline
Configuration manuelle via settings.json
Comment fonctionne le moteur de status line
Le JSON que ton script reçoit en entrée
Scripts de status line prêts à copier
Status line Bash simple
Status line Bash avec git
Status line Bash complète
Bash avec couleurs ANSI
Approche avec fonctions helper pour les scripts complexes
Status line Python
Status line Node.js
Suivre l'utilisation de la fenêtre de contexte
Suivre le coût de session
Dépannage
Idées créatives de status line
Et maintenant ?

Arrêtez de configurer. Commencez à construire.

Templates SaaS avec orchestration IA.