ccusage 0.6.2 → 0.8.0

package/dist/{data-loader-BfnzLKGl.js → data-loader-Bz6Vemxw.js}

@@ -1,5 +1,6 @@
 import { array, number, object, optional, pipe, regex, safeParse, string } from "./dist-BEQ1tJCL.js";
-import { PricingFetcher } from "./pricing-fetcher-BY3-ryVq.js";
+import { logger } from "./logger-DN-RT9jL.js";
+import { PricingFetcher } from "./pricing-fetcher-DMNBE90M.js";
 import { createRequire } from "node:module";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -2496,7 +2497,7 @@ var require_picomatch$1 = __commonJS({ "node_modules/picomatch/lib/picomatch.js"
 	* @api public
 	*/
 	picomatch$2.parse = (pattern, options) => {
-		if (Array.isArray(pattern)) return pattern.map((p) => picomatch$2.parse(p, options));
+		if (Array.isArray(pattern)) return pattern.map((p$1) => picomatch$2.parse(p$1, options));
 		return parse(pattern, {
 			...options,
 			fastpaths: false
@@ -2793,7 +2794,7 @@ var require_dist$1 = __commonJS({ "node_modules/fdir/dist/index.js"(exports) {
 		o[k2] = m[k];
 	});
 	var __exportStar = void 0 && (void 0).__exportStar || function(m, exports$1) {
-		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
+		for (var p$1 in m) if (p$1 !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p$1)) __createBinding(exports$1, m, p$1);
 	};
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.fdir = void 0;
@@ -2973,20 +2974,20 @@ function crawl(options, cwd, sync$1) {
 		nocase
 	});
 	const fdirOptions = {
-		filters: [options.debug ? (p, isDirectory) => {
-			const path$1$1 = processPath(p, cwd, props.root, isDirectory, options.absolute);
+		filters: [options.debug ? (p$1, isDirectory) => {
+			const path$1$1 = processPath(p$1, cwd, props.root, isDirectory, options.absolute);
 			const matches = matcher(path$1$1);
 			if (matches) log(`matched ${path$1$1}`);
 			return matches;
-		} : (p, isDirectory) => matcher(processPath(p, cwd, props.root, isDirectory, options.absolute))],
-		exclude: options.debug ? (_, p) => {
-			const relativePath = processPath(p, cwd, props.root, true, true);
+		} : (p$1, isDirectory) => matcher(processPath(p$1, cwd, props.root, isDirectory, options.absolute))],
+		exclude: options.debug ? (_, p$1) => {
+			const relativePath = processPath(p$1, cwd, props.root, true, true);
 			const skipped = relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
-			if (skipped) log(`skipped ${p}`);
-			else log(`crawling ${p}`);
+			if (skipped) log(`skipped ${p$1}`);
+			else log(`crawling ${p$1}`);
 			return skipped;
-		} : (_, p) => {
-			const relativePath = processPath(p, cwd, props.root, true, true);
+		} : (_, p$1) => {
+			const relativePath = processPath(p$1, cwd, props.root, true, true);
 			return relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
 		},
 		pathSeparator: "/",
@@ -3024,8 +3025,78 @@ async function glob(patternsOrOptions, options) {
 	return crawl(opts, cwd, false);
 }
 
+//#endregion
+//#region node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({ "node_modules/picocolors/picocolors.js"(exports, module) {
+	let p = process || {}, argv = p.argv || [], env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => (input) => {
+		let string$1 = "" + input, index = string$1.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string$1, close, replace, index) + close : open + string$1 + close;
+	};
+	let replaceClose = (string$1, close, replace, index) => {
+		let result = "", cursor = 0;
+		do {
+			result += string$1.substring(cursor, index) + replace;
+			cursor = index + close.length;
+			index = string$1.indexOf(close, cursor);
+		} while (~index);
+		return result + string$1.substring(cursor);
+	};
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1B[0m", "\x1B[0m"),
+			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+			italic: f("\x1B[3m", "\x1B[23m"),
+			underline: f("\x1B[4m", "\x1B[24m"),
+			inverse: f("\x1B[7m", "\x1B[27m"),
+			hidden: f("\x1B[8m", "\x1B[28m"),
+			strikethrough: f("\x1B[9m", "\x1B[29m"),
+			black: f("\x1B[30m", "\x1B[39m"),
+			red: f("\x1B[31m", "\x1B[39m"),
+			green: f("\x1B[32m", "\x1B[39m"),
+			yellow: f("\x1B[33m", "\x1B[39m"),
+			blue: f("\x1B[34m", "\x1B[39m"),
+			magenta: f("\x1B[35m", "\x1B[39m"),
+			cyan: f("\x1B[36m", "\x1B[39m"),
+			white: f("\x1B[37m", "\x1B[39m"),
+			gray: f("\x1B[90m", "\x1B[39m"),
+			bgBlack: f("\x1B[40m", "\x1B[49m"),
+			bgRed: f("\x1B[41m", "\x1B[49m"),
+			bgGreen: f("\x1B[42m", "\x1B[49m"),
+			bgYellow: f("\x1B[43m", "\x1B[49m"),
+			bgBlue: f("\x1B[44m", "\x1B[49m"),
+			bgMagenta: f("\x1B[45m", "\x1B[49m"),
+			bgCyan: f("\x1B[46m", "\x1B[49m"),
+			bgWhite: f("\x1B[47m", "\x1B[49m"),
+			blackBright: f("\x1B[90m", "\x1B[39m"),
+			redBright: f("\x1B[91m", "\x1B[39m"),
+			greenBright: f("\x1B[92m", "\x1B[39m"),
+			yellowBright: f("\x1B[93m", "\x1B[39m"),
+			blueBright: f("\x1B[94m", "\x1B[39m"),
+			magentaBright: f("\x1B[95m", "\x1B[39m"),
+			cyanBright: f("\x1B[96m", "\x1B[39m"),
+			whiteBright: f("\x1B[97m", "\x1B[39m"),
+			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+			bgRedBright: f("\x1B[101m", "\x1B[49m"),
+			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+		};
+	};
+	module.exports = createColors();
+	module.exports.createColors = createColors;
+} });
+
 //#endregion
 //#region src/utils.internal.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
 function formatNumber(num) {
 	return num.toLocaleString("en-US");
 }
@@ -3043,6 +3114,32 @@ function groupBy(array$1, keyFn) {
 		return groups;
 	}, {});
 }
