repo_Claude/.claude/statusline.sh

#!/bin/bash
# Status Line para Claude Code - Optimizado para Vibecoding
# Muestra: modelo, contexto, git, costos, rate limits y más

# Leer JSON desde stdin
INPUT=$(cat)

# Colores ANSI
RESET='\033[0m'
BOLD='\033[1m'
DIM='\033[2m'
CYAN='\033[36m'
GREEN='\033[32m'
YELLOW='\033[33m'
RED='\033[31m'
BLUE='\033[34m'
MAGENTA='\033[35m'
WHITE='\033[37m'
GRAY='\033[90m'

# Extraer datos del JSON
MODEL=$(echo "$INPUT" | jq -r '.model.display_name // "Unknown"')
CONTEXT_PCT=$(echo "$INPUT" | jq -r '.context_window.used_percentage // 0' | xargs printf "%.0f")
CONTEXT_TOTAL=$(echo "$INPUT" | jq -r '.context_window.context_window_size // 200000')
CURRENT_DIR=$(echo "$INPUT" | jq -r '.workspace.current_dir // "~"' | sed "s|$HOME|~|")

# Tokens de entrada y salida (current_usage puede ser null antes del primer API call)
INPUT_TOKENS=$(echo "$INPUT" | jq -r '.context_window.current_usage.input_tokens // 0')
OUTPUT_TOKENS=$(echo "$INPUT" | jq -r '.context_window.current_usage.output_tokens // 0')
CACHE_READ=$(echo "$INPUT" | jq -r '.context_window.current_usage.cache_read_input_tokens // 0')
CACHE_CREATION=$(echo "$INPUT" | jq -r '.context_window.current_usage.cache_creation_input_tokens // 0')
TOTAL_INPUT=$(echo "$INPUT" | jq -r '.context_window.total_input_tokens // 0')
TOTAL_OUTPUT=$(echo "$INPUT" | jq -r '.context_window.total_output_tokens // 0')

# Calcular contexto usado (suma de todos los tokens de entrada)
CONTEXT_USED=$((INPUT_TOKENS + CACHE_READ + CACHE_CREATION))

# Calcular porcentaje manualmente si el del JSON es 0
if [ "$CONTEXT_PCT" -eq 0 ] && [ "$CONTEXT_USED" -gt 0 ]; then
    CONTEXT_PCT=$(echo "scale=0; $CONTEXT_USED * 100 / $CONTEXT_TOTAL" | bc)
fi

# Costos
TOTAL_COST=$(echo "$INPUT" | jq -r '.cost.total_cost_usd // 0' | xargs printf "%.3f")
SESSION_DURATION=$(echo "$INPUT" | jq -r '.cost.total_duration_ms // 0')
LINES_ADDED=$(echo "$INPUT" | jq -r '.cost.total_lines_added // 0')
LINES_REMOVED=$(echo "$INPUT" | jq -r '.cost.total_lines_removed // 0')

# Rate Limits
RATE_5H=$(echo "$INPUT" | jq -r '.rate_limits.five_hour.used_percentage // 0' | xargs printf "%.0f")
RATE_7D=$(echo "$INPUT" | jq -r '.rate_limits.seven_day.used_percentage // 0' | xargs printf "%.0f")

# Git info (si estamos en un repo)
GIT_BRANCH=""
GIT_STATUS=""
if git rev-parse --git-dir > /dev/null 2>&1; then
    GIT_BRANCH=$(git branch --show-current 2>/dev/null || echo "detached")

    # Obtener archivos staged, modified, untracked
    STAGED=$(git diff --cached --numstat 2>/dev/null | wc -l)
    MODIFIED=$(git diff --numstat 2>/dev/null | wc -l)
    UNTRACKED=$(git ls-files --others --exclude-standard 2>/dev/null | wc -l)

    # Commits ahead/behind
    UPSTREAM=$(git rev-parse --abbrev-ref --symbolic-full-name @{u} 2>/dev/null)
    if [ -n "$UPSTREAM" ]; then
        AHEAD=$(git rev-list --count @{u}..HEAD 2>/dev/null || echo "0")
        BEHIND=$(git rev-list --count HEAD..@{u} 2>/dev/null || echo "0")
    else
        AHEAD="0"
        BEHIND="0"
    fi

    # Construir status compacto
    GIT_STATUS=""
    [ "$STAGED" -gt 0 ] && GIT_STATUS="${GIT_STATUS}+${STAGED} "
    [ "$MODIFIED" -gt 0 ] && GIT_STATUS="${GIT_STATUS}~${MODIFIED} "
    [ "$UNTRACKED" -gt 0 ] && GIT_STATUS="${GIT_STATUS}?${UNTRACKED} "
    [ "$AHEAD" -gt 0 ] && GIT_STATUS="${GIT_STATUS}↑${AHEAD} "
    [ "$BEHIND" -gt 0 ] && GIT_STATUS="${GIT_STATUS}↓${BEHIND} "

    # Trim trailing space
    GIT_STATUS=$(echo "$GIT_STATUS" | sed 's/ $//')
fi

# Función para crear barra de progreso
progress_bar() {
    local pct=$1
    local width=10
    local filled=$(( pct * width / 100 ))
    local empty=$(( width - filled ))

    # Color según porcentaje
    local color=$GREEN
    if [ "$pct" -ge 80 ]; then
        color=$RED
    elif [ "$pct" -ge 60 ]; then
        color=$YELLOW
    fi

    printf "${color}"
    for ((i=0; i<filled; i++)); do printf "█"; done
    printf "${GRAY}"
    for ((i=0; i<empty; i++)); do printf "░"; done
    printf "${RESET}"
}

