ccusage 15.2.0 → 15.3.1

package/README.md

@@ -20,8 +20,29 @@
 
 ## Installation
 
+### Quick Start (Recommended)
+
+Thanks to ccusage's incredibly small bundle size ([![install size](https://packagephobia.com/badge?p=ccusage)](https://packagephobia.com/result?p=ccusage)), you can run it directly without installation:
+
+```bash
+# Using bunx (recommended for speed)
+bunx ccusage
+
+# Using npx
+npx ccusage@latest
+
+# Using deno (with security flags)
+deno run -E -R=$HOME/.claude/projects/ -S=homedir -N='raw.githubusercontent.com:443' npm:ccusage@latest
+```
+
+> 💡 **Tip**: We recommend using `bunx` instead of `npx` for a massive speed improvement!
+
+### Local Installation (Optional)
+
+Since ccusage has such a small bundle size, installation is entirely optional:
+
 ```bash
-npm i -g ccusage
+npm install -g ccusage
 ```
 
 ## Usage
@@ -62,6 +83,7 @@ ccusage daily --breakdown  # Per-model cost breakdown
 - 🔄 **Cache Token Support**: Tracks and displays cache creation and cache read tokens separately
 - 🌐 **Offline Mode**: Use pre-cached pricing data without network connectivity with `--offline` (Claude models only)
 - 🔌 **MCP Integration**: Built-in Model Context Protocol server for integration with other tools
+- 🚀 **Ultra-Small Bundle**: Unlike other CLI tools, we pay extreme attention to bundle size - incredibly small even without minification!
 
 ## Documentation
 
