Build This Now
Build This Now
Raccourcis clavierGuide de la Status Line
speedy_devvkoen_salo
Blog/Toolkit/Status Line Guide

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.

Arrêtez de configurer. Commencez à construire.

Templates SaaS avec orchestration IA.

Published Feb 27, 2026Toolkit hub

Configure une status line Claude Code personnalisée qui affiche le nom du modèle, la branche git, le coût et l'utilisation du contexte. Des scripts prêts à copier sont inclus.

Ton terminal Claude Code manque d'informations utiles. La status line règle ça en affichant le nom du modèle, la branche git, le coût de session et l'utilisation du contexte directement en bas de l'interface.

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

Ce que la Status Line Affiche

La status line se trouve en bas de l'interface Claude Code et se met à jour à chaque changement de conversation. Elle peut afficher ce que ton script renvoie : le modèle courant, la branche git sur laquelle tu es, combien tu as dépensé cette session, ou à quel point ta fenêtre de contexte est remplie.

Voilà à quoi ressemble une status line configurée en pratique :

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

Cette ligne te donne le modèle, le dossier du projet, la branche git, le coût de la session jusqu'ici, et le pourcentage de ta fenêtre de contexte utilisé. Tout ça mis à jour automatiquement.

Configuration Rapide avec /statusline

Le chemin le plus rapide vers une status line fonctionnelle, c'est la commande intégrée /statusline. Tape-la directement dans Claude Code et il génère un script pour toi.

/statusline

Claude Code va créer un script de status line qui reproduit ton prompt terminal par défaut. Mais tu peux aussi lui donner des instructions précises :

/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, configure les paramètres, et la status line apparaît. Si tu veux plus de contrôle, continue la lecture pour la configuration manuelle.

Configuration Manuelle via settings.json

Pour un contrôle total, ajoute une entrée statusLine dans le fichier .claude/settings.json de ton projet (ou dans ton ~/.claude/settings.json global pour tous les projets) :

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

Trois champs à retenir :

  • type : Toujours "command" pour les status lines basées sur des scripts
  • command : Chemin vers le script qui génère le contenu de ta status line
  • padding : Nombre de lignes vides au-dessus de la status line (0 en général)

Après avoir ajouté ça, crée le fichier script et rends-le exécutable :

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

Le chmod +x est important. Si ta status line n'apparaît pas, une permission d'exécution manquante est presque toujours la raison.

Comment Fonctionne le Moteur de la Status Line

Comprendre les mécanismes aide quand tu débogues ou que tu construis des scripts personnalisés :

  • 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 pour le style
  • 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 du JSON structuré contenant le modèle courant, les chemins du workspace, le coût de session, les stats de la fenêtre de contexte, et bien plus. Parse-le, formate-le, affiche une ligne sur stdout.

Le JSON d'Entrée que Reçoit ton Script

À chaque mise à jour de la status line, ton script reçoit cette structure JSON via 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 les plus utiles pour les status lines pratiques :

  • 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 cumulé de la session 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 à Copier

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

Status Line Bash Simple

La status line la plus simple et utile. Affiche le nom du modèle et le 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

Ce script utilise jq pour parser le JSON. Si tu ne l'as pas installé, lance brew install jq sur macOS ou sudo apt install jq sur Ubuntu.

Status Line Bash avec Git

Ajoute la branche git courante, pratique quand tu jonglles entre plusieurs 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 et pourcentage de contexte, tout sur une seule 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

Une sortie colorée rend l'information lisible d'un coup d'oeil :

#!/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}"

Le pourcentage de contexte passe en vert en dessous de 50%, en jaune entre 50-80%, et en rouge au-dessus de 80%. Tu vois immédiatement quand c'est le moment de gérer ta fenêtre de contexte.

Approche avec Fonctions Helpers pour les Scripts Complexes

Quand ton script de status line grossit, des fonctions helpers gardent ça 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 montre les lignes ajoutées et supprimées dans la session. Un moyen rapide d'estimer combien de code a changé.

