claude-limitline 1.5.1 → 1.5.3

package/dist/index.js

@@ -35,7 +35,11 @@ var DEFAULT_CONFIG = {
     enabled: true,
     displayStyle: "text",
     barWidth: 10,
-    showTimeRemaining: true
+    showTimeRemaining: true,
+    timeDisplay: "remaining",
+    timeFormat: "12h",
+    showSparkline: false,
+    sparklineWidth: 8
   },
   weekly: {
     enabled: true,
@@ -161,32 +165,86 @@ async function getOAuthTokenWindows() {
   }
   return null;
 }
-async function getOAuthTokenMacOS() {
+async function findKeychainServiceName() {
   try {
     const { stdout } = await execAsync(
-      `security find-generic-password -s "Claude Code-credentials" -w`,
+      `security dump-keychain 2>/dev/null | grep -o '"Claude Code-credentials[^"]*"'`,
       { timeout: 5e3 }
     );
-    const content = stdout.trim();
-    if (content.startsWith("{")) {
-      try {
-        const parsed = JSON.parse(content);
-        if (parsed.claudeAiOauth && typeof parsed.claudeAiOauth === "object") {
-          const token = parsed.claudeAiOauth.accessToken;
+    const matches = stdout.trim().split("\n").map((s) => s.replace(/^"|"$/g, "")).filter(Boolean).sort((a, b) => b.length - a.length);
+    if (matches.length > 0) {
+      debug(`Found keychain service: ${matches[0]}`);
+      return matches[0];
+    }
+  } catch (error) {
+    debug("Keychain service name lookup failed:", error);
+  }
+  return "Claude Code-credentials";
+}
+function extractTokenFromKeychainContent(content) {
+  if (content.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(content);
+      if (parsed.claudeAiOauth && typeof parsed.claudeAiOauth === "object") {
+        const token = parsed.claudeAiOauth.accessToken;
+        if (token && typeof token === "string" && token.startsWith("sk-ant-oat")) {
+          return token;
+        }
+      }
+    } catch (parseError) {
+      debug("Failed to parse keychain JSON:", parseError);
+    }
+  }
+  if (content.startsWith("sk-ant-oat")) {
+    return content;
+  }
+  return null;
+}
+async function getOAuthTokenMacOS() {
+  const serviceName = await findKeychainServiceName();
+  for (const name of [serviceName, "Claude Code-credentials"]) {
+    try {
+      const { stdout } = await execAsync(
+        `security find-generic-password -s "${name}" -w`,
+        { timeout: 5e3 }
+      );
+      const token = extractTokenFromKeychainContent(stdout.trim());
+      if (token) {
+        debug(`Found OAuth token in macOS Keychain (${name})`);
+        return token;
+      }
+    } catch (error) {
+      debug(`macOS Keychain retrieval failed for "${name}":`, error);
+    }
+  }
+  const configPaths = [
+    path2.join(os2.homedir(), ".claude", ".credentials.json"),
+    path2.join(os2.homedir(), ".claude", "credentials.json"),
+    path2.join(os2.homedir(), ".config", "claude-code", "credentials.json")
+  ];
+  for (const configPath of configPaths) {
+    try {
+      if (fs2.existsSync(configPath)) {
+        const content = fs2.readFileSync(configPath, "utf-8");
+        const config = JSON.parse(content);
+        if (config.claudeAiOauth && typeof config.claudeAiOauth === "object") {
+          const token = config.claudeAiOauth.accessToken;
           if (token && typeof token === "string" && token.startsWith("sk-ant-oat")) {
-            debug("Found OAuth token in macOS Keychain under claudeAiOauth.accessToken");
+            debug(`Found OAuth token in ${configPath} under claudeAiOauth.accessToken`);
+            return token;
+          }
+        }
+        for (const key of ["oauth_token", "token", "accessToken"]) {
+          const token = config[key];
+          if (token && typeof token === "string" && token.startsWith("sk-ant-oat")) {
+            debug(`Found OAuth token in ${configPath} under key ${key}`);
             return token;
           }
         }
-      } catch (parseError) {
-        debug("Failed to parse keychain JSON:", parseError);
       }
+    } catch (error) {
+      debug(`Failed to read config from ${configPath}:`, error);
     }
-    if (content.startsWith("sk-ant-oat")) {
-      return content;
-    }
-  } catch (error) {
-    debug("macOS Keychain retrieval failed:", error);
   }
   return null;
 }
@@ -286,9 +344,57 @@ async function fetchUsageFromAPI(token) {
     return null;
   }
 }
-var cachedUsage = null;
-var previousUsage = null;
-var cacheTimestamp = 0;
+var USAGE_CACHE_FILE = "limitline-usage-cache.json";
+function getCachePath() {
+  return path2.join(os2.homedir(), ".claude", USAGE_CACHE_FILE);
+}
+function loadDiskCache() {
+  try {
+    const cachePath = getCachePath();
+    if (fs2.existsSync(cachePath)) {
+      const content = fs2.readFileSync(cachePath, "utf-8");
+      const data = JSON.parse(content);
+      const rehydrate = (usage) => {
+        if (!usage) return null;
+        const fix = (ud) => {
+          if (!ud) return null;
+          return { ...ud, resetAt: new Date(ud.resetAt) };
+        };
+        return {
+          ...usage,
+          fiveHour: fix(usage.fiveHour),
+          sevenDay: fix(usage.sevenDay),
+          sevenDayOpus: fix(usage.sevenDayOpus),
+          sevenDaySonnet: fix(usage.sevenDaySonnet)
+        };
+      };
+      return {
+        timestamp: data.timestamp,
+        usage: rehydrate(data.usage),
+        previousUsage: rehydrate(data.previousUsage)
+      };
+    }
+  } catch (error) {
+    debug("Failed to load usage cache from disk:", error);
+  }
+  return null;
+}
+function saveDiskCache(cache) {
+  try {
+    const cachePath = getCachePath();
+    const dir = path2.dirname(cachePath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    fs2.writeFileSync(cachePath, JSON.stringify(cache));
+  } catch (error) {
+    debug("Failed to save usage cache to disk:", error);
+  }
+}
+var diskCache = loadDiskCache();
+var cachedUsage = diskCache?.usage ?? null;
+var previousUsage = diskCache?.previousUsage ?? null;
+var cacheTimestamp = diskCache?.timestamp ?? 0;
 var cachedToken = null;
 function getUsageTrend() {
   const result = {
@@ -333,6 +439,7 @@ async function getRealtimeUsage(pollIntervalMinutes = 15) {
     previousUsage = cachedUsage;
     cachedUsage = usage;
     cacheTimestamp = now;
+    saveDiskCache({ timestamp: now, usage: cachedUsage, previousUsage });
     debug("Refreshed realtime usage cache");
   } else {
     cachedToken = null;
@@ -649,6 +756,75 @@ function getTerminalWidth() {
   return process.stdout.columns || 80;
 }
 
+// src/utils/history.ts
+import fs3 from "fs";
+import path3 from "path";
+import os3 from "os";
+var SPARKLINE_CHARS = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+var MAX_HISTORY_AGE_MS = 24 * 60 * 60 * 1e3;
+var HISTORY_FILE = "limitline-history.json";
+function getHistoryPath() {
+  return path3.join(os3.homedir(), ".claude", HISTORY_FILE);
+}
+function loadHistory() {
+  const historyPath = getHistoryPath();
+  try {
+    if (fs3.existsSync(historyPath)) {
+      const content = fs3.readFileSync(historyPath, "utf-8");
+      const data = JSON.parse(content);
+      return data;
+    }
+  } catch (error) {
+    debug("Failed to load history:", error);
+  }
+  return { samples: [] };
+}
+function saveHistory(data) {
+  const historyPath = getHistoryPath();
+  try {
+    const dir = path3.dirname(historyPath);
+    if (!fs3.existsSync(dir)) {
+      fs3.mkdirSync(dir, { recursive: true });
+    }
+    fs3.writeFileSync(historyPath, JSON.stringify(data, null, 2));
+  } catch (error) {
+    debug("Failed to save history:", error);
+  }
+}
+function pruneOldSamples(data) {
+  const cutoff = Date.now() - MAX_HISTORY_AGE_MS;
+  return {
+    samples: data.samples.filter((s) => s.timestamp > cutoff)
+  };
+}
+function addSample(blockPercent, weeklyPercent) {
+  const history = loadHistory();
+  history.samples.push({
+    timestamp: Date.now(),
+    blockPercent,
+    weeklyPercent
+  });
+  const pruned = pruneOldSamples(history);
+  saveHistory(pruned);
+}
+function getSparkline(samples, width) {
+  const validSamples = samples.filter((s) => s !== null);
+  if (validSamples.length === 0) {
+    return "";
+  }
+  const recentSamples = validSamples.slice(-width);
+  return recentSamples.map((value) => {
+    const clamped = Math.max(0, Math.min(100, value));
+    const index = Math.floor(clamped / 100 * 7);
+    return SPARKLINE_CHARS[index];
+  }).join("");
+}
+function getBlockSparkline(width) {
+  const history = loadHistory();
+  const blockSamples = history.samples.map((s) => s.blockPercent);
+  return getSparkline(blockSamples, width);
+}
+
 // src/renderer.ts
 var Renderer = class {
   config;
@@ -704,6 +880,18 @@ var Renderer = class {
     }
     return `${minutes}m`;
   }
+  formatAbsoluteTime(resetAt, format) {
+    const hours = resetAt.getHours();
+    const minutes = resetAt.getMinutes();
+    const paddedMinutes = minutes.toString().padStart(2, "0");
+    if (format === "24h") {
+      const paddedHours = hours.toString().padStart(2, "0");
+      return `${paddedHours}:${paddedMinutes}`;
+    }
+    const hour12 = hours % 12 || 12;
+    const ampm = hours < 12 ? "am" : "pm";
+    return `${hour12}:${paddedMinutes}${ampm}`;
+  }
   getTrendSymbol(trend) {
     if (!this.config.showTrend) return "";
     if (trend === "up") return this.symbols.trendUp;
@@ -812,9 +1000,24 @@ var Renderer = class {
     } else {
       text = `${Math.round(percent)}%${trend}`;
     }
-    if (showTime && ctx.blockInfo.timeRemaining !== null && !ctx.compact) {
-      const timeStr = this.formatTimeRemaining(ctx.blockInfo.timeRemaining, ctx.compact);
-      text += ` (${timeStr})`;
+    const showSparkline = this.config.block?.showSparkline ?? false;
+    if (showSparkline && !ctx.compact) {
+      const sparklineWidth = this.config.block?.sparklineWidth ?? 8;
+      const sparkline = getBlockSparkline(sparklineWidth);
+      if (sparkline) {
+        text += ` ${sparkline}`;
+      }
+    }
+    if (showTime && !ctx.compact) {
+      const timeDisplay = this.config.block?.timeDisplay ?? "remaining";
+      const timeFormat = this.config.block?.timeFormat ?? "12h";
+      if (timeDisplay === "absolute" && ctx.blockInfo.resetAt) {
+        const timeStr = this.formatAbsoluteTime(ctx.blockInfo.resetAt, timeFormat);
+        text += ` (${timeStr})`;
+      } else if (ctx.blockInfo.timeRemaining !== null) {
+        const timeStr = this.formatTimeRemaining(ctx.blockInfo.timeRemaining, ctx.compact);
+        text += ` (${timeStr})`;
+      }
     }
     return {
       text: ` ${icon} ${text} `,
@@ -1136,6 +1339,12 @@ async function main() {
     ]);
     debug("Block info:", JSON.stringify(blockInfo));
     debug("Weekly info:", JSON.stringify(weeklyInfo));
+    if (blockInfo?.percentUsed !== null || weeklyInfo?.percentUsed !== null) {
+      addSample(
+        blockInfo?.percentUsed ?? null,
+        weeklyInfo?.percentUsed ?? null
+      );
+    }
     const trendInfo = config.showTrend ? getUsageTrend() : null;
     debug("Trend info:", JSON.stringify(trendInfo));
     const renderer = new Renderer(config);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-limitline",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "A statusline for Claude Code showing real-time usage limits and weekly tracking",
   "main": "dist/index.js",
   "bin": {
@@ -8,6 +8,7 @@
   },
   "type": "module",
   "scripts": {
+    "prepare": "tsup src/index.ts --format esm --dts --clean",
     "build": "tsup src/index.ts --format esm --dts --clean",
     "dev": "tsup src/index.ts --format esm --watch",
     "start": "node dist/index.js",