ccusage 0.6.0 → 0.6.2

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

@@ -1,5 +1,5 @@
-import { array, number, object, optional, pipe, regex, safeParse, string } from "./dist-FwNhpFrW.js";
-import { calculateCostFromTokens, fetchModelPricing, getModelPricing } from "./pricing-fetcher-BCv1Vods.js";
+import { array, number, object, optional, pipe, regex, safeParse, string } from "./dist-BEQ1tJCL.js";
+import { PricingFetcher } from "./pricing-fetcher-BY3-ryVq.js";
 import { createRequire } from "node:module";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -32,6 +32,262 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+//#endregion
+//#region node_modules/@jsr/core__unknownutil/is/string.js
+/**
+* Return `true` if the type of `x` is `string`.
+*
+* ```ts
+* import { is } from "@core/unknownutil";
+*
+* const a: unknown = "a";
+* if (is.String(a)) {
+*   const _: string = a;
+* }
+* ```
+*/ function isString(x) {
+	return typeof x === "string";
+}
+
+//#endregion
+//#region node_modules/@jsr/core__unknownutil/is/record.js
+/**
+* Return `true` if the type of `x` satisfies `Record<PropertyKey, unknown>`.
+*
+* Note that this function returns `true` for ambiguous instances like `Set`, `Map`, `Date`, `Promise`, etc.
+* Use {@linkcode [is/record-object].isRecordObject|isRecordObject} instead if you want to check if `x` is an instance of `Object`.
+*
+* ```ts
+* import { is } from "@core/unknownutil";
+*
+* const a: unknown = {"a": 0, "b": 1};
+* if (is.Record(a)) {
+*   const _: Record<PropertyKey, unknown> = a;
+* }
+*
+* const b: unknown = new Set();
+* if (is.Record(b)) {
+*   const _: Record<PropertyKey, unknown> = b;
+* }
+* ```
+*/ function isRecord(x) {
+	return x != null && !Array.isArray(x) && typeof x === "object";
+}
+
+//#endregion
+//#region node_modules/@jsr/core__unknownutil/_inspect.js
+const defaultThreshold = 20;
+/**
+* Inspect a value
+*/ function inspect(value, options = {}) {
+	if (value === null) return "null";
+	else if (Array.isArray(value)) return inspectArray(value, options);
+	switch (typeof value) {
+		case "string": return JSON.stringify(value);
+		case "bigint": return `${value}n`;
+		case "object":
+			if (value.constructor?.name !== "Object") return value.constructor?.name;
+			return inspectRecord(value, options);
+		case "function": return value.name || "(anonymous)";
+	}
+	return value?.toString() ?? "undefined";
+}
+function inspectArray(value, options) {
+	const { threshold = defaultThreshold } = options;
+	const vs = value.map((v) => inspect(v, options));
+	const s = vs.join(", ");
+	if (s.length <= threshold) return `[${s}]`;
+	const m = vs.join(",\n");
+	return `[\n${indent(2, m)}\n]`;
+}
+function inspectRecord(value, options) {
+	const { threshold = defaultThreshold } = options;
+	const vs = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)].map((k) => `${k.toString()}: ${inspect(value[k], options)}`);
+	const s = vs.join(", ");
+	if (s.length <= threshold) return `{${s}}`;
+	const m = vs.join(",\n");
+	return `{\n${indent(2, m)}\n}`;
+}
+function indent(level, text) {
+	const prefix = " ".repeat(level);
+	return text.split("\n").map((line) => `${prefix}${line}`).join("\n");
+}
+
+//#endregion
+//#region node_modules/@jsr/core__unknownutil/_funcutil.js
+/**
+* Rewrite the function name.
+*/ function rewriteName(fn, name, ...args) {
+	let cachedName;
+	return Object.defineProperties(fn, { name: { get: () => {
+		if (cachedName) return cachedName;
+		cachedName = `${name}(${args.map((v) => inspect(v)).join(", ")})`;
+		return cachedName;
+	} } });
+}
+
+//#endregion
+//#region node_modules/@jsr/core__unknownutil/_annotation.js
+function annotate(fn, name, value) {
+	return Object.defineProperties(fn, { [name]: { value } });
+}
+function hasAnnotation(fn, name) {
+	return !!fn[name];
+}
+
+//#endregion
+//#region node_modules/@jsr/core__unknownutil/is/object_of.js
+/**
+* Return a type predicate function that returns `true` if the type of `x` is `ObjectOf<T>`.
+*
+* Use {@linkcode [is/record-of].isRecordOf|isRecordOf} if you want to check if the type of `x` is a record of `T`.
+*
+* If {@linkcode [as/optional].asOptional|asOptional} is specified in the predicate function in `predObj`, the property becomes optional.
+* If {@linkcode [as/readonly].asReadonly|asReadonly} is specified in the predicate function in `predObj`, the property becomes readonly.
+*
+* The number of keys of `x` must be greater than or equal to the number of keys of `predObj`.
+* Use {@linkcode [is/strict-of].isStrictOf|isStrictOf} if you want to check the exact number of keys.
+*
+* To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
+*
+* ```ts
+* import { as, is } from "@core/unknownutil";
+*
+* const isMyType = is.ObjectOf({
+*   a: is.Number,
+*   b: is.String,
+*   c: as.Optional(is.Boolean),
+*   d: as.Readonly(is.String),
+* });
+* const a: unknown = { a: 0, b: "a", d: "d" };
+* if (isMyType(a)) {
+*   const _: { a: number; b: string; c?: boolean | undefined, readonly d: string } = a;
+* }
+* ```
+*/ function isObjectOf(predObj) {
+	const preds = [...Object.keys(predObj), ...Object.getOwnPropertySymbols(predObj)].map((k) => [k, predObj[k]]);
+	const pred = rewriteName((x) => {
+		if (!isObject$1(x)) return false;
+		return preds.every(([k, pred$1]) => pred$1(x[k]));
+	}, "isObjectOf", predObj);
+	return annotate(pred, "predObj", predObj);
+}
+function isObject$1(x) {
+	if (x == null) return false;
+	if (typeof x !== "object" && typeof x !== "function") return false;
+	if (Array.isArray(x)) return false;
+	return true;
+}
+
+//#endregion
+//#region node_modules/@jsr/core__unknownutil/as/optional.js
+/**
+* Annotate the given predicate function as optional.
+*
+* Use this function to annotate a predicate function of `predObj` in {@linkcode [is/object-of].isObjectOf|isObjectOf}.
+*
+* Note that the annotated predicate function will return `true` if the type of `x` is `T` or `undefined`, indicating that
+* this function is not just for annotation but it also changes the behavior of the predicate function.
+*
+* Use {@linkcode asUnoptional} to remove the annotation.
+* Use {@linkcode hasOptional} to check if a predicate function has annotated with this function.
+*
+* To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
+*
+* ```ts
+* import { as, is } from "@core/unknownutil";
+*
+* const isMyType = is.ObjectOf({
+*   foo: as.Optional(is.String),
+* });
+* const a: unknown = {};
+* if (isMyType(a)) {
+*   const _: {foo?: string} = a;
+* }
+* ```
+*/ function asOptional(pred) {
+	if (hasAnnotation(pred, "optional")) return pred;
+	return rewriteName(annotate((x) => x === void 0 || pred(x), "optional", pred), "asOptional", pred);
+}
+
+//#endregion
+//#region node_modules/@core/errorutil/error_object.js
+/**
+* Check if a value is an error object
+*/ const isErrorObject = isObjectOf({
+	proto: isString,
+	name: isString,
+	message: isString,
+	stack: asOptional(isString),
+	attributes: isRecord
+});
+
+//#endregion
+//#region node_modules/@core/errorutil/unreachable.js
+/**
+* Error indicating that this part is unreachable.
+*/ var UnreachableError = class UnreachableError extends Error {
+	args;
+	constructor(args) {
+		super(`unreachable: ${args}`);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, UnreachableError);
+		this.name = this.constructor.name;
+		this.args = args;
+	}
+};
+/**
+* Function indicating that this part is unreachable.
+*
+* For example, the following code passed type checking.
+*
+* ```ts
+* import { unreachable } from "@core/errorutil/unreachable";
+*
+* type Animal = "dog" | "cat";
+*
+* function say(animal: Animal): void {
+*   switch (animal) {
+*     case "dog":
+*       console.log("dog");
+*       break;
+*     case "cat":
+*       console.log("dog");
+*       break;
+*     default:
+*       unreachable(animal);
+*   }
+* }
+* say("dog");
+* ```
+*
+* But the following code because a case for "bird" is missing.
+*
+* ```ts
+* import { unreachable } from "@core/errorutil/unreachable";
+*
+* type Animal = "dog" | "cat" | "bird";
+*
+* function say(animal: Animal): void {
+*   switch (animal) {
+*     case "dog":
+*       console.log("dog");
+*       break;
+*     case "cat":
+*       console.log("dog");
+*       break;
+*     default: {
+*       // The line below causes a type error if we uncomment it.
+*       // error: TS2345 [ERROR]: Argument of type 'string' is not assignable to parameter of type 'never'.
+*       //unreachable(animal);
+*     }
+*   }
+* }
+* say("dog");
+* ```
+*/ function unreachable(...args) {
+	throw new UnreachableError(args);
+}
+
 //#endregion
 //#region node_modules/fast-sort/dist/sort.mjs
 var castComparer = function(comparer) {
@@ -575,7 +831,7 @@ var require_walker = __commonJS({ "node_modules/fdir/dist/api/walker.js"(exports
 				counts: new counter_1.Counter(),
 				options,
 				queue: new queue_1.Queue((error, state) => this.callbackInvoker(state, error, callback$1)),
-				symlinks: new Map(),
+				symlinks: /* @__PURE__ */ new Map(),
 				visited: [""].slice(0, 0),
 				controller: new AbortController()
 			};
@@ -2608,7 +2864,7 @@ function isDynamicPattern(pattern, options) {
 	return scan$2.isGlob || scan$2.negated;
 }
 function log(...tasks) {
-	console.log(`[tinyglobby ${new Date().toLocaleTimeString("es")}]`, ...tasks);
+	console.log(`[tinyglobby ${(/* @__PURE__ */ new Date()).toLocaleTimeString("es")}]`, ...tasks);
 }
 const PARENT_DIRECTORY = /^(\/?\.\.)+/;
 const ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
@@ -2768,9 +3024,92 @@ async function glob(patternsOrOptions, options) {
 	return crawl(opts, cwd, false);
 }
 
+//#endregion
+//#region src/utils.internal.ts
+function formatNumber(num) {
+	return num.toLocaleString("en-US");
+}
+function formatCurrency(amount) {
+	return `$${amount.toFixed(2)}`;
+}
+/**
+* WHY: Object.groupBy requires Node.js 21+. tsdown doesn't support runtime polyfills, only syntax transforms.
+*/
+function groupBy(array$1, keyFn) {
+	return array$1.reduce((groups, item) => {
+		const key = keyFn(item);
+		if (groups[key] == null) groups[key] = [];
+		groups[key].push(item);
+		return groups;
+	}, {});
+}
+
+//#endregion
+//#region node_modules/rolldown/node_modules/@oxc-project/runtime/src/helpers/usingCtx.js
+var require_usingCtx = __commonJS({ "node_modules/rolldown/node_modules/@oxc-project/runtime/src/helpers/usingCtx.js"(exports, module) {
+	function _usingCtx() {
+		var r = "function" == typeof SuppressedError ? SuppressedError : function(r$1, e$1) {
+			var n$1 = Error();
+			return n$1.name = "SuppressedError", n$1.error = r$1, n$1.suppressed = e$1, n$1;
+		}, e = {}, n = [];
+		function using(r$1, e$1) {
+			if (null != e$1) {
+				if (Object(e$1) !== e$1) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+				if (r$1) var o = e$1[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+				if (void 0 === o && (o = e$1[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r$1)) var t = o;
+				if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+				t && (o = function o$1() {
+					try {
+						t.call(e$1);
+					} catch (r$2) {
+						return Promise.reject(r$2);
+					}
+				}), n.push({
+					v: e$1,
+					d: o,
+					a: r$1
+				});
+			} else r$1 && n.push({
+				d: e$1,
+				a: r$1
+			});
+			return e$1;
+		}
+		return {
+			e,
+			u: using.bind(null, !1),
+			a: using.bind(null, !0),
+			d: function d() {
+				var o, t = this.e, s = 0;
+				function next() {
+					for (; o = n.pop();) try {
+						if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+						if (o.d) {
+							var r$1 = o.d.call(o.v);
+							if (o.a) return s |= 2, Promise.resolve(r$1).then(next, err);
+						} else s |= 1;
+					} catch (r$2) {
+						return err(r$2);
+					}
+					if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+					if (t !== e) throw t;
+				}
+				function err(n$1) {
+					return t = t !== e ? new r(n$1, t) : n$1, next();
+				}
+				return next();
+			}
+		};
+	}
+	module.exports = _usingCtx, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+
 //#endregion
 //#region src/data-loader.ts
-const getDefaultClaudePath = () => path.join(homedir(), ".claude");
+var import_usingCtx = __toESM(require_usingCtx(), 1);
+function getDefaultClaudePath() {
+	return path.join(homedir(), ".claude");
+}
 const UsageDataSchema = object({
 	timestamp: string(),
 	version: optional(string()),
@@ -2812,170 +3151,203 @@ const MonthlyUsageSchema = object({
 	cacheReadTokens: number(),
 	totalCost: number()
 });
-const formatDate = (dateStr) => {
+function formatDate(dateStr) {
 	const date = new Date(dateStr);
 	const year = date.getFullYear();
 	const month = String(date.getMonth() + 1).padStart(2, "0");
 	const day = String(date.getDate()).padStart(2, "0");
 	return `${year}-${month}-${day}`;
-};
-const calculateCostForEntry = (data, mode, modelPricing) => {
+}
+async function calculateCostForEntry(data, mode, fetcher) {
 	if (mode === "display") return data.costUSD ?? 0;
 	if (mode === "calculate") {
-		if (data.message.model) {
-			const pricing = getModelPricing(data.message.model, modelPricing);
-			if (pricing) return calculateCostFromTokens(data.message.usage, pricing);
-		}
+		if (data.message.model != null) return fetcher.calculateCostFromTokens(data.message.usage, data.message.model);
 		return 0;
 	}
-	if (data.costUSD !== void 0) return data.costUSD;
-	if (data.message.model) {
-		const pricing = getModelPricing(data.message.model, modelPricing);
-		if (pricing) return calculateCostFromTokens(data.message.usage, pricing);
+	if (mode === "auto") {
+		if (data.costUSD != null) return data.costUSD;
+		if (data.message.model != null) return fetcher.calculateCostFromTokens(data.message.usage, data.message.model);
+		return 0;
 	}
-	return 0;
-};
+	unreachable(mode);
+}
 async function loadDailyUsageData(options) {
-	const claudePath = options?.claudePath ?? getDefaultClaudePath();
-	const claudeDir = path.join(claudePath, "projects");
-	const files = await glob(["**/*.jsonl"], {
-		cwd: claudeDir,
-		absolute: true
-	});
-	if (files.length === 0) return [];
-	const mode = options?.mode || "auto";
-	const modelPricing = mode === "display" ? {} : await fetchModelPricing();
-	const dailyMap = new Map();
-	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 = safeParse(UsageDataSchema, parsed);
-			if (!result.success) continue;
-			const data = result.output;
-			const date = formatDate(data.timestamp);
-			const existing = dailyMap.get(date) || {
+	try {
+		var _usingCtx$1 = (0, import_usingCtx.default)();
+		const claudePath = options?.claudePath ?? getDefaultClaudePath();
+		const claudeDir = path.join(claudePath, "projects");
+		const files = await glob(["**/*.jsonl"], {
+			cwd: claudeDir,
+			absolute: true
+		});
+		if (files.length === 0) return [];
+		const mode = options?.mode ?? "auto";
+		const fetcher = _usingCtx$1.u(mode === "display" ? null : new PricingFetcher());
+		const allEntries = [];
+		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 = safeParse(UsageDataSchema, parsed);
+				if (!result.success) continue;
+				const data = result.output;
+				const date = formatDate(data.timestamp);
+				const cost = fetcher != null ? await calculateCostForEntry(data, mode, fetcher) : data.costUSD ?? 0;
+				allEntries.push({
+					data,
+					date,
+					cost
+				});
+			} 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,
+				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
-			};
-			existing.inputTokens += data.message.usage.input_tokens ?? 0;
-			existing.outputTokens += data.message.usage.output_tokens ?? 0;
-			existing.cacheCreationTokens += data.message.usage.cache_creation_input_tokens ?? 0;
-			existing.cacheReadTokens += data.message.usage.cache_read_input_tokens ?? 0;
-			const cost = calculateCostForEntry(data, mode, modelPricing);
-			existing.totalCost += cost;
-			dailyMap.set(date, existing);
-		} catch (e) {}
+			});
+		}).filter((item) => item != null).filter((item) => {
+			if (options?.since != null || options?.until != null) {
+				const dateStr = item.date.replace(/-/g, "");
+				if (options.since != null && dateStr < options.since) return false;
+				if (options.until != null && dateStr > options.until) return false;
+			}
+			return true;
+		});
+		const sortOrder = options?.order ?? "desc";
+		const sortedResults = sort(results);
+		switch (sortOrder) {
+			case "desc": return sortedResults.desc((item) => new Date(item.date).getTime());
+			case "asc": return sortedResults.asc((item) => new Date(item.date).getTime());
+			default: unreachable(sortOrder);
+		}
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
 	}
-	let results = Array.from(dailyMap.values());
-	if (options?.since || options?.until) results = results.filter((data) => {
-		const dateStr = data.date.replace(/-/g, "");
-		if (options.since && dateStr < options.since) return false;
-		if (options.until && dateStr > options.until) return false;
-		return true;
-	});
-	const sortOrder = options?.order || "desc";
-	const sortedResults = sort(results);
-	return sortOrder === "desc" ? sortedResults.desc((item) => new Date(item.date).getTime()) : sortedResults.asc((item) => new Date(item.date).getTime());
 }
 async function loadSessionData(options) {
-	const claudePath = options?.claudePath ?? getDefaultClaudePath();
-	const claudeDir = path.join(claudePath, "projects");
-	const files = await glob(["**/*.jsonl"], {
-		cwd: claudeDir,
-		absolute: true
-	});
-	if (files.length === 0) return [];
-	const mode = options?.mode || "auto";
-	const modelPricing = mode === "display" ? {} : await fetchModelPricing();
-	const sessionMap = new Map();
-	for (const file of files) {
-		const relativePath = path.relative(claudeDir, file);
-		const parts = relativePath.split(path.sep);
-		const sessionId = parts[parts.length - 2];
-		const projectPath = parts.slice(0, -2).join(path.sep);
-		const content = await readFile(file, "utf-8");
-		const lines = content.trim().split("\n").filter((line) => line.length > 0);
-		let lastTimestamp = "";
-		for (const line of lines) try {
-			const parsed = JSON.parse(line);
-			const result = safeParse(UsageDataSchema, parsed);
-			if (!result.success) continue;
-			const data = result.output;
-			const key = `${projectPath}/${sessionId}`;
-			const existing = sessionMap.get(key) || {
-				sessionId: sessionId || "unknown",
-				projectPath: projectPath || "Unknown Project",
+	try {
+		var _usingCtx3 = (0, import_usingCtx.default)();
+		const claudePath = options?.claudePath ?? getDefaultClaudePath();
+		const claudeDir = path.join(claudePath, "projects");
+		const files = await glob(["**/*.jsonl"], {
+			cwd: claudeDir,
+			absolute: true
+		});
+		if (files.length === 0) return [];
+		const mode = options?.mode ?? "auto";
+		const fetcher = _usingCtx3.u(mode === "display" ? null : new PricingFetcher());
+		const allEntries = [];
+		for (const file of files) {
+			const relativePath = path.relative(claudeDir, file);
+			const parts = relativePath.split(path.sep);
+			const sessionId = parts[parts.length - 2] ?? "unknown";
+			const joinedPath = parts.slice(0, -2).join(path.sep);
+			const projectPath = joinedPath.length > 0 ? joinedPath : "Unknown Project";
+			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 = safeParse(UsageDataSchema, parsed);
+				if (!result.success) continue;
+				const data = result.output;
+				const sessionKey = `${projectPath}/${sessionId}`;
+				const cost = fetcher != null ? await calculateCostForEntry(data, mode, fetcher) : data.costUSD ?? 0;
+				allEntries.push({
+					data,
+					sessionKey,
+					sessionId,
+					projectPath,
+					cost,
+					timestamp: data.timestamp
+				});
+			} catch {}
+		}
+		const groupedBySessions = groupBy(allEntries, (entry) => entry.sessionKey);
+		const results = Object.entries(groupedBySessions).map(([_, entries]) => {
+			if (entries == null) return void 0;
+			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,
+				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()
+			}), {
+				sessionId: latestEntry.sessionId,
+				projectPath: latestEntry.projectPath,
 				inputTokens: 0,
 				outputTokens: 0,
 				cacheCreationTokens: 0,
 				cacheReadTokens: 0,
 				totalCost: 0,
-				lastActivity: "",
-				versions: [],
-				versionSet: new Set()
-			};
-			existing.inputTokens += data.message.usage.input_tokens ?? 0;
-			existing.outputTokens += data.message.usage.output_tokens ?? 0;
-			existing.cacheCreationTokens += data.message.usage.cache_creation_input_tokens ?? 0;
-			existing.cacheReadTokens += data.message.usage.cache_read_input_tokens ?? 0;
-			const cost = calculateCostForEntry(data, mode, modelPricing);
-			existing.totalCost += cost;
-			if (data.timestamp > lastTimestamp) {
-				lastTimestamp = data.timestamp;
-				existing.lastActivity = formatDate(data.timestamp);
+				lastActivity: formatDate(latestEntry.timestamp),
+				versions: Array.from(versionSet).sort()
+			});
+			return aggregated;
+		}).filter((item) => item != null).filter((item) => {
+			if (options?.since != null || options?.until != null) {
+				const dateStr = item.lastActivity.replace(/-/g, "");
+				if (options.since != null && dateStr < options.since) return false;
+				if (options.until != null && dateStr > options.until) return false;
 			}
-			if (data.version) existing.versionSet.add(data.version);
-			sessionMap.set(key, existing);
-		} catch (e) {}
+			return true;
+		});
+		const sortOrder = options?.order ?? "desc";
+		const sortedResults = sort(results);
+		return sortOrder === "desc" ? sortedResults.desc((item) => new Date(item.lastActivity).getTime()) : sortedResults.asc((item) => new Date(item.lastActivity).getTime());
+	} catch (_) {
+		_usingCtx3.e = _;
+	} finally {
+		_usingCtx3.d();
 	}
-	let results = Array.from(sessionMap.values()).map((session) => {
-		const { versionSet,...sessionData } = session;
-		return {
-			...sessionData,
-			versions: Array.from(versionSet).sort()
-		};
-	});
-	if (options?.since || options?.until) results = results.filter((session) => {
-		const dateStr = session.lastActivity.replace(/-/g, "");
-		if (options.since && dateStr < options.since) return false;
-		if (options.until && dateStr > options.until) return false;
-		return true;
-	});
-	const sortOrder = options?.order || "desc";
-	const sortedResults = sort(results);
-	return sortOrder === "desc" ? sortedResults.desc((item) => new Date(item.lastActivity).getTime()) : sortedResults.asc((item) => new Date(item.lastActivity).getTime());
 }
 async function loadMonthlyUsageData(options) {
 	const dailyData = await loadDailyUsageData(options);
-	const monthlyMap = new Map();
-	for (const data of dailyData) {
-		const month = data.date.substring(0, 7);
-		const existing = monthlyMap.get(month) || {
+	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
+		}), {
 			month,
 			inputTokens: 0,
 			outputTokens: 0,
 			cacheCreationTokens: 0,
 			cacheReadTokens: 0,
 			totalCost: 0
-		};
-		existing.inputTokens += data.inputTokens;
-		existing.outputTokens += data.outputTokens;
-		existing.cacheCreationTokens += data.cacheCreationTokens;
-		existing.cacheReadTokens += data.cacheReadTokens;
-		existing.totalCost += data.totalCost;
-		monthlyMap.set(month, existing);
-	}
-	const monthlyArray = Array.from(monthlyMap.values());
-	const sortOrder = options?.order || "desc";
+		});
+	}).filter((item) => item != null);
+	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, formatDate, getDefaultClaudePath, glob, loadDailyUsageData, loadMonthlyUsageData, loadSessionData };
+export { DailyUsageSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, __commonJS, __require, __toESM, calculateCostForEntry, formatCurrency, formatDate, formatNumber, getDefaultClaudePath, glob, loadDailyUsageData, loadMonthlyUsageData, loadSessionData, require_usingCtx };