@phuc1403/musketeer 0.9.0 → 0.10.0

package/template/.claude/statusline.cjs

@@ -23,6 +23,12 @@ const { getGitInfo } = require('./hooks/lib/git-info-cache.cjs');
 
 // Buffer constant for fallback context calculation
 const AUTOCOMPACT_BUFFER = 40000;
+
+// Quota cache older than this is not rendered — a stale number is worse than none.
+const USAGE_CACHE_RENDER_TTL_MS = 300000;
+// Any window at or above this utilization flips the quota segment to red.
+const QUOTA_HIGH_PERCENT = 85;
+
 const GRAPHEME_SEGMENTER = (
   typeof Intl !== 'undefined' && typeof Intl.Segmenter === 'function'
 )
@@ -169,14 +175,98 @@ async function readStdin() {
 // ============================================================================
 
 /**
- * Build usage time string with optional percentage
- * @returns {string|null} Formatted usage string or null if unavailable
+ * Read the usage limits cache written by the usage-quota-cache-refresh hook.
+ * @returns {object|null} Parsed cache, or null when absent/unreadable
+ */
+function readUsageCache() {
+  try {
+    const cachePath = env.CK_USAGE_CACHE_PATH || path.join(os.tmpdir(), 'ck-usage-limits-cache.json');
+    if (!fs.existsSync(cachePath)) return null;
+    return JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Coerce an API utilization value to a whole percent.
+ * The API returns either a 0-1 fraction or an already-scaled percent.
+ * @returns {number|null} Percent, or null when the value is unusable
+ */
+function normalizeUtilization(utilization) {
+  if (typeof utilization !== 'number' || !Number.isFinite(utilization)) return null;
+  if (utilization > 0 && utilization < 1) return Math.round(utilization * 100);
+  return Math.max(0, Math.round(utilization));
+}
+
+/**
+ * Compact countdown: "45m", "2h21m", "5d".
+ * @returns {string} Empty string once the deadline has passed
+ */
+function formatCountdown(msLeft) {
+  if (msLeft <= 0) return '';
+  const mins = Math.floor(msLeft / 60000);
+  if (mins < 60) return `${mins}m`;
+  if (mins < 1440) {
+    const h = Math.floor(mins / 60);
+    const m = mins % 60;
+    return m > 0 ? `${h}h${m}m` : `${h}h`;
+  }
+  return `${Math.floor(mins / 1440)}d`;
+}
+
+/**
+ * Build the quota window strings, e.g. ["5h 14% (2h21m)", "wk 43% (5d)"].
+ *
+ * Reads the pre-calculated `snapshot` when the cache carries one, and falls
+ * back to the raw `data.*.utilization` otherwise — the hook in this project
+ * writes only `{timestamp, status, data}`, so the fallback is the normal path.
+ *
+ * @returns {string[]} One entry per window; empty when unavailable or stale
+ */
+function buildUsageWindows(cache) {
+  if (!cache || cache.status !== 'available') return [];
+  if (typeof cache.timestamp !== 'number') return [];
+  const now = Date.now();
+  if (now - cache.timestamp > USAGE_CACHE_RENDER_TTL_MS) return [];
+
+  return [
+    { label: '5h', snapPercent: cache.snapshot?.fiveHourPercent, window: cache.data?.five_hour },
+    { label: 'wk', snapPercent: cache.snapshot?.weekPercent,     window: cache.data?.seven_day }
+  ].map(({ label, snapPercent, window }) => {
+    const percent = snapPercent != null ? snapPercent : normalizeUtilization(window?.utilization);
+    if (percent == null) return null;
+    let countdown = '';
+    if (window?.resets_at) {
+      const cd = formatCountdown(new Date(window.resets_at).getTime() - now);
+      if (cd) countdown = ` (${cd})`;
+    }
+    return `${label} ${percent}%${countdown}`;
+  }).filter(Boolean);
+}
+
+/**
+ * Join the quota windows into one segment string
+ * @returns {string|null} e.g. "5h 14% (2h21m)  wk 43% (5d)", or null when there is nothing to show
  */
 function buildUsageString(ctx) {
-  if (!ctx.sessionText || ctx.sessionText === 'N/A') return null;
-  let str = ctx.sessionText.replace(' until reset', ' left');
-  if (ctx.usagePercent != null) str += ` (${Math.round(ctx.usagePercent)}%)`;
-  return str;
+  if (!Array.isArray(ctx.usageWindows) || ctx.usageWindows.length === 0) return null;
+  return ctx.usageWindows.join('  ');
+}
+
+/**
+ * Pick the quota segment color: red once any window is near its ceiling.
+ * @returns {(s: string) => string} Color function from the colors module
+ */
+function getQuotaColor(usageWindows) {
+  // Match the percent token specifically — the label carries digits too ("5h 90%").
+  const percents = (usageWindows || [])
+    .map((windowText) => {
+      const match = String(windowText).match(/(\d+)%/);
+      return match ? Number(match[1]) : null;
+    })
+    .filter((percent) => Number.isFinite(percent));
+  return percents.some((n) => n >= QUOTA_HIGH_PERCENT) ? red : green;
 }
 
 /**
@@ -223,7 +313,7 @@ function renderSessionLines(ctx) {
   // Keep usage/reset info close to model/context for quick scanning.
   const usageStr = buildUsageString(ctx);
   if (usageStr) {
-    sessionPart += `  ⌛ ${dim(usageStr.replace(/\)$/, ' used)'))}`;
+    sessionPart += `  ⌛ ${getQuotaColor(ctx.usageWindows)(usageStr)}`;
   }
 
   // Build stats part (only lines changed now)
@@ -469,39 +559,13 @@ async function main() {
       } catch {}
     }
 
-    // Session timer - read actual reset time from usage limits cache
-    let sessionText = '';
     const transcriptPath = data.transcript_path;
 
     // Parse transcript for tools/agents/todos
     const transcript = transcriptPath ? await parseTranscript(transcriptPath) : { tools: [], agents: [], todos: [], sessionStart: null };
 
-    // Read actual reset time and utilization from usage limits cache (written by usage-quota-cache-refresh hook)
-    let usagePercent = null;
-    try {
-      const usageCachePath = env.CK_USAGE_CACHE_PATH || path.join(os.tmpdir(), 'ck-usage-limits-cache.json');
-      if (fs.existsSync(usageCachePath)) {
-        const cache = JSON.parse(fs.readFileSync(usageCachePath, 'utf8'));
-
-        // Check status flag for fallback (non-OAuth scenarios)
-        if (cache.status === 'unavailable') {
-          sessionText = 'N/A';
-        } else {
-          const fiveHour = cache.data?.five_hour;
-          usagePercent = fiveHour?.utilization ?? null;
-          const resetAt = fiveHour?.resets_at;
-          if (resetAt) {
-            const resetTime = new Date(resetAt);
-            const remaining = Math.floor(resetTime.getTime() / 1000) - Math.floor(Date.now() / 1000);
-            if (remaining > 0 && remaining < 18000) {
-              const rh = Math.floor(remaining / 3600);
-              const rm = Math.floor((remaining % 3600) / 60);
-              sessionText = `${rh}h ${rm}m until reset`;
-            }
-          }
-        }
-      }
-    } catch {}
+    // Usage quota windows from the cache written by usage-quota-cache-refresh hook
+    const usageWindows = buildUsageWindows(readUsageCache());
 
     // Lines changed
     const linesAdded = data.cost?.total_lines_added || 0;
@@ -517,8 +581,7 @@ async function main() {
       gitAhead,
       gitBehind,
       contextPercent,
-      sessionText,
-      usagePercent,
+      usageWindows,
       linesAdded,
       linesRemoved,
       transcript