+function formatModelName(modelName) {
+	const match = modelName.match(/claude-(\w+)-(\d+)-\d+/);
+	if (match != null) return `${match[1]}-${match[2]}`;
+	return modelName;
+}
+function formatModelsDisplay(models) {
+	const uniqueModels = [...new Set(models.map(formatModelName))];
+	return uniqueModels.sort().join(", ");
+}
+/**
+* Pushes model breakdown rows to a table
+* @param table - The table to push rows to
+* @param breakdowns - Array of model breakdowns
+* @param extraColumns - Number of extra empty columns before the data (default: 1 for models column)
+* @param trailingColumns - Number of extra empty columns after the data (default: 0)
+*/
+function pushBreakdownRows(table, breakdowns, extraColumns = 1, trailingColumns = 0) {
+	for (const breakdown of breakdowns) {
+		const row = [`  └─ ${formatModelName(breakdown.modelName)}`];
+		for (let i = 0; i < extraColumns; i++) row.push("");
+		const totalTokens = breakdown.inputTokens + breakdown.outputTokens + breakdown.cacheCreationTokens + breakdown.cacheReadTokens;
+		row.push(import_picocolors.default.gray(formatNumber(breakdown.inputTokens)), import_picocolors.default.gray(formatNumber(breakdown.outputTokens)), import_picocolors.default.gray(formatNumber(breakdown.cacheCreationTokens)), import_picocolors.default.gray(formatNumber(breakdown.cacheReadTokens)), import_picocolors.default.gray(formatNumber(totalTokens)), import_picocolors.default.gray(formatCurrency(breakdown.cost)));
+		for (let i = 0; i < trailingColumns; i++) row.push("");
+		table.push(row);
+	}
+}
 
 //#endregion
 //#region node_modules/rolldown/node_modules/@oxc-project/runtime/src/helpers/usingCtx.js
@@ -3120,9 +3217,19 @@ const UsageDataSchema = object({
 			cache_creation_input_tokens: optional(number()),
 			cache_read_input_tokens: optional(number())
 		}),
-		model: optional(string())
+		model: optional(string()),
+		id: optional(string())
 	}),
