Configuração da linha de status

Personalize Claude Code com uma linha de status personalizada que é exibida na parte inferior da interface Claude Code, semelhante a como os prompts de terminal (PS1) funcionam em shells como Oh-my-zsh.

Criar uma linha de status personalizada

Você pode:

Executar /statusline para pedir ao Claude Code que o ajude a configurar uma linha de status personalizada. Por padrão, ele tentará reproduzir o prompt do seu terminal, mas você pode fornecer instruções adicionais sobre o comportamento que deseja ao Claude Code, como /statusline show the model name in orange
Adicionar diretamente um comando statusLine ao seu .claude/settings.json:

{
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh",
    "padding": 0 // Opcional: defina como 0 para deixar a linha de status ir até a borda
  }
}

Como funciona

A linha de status é atualizada quando as mensagens da conversa são atualizadas
As atualizações são executadas no máximo a cada 300 ms
A primeira linha de stdout do seu comando se torna o texto da linha de status
Códigos de cor ANSI são suportados para estilizar sua linha de status
Claude Code passa informações contextuais sobre a sessão atual (modelo, diretórios, etc.) como JSON para seu script via stdin

Estrutura de entrada JSON

Seu comando de linha de status recebe dados estruturados via stdin em formato JSON:

{
  "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
    }
  }
}

Scripts de exemplo

Linha de status simples

#!/bin/bash
# Ler entrada JSON de stdin
input=$(cat)

# Extrair valores usando jq
MODEL_DISPLAY=$(echo "$input" | jq -r '.model.display_name')
CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir')

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

Linha de status com suporte a Git

#!/bin/bash
# Ler entrada JSON de stdin
input=$(cat)

# Extrair valores usando jq
MODEL_DISPLAY=$(echo "$input" | jq -r '.model.display_name')
CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir')

# Mostrar branch do git se estiver em um repositório git
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"

Exemplo em Python

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

# Ler JSON de stdin
data = json.load(sys.stdin)

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

# Verificar branch do git
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}")

Exemplo em Node.js

#!/usr/bin/env node

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

// Ler JSON de stdin
let input = '';
process.stdin.on('data', chunk => input += chunk);
process.stdin.on('end', () => {
    const data = JSON.parse(input);
    
    // Extrair valores
    const model = data.model.display_name;
    const currentDir = path.basename(data.workspace.current_dir);
    
    // Verificar branch do git
    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) {
        // Não é um repositório git ou não é possível ler HEAD
    }
    
    console.log(`[${model}] 📁 ${currentDir}${gitBranch}`);
});

Abordagem com função auxiliar

Para scripts bash mais complexos, você pode criar funções auxiliares:

#!/bin/bash
# Ler entrada JSON uma vez
input=$(cat)

# Funções auxiliares para extrações comuns
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'; }

# Usar os auxiliares
MODEL=$(get_model_name)
DIR=$(get_current_dir)
echo "[$MODEL] 📁 ${DIR##*/}"

Uso da janela de contexto

Exiba a porcentagem da janela de contexto consumida. O objeto context_window contém:

total_input_tokens / total_output_tokens: Totais cumulativos em toda a sessão
current_usage: Uso atual da janela de contexto da última chamada de API (pode ser null se não houver mensagens ainda)
- input_tokens: Tokens de entrada no contexto atual
- output_tokens: Tokens de saída gerados
- cache_creation_input_tokens: Tokens escritos no cache
- cache_read_input_tokens: Tokens lidos do cache

Para uma porcentagem de contexto precisa, use current_usage que reflete o estado real da janela de contexto:

#!/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
    # Calcular contexto atual a partir dos campos current_usage
    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

Dicas

Mantenha sua linha de status concisa - ela deve caber em uma linha
Use emojis (se seu terminal os suportar) e cores para tornar as informações facilmente escaneáveis
Use jq para análise JSON em Bash (veja exemplos acima)
Teste seu script executando-o manualmente com entrada JSON simulada: echo '{"model":{"display_name":"Test"},"workspace":{"current_dir":"/test"}}' | ./statusline.sh
Considere armazenar em cache operações caras (como status do git) se necessário

Solução de problemas

Se sua linha de status não aparecer, verifique se seu script é executável (chmod +x)
Certifique-se de que seu script produz saída para stdout (não stderr)

Configuração

​Criar uma linha de status personalizada

​Como funciona

​Estrutura de entrada JSON

​Scripts de exemplo

​Linha de status simples

​Linha de status com suporte a Git

​Exemplo em Python

​Exemplo em Node.js

​Abordagem com função auxiliar

​Uso da janela de contexto

​Dicas

​Solução de problemas