mr-claude-stats 1.0.3 → 1.3.0

package/README.md

@@ -88,19 +88,17 @@ This matches the official `/context` command output.
 
 ## Requirements
 
-- `jq` (JSON processor)
-- `bash`
+- Node.js 14+ (comes with npm)
 
 ## Compatibility
 
-| OS | Status | Notes |
-|----|--------|-------|
-| Linux | ✅ Works | Native support |
-| macOS | ✅ Works | Uses `tail -r` instead of `tac` |
-| Windows | ⚠️ WSL/Git Bash | Requires bash environment |
+| OS | Status |
+|----|--------|
+| Linux | ✅ Native |
+| macOS | ✅ Native |
+| Windows | ✅ Native |
 
-**macOS**: Install jq with `brew install jq`
-**Windows**: Use WSL or Git Bash, install jq
+**No additional dependencies!** Pure Node.js, no bash or jq needed.
 
 ## License
 

package/bin/mr-claude-stats.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+// mr-claude-stats - Accurate statusline for Claude Code CLI
+// https://github.com/MrIago/mr-claude-stats
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const VERSION = '1.3.0';
+const BAR_SIZE = 45;
+
+// Handle --help and --version
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  console.log(`mr-claude-stats - The most accurate Claude Code statusline
+
+INSTALL:
+  npm install -g mr-claude-stats
+
+SETUP:
+  Add to ~/.claude/settings.json:
+
+  {
+    "statusLine": {
+      "type": "command",
+      "command": "mr-claude-stats"
+    }
+  }
+
+WHAT IT SHOWS:
+  ████████████████████████░░░░░░░░░░░░░░░░░░░
+  Opus 4.5 in /lasy          130k/200k (65%)
+
+WORKS ON:
+  Linux, macOS, Windows (native!)
+
+MORE INFO:
+  https://github.com/MrIago/mr-claude-stats`);
+  process.exit(0);
+}
+
+if (process.argv.includes('--version') || process.argv.includes('-v')) {
+  console.log(`mr-claude-stats v${VERSION}`);
+  process.exit(0);
+}
+
+// ANSI colors (pastel)
+const BLUE = '\x1b[38;5;117m';
+const GREEN = '\x1b[38;5;114m';
+const YELLOW = '\x1b[38;5;186m';
+const ORANGE = '\x1b[38;5;216m';
+const RED = '\x1b[38;5;174m';
+const GRAY = '\x1b[38;5;242m';
+const RESET = '\x1b[0m';
+
+function formatTokens(n) {
+  return n >= 1000 ? Math.floor(n / 1000) + 'k' : String(n);
+}
+
+function getColorForPercent(percent) {
+  if (percent < 25) return GREEN;
+  if (percent < 50) return YELLOW;
+  if (percent < 75) return ORANGE;
+  return RED;
+}
+
+function buildProgressBar(percent, size = BAR_SIZE) {
+  const filled = Math.floor(percent * size / 100);
+  const empty = size - filled;
+
+  const t1 = Math.floor(size * 0.25);
+  const t2 = Math.floor(size * 0.50);
+  const t3 = Math.floor(size * 0.75);
+
+  let bar = '';
+  for (let i = 0; i < filled; i++) {
+    if (i < t1) bar += GREEN + '█';
+    else if (i < t2) bar += YELLOW + '█';
+    else if (i < t3) bar += ORANGE + '█';
+    else bar += RED + '█';
+  }
+  bar += GRAY + '░'.repeat(empty) + RESET;
+  return bar;
+}
+
+function getCacheFile(sessionId) {
+  const os = require('os');
+  return path.join(os.tmpdir(), `statusline_cache_${sessionId || 'default'}`);
+}
+
+function readCache(sessionId) {
+  try {
+    const cacheFile = getCacheFile(sessionId);
+    if (fs.existsSync(cacheFile)) {
+      return parseInt(fs.readFileSync(cacheFile, 'utf8').trim()) || 0;
+    }
+  } catch (e) {}
+  return 0;
+}
+
+function writeCache(sessionId, value) {
+  try {
+    fs.writeFileSync(getCacheFile(sessionId), String(value));
+  } catch (e) {}
+}
+
+function findLastUsage(transcriptPath) {
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) return null;
+
+  try {
+    const content = fs.readFileSync(transcriptPath, 'utf8');
+    const lines = content.trim().split('\n').reverse();
+
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        const usage = entry.usage || (entry.message && entry.message.usage);
+        if (usage && usage.input_tokens !== undefined) {
+          return usage;
+        }
+      } catch (e) {}
+    }
+  } catch (e) {}
+  return null;
+}
+
+function truncatePath(dirName, maxLen = 10) {
+  if (dirName.length > maxLen) {
+    return dirName.substring(0, 7) + '...';
+  }
+  return dirName;
+}
+
+async function main() {
+  // Read JSON from stdin
+  const rl = readline.createInterface({ input: process.stdin });
+  let inputData = '';
+
+  for await (const line of rl) {
+    inputData += line;
+  }
+
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch (e) {
+    input = {};
+  }
+
+  const model = input.model?.display_name || 'Claude';
+  const contextSize = input.context_window?.context_window_size || 200000;
+  const transcriptPath = input.transcript_path || '';
+  const sessionId = input.session_id || 'default';
+  const cwd = input.cwd || process.cwd();
+
+  // Get last directory name and truncate if needed
+  const lastDir = truncatePath(path.basename(cwd));
+  const modelWithPath = `${model} in /${lastDir}`;
+
+  // Calculate total tokens
+  let total = 0;
+  const usage = findLastUsage(transcriptPath);
+
+  if (usage) {
+    const inputTokens = usage.input_tokens || 0;
+    const cacheCreate = usage.cache_creation_input_tokens || 0;
+    const cacheRead = usage.cache_read_input_tokens || 0;
+    const outputTokens = usage.output_tokens || 0;
+
+    total = inputTokens + cacheCreate + cacheRead + outputTokens;
+    writeCache(sessionId, total);
+  } else {
+    total = readCache(sessionId);
+  }
+
+  // If no data, show only model with path
+  if (total === 0) {
+    console.log(`${BLUE}${modelWithPath}${RESET}`);
+    return;
+  }
+
+  const percent = Math.floor(total * 100 / contextSize);
+  const textColor = getColorForPercent(percent);
+
+  // Format output
+  const totalFmt = formatTokens(total);
+  const contextFmt = formatTokens(contextSize);
+  const rightInfo = `${totalFmt}/${contextFmt} (${percent}%)`.padStart(18);
+
+  // Left side width = BAR_SIZE - 18 (right info width)
+  const leftWidth = BAR_SIZE - 18;
+
+  // Row 1: Progress bar
+  console.log(buildProgressBar(percent));
+  // Row 2: Model with path (left) + tokens (right)
+  console.log(`${BLUE}${modelWithPath.padEnd(leftWidth)}${RESET}${textColor}${rightInfo}${RESET}`);
+}
+
+main().catch(() => process.exit(1));

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "mr-claude-stats",
-  "version": "1.0.3",
+  "version": "1.3.0",
   "description": "Accurate statusline for Claude Code CLI with colorful progress bar",
   "bin": {
-    "mr-claude-stats": "./bin/mr-claude-stats"
+    "mr-claude-stats": "./bin/mr-claude-stats.js"
   },
   "keywords": [
     "claude",

package/bin/mr-claude-stats

@@ -1,158 +0,0 @@
-#!/bin/bash
-# mr-claude-stats - Accurate statusline for Claude Code CLI
-# https://github.com/MrIago/mr-claude-stats
-
-VERSION="1.0.2"
-
-# Handle --help and --version
-if [[ "$1" == "--help" || "$1" == "-h" ]]; then
-  cat << 'EOF'
-mr-claude-stats - The most accurate Claude Code statusline
-
-INSTALL:
-  npm install -g mr-claude-stats
-
-SETUP:
-  Add to ~/.claude/settings.json:
-
-  {
-    "statusLine": {
-      "type": "command",
-      "command": "mr-claude-stats"
-    }
-  }
-
-WHAT IT SHOWS:
-  ████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
-  Opus 4.5                                     130k/200k (65%)
-
-REQUIREMENTS:
-  - jq (JSON processor)
-  - bash
-
-MORE INFO:
-  https://github.com/MrIago/mr-claude-stats
-EOF
-  exit 0
-fi
-
-if [[ "$1" == "--version" || "$1" == "-v" ]]; then
-  echo "mr-claude-stats v$VERSION"
-  exit 0
-fi
-
-export LC_NUMERIC=C
-input=$(cat)
-
-MODEL=$(echo "$input" | jq -r '.model.display_name // "Claude"')
-CONTEXT=$(echo "$input" | jq -r '.context_window.context_window_size // 200000')
-TRANSCRIPT=$(echo "$input" | jq -r '.transcript_path // ""')
-
-# Cache para persistir último valor conhecido
-CACHE_FILE="/tmp/statusline_cache_${SESSION_ID:-default}"
-SESSION_ID=$(echo "$input" | jq -r '.session_id // "default"')
-CACHE_FILE="/tmp/statusline_cache_${SESSION_ID}"
-
-# Ler usage do último request com usage válido no transcript
-TOTAL=0
-if [ -n "$TRANSCRIPT" ] && [ -f "$TRANSCRIPT" ]; then
-  # Buscar último entry que tem usage (ignorar comandos locais sem usage)
-  # Usar tail -r no Mac, tac no Linux
-  if command -v tac &>/dev/null; then
-    LAST_USAGE=$(tac "$TRANSCRIPT" 2>/dev/null | jq -s '[.[] | select(.usage != null or .message.usage != null)] | .[0] | .usage // .message.usage' 2>/dev/null)
-  else
-    LAST_USAGE=$(tail -r "$TRANSCRIPT" 2>/dev/null | jq -s '[.[] | select(.usage != null or .message.usage != null)] | .[0] | .usage // .message.usage' 2>/dev/null)
-  fi
-  if [ -n "$LAST_USAGE" ] && [ "$LAST_USAGE" != "null" ]; then
-    INPUT_T=$(echo "$LAST_USAGE" | jq -r '.input_tokens // 0')
-    CACHE_CREATE=$(echo "$LAST_USAGE" | jq -r '.cache_creation_input_tokens // 0')
-    CACHE_READ=$(echo "$LAST_USAGE" | jq -r '.cache_read_input_tokens // 0')
-    OUTPUT_T=$(echo "$LAST_USAGE" | jq -r '.output_tokens // 0')
-    # Total = input atual + cache + output + buffer de autocompact (45k)
-    MESSAGES=$((INPUT_T + CACHE_CREATE + CACHE_READ + OUTPUT_T))
-    AUTOCOMPACT_BUFFER=45000
-    TOTAL=$((MESSAGES + AUTOCOMPACT_BUFFER))
-    # Salvar no cache
-    echo "$TOTAL" > "$CACHE_FILE"
-  fi
-fi
-
-# Se não encontrou, usar cache anterior
-if [ "$TOTAL" -eq 0 ] && [ -f "$CACHE_FILE" ]; then
-  TOTAL=$(cat "$CACHE_FILE" 2>/dev/null || echo 0)
-fi
-
-# Se não tem dados, mostrar só o modelo
-if [ "$TOTAL" -eq 0 ]; then
-  echo -e "\033[38;5;117m${MODEL}\033[0m"
-  exit 0
-fi
-PERCENT=$((TOTAL * 100 / CONTEXT))
-
-# Cores ANSI (pastel)
-BLUE='\033[38;5;117m'
-GREEN='\033[38;5;114m'
-YELLOW='\033[38;5;186m'
-ORANGE='\033[38;5;216m'
-RED='\033[38;5;174m'
-GRAY='\033[38;5;242m'
-RESET='\033[0m'
-
-
-# Formatar tokens
-format_tokens() {
-  local n=$1
-  if [ $n -ge 1000 ]; then
-    echo "$((n / 1000))k"
-  else
-    echo "$n"
-  fi
-}
-
-TOTAL_FMT=$(format_tokens $TOTAL)
-CONTEXT_FMT=$(format_tokens $CONTEXT)
-
-# Barra de 60 caracteres com gradiente
-BAR_SIZE=60
-FILLED=$((PERCENT * BAR_SIZE / 100))
-EMPTY=$((BAR_SIZE - FILLED))
-
-# Thresholds para cores (em chars)
-T1=$((BAR_SIZE * 25 / 100))  # 25% = 15 chars
-T2=$((BAR_SIZE * 50 / 100))  # 50% = 30 chars
-T3=$((BAR_SIZE * 75 / 100))  # 75% = 45 chars
-
-BAR=""
-for ((i=0; i<FILLED; i++)); do
-  if [ $i -lt $T1 ]; then
-    BAR+="${GREEN}█"
-  elif [ $i -lt $T2 ]; then
-    BAR+="${YELLOW}█"
-  elif [ $i -lt $T3 ]; then
-    BAR+="${ORANGE}█"
-  else
-    BAR+="${RED}█"
-  fi
-done
-BAR+="${GRAY}"
-for ((i=0; i<EMPTY; i++)); do BAR+="░"; done
-BAR+="${RESET}"
-
-# Cor do texto baseada no percentual
-if [ $PERCENT -lt 25 ]; then
-  TEXT_COLOR=$GREEN
-elif [ $PERCENT -lt 50 ]; then
-  TEXT_COLOR=$YELLOW
-elif [ $PERCENT -lt 75 ]; then
-  TEXT_COLOR=$ORANGE
-else
-  TEXT_COLOR=$RED
-fi
-
-# Info formatada com largura fixa (18 chars total)
-RIGHT=$(printf "%18s" "${TOTAL_FMT}/${CONTEXT_FMT} (${PERCENT}%)")
-
-# Row 1: Barra
-echo -e "$BAR"
-# Row 2: Model (azul) esquerda, tokens (cor) direita
-echo -e "${BLUE}$(printf "%-42s" "$MODEL")${RESET}${TEXT_COLOR}${RIGHT}${RESET}"