-	costUSD: optional(number())
+	costUSD: optional(number()),
+	requestId: optional(string())
+});
+const ModelBreakdownSchema = object({
+	modelName: string(),
+	inputTokens: number(),
+	outputTokens: number(),
+	cacheCreationTokens: number(),
+	cacheReadTokens: number(),
+	cost: number()
 });
 const DailyUsageSchema = object({
 	date: pipe(string(), regex(/^\d{4}-\d{2}-\d{2}$/)),
@@ -3130,7 +3237,9 @@ const DailyUsageSchema = object({
 	outputTokens: number(),
 	cacheCreationTokens: number(),
 	cacheReadTokens: number(),
-	totalCost: number()
+	totalCost: number(),
+	modelsUsed: array(string()),
+	modelBreakdowns: array(ModelBreakdownSchema)
 });
 const SessionUsageSchema = object({
 	sessionId: string(),
@@ -3141,7 +3250,9 @@ const SessionUsageSchema = object({
 	cacheReadTokens: number(),
 	totalCost: number(),
 	lastActivity: string(),
-	versions: array(string())
+	versions: array(string()),
+	modelsUsed: array(string()),
+	modelBreakdowns: array(ModelBreakdownSchema)
 });
 const MonthlyUsageSchema = object({
 	month: pipe(string(), regex(/^\d{4}-\d{2}$/)),
@@ -3149,7 +3260,9 @@ const MonthlyUsageSchema = object({
 	outputTokens: number(),
 	cacheCreationTokens: number(),
 	cacheReadTokens: number(),
-	totalCost: number()
+	totalCost: number(),
+	modelsUsed: array(string()),
+	modelBreakdowns: array(ModelBreakdownSchema)
 });
 function formatDate(dateStr) {
 	const date = new Date(dateStr);
@@ -3158,6 +3271,60 @@ function formatDate(dateStr) {
 	const day = String(date.getDate()).padStart(2, "0");
 	return `${year}-${month}-${day}`;
 }
+/**
+* Create a unique identifier for deduplication using message ID and request ID
+*/
+function createUniqueHash(data) {
+	const messageId = data.message.id;
+	const requestId = data.requestId;
+	if (messageId == null || requestId == null) return null;
+	return `${messageId}:${requestId}`;
+}
+/**
+* Extract the earliest timestamp from a JSONL file
+* Scans through the file until it finds a valid timestamp
+*/
+async function getEarliestTimestamp(filePath) {
+	try {
+		const content = await readFile(filePath, "utf-8");
+		const lines = content.trim().split("\n");
+		let earliestDate = null;
+		for (const line of lines) {
+			if (line.trim() === "") continue;
+			try {
+				const json = JSON.parse(line);
+				if (json.timestamp != null && typeof json.timestamp === "string") {
+					const date = new Date(json.timestamp);
+					if (!Number.isNaN(date.getTime())) {
+						if (earliestDate == null || date < earliestDate) earliestDate = date;
+					}
+				}
+			} catch {
+				continue;
+			}
+		}
+		return earliestDate;
+	} catch (error) {
+		logger.debug(`Failed to get earliest timestamp for ${filePath}:`, error);
+		return null;
+	}
+}
+/**
+* Sort files by their earliest timestamp
+* Files without valid timestamps are placed at the end
+*/
+async function sortFilesByTimestamp(files) {
+	const filesWithTimestamps = await Promise.all(files.map(async (file) => ({
+		file,
+		timestamp: await getEarliestTimestamp(file)
+	})));
+	return filesWithTimestamps.sort((a, b) => {
+		if (a.timestamp == null && b.timestamp == null) return 0;
+		if (a.timestamp == null) return 1;
+		if (b.timestamp == null) return -1;
+		return a.timestamp.getTime() - b.timestamp.getTime();
+	}).map((item) => item.file);
+}
 async function calculateCostForEntry(data, mode, fetcher) {
 	if (mode === "display") return data.costUSD ?? 0;
 	if (mode === "calculate") {
@@ -3181,10 +3348,12 @@ async function loadDailyUsageData(options) {
 			absolute: true
 		});
 		if (files.length === 0) return [];
+		const sortedFiles = await sortFilesByTimestamp(files);
 		const mode = options?.mode ?? "auto";
 		const fetcher = _usingCtx$1.u(mode === "display" ? null : new PricingFetcher());
+		const processedHashes = /* @__PURE__ */ new Set();
 		const allEntries = [];
-		for (const file of files) {
+		for (const file of sortedFiles) {
 			const content = await readFile(file, "utf-8");
 			const lines = content.trim().split("\n").filter((line) => line.length > 0);
 			for (const line of lines) try {
@@ -3192,33 +3361,65 @@ async function loadDailyUsageData(options) {
 				const result = safeParse(UsageDataSchema, parsed);
 				if (!result.success) continue;
 				const data = result.output;
+				const uniqueHash = createUniqueHash(data);
+				if (uniqueHash != null && processedHashes.has(uniqueHash)) continue;
+				if (uniqueHash != null) processedHashes.add(uniqueHash);
 				const date = formatDate(data.timestamp);
 				const cost = fetcher != null ? await calculateCostForEntry(data, mode, fetcher) : data.costUSD ?? 0;
 				allEntries.push({
 					data,
 					date,
-					cost
+					cost,
+					model: data.message.model
 				});
 			} catch {}
 		}
 		const groupedByDate = groupBy(allEntries, (entry) => entry.date);
 		const results = Object.entries(groupedByDate).map(([date, entries]) => {
 			if (entries == null) return void 0;
-			return entries.reduce((acc, entry) => ({
-				date,
+			const modelAggregates = /* @__PURE__ */ new Map();
+			for (const entry of entries) {
+				const modelName = entry.model ?? "unknown";
+				if (modelName === "<synthetic>") continue;
+				const existing = modelAggregates.get(modelName) ?? {
+					inputTokens: 0,
+					outputTokens: 0,
+					cacheCreationTokens: 0,
+					cacheReadTokens: 0,
+					cost: 0
+				};
+				modelAggregates.set(modelName, {
+					inputTokens: existing.inputTokens + (entry.data.message.usage.input_tokens ?? 0),
+					outputTokens: existing.outputTokens + (entry.data.message.usage.output_tokens ?? 0),
+					cacheCreationTokens: existing.cacheCreationTokens + (entry.data.message.usage.cache_creation_input_tokens ?? 0),
+					cacheReadTokens: existing.cacheReadTokens + (entry.data.message.usage.cache_read_input_tokens ?? 0),
+					cost: existing.cost + entry.cost
+				});
+			}
+			const modelBreakdowns = Array.from(modelAggregates.entries()).map(([modelName, stats]) => ({
+				modelName,
+				...stats
+			})).sort((a, b) => b.cost - a.cost);
+			const totals = entries.reduce((acc, entry) => ({
 				inputTokens: acc.inputTokens + (entry.data.message.usage.input_tokens ?? 0),
 				outputTokens: acc.outputTokens + (entry.data.message.usage.output_tokens ?? 0),
 				cacheCreationTokens: acc.cacheCreationTokens + (entry.data.message.usage.cache_creation_input_tokens ?? 0),
 				cacheReadTokens: acc.cacheReadTokens + (entry.data.message.usage.cache_read_input_tokens ?? 0),
 				totalCost: acc.totalCost + entry.cost
 			}), {
-				date,
 				inputTokens: 0,
 				outputTokens: 0,
 				cacheCreationTokens: 0,
 				cacheReadTokens: 0,
 				totalCost: 0
 			});
+			const modelsUsed = [...new Set(entries.map((e) => e.model).filter((m) => m != null && m !== "<synthetic>"))];
+			return {
+				date,
+				...totals,
+				modelsUsed,
+				modelBreakdowns
+			};
 		}).filter((item) => item != null).filter((item) => {
 			if (options?.since != null || options?.until != null) {
 				const dateStr = item.date.replace(/-/g, "");
@@ -3250,10 +3451,12 @@ async function loadSessionData(options) {
 			absolute: true
 		});
 		if (files.length === 0) return [];
+		const sortedFiles = await sortFilesByTimestamp(files);
 		const mode = options?.mode ?? "auto";
 		const fetcher = _usingCtx3.u(mode === "display" ? null : new PricingFetcher());
+		const processedHashes = /* @__PURE__ */ new Set();
 		const allEntries = [];
-		for (const file of files) {
+		for (const file of sortedFiles) {
 			const relativePath = path.relative(claudeDir, file);
 			const parts = relativePath.split(path.sep);
 			const sessionId = parts[parts.length - 2] ?? "unknown";
@@ -3266,6 +3469,9 @@ async function loadSessionData(options) {
 				const result = safeParse(UsageDataSchema, parsed);
 				if (!result.success) continue;
 				const data = result.output;
+				const uniqueHash = createUniqueHash(data);
+				if (uniqueHash != null && processedHashes.has(uniqueHash)) continue;
+				if (uniqueHash != null) processedHashes.add(uniqueHash);
 				const sessionKey = `${projectPath}/${sessionId}`;
 				const cost = fetcher != null ? await calculateCostForEntry(data, mode, fetcher) : data.costUSD ?? 0;
 				allEntries.push({
@@ -3274,7 +3480,8 @@ async function loadSessionData(options) {
 					sessionId,
 					projectPath,
 					cost,
-					timestamp: data.timestamp
+					timestamp: data.timestamp,
+					model: data.message.model
 				});
 			} catch {}
 		}
@@ -3284,28 +3491,52 @@ async function loadSessionData(options) {
 			const latestEntry = entries.reduce((latest, current) => current.timestamp > latest.timestamp ? current : latest);
 			const versionSet = /* @__PURE__ */ new Set();
 			for (const entry of entries) if (entry.data.version != null) versionSet.add(entry.data.version);
-			const aggregated = entries.reduce((acc, entry) => ({
-				sessionId: latestEntry.sessionId,
-				projectPath: latestEntry.projectPath,
+			const modelAggregates = /* @__PURE__ */ new Map();
+			for (const entry of entries) {
+				const modelName = entry.model ?? "unknown";
+				if (modelName === "<synthetic>") continue;
+				const existing = modelAggregates.get(modelName) ?? {
+					inputTokens: 0,
+					outputTokens: 0,
+					cacheCreationTokens: 0,
+					cacheReadTokens: 0,
+					cost: 0
+				};
+				modelAggregates.set(modelName, {
+					inputTokens: existing.inputTokens + (entry.data.message.usage.input_tokens ?? 0),
+					outputTokens: existing.outputTokens + (entry.data.message.usage.output_tokens ?? 0),
+					cacheCreationTokens: existing.cacheCreationTokens + (entry.data.message.usage.cache_creation_input_tokens ?? 0),
+					cacheReadTokens: existing.cacheReadTokens + (entry.data.message.usage.cache_read_input_tokens ?? 0),
+					cost: existing.cost + entry.cost
+				});
+			}
+			const modelBreakdowns = Array.from(modelAggregates.entries()).map(([modelName, stats]) => ({
+				modelName,
+				...stats
+			})).sort((a, b) => b.cost - a.cost);
+			const totals = entries.reduce((acc, entry) => ({
 				inputTokens: acc.inputTokens + (entry.data.message.usage.input_tokens ?? 0),
 				outputTokens: acc.outputTokens + (entry.data.message.usage.output_tokens ?? 0),
 				cacheCreationTokens: acc.cacheCreationTokens + (entry.data.message.usage.cache_creation_input_tokens ?? 0),
 				cacheReadTokens: acc.cacheReadTokens + (entry.data.message.usage.cache_read_input_tokens ?? 0),
-				totalCost: acc.totalCost + entry.cost,
-				lastActivity: formatDate(latestEntry.timestamp),
-				versions: Array.from(versionSet).sort()
+				totalCost: acc.totalCost + entry.cost
 			}), {
-				sessionId: latestEntry.sessionId,
-				projectPath: latestEntry.projectPath,
 				inputTokens: 0,
 				outputTokens: 0,
 				cacheCreationTokens: 0,
 				cacheReadTokens: 0,
-				totalCost: 0,
-				lastActivity: formatDate(latestEntry.timestamp),
-				versions: Array.from(versionSet).sort()
+				totalCost: 0
 			});
-			return aggregated;
+			const modelsUsed = [...new Set(entries.map((e) => e.model).filter((m) => m != null && m !== "<synthetic>"))];
+			return {
+				sessionId: latestEntry.sessionId,
+				projectPath: latestEntry.projectPath,
+				...totals,
+				lastActivity: formatDate(latestEntry.timestamp),
+				versions: Array.from(versionSet).sort(),
+				modelsUsed,
+				modelBreakdowns
+			};
 		}).filter((item) => item != null).filter((item) => {
 			if (options?.since != null || options?.until != null) {
 				const dateStr = item.lastActivity.replace(/-/g, "");
@@ -3326,28 +3557,61 @@ async function loadSessionData(options) {
 async function loadMonthlyUsageData(options) {
 	const dailyData = await loadDailyUsageData(options);
 	const groupedByMonth = groupBy(dailyData, (data) => data.date.substring(0, 7));
-	const monthlyArray = Object.entries(groupedByMonth).map(([month, dailyEntries]) => {
-		if (dailyEntries == null) return void 0;
-		return dailyEntries.reduce((acc, data) => ({
-			month,
-			inputTokens: acc.inputTokens + data.inputTokens,
-			outputTokens: acc.outputTokens + data.outputTokens,
-			cacheCreationTokens: acc.cacheCreationTokens + data.cacheCreationTokens,
-			cacheReadTokens: acc.cacheReadTokens + data.cacheReadTokens,
-			totalCost: acc.totalCost + data.totalCost
-		}), {
+	const monthlyArray = [];
+	for (const [month, dailyEntries] of Object.entries(groupedByMonth)) {
+		if (dailyEntries == null) continue;
+		const modelAggregates = /* @__PURE__ */ new Map();
+		for (const daily of dailyEntries) for (const breakdown of daily.modelBreakdowns) {
+			if (breakdown.modelName === "<synthetic>") continue;
+			const existing = modelAggregates.get(breakdown.modelName) ?? {
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheCreationTokens: 0,
+				cacheReadTokens: 0,
+				cost: 0
+			};
+			modelAggregates.set(breakdown.modelName, {
+				inputTokens: existing.inputTokens + breakdown.inputTokens,
+				outputTokens: existing.outputTokens + breakdown.outputTokens,
+				cacheCreationTokens: existing.cacheCreationTokens + breakdown.cacheCreationTokens,
+				cacheReadTokens: existing.cacheReadTokens + breakdown.cacheReadTokens,
+				cost: existing.cost + breakdown.cost
+			});
+		}
+		const modelBreakdowns = Array.from(modelAggregates.entries()).map(([modelName, stats]) => ({
+			modelName,
+			...stats
+		})).sort((a, b) => b.cost - a.cost);
+		const modelsSet = /* @__PURE__ */ new Set();
+		for (const data of dailyEntries) for (const model of data.modelsUsed) if (model !== "<synthetic>") modelsSet.add(model);
+		let totalInputTokens = 0;
+		let totalOutputTokens = 0;
+		let totalCacheCreationTokens = 0;
+		let totalCacheReadTokens = 0;
+		let totalCost = 0;
+		for (const daily of dailyEntries) {
+			totalInputTokens += daily.inputTokens;
+			totalOutputTokens += daily.outputTokens;
+			totalCacheCreationTokens += daily.cacheCreationTokens;
+			totalCacheReadTokens += daily.cacheReadTokens;
+			totalCost += daily.totalCost;
+		}
+		const monthlyUsage = {
 			month,
-			inputTokens: 0,
-			outputTokens: 0,
-			cacheCreationTokens: 0,
-			cacheReadTokens: 0,
-			totalCost: 0
-		});
-	}).filter((item) => item != null);
+			inputTokens: totalInputTokens,
+			outputTokens: totalOutputTokens,
+			cacheCreationTokens: totalCacheCreationTokens,
+			cacheReadTokens: totalCacheReadTokens,
+			totalCost,
+			modelsUsed: Array.from(modelsSet),
+			modelBreakdowns
+		};
+		monthlyArray.push(monthlyUsage);
+	}
 	const sortOrder = options?.order ?? "desc";
 	const sortedMonthly = sort(monthlyArray);
 	return sortOrder === "desc" ? sortedMonthly.desc((item) => item.month) : sortedMonthly.asc((item) => item.month);
 }
 
 //#endregion
-export { DailyUsageSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, __commonJS, __require, __toESM, calculateCostForEntry, formatCurrency, formatDate, formatNumber, getDefaultClaudePath, glob, loadDailyUsageData, loadMonthlyUsageData, loadSessionData, require_usingCtx };
+export { DailyUsageSchema, ModelBreakdownSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, __commonJS, __require, __toESM, calculateCostForEntry, createUniqueHash, formatCurrency, formatDate, formatModelsDisplay, formatNumber, getDefaultClaudePath, getEarliestTimestamp, glob, loadDailyUsageData, loadMonthlyUsageData, loadSessionData, pushBreakdownRows, require_picocolors, require_usingCtx, sortFilesByTimestamp };

package/dist/{data-loader-B0tJZeHI.d.ts → data-loader-amTZCtBR.d.ts}

@@ -92,10 +92,21 @@ declare const UsageDataSchema: ObjectSchema<{
       readonly cache_read_input_tokens: OptionalSchema<NumberSchema<undefined>, undefined>;
     }, undefined>;
     readonly model: OptionalSchema<StringSchema<undefined>, undefined>;
+    readonly id: OptionalSchema<StringSchema<undefined>, undefined>;
   }, undefined>;
   readonly costUSD: OptionalSchema<NumberSchema<undefined>, undefined>;
+  readonly requestId: OptionalSchema<StringSchema<undefined>, undefined>;
 }, undefined>;
 type UsageData = InferOutput<typeof UsageDataSchema>;
+declare const ModelBreakdownSchema: ObjectSchema<{
+  readonly modelName: StringSchema<undefined>;
+  readonly inputTokens: NumberSchema<undefined>;
+  readonly outputTokens: NumberSchema<undefined>;
+  readonly cacheCreationTokens: NumberSchema<undefined>;
+  readonly cacheReadTokens: NumberSchema<undefined>;
+  readonly cost: NumberSchema<undefined>;
+}, undefined>;
+type ModelBreakdown = InferOutput<typeof ModelBreakdownSchema>;
 declare const DailyUsageSchema: ObjectSchema<{
   readonly date: SchemaWithPipe<readonly [StringSchema<undefined>, RegexAction<string, undefined>]>;
   readonly inputTokens: NumberSchema<undefined>;
@@ -103,6 +114,15 @@ declare const DailyUsageSchema: ObjectSchema<{
   readonly cacheCreationTokens: NumberSchema<undefined>;
   readonly cacheReadTokens: NumberSchema<undefined>;
   readonly totalCost: NumberSchema<undefined>;
+  readonly modelsUsed: ArraySchema<StringSchema<undefined>, undefined>;
+  readonly modelBreakdowns: ArraySchema<ObjectSchema<{
+    readonly modelName: StringSchema<undefined>;
+    readonly inputTokens: NumberSchema<undefined>;
+    readonly outputTokens: NumberSchema<undefined>;
+    readonly cacheCreationTokens: NumberSchema<undefined>;
+    readonly cacheReadTokens: NumberSchema<undefined>;
+    readonly cost: NumberSchema<undefined>;
+  }, undefined>, undefined>;
 }, undefined>;
 type DailyUsage = InferOutput<typeof DailyUsageSchema>;
 declare const SessionUsageSchema: ObjectSchema<{
@@ -115,6 +135,15 @@ declare const SessionUsageSchema: ObjectSchema<{
   readonly totalCost: NumberSchema<undefined>;
   readonly lastActivity: StringSchema<undefined>;
   readonly versions: ArraySchema<StringSchema<undefined>, undefined>;
+  readonly modelsUsed: ArraySchema<StringSchema<undefined>, undefined>;
+  readonly modelBreakdowns: ArraySchema<ObjectSchema<{
+    readonly modelName: StringSchema<undefined>;
+    readonly inputTokens: NumberSchema<undefined>;
+    readonly outputTokens: NumberSchema<undefined>;
+    readonly cacheCreationTokens: NumberSchema<undefined>;
+    readonly cacheReadTokens: NumberSchema<undefined>;
+    readonly cost: NumberSchema<undefined>;
+  }, undefined>, undefined>;
 }, undefined>;
 type SessionUsage = InferOutput<typeof SessionUsageSchema>;
 declare const MonthlyUsageSchema: ObjectSchema<{
@@ -124,9 +153,32 @@ declare const MonthlyUsageSchema: ObjectSchema<{
   readonly cacheCreationTokens: NumberSchema<undefined>;
   readonly cacheReadTokens: NumberSchema<undefined>;
   readonly totalCost: NumberSchema<undefined>;
+  readonly modelsUsed: ArraySchema<StringSchema<undefined>, undefined>;
+  readonly modelBreakdowns: ArraySchema<ObjectSchema<{
+    readonly modelName: StringSchema<undefined>;
+    readonly inputTokens: NumberSchema<undefined>;
+    readonly outputTokens: NumberSchema<undefined>;
+    readonly cacheCreationTokens: NumberSchema<undefined>;
+    readonly cacheReadTokens: NumberSchema<undefined>;
+    readonly cost: NumberSchema<undefined>;
+  }, undefined>, undefined>;
 }, undefined>;
 type MonthlyUsage = InferOutput<typeof MonthlyUsageSchema>;
 declare function formatDate(dateStr: string): string;
+/**
+ * Create a unique identifier for deduplication using message ID and request ID
+ */
+declare function createUniqueHash(data: UsageData): string | null;
+/**
+ * Extract the earliest timestamp from a JSONL file
+ * Scans through the file until it finds a valid timestamp
+ */
+declare function getEarliestTimestamp(filePath: string): Promise<Date | null>;
+/**
+ * Sort files by their earliest timestamp
+ * Files without valid timestamps are placed at the end
+ */
+declare function sortFilesByTimestamp(files: string[]): Promise<string[]>;
 declare function calculateCostForEntry(data: UsageData, mode: CostMode, fetcher: PricingFetcher): Promise<number>;
 type DateFilter = {
   since?: string;
@@ -141,4 +193,4 @@ declare function loadDailyUsageData(options?: LoadOptions): Promise<DailyUsage[]
 declare function loadSessionData(options?: LoadOptions): Promise<SessionUsage[]>;
 declare function loadMonthlyUsageData(options?: LoadOptions): Promise<MonthlyUsage[]>;
 //#endregion
-export { DailyUsage, DailyUsageSchema, DateFilter, LoadOptions, MonthlyUsage, MonthlyUsageSchema, SessionUsage, SessionUsageSchema, UsageData, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadDailyUsageData, loadMonthlyUsageData, loadSessionData };
+export { DailyUsage, DailyUsageSchema, DateFilter, LoadOptions, ModelBreakdown, ModelBreakdownSchema, MonthlyUsage, MonthlyUsageSchema, SessionUsage, SessionUsageSchema, UsageData, UsageDataSchema, calculateCostForEntry, createUniqueHash, formatDate, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionData, sortFilesByTimestamp };

package/dist/data-loader.d.ts

@@ -1,3 +1,3 @@
-import { DailyUsage, DailyUsageSchema, DateFilter, LoadOptions, MonthlyUsage, MonthlyUsageSchema, SessionUsage, SessionUsageSchema, UsageData, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadDailyUsageData, loadMonthlyUsageData, loadSessionData } from "./data-loader-B0tJZeHI.js";
+import { DailyUsage, DailyUsageSchema, DateFilter, LoadOptions, ModelBreakdown, ModelBreakdownSchema, MonthlyUsage, MonthlyUsageSchema, SessionUsage, SessionUsageSchema, UsageData, UsageDataSchema, calculateCostForEntry, createUniqueHash, formatDate, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionData, sortFilesByTimestamp } from "./data-loader-amTZCtBR.js";
 import "./pricing-fetcher-Dq-OLBp4.js";
-export { DailyUsage, DailyUsageSchema, DateFilter, LoadOptions, MonthlyUsage, MonthlyUsageSchema, SessionUsage, SessionUsageSchema, UsageData, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadDailyUsageData, loadMonthlyUsageData, loadSessionData };
+export { DailyUsage, DailyUsageSchema, DateFilter, LoadOptions, ModelBreakdown, ModelBreakdownSchema, MonthlyUsage, MonthlyUsageSchema, SessionUsage, SessionUsageSchema, UsageData, UsageDataSchema, calculateCostForEntry, createUniqueHash, formatDate, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionData, sortFilesByTimestamp };

package/dist/data-loader.js

@@ -1,6 +1,6 @@
-import { DailyUsageSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadDailyUsageData, loadMonthlyUsageData, loadSessionData } from "./data-loader-BfnzLKGl.js";
+import { DailyUsageSchema, ModelBreakdownSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, createUniqueHash, formatDate, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionData, sortFilesByTimestamp } from "./data-loader-Bz6Vemxw.js";
 import "./dist-BEQ1tJCL.js";
-import "./logger-DixU80sg.js";
-import "./pricing-fetcher-BY3-ryVq.js";
+import "./logger-DN-RT9jL.js";
+import "./pricing-fetcher-DMNBE90M.js";
 
-export { DailyUsageSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadDailyUsageData, loadMonthlyUsageData, loadSessionData };
+export { DailyUsageSchema, ModelBreakdownSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, createUniqueHash, formatDate, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionData, sortFilesByTimestamp };

package/dist/{debug-Bf6GUNZE.js → debug-DQXeZIjf.js}

@@ -1,7 +1,7 @@
-import { UsageDataSchema, __toESM, glob, require_usingCtx } from "./data-loader-BfnzLKGl.js";
+import { UsageDataSchema, __toESM, glob, require_usingCtx } from "./data-loader-Bz6Vemxw.js";
 import { safeParse } from "./dist-BEQ1tJCL.js";
-import { logger } from "./logger-DixU80sg.js";
-import { PricingFetcher } from "./pricing-fetcher-BY3-ryVq.js";
+import { logger } from "./logger-DN-RT9jL.js";
+import { PricingFetcher } from "./pricing-fetcher-DMNBE90M.js";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";