# Función para formatear duración
format_duration() {
    local ms=$1
    local seconds=$((ms / 1000))
    local minutes=$((seconds / 60))
    local hours=$((minutes / 60))

    if [ "$hours" -gt 0 ]; then
        printf "%dh%dm" $hours $((minutes % 60))
    elif [ "$minutes" -gt 0 ]; then
        printf "%dm%ds" $minutes $((seconds % 60))
    else
        printf "%ds" $seconds
    fi
}

# Función para formatear tokens (k para miles, M para millones)
format_tokens() {
    local tokens=$1
    if [ "$tokens" -ge 1000000 ]; then
        printf "%.1fM" $(echo "scale=1; $tokens / 1000000" | bc)
    elif [ "$tokens" -ge 1000 ]; then
        printf "%.0fk" $(echo "scale=0; $tokens / 1000" | bc)
    else
        printf "%d" $tokens
    fi
}

# Hora actual
CURRENT_TIME=$(date +"%H:%M")

# ===== CONSTRUIR STATUS LINE (2 LÍNEAS) =====

# ===== LÍNEA 1: Información Principal =====
LINE1=""

# 1. Modelo
LINE1="${LINE1}${BOLD}${CYAN}${MODEL}${RESET}"

# 2. Contexto con barra y usado/total
CONTEXT_USED_FMT=$(format_tokens $CONTEXT_USED)
CONTEXT_TOTAL_FMT=$(format_tokens $CONTEXT_TOTAL)
LINE1="${LINE1} ${GRAY}│${RESET} ${BOLD}CTX:${RESET} $(progress_bar $CONTEXT_PCT) ${YELLOW}${CONTEXT_PCT}%${RESET} ${DIM}(${CONTEXT_USED_FMT}/${CONTEXT_TOTAL_FMT})${RESET}"

# 3. Tokens entrada/salida (formateados)
INPUT_FMT=$(format_tokens $INPUT_TOKENS)
OUTPUT_FMT=$(format_tokens $OUTPUT_TOKENS)
LINE1="${LINE1} ${GRAY}│${RESET} ${CYAN}IN:${RESET}${INPUT_FMT} ${MAGENTA}OUT:${RESET}${OUTPUT_FMT}"
if [ "$CACHE_READ" -gt 0 ]; then
    CACHE_FMT=$(format_tokens $CACHE_READ)
    LINE1="${LINE1} ${DIM}(cache:${CACHE_FMT})${RESET}"
fi

# 4. Git (si existe)
if [ -n "$GIT_BRANCH" ]; then
    LINE1="${LINE1} ${GRAY}│${RESET} ${BOLD}${MAGENTA}⎇ ${GIT_BRANCH}${RESET}"
    if [ -n "$GIT_STATUS" ]; then
        LINE1="${LINE1} ${DIM}[${GIT_STATUS}]${RESET}"
    fi
fi

# 5. Hora actual
LINE1="${LINE1} ${GRAY}│${RESET} ${WHITE}${CURRENT_TIME}${RESET}"

# ===== LÍNEA 2: Detalles =====
LINE2=""

# 1. Costos
if (( $(echo "$TOTAL_COST > 0" | bc -l) )); then
    LINE2="${LINE2}${BOLD}${GREEN}\$${TOTAL_COST}${RESET}"
else
    LINE2="${LINE2}${DIM}\$0.000${RESET}"
fi

# 2. Ediciones
LINE2="${LINE2} ${GRAY}│${RESET} ${GREEN}+${LINES_ADDED}${RESET}${GRAY}/${RED}-${LINES_REMOVED}${RESET}"

# 3. Tokens totales acumulados (formateados)
TOTAL_IN_FMT=$(format_tokens $TOTAL_INPUT)
TOTAL_OUT_FMT=$(format_tokens $TOTAL_OUTPUT)
LINE2="${LINE2} ${GRAY}│${RESET} ${DIM}Total:${RESET} ${CYAN}↓${TOTAL_IN_FMT}${RESET}${GRAY}/${MAGENTA}↑${TOTAL_OUT_FMT}${RESET}"

# 4. Rate Limits (siempre mostrar)
LINE2="${LINE2} ${GRAY}│${RESET} ${BOLD}Limits:${RESET}"

# 5h limit
if [ "$RATE_5H" -ge 80 ]; then
    LINE2="${LINE2} ${RED}5h:${RATE_5H}%${RESET}"
elif [ "$RATE_5H" -ge 50 ]; then
    LINE2="${LINE2} ${YELLOW}5h:${RATE_5H}%${RESET}"
else
    LINE2="${LINE2} ${GREEN}5h:${RATE_5H}%${RESET}"
fi

# 7d limit
if [ "$RATE_7D" -ge 80 ]; then
    LINE2="${LINE2} ${RED}7d:${RATE_7D}%${RESET}"
elif [ "$RATE_7D" -ge 50 ]; then
    LINE2="${LINE2} ${YELLOW}7d:${RATE_7D}%${RESET}"
else
    LINE2="${LINE2} ${GREEN}7d:${RATE_7D}%${RESET}"
fi

# 5. Duración sesión
if [ "$SESSION_DURATION" -gt 0 ]; then
    DURATION_STR=$(format_duration $SESSION_DURATION)
    LINE2="${LINE2} ${GRAY}│${RESET} ${DIM}⏱ ${DURATION_STR}${RESET}"
fi

# 6. Directorio actual
LINE2="${LINE2} ${GRAY}│${RESET} ${BLUE}${CURRENT_DIR}${RESET}"

# Imprimir resultado (2 líneas)
echo -e "$LINE1"
echo -e "$LINE2"