cc-statusline-pro 1.0.0

package/statusline-template.js

@@ -0,0 +1,458 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const os = require('os');
+
+// ANSI Color Codes
+const colors = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+
+  // Regular colors
+  black: '\x1b[30m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+
+  // Bright colors
+  brightRed: '\x1b[91m',
+  brightGreen: '\x1b[92m',
+  brightYellow: '\x1b[93m',
+  brightBlue: '\x1b[94m',
+  brightMagenta: '\x1b[95m',
+  brightCyan: '\x1b[96m',
+
+  // Combined styles
+  boldCyan: '\x1b[1;36m',
+  boldGreen: '\x1b[1;32m',
+  boldYellow: '\x1b[1;33m',
+  boldRed: '\x1b[1;31m',
+  boldMagenta: '\x1b[1;35m',
+};
+
+// Cache cho usage limits (5 phút)
+const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes in ms
+let usageLimitsCache = {
+  data: null,
+  timestamp: 0
+};
+
+// Đọc input JSON từ stdin
+let inputData = '';
+process.stdin.on('data', chunk => {
+  inputData += chunk;
+});
+
+process.stdin.on('end', async () => {
+  try {
+    const data = JSON.parse(inputData);
+    const statusLine = await buildStatusLine(data);
+    process.stdout.write(statusLine);
+  } catch (error) {
+    // Fallback nếu có lỗi
+    process.stdout.write('Claude Code');
+  }
+});
+
+async function buildStatusLine(data) {
+  const parts = [];
+
+  // 1. Tên model
+  const modelName = getModelDisplayName(data);
+  parts.push(modelName);
+
+  // 2. Context usage với thanh tiến trình
+  const contextInfo = getContextUsage(data);
+  if (contextInfo) {
+    parts.push(contextInfo);
+  }
+
+  // 3. Thời gian session
+  const sessionTime = getSessionTime(data);
+  if (sessionTime) {
+    parts.push(sessionTime);
+  }
+
+  // 4. Usage limits từ Anthropic API
+  const usageLimits = await getUsageLimits();
+  if (usageLimits) {
+    parts.push(usageLimits);
+  }
+
+  // 5. Cost information
+  const costInfo = getCostInfo(data);
+  if (costInfo) {
+    parts.push(costInfo);
+  }
+
+  // 6. Code changes (lines added/removed)
+  const codeChanges = getCodeChanges(data);
+  if (codeChanges) {
+    parts.push(codeChanges);
+  }
+
+  // 7. Git branch (chỉ hiện nếu trong git repo)
+  const gitBranch = getGitBranch(data);
+  if (gitBranch) {
+    parts.push(gitBranch);
+  }
+
+  return parts.join(' | ');
+}
+
+function getModelDisplayName(data) {
+  const name = data.model?.display_name || 'Claude';
+  return `${colors.boldCyan}${name}${colors.reset}`;
+}
+
+function getContextUsage(data) {
+  if (!data.context_window || !data.context_window.current_usage) {
+    return null;
+  }
+
+  const usage = data.context_window.current_usage;
+  const windowSize = data.context_window.context_window_size;
+
+  // Tính tổng tokens đang sử dụng
+  const currentTokens = (usage.input_tokens || 0) +
+                        (usage.cache_creation_input_tokens || 0) +
+                        (usage.cache_read_input_tokens || 0);
+
+  const percentage = Math.round((currentTokens / windowSize) * 100);
+
+  // Chọn màu dựa trên percentage
+  let percentColor;
+  if (percentage < 40) {
+    percentColor = colors.green;
+  } else if (percentage < 70) {
+    percentColor = colors.yellow;
+  } else {
+    percentColor = colors.red;
+  }
+
+  // Tạo thanh tiến trình (10 ký tự) với màu
+  const barLength = 10;
+  const filled = Math.round((percentage / 100) * barLength);
+  const empty = barLength - filled;
+
+  const barColor = percentage < 40 ? colors.green :
+                   percentage < 70 ? colors.yellow : colors.red;
+
+  const bar = `${barColor}${'▓'.repeat(filled)}${colors.reset}${'░'.repeat(empty)}`;
+
+  return `${bar} ${percentColor}${percentage}%${colors.reset}`;
+}
+
+function getSessionTime(data) {
+  if (!data.session_id || !data.transcript_path) {
+    return null;
+  }
+
+  try {
+    // Lấy thời gian tạo file transcript
+    const stats = fs.statSync(data.transcript_path);
+    const startTime = stats.birthtimeMs || stats.ctimeMs;
+    const now = Date.now();
+    const elapsed = Math.floor((now - startTime) / 1000); // seconds
+
+    // Tính thời gian đã trôi qua
+    const hours = Math.floor(elapsed / 3600);
+    const minutes = Math.floor((elapsed % 3600) / 60);
+    const seconds = elapsed % 60;
+
+    let timeStr;
+    if (hours > 0) {
+      timeStr = `⏱ ${hours}h ${minutes}m`;
+    } else if (minutes > 0) {
+      timeStr = `⏱ ${minutes}m ${seconds}s`;
+    } else {
+      timeStr = `⏱ ${seconds}s`;
+    }
+
+    return `${colors.blue}${timeStr}${colors.reset}`;
+  } catch (error) {
+    return null;
+  }
+}
+
+function getCostInfo(data) {
+  if (!data.cost) {
+    return null;
+  }
+
+  const cost = data.cost.total_cost_usd;
+
+  if (cost === undefined || cost === null) {
+    return null;
+  }
+
+  // Format chi phí với 4 chữ số thập phân
+  const costFormatted = cost.toFixed(4);
+
+  return `${colors.yellow}$${costFormatted}${colors.reset}`;
+}
+
+function getCodeChanges(data) {
+  if (!data.cost) {
+    return null;
+  }
+
+  const added = data.cost.total_lines_added || 0;
+  const removed = data.cost.total_lines_removed || 0;
+
+  // Chỉ hiển thị nếu có thay đổi code
+  if (added === 0 && removed === 0) {
+    return null;
+  }
+
+  const parts = [];
+
+  if (added > 0) {
+    parts.push(`${colors.green}+${added}${colors.reset}`);
+  }
+
+  if (removed > 0) {
+    parts.push(`${colors.red}-${removed}${colors.reset}`);
+  }
+
+  return parts.length > 0 ? parts.join(' ') : null;
+}
+
+// ============================================================================
+// USAGE LIMITS FROM ANTHROPIC API
+// ============================================================================
+
+function getAccessToken() {
+  const platform = os.platform();
+
+  try {
+    if (platform === 'darwin') {
+      // macOS: Keychain
+      const token = execSync(
+        'security find-generic-password -s "Claude Code-credentials" -w',
+        { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+      ).trim();
+      return token;
+    } else if (platform === 'win32') {
+      // Windows: Thử nhiều phương pháp
+
+      // Phương pháp 1: Windows Credential Manager via PowerShell
+      try {
+        const psScript = `
+          $cred = cmdkey /list | Select-String "Claude Code"
+          if ($cred) {
+            $target = ($cred -split ':')[1].Trim()
+            $password = cmdkey /list:$target | Select-String "Password"
+            if ($password) {
+              ($password -split ':')[1].Trim()
+            }
+          }
+        `;
+        const token = execSync(`powershell -Command "${psScript}"`, {
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+        if (token) return token;
+      } catch (e) {
+        // Ignore and try next method
+      }
+
+      // Phương pháp 2: Tìm trong AppData
+      const appDataPaths = [
+        path.join(os.homedir(), '.claude', '.credentials.json'),
+        path.join(process.env.APPDATA || '', 'Claude Code', 'credentials'),
+        path.join(process.env.LOCALAPPDATA || '', 'Claude Code', 'credentials'),
+        path.join(os.homedir(), '.claude', 'credentials'),
+      ];
+
+      for (const credPath of appDataPaths) {
+        if (fs.existsSync(credPath)) {
+          const content = fs.readFileSync(credPath, 'utf8');
+          // Thử parse JSON
+          try {
+            const parsed = JSON.parse(content);
+
+            // Check for claudeAiOauth.accessToken (most common)
+            if (parsed.claudeAiOauth && parsed.claudeAiOauth.accessToken) {
+              return parsed.claudeAiOauth.accessToken;
+            }
+
+            // Fallback
+            if (parsed.access_token || parsed.token) {
+              return parsed.access_token || parsed.token;
+            }
+          } catch (e) {
+            // Có thể là plain text
+            return content.trim();
+          }
+        }
+      }
+    }
+  } catch (error) {
+    // Không tìm thấy access token
+    return null;
+  }
+
+  return null;
+}
+
+async function fetchUsageLimitsFromAPI() {
+  return new Promise((resolve) => {
+    const accessToken = getAccessToken();
+
+    if (!accessToken) {
+      resolve(null);
+      return;
+    }
+
+    const options = {
+      hostname: 'api.anthropic.com',
+      path: '/api/oauth/usage',
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'anthropic-beta': 'oauth-2025-04-20',
+        'User-Agent': `claude-code/${process.env.CLAUDE_CODE_VERSION || '2.0.76'}`
+      },
+      timeout: 2000 // 2 second timeout
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          if (res.statusCode === 200) {
+            const usage = JSON.parse(data);
+            resolve(usage);
+          } else {
+            resolve(null);
+          }
+        } catch (error) {
+          resolve(null);
+        }
+      });
+    });
+
+    req.on('error', () => {
+      resolve(null);
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(null);
+    });
+
+    req.end();
+  });
+}
+
+async function getUsageLimits() {
+  // Kiểm tra cache
+  const now = Date.now();
+  if (usageLimitsCache.data && (now - usageLimitsCache.timestamp) < CACHE_DURATION) {
+    return formatUsageLimits(usageLimitsCache.data);
+  }
+
+  // Fetch mới từ API
+  const usage = await fetchUsageLimitsFromAPI();
+
+  if (usage) {
+    usageLimitsCache.data = usage;
+    usageLimitsCache.timestamp = now;
+    return formatUsageLimits(usage);
+  }
+
+  return null;
+}
+
+function formatUsageLimits(usage) {
+  if (!usage || !usage.five_hour) {
+    return null;
+  }
+
+  const utilization = usage.five_hour.utilization;
+  const resetsAt = usage.five_hour.resets_at;
+
+  if (utilization === undefined || !resetsAt) {
+    return null;
+  }
+
+  // Dynamic color based on utilization
+  let usageColor;
+  if (utilization < 50) {
+    usageColor = colors.green;
+  } else if (utilization < 80) {
+    usageColor = colors.yellow;
+  } else {
+    usageColor = colors.red;
+  }
+
+  const parts = [];
+
+  // Format utilization with dynamic color
+  parts.push(`${usageColor}Plan: ${Math.round(utilization)}% used${colors.reset}`);
+
+  // Calculate time until reset
+  const resetTime = new Date(resetsAt);
+  const now = new Date();
+  const diff = resetTime - now;
+
+  if (diff > 0) {
+    const hours = Math.floor(diff / (1000 * 60 * 60));
+    const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
+
+    let resetStr;
+    if (hours > 0) {
+      resetStr = `Resets in ${hours}h ${minutes}m`;
+    } else if (minutes > 0) {
+      resetStr = `Resets in ${minutes}m`;
+    } else {
+      resetStr = `Resets soon`;
+    }
+
+    parts.push(`${colors.magenta}${resetStr}${colors.reset}`);
+  }
+
+  return parts.join(' | ');
+}
+
+function getGitBranch(data) {
+  try {
+    const cwd = data.workspace?.project_dir || data.workspace?.current_dir || process.cwd();
+
+    // Kiểm tra xem có phải git repo không
+    const gitDir = path.join(cwd, '.git');
+    if (!fs.existsSync(gitDir)) {
+      return null;
+    }
+
+    // Lấy branch name (skip optional locks để tránh conflict)
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+      cwd: cwd,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'ignore'],
+      env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' }
+    }).trim();
+
+    if (branch && branch !== 'HEAD') {
+      return `${colors.cyan}⎇ ${branch}${colors.reset}`;
+    }
+
+    return null;
+  } catch (error) {
+    // Không phải git repo hoặc có lỗi
+    return null;
+  }
+}