Status Line Python

Si tu préfères 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

Surveiller ta fenêtre de contexte est l'une des utilisations les plus pratiques de la status line. Quand le contexte se remplit, Claude Code compacte la conversation et tu perds des détails. Savoir où tu en es t'aide à décider quand repartir à zéro ou compacter de façon stratégique.

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 à partir du nombre brut de tokens :

#!/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

L'approche manuelle te permet de voir les nombres bruts de tokens en plus du pourcentage. Utile quand tu veux savoir exactement combien de tokens il te reste, surtout quand tu choisis entre différents modèles avec des tailles de contexte différentes.

Suivre le Coût de Session

Le champ cost.total_cost_usd se met à jour en temps réel. L'afficher dans ta status line garde les dépenses visibles sans avoir à consulter le tableau de bord :

#!/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}"

Si tu as un budget à respecter ou que tu suis les coûts par fonctionnalité, c'est immédiatement utile. Associe ça à des stratégies de sélection de modèle pour switcher vers des modèles moins chers quand une tâche n'en a pas besoin.

Dépannage

La status line n'apparaît pas du tout

La cause la plus courante est une permission d'exécution manquante sur le fichier script. Corrige-le avec :

chmod +x ~/.claude/statusline.sh

Le script tourne mais la sortie est vide

Ton script écrit peut-être sur stderr au lieu de stdout. La status line ne lit que la première ligne de stdout. Ajoute un simple echo "test" pour vérifier la sortie, puis construis à partir de là.

Tester ton script manuellement

Tu peux tester sans lancer Claude Code en passant du JSON simulé dans ton 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 sortie attendue, le script fonctionne. Si non, le problème est dans le parsing.

jq introuvable

Installe-le avec ton gestionnaire de paquets :

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

Idées Créatives pour la Status Line

Une fois que tu as les bases qui fonctionnent, voici quelques idées pour rendre ta status line encore plus utile :

  • Compteur de lignes modifiées : Affiche +ajoutées/-supprimées pour suivre la productivité de la session
  • Durée de session : Calcule le temps écoulé à partir de total_duration_ms
  • Affichage de l'ID du modèle : Montre l'identifiant complet du modèle quand tu testes différentes configurations
  • Répertoire projet vs répertoire courant : Montre les deux quand Claude Code navigue dans des sous-répertoires
  • Coût par minute : Divise total_cost_usd par total_duration_ms pour voir le 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 quand le coût franchit un seuil

La status line exécute un script que tu contrôles. Si tu peux l'écrire en bash, Python ou Node.js, tu peux l'afficher. Si tu préfères éviter le scripting, le Code Kit de ClaudeFast inclut un statusline-monitor.mjs pré-construit qui affiche l'utilisation du contexte, le budget API et le statut de sauvegarde directement.

Quoi Tester Ensuite

Ta status line est configurée. Voici les prochaines étapes naturelles :

  • Gère le contexte de façon proactive : Utilise ton affichage de pourcentage de contexte avec des stratégies de gestion du buffer de contexte
  • Configure l'environnement terminal : Apprends les techniques de contrôle du terminal pour un workspace Claude Code complet
  • Configure les paramètres du projet : Assure-toi que tes bases de configuration sont solides pour que chaque session démarre avec le bon contexte

More in 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.
  • 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.

Arrêtez de configurer. Commencez à construire.

Templates SaaS avec orchestration IA.

On this page

Ce que la Status Line Affiche
Configuration Rapide avec /statusline
Configuration Manuelle via settings.json
Comment Fonctionne le Moteur de la Status Line
Le JSON d'Entrée que Reçoit ton Script
Scripts de Status Line à Copier
Status Line Bash Simple
Status Line Bash avec Git
Status Line Bash Complète
Bash avec Couleurs ANSI
Approche avec Fonctions Helpers 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 pour la Status Line
Quoi Tester Ensuite

Arrêtez de configurer. Commencez à construire.

Templates SaaS avec orchestration IA.