@@ -69,6 +91,16 @@ Full documentation is available at **[ccusage.com](https://ccusage.com/)**
 
 ## Sponsors
 
+### Featured Sponsor
+
+Check out these [47 Claude Code ProTips from Greg Baugues.](https://www.youtube.com/watch?v=TiNpzxoBPz0&lc=UgyVgQyOhfJJlheVMcB4AaABAg)
+
+<p align="center">
+    <a href="https://www.youtube.com/watch?v=TiNpzxoBPz0&lc=UgyVgQyOhfJJlheVMcB4AaABAg">
+        <img src="https://cdn.jsdelivr.net/gh/ryoppippi/ccusage@main/docs/public/claude_code_protips_thumbnail_v1.png" alt="47 Claude Code ProTips from Greg Baugues" width="600">
+    </a>
+</p>
+
 <p align="center">
     <a href="https://github.com/sponsors/ryoppippi">
         <img src="https://cdn.jsdelivr.net/gh/ryoppippi/sponsors@main/sponsors.svg">

package/dist/_token-utils-WjkbrjKv.js

@@ -0,0 +1,12 @@
+/**
+* Calculates the total number of tokens across all token types
+* Supports both raw usage data format and aggregated data format
+* @param tokenCounts - Object containing counts for each token type
+* @returns Total number of tokens
+*/
+function getTotalTokens(tokenCounts) {
+	const cacheCreation = "cacheCreationInputTokens" in tokenCounts ? tokenCounts.cacheCreationInputTokens : tokenCounts.cacheCreationTokens;
+	const cacheRead = "cacheReadInputTokens" in tokenCounts ? tokenCounts.cacheReadInputTokens : tokenCounts.cacheReadTokens;
+	return tokenCounts.inputTokens + tokenCounts.outputTokens + cacheCreation + cacheRead;
+}
+export { getTotalTokens };

package/dist/{_types-CmSE0O0q.js → _types-BHFM59hI.js}

@@ -725,7 +725,7 @@ const ipv6CidrRegex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1
 const base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
 const base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;
 const dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
-const dateRegex = new RegExp(`^${dateRegexSource}$`);
+const dateRegex = /* @__PURE__ */ new RegExp(`^${dateRegexSource}$`);
 function timeRegexSource(args) {
 	let secondsRegexSource = `[0-5]\\d`;
 	if (args.precision) secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`;
@@ -734,7 +734,7 @@ function timeRegexSource(args) {
 	return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
 }
 function timeRegex(args) {
-	return new RegExp(`^${timeRegexSource(args)}$`);
+	return /* @__PURE__ */ new RegExp(`^${timeRegexSource(args)}$`);
 }
 function datetimeRegex(args) {
 	let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
@@ -742,7 +742,7 @@ function datetimeRegex(args) {
 	opts.push(args.local ? `Z?` : `Z`);
 	if (args.offset) opts.push(`([+-]\\d{2}:?\\d{2})`);
 	regex = `${regex}(${opts.join("|")})`;
-	return new RegExp(`^${regex}$`);
+	return /* @__PURE__ */ new RegExp(`^${regex}$`);
 }
 function isValidIP(ip, version) {
 	if ((version === "v4" || !version) && ipv4Regex.test(ip)) return true;

package/dist/{calculate-cost-B0RYn0Vm.js → calculate-cost-BDqO4yWA.js}

@@ -1,3 +1,4 @@
+import { getTotalTokens } from "./_token-utils-WjkbrjKv.js";
 /**
 * Calculates total token usage and cost across multiple usage data entries
 * @param data - Array of daily, monthly, or session usage data
@@ -19,14 +20,6 @@ function calculateTotals(data) {
 	});
 }
 /**
-* Calculates the sum of all token types (input, output, cache creation, cache read)
-* @param tokens - Token data containing different token counts
-* @returns Total number of tokens across all types
-*/
-function getTotalTokens(tokens) {
-	return tokens.inputTokens + tokens.outputTokens + tokens.cacheCreationTokens + tokens.cacheReadTokens;
-}
-/**
 * Creates a complete totals object by adding total token count to existing totals
 * @param totals - Token totals with cost information
 * @returns Complete totals object including total token sum
@@ -37,4 +30,4 @@ function createTotalsObject(totals) {
 		totalTokens: getTotalTokens(totals)
 	};
 }
-export { calculateTotals, createTotalsObject, getTotalTokens };
+export { calculateTotals, createTotalsObject };

package/dist/calculate-cost.d.ts

@@ -1,17 +1,51 @@
-import { DailyUsage, MonthlyUsage, SessionUsage } from "./data-loader-BuHgMcpg.js";
-import "./pricing-fetcher-CrV0acwD.js";
+import { DailyUsage, MonthlyUsage, SessionUsage } from "./data-loader-a9CiVyT5.js";
+import "./pricing-fetcher-B3SvKOod.js";
 
-//#region src/calculate-cost.d.ts
+//#region src/_token-utils.d.ts
 
 /**
- * Token usage data structure containing input, output, and cache token counts
+ * @fileoverview Token calculation utilities
+ *
+ * This module provides shared utilities for calculating token totals
+ * across different token types. Used throughout the application to
+ * ensure consistent token counting logic.
+ */
+/**
+ * Token counts structure for raw usage data (uses InputTokens suffix)
+ */
+type TokenCounts = {
+  inputTokens: number;
+  outputTokens: number;
+  cacheCreationInputTokens: number;
+  cacheReadInputTokens: number;
+};
+/**
+ * Token counts structure for aggregated data (uses shorter names)
  */
-type TokenData = {
+type AggregatedTokenCounts = {
   inputTokens: number;
   outputTokens: number;
   cacheCreationTokens: number;
   cacheReadTokens: number;
 };
+/**
+ * Union type that supports both token count formats
+ */
+type AnyTokenCounts = TokenCounts | AggregatedTokenCounts;
+/**
+ * Calculates the total number of tokens across all token types
+ * Supports both raw usage data format and aggregated data format
+ * @param tokenCounts - Object containing counts for each token type
+ * @returns Total number of tokens
+ */
+declare function getTotalTokens(tokenCounts: AnyTokenCounts): number;
+//#endregion
+//#region src/calculate-cost.d.ts
+/**
+ * Alias for AggregatedTokenCounts from shared utilities
+ * @deprecated Use AggregatedTokenCounts from _token-utils.ts instead
+ */
+type TokenData = AggregatedTokenCounts;
 /**
  * Token totals including cost information
  */
@@ -30,12 +64,8 @@ type TotalsObject = TokenTotals & {
  * @returns Aggregated token totals and cost
  */
 declare function calculateTotals(data: Array<DailyUsage | MonthlyUsage | SessionUsage>): TokenTotals;
-/**
- * Calculates the sum of all token types (input, output, cache creation, cache read)
- * @param tokens - Token data containing different token counts
- * @returns Total number of tokens across all types
- */
-declare function getTotalTokens(tokens: TokenData): number;
+// Re-export getTotalTokens from shared utilities for backward compatibility
+
 /**
  * Creates a complete totals object by adding total token count to existing totals
  * @param totals - Token totals with cost information

package/dist/calculate-cost.js

@@ -1,3 +1,4 @@
-import "./_types-CmSE0O0q.js";
-import { calculateTotals, createTotalsObject, getTotalTokens } from "./calculate-cost-B0RYn0Vm.js";
+import { getTotalTokens } from "./_token-utils-WjkbrjKv.js";
+import "./_types-BHFM59hI.js";
+import { calculateTotals, createTotalsObject } from "./calculate-cost-BDqO4yWA.js";
 export { calculateTotals, createTotalsObject, getTotalTokens };

package/dist/{data-loader-CzOPffdg.js → data-loader-DqK3z1AK.js}

@@ -1,6 +1,7 @@
-import { CLAUDE_CONFIG_DIR_ENV, CLAUDE_PROJECTS_DIR_NAME, DEFAULT_CLAUDE_CODE_PATH, DEFAULT_CLAUDE_CONFIG_PATH, DEFAULT_RECENT_DAYS, PricingFetcher, USAGE_DATA_GLOB_PATTERN, USER_HOME_DIR, __commonJSMin, __require, __toESM, require_usingCtx } from "./pricing-fetcher-fT0o6CKK.js";
-import { activityDateSchema, arrayType, createDailyDate, createMonthlyDate, createProjectPath, createSessionId, dailyDateSchema, isoTimestampSchema, messageIdSchema, modelNameSchema, monthlyDateSchema, numberType, objectType, projectPathSchema, requestIdSchema, sessionIdSchema, versionSchema } from "./_types-CmSE0O0q.js";
-import { logger } from "./logger-CeR-gFvq.js";
+import { CLAUDE_CONFIG_DIR_ENV, CLAUDE_PROJECTS_DIR_NAME, DEFAULT_CLAUDE_CODE_PATH, DEFAULT_CLAUDE_CONFIG_PATH, DEFAULT_RECENT_DAYS, PricingFetcher, USAGE_DATA_GLOB_PATTERN, USER_HOME_DIR, __commonJSMin, __require, __toESM, isFailure, isPromise, require_usingCtx } from "./pricing-fetcher-DpoTR8Md.js";
+import { getTotalTokens } from "./_token-utils-WjkbrjKv.js";
+import { activityDateSchema, arrayType, booleanType, createDailyDate, createMonthlyDate, createProjectPath, createSessionId, dailyDateSchema, isoTimestampSchema, messageIdSchema, modelNameSchema, monthlyDateSchema, numberType, objectType, projectPathSchema, requestIdSchema, sessionIdSchema, stringType, versionSchema } from "./_types-BHFM59hI.js";
+import { logger } from "./logger-D7tlrIfv.js";
 import a, { readFile } from "node:fs/promises";
 import path, { posix } from "node:path";
 import process$1 from "node:process";
@@ -240,6 +241,35 @@ function isObject$1(x) {
 */ function unreachable(...args) {
 	throw new UnreachableError(args);
 }
+const isResult = (result) => "object" == typeof result && null !== result && "type" in result && ("Success" === result.type && "value" in result || "Failure" === result.type && "error" in result);
+const unwrap = (...args) => {
+	const firstArgument = args[0];
+	if (isResult(firstArgument) || isPromise(firstArgument)) {
+		const result = firstArgument;
+		const hasDefault$1 = 2 === args.length;
+		const defaultValue$1 = hasDefault$1 ? args[1] : void 0;
+		const apply = (r) => {
+			if (isFailure(r)) {
+				if (hasDefault$1) return defaultValue$1;
+				throw new Error(String(r.error));
+			}
+			return r.value;
+		};
+		return isPromise(result) ? result.then(apply) : apply(result);
+	}
+	const hasDefault = 1 === args.length;
+	const defaultValue = hasDefault ? args[0] : void 0;
+	return (result) => {
+		const apply = (r) => {
+			if (isFailure(r)) {
+				if (hasDefault) return defaultValue;
+				throw new Error(String(r.error));
+			}
+			return r.value;
+		};
+		return isPromise(result) ? result.then(apply) : apply(result);
+	};
+};
 function groupBy(arr, getKeyFromItem) {
 	const result = {};
 	for (let i = 0; i < arr.length; i++) {
@@ -3139,12 +3169,14 @@ function createBlock(startTime, entries, now, sessionDurationMs) {
 	};
 	let costUSD = 0;
 	const models = [];
+	let usageLimitResetTime;
 	for (const entry of entries) {
 		tokenCounts.inputTokens += entry.usage.inputTokens;
 		tokenCounts.outputTokens += entry.usage.outputTokens;
 		tokenCounts.cacheCreationInputTokens += entry.usage.cacheCreationInputTokens;
 		tokenCounts.cacheReadInputTokens += entry.usage.cacheReadInputTokens;
 		costUSD += entry.costUSD ?? 0;
+		usageLimitResetTime = entry.usageLimitResetTime ?? usageLimitResetTime;
 		models.push(entry.model);
 	}
 	return {
@@ -3156,7 +3188,8 @@ function createBlock(startTime, entries, now, sessionDurationMs) {
 		entries,
 		tokenCounts,
 		costUSD,
-		models: uniq(models)
+		models: uniq(models),
+		usageLimitResetTime
 	};
 }
 /**
@@ -3202,11 +3235,14 @@ function calculateBurnRate(block) {
 	const lastEntry = lastEntryData.timestamp;
 	const durationMinutes = (lastEntry.getTime() - firstEntry.getTime()) / (1e3 * 60);
 	if (durationMinutes <= 0) return null;
-	const totalTokens = block.tokenCounts.inputTokens + block.tokenCounts.outputTokens;
+	const totalTokens = getTotalTokens(block.tokenCounts);
 	const tokensPerMinute = totalTokens / durationMinutes;
+	const nonCacheTokens = (block.tokenCounts.inputTokens ?? 0) + (block.tokenCounts.outputTokens ?? 0);
+	const tokensPerMinuteForIndicator = nonCacheTokens / durationMinutes;
 	const costPerHour = block.costUSD / durationMinutes * 60;
 	return {
 		tokensPerMinute,
+		tokensPerMinuteForIndicator,
 		costPerHour
 	};
 }
@@ -3222,7 +3258,7 @@ function projectBlockUsage(block) {
 	const now = /* @__PURE__ */ new Date();
 	const remainingTime = block.endTime.getTime() - now.getTime();
 	const remainingMinutes = Math.max(0, remainingTime / (1e3 * 60));
-	const currentTokens = block.tokenCounts.inputTokens + block.tokenCounts.outputTokens;
+	const currentTokens = getTotalTokens(block.tokenCounts);
 	const projectedAdditionalTokens = burnRate.tokensPerMinute * remainingMinutes;
 	const totalTokens = currentTokens + projectedAdditionalTokens;
 	const projectedAdditionalCost = burnRate.costPerHour / 60 * remainingMinutes;
@@ -3241,7 +3277,7 @@ function projectBlockUsage(block) {
 */
 function filterRecentBlocks(blocks, days = DEFAULT_RECENT_DAYS) {
 	const now = /* @__PURE__ */ new Date();
-	const cutoffTime = new Date(now.getTime() - days * 24 * 60 * 60 * 1e3);
+	const cutoffTime = /* @__PURE__ */ new Date(now.getTime() - days * 24 * 60 * 60 * 1e3);
 	return blocks.filter((block) => {
 		return block.startTime >= cutoffTime || block.isActive;
 	});
@@ -3304,10 +3340,12 @@ const usageDataSchema = objectType({
 			cache_read_input_tokens: numberType().optional()
 		}),
 		model: modelNameSchema.optional(),
-		id: messageIdSchema.optional()
+		id: messageIdSchema.optional(),
+		content: arrayType(objectType({ text: stringType().optional() })).optional()
 	}),
 	costUSD: numberType().optional(),
-	requestId: requestIdSchema.optional()
+	requestId: requestIdSchema.optional(),
+	isApiErrorMessage: booleanType().optional()
 });
 /**
 * Zod schema for model-specific usage breakdown data
@@ -3582,17 +3620,33 @@ async function sortFilesByTimestamp(files) {
 async function calculateCostForEntry(data, mode, fetcher) {
 	if (mode === "display") return data.costUSD ?? 0;
 	if (mode === "calculate") {
-		if (data.message.model != null) return fetcher.calculateCostFromTokens(data.message.usage, data.message.model);
+		if (data.message.model != null) return unwrap(fetcher.calculateCostFromTokens(data.message.usage, data.message.model), 0);
 		return 0;
 	}
 	if (mode === "auto") {
 		if (data.costUSD != null) return data.costUSD;
-		if (data.message.model != null) return fetcher.calculateCostFromTokens(data.message.usage, data.message.model);
+		if (data.message.model != null) return unwrap(fetcher.calculateCostFromTokens(data.message.usage, data.message.model), 0);
 		return 0;
 	}
 	unreachable(mode);
 }
 /**
+* Get Claude Code usage limit expiration date
+* @param data - Usage data entry
+* @returns Usage limit expiration date
+*/
+function getUsageLimitResetTime(data) {
+	let resetTime = null;
+	if (data.isApiErrorMessage === true) {
+		const timestampMatch = data.message?.content?.find((c) => c.text != null && c.text.includes("Claude AI usage limit reached"))?.text?.match(/\|(\d+)/) ?? null;
+		if (timestampMatch?.[1] != null) {
+			const resetTimestamp = Number.parseInt(timestampMatch[1]);
+			resetTime = resetTimestamp > 0 ? /* @__PURE__ */ new Date(resetTimestamp * 1e3) : null;
+		}
+	}
+	return resetTime;
+}
+/**
 * Loads and aggregates Claude usage data by day
 * Processes all JSONL files in the Claude projects directory and groups usage by date
 * @param options - Optional configuration for loading and filtering data
@@ -3829,6 +3883,7 @@ async function loadSessionBlockData(options) {
 				if (isDuplicateEntry(uniqueHash, processedHashes)) continue;
 				markAsProcessed(uniqueHash, processedHashes);
 				const cost = fetcher != null ? await calculateCostForEntry(data, mode, fetcher) : data.costUSD ?? 0;
+				const usageLimitResetTime = getUsageLimitResetTime(data);
 				allEntries.push({
 					timestamp: new Date(data.timestamp),
 					usage: {
@@ -3839,7 +3894,8 @@ async function loadSessionBlockData(options) {
 					},
 					costUSD: cost,
 					model: data.message.model ?? "unknown",
-					version: data.version
+					version: data.version,
+					usageLimitResetTime: usageLimitResetTime ?? void 0
 				});
 			} catch (error) {
 				logger.debug(`Skipping invalid JSON line in 5-hour blocks: ${error instanceof Error ? error.message : String(error)}`);
@@ -3859,4 +3915,4 @@ async function loadSessionBlockData(options) {
 		_usingCtx4.d();
 	}
 }
-export { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, calculateCostForEntry, createUniqueHash, dailyUsageSchema, filterRecentBlocks, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, glob, identifySessionBlocks, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, projectBlockUsage, sessionUsageSchema, sortFilesByTimestamp, uniq, usageDataSchema };
+export { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, calculateCostForEntry, createUniqueHash, dailyUsageSchema, filterRecentBlocks, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, glob, identifySessionBlocks, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, projectBlockUsage, sessionUsageSchema, sortFilesByTimestamp, uniq, unwrap, usageDataSchema };

package/dist/{data-loader-BuHgMcpg.d.ts → data-loader-a9CiVyT5.d.ts}

@@ -1,4 +1,4 @@
-import { CostMode, PricingFetcher, SortOrder } from "./pricing-fetcher-CrV0acwD.js";
+import { CostMode, PricingFetcher, SortOrder } from "./pricing-fetcher-B3SvKOod.js";
 import { z } from "zod";
 
 //#region src/_session-blocks.d.ts
@@ -17,6 +17,7 @@ type LoadedUsageEntry = {
   costUSD: number | null;
   model: string;
   version?: string;
+  usageLimitResetTime?: Date; // Claude API usage limit reset time
 };
 /**
  * Aggregated token counts for different token types
@@ -41,6 +42,7 @@ type SessionBlock = {
   tokenCounts: TokenCounts;
   costUSD: number;
   models: string[];
+  usageLimitResetTime?: Date; // Claude API usage limit reset time
 };
 /**
  * Represents usage burn rate calculations
@@ -78,6 +80,13 @@ declare const usageDataSchema: z.ZodObject<{
     }>;
     model: z.ZodOptional<z.ZodBranded<z.ZodString, "ModelName">>;
     id: z.ZodOptional<z.ZodBranded<z.ZodString, "MessageId">>;
+    content: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      text: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+      text?: string | undefined;
+    }, {
+      text?: string | undefined;
+    }>, "many">>;
   }, "strip", z.ZodTypeAny, {
     usage: {
       input_tokens: number;
@@ -87,6 +96,9 @@ declare const usageDataSchema: z.ZodObject<{
     };
     model?: (string & z.BRAND<"ModelName">) | undefined;
     id?: (string & z.BRAND<"MessageId">) | undefined;
+    content?: {
+      text?: string | undefined;
+    }[] | undefined;
   }, {
     usage: {
       input_tokens: number;
@@ -96,9 +108,13 @@ declare const usageDataSchema: z.ZodObject<{
     };
     model?: string | undefined;
     id?: string | undefined;
+    content?: {
+      text?: string | undefined;
+    }[] | undefined;
   }>;
   costUSD: z.ZodOptional<z.ZodNumber>;
   requestId: z.ZodOptional<z.ZodBranded<z.ZodString, "RequestId">>;
+  isApiErrorMessage: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
   timestamp: string & z.BRAND<"ISOTimestamp">;
   version?: (string & z.BRAND<"Version">) | undefined;
@@ -111,9 +127,13 @@ declare const usageDataSchema: z.ZodObject<{
     };
     model?: (string & z.BRAND<"ModelName">) | undefined;
     id?: (string & z.BRAND<"MessageId">) | undefined;
+    content?: {
+      text?: string | undefined;
+    }[] | undefined;
   };
   costUSD?: number | undefined;
   requestId?: (string & z.BRAND<"RequestId">) | undefined;
+  isApiErrorMessage?: boolean | undefined;
 }, {
   timestamp: string;
   version?: string | undefined;
@@ -126,9 +146,13 @@ declare const usageDataSchema: z.ZodObject<{
     };
     model?: string | undefined;
     id?: string | undefined;
+    content?: {
+      text?: string | undefined;
+    }[] | undefined;
   };
   costUSD?: number | undefined;
   requestId?: string | undefined;
+  isApiErrorMessage?: boolean | undefined;
 }>;
 /**
  * Type definition for Claude usage data entries from JSONL files
@@ -416,6 +440,12 @@ declare function sortFilesByTimestamp(files: string[]): Promise<string[]>;
  * @returns Calculated cost in USD
  */
 declare function calculateCostForEntry(data: UsageData, mode: CostMode, fetcher: PricingFetcher): Promise<number>;
+/**
+ * Get Claude Code usage limit expiration date
+ * @param data - Usage data entry
+ * @returns Usage limit expiration date
+ */
+declare function getUsageLimitResetTime(data: UsageData): Date | null;
 /**
  * Date range filter for limiting usage data by date
  */
@@ -462,4 +492,4 @@ declare function loadMonthlyUsageData(options?: LoadOptions): Promise<MonthlyUsa
  */
 declare function loadSessionBlockData(options?: LoadOptions): Promise<SessionBlock[]>;
 //#endregion
-export { DailyUsage, DateFilter, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };
+export { DailyUsage, DateFilter, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };

package/dist/data-loader.d.ts

@@ -1,3 +1,3 @@
-import { DailyUsage, DateFilter, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-BuHgMcpg.js";
-import "./pricing-fetcher-CrV0acwD.js";
-export { DailyUsage, DateFilter, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };
+import { DailyUsage, DateFilter, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-a9CiVyT5.js";
+import "./pricing-fetcher-B3SvKOod.js";
+export { DailyUsage, DateFilter, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };

package/dist/data-loader.js

@@ -1,5 +1,6 @@
-import "./pricing-fetcher-fT0o6CKK.js";
-import "./_types-CmSE0O0q.js";
-import { calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-CzOPffdg.js";
-import "./logger-CeR-gFvq.js";
-export { calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };
+import "./pricing-fetcher-DpoTR8Md.js";
+import "./_token-utils-WjkbrjKv.js";
+import "./_types-BHFM59hI.js";
+import { calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-DqK3z1AK.js";
+import "./logger-D7tlrIfv.js";
+export { calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };

package/dist/{debug-CCsUo8-n.js → debug-Cby_QhQQ.js}

@@ -1,6 +1,6 @@
-import { CLAUDE_PROJECTS_DIR_NAME, DEBUG_MATCH_THRESHOLD_PERCENT, PricingFetcher, USAGE_DATA_GLOB_PATTERN, __toESM, require_usingCtx } from "./pricing-fetcher-fT0o6CKK.js";
-import { getClaudePaths, glob, usageDataSchema } from "./data-loader-CzOPffdg.js";
-import { logger } from "./logger-CeR-gFvq.js";
+import { CLAUDE_PROJECTS_DIR_NAME, DEBUG_MATCH_THRESHOLD_PERCENT, PricingFetcher, USAGE_DATA_GLOB_PATTERN, __toESM, isFailure, require_usingCtx, try_ } from "./pricing-fetcher-DpoTR8Md.js";
+import { getClaudePaths, glob, unwrap, usageDataSchema } from "./data-loader-DqK3z1AK.js";
+import { logger } from "./logger-D7tlrIfv.js";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 var import_usingCtx = __toESM(require_usingCtx(), 1);
@@ -37,16 +37,21 @@ async function detectMismatches(claudePath) {
 		for (const file of files) {
 			const content = await readFile(file, "utf-8");
 			const lines = content.trim().split("\n").filter((line) => line.length > 0);
-			for (const line of lines) try {
-				const parsed = JSON.parse(line);
-				const result = usageDataSchema.safeParse(parsed);
-				if (!result.success) continue;
-				const data = result.data;
+			for (const line of lines) {
+				const parseParser = try_({
+					try: () => JSON.parse(line),
+					catch: () => /* @__PURE__ */ new Error("Invalid JSON")
+				});
+				const parseResult = parseParser();
+				if (isFailure(parseResult)) continue;
+				const schemaResult = usageDataSchema.safeParse(parseResult.value);
+				if (!schemaResult.success) continue;
+				const data = schemaResult.data;
 				stats.totalEntries++;
 				if (data.costUSD !== void 0 && data.message.model != null && data.message.model !== "<synthetic>") {
 					stats.entriesWithBoth++;
 					const model = data.message.model;
-					const calculatedCost = await fetcher.calculateCostFromTokens(data.message.usage, model);
+					const calculatedCost = await unwrap(fetcher.calculateCostFromTokens(data.message.usage, model));
 					const difference = Math.abs(data.costUSD - calculatedCost);
 					const percentDiff = data.costUSD > 0 ? difference / data.costUSD * 100 : 0;
 					const modelStat = stats.modelStats.get(model) ?? {
@@ -89,7 +94,7 @@ async function detectMismatches(claudePath) {
 					modelStat.avgPercentDiff = (modelStat.avgPercentDiff * (modelStat.total - 1) + percentDiff) / modelStat.total;
 					stats.modelStats.set(model, modelStat);
 				}
-			} catch {}
+			}
 		}
 		return stats;
 	} catch (_) {

package/dist/debug.js

@@ -1,6 +1,7 @@
-import "./pricing-fetcher-fT0o6CKK.js";
-import "./_types-CmSE0O0q.js";
-import "./data-loader-CzOPffdg.js";
-import "./logger-CeR-gFvq.js";
-import { detectMismatches, printMismatchReport } from "./debug-CCsUo8-n.js";
+import "./pricing-fetcher-DpoTR8Md.js";
+import "./_token-utils-WjkbrjKv.js";
+import "./_types-BHFM59hI.js";
+import "./data-loader-DqK3z1AK.js";
+import "./logger-D7tlrIfv.js";
+import { detectMismatches, printMismatchReport } from "./debug-Cby_QhQQ.js";
 export { detectMismatches, printMismatchReport };