ccusage 0.6.1 → 0.7.0

package/dist/{data-loader-DP5qBPn6.js → data-loader-nOFcMg_V.js}

@@ -1,5 +1,5 @@
-import { array, number, object, optional, pipe, regex, safeParse, string } from "./dist-C0-Tf5eD.js";
-import { calculateCostFromTokens, fetchModelPricing, getModelPricing } from "./pricing-fetcher-BPUgMrB_.js";
+import { array, number, object, optional, pipe, regex, safeParse, string } from "./dist-BEQ1tJCL.js";
+import { PricingFetcher } from "./pricing-fetcher-CAeJvZnF.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) {
@@ -2240,7 +2496,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
@@ -2537,7 +2793,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;
@@ -2717,20 +2973,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: "/",
@@ -2768,8 +3024,185 @@ 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");
+}
+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;
+	}, {});
+}
+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
+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
+var import_usingCtx = __toESM(require_usingCtx(), 1);
 function getDefaultClaudePath() {
 	return path.join(homedir(), ".claude");
 }
@@ -2787,13 +3220,23 @@ const UsageDataSchema = object({
 	}),
 	costUSD: optional(number())
 });
+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}$/)),
 	inputTokens: number(),
 	outputTokens: number(),
 	cacheCreationTokens: number(),
 	cacheReadTokens: number(),
-	totalCost: number()
+	totalCost: number(),
+	modelsUsed: array(string()),
+	modelBreakdowns: array(ModelBreakdownSchema)
 });
 const SessionUsageSchema = object({
 	sessionId: string(),
@@ -2804,7 +3247,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}$/)),
@@ -2812,7 +3257,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);
@@ -2821,181 +3268,283 @@ function formatDate(dateStr) {
 	const day = String(date.getDate()).padStart(2, "0");
 	return `${year}-${month}-${day}`;
 }
-function calculateCostForEntry(data, mode, modelPricing) {
+async function calculateCostForEntry(data, mode, fetcher) {
 	if (mode === "display") return data.costUSD ?? 0;
 	if (mode === "calculate") {
-		if (data.message.model != null) {
-			const pricing = getModelPricing(data.message.model, modelPricing);
-			if (pricing != null) 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 != null) return data.costUSD;
-	if (data.message.model != null) {
-		const pricing = getModelPricing(data.message.model, modelPricing);
-		if (pricing != null) 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 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 = calculateCostForEntry(data, mode, modelPricing);
-			allEntries.push({
-				data,
-				date,
-				cost
+	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,
+					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;
+			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
+			}), {
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheCreationTokens: 0,
+				cacheReadTokens: 0,
+				totalCost: 0
 			});
-		} catch {}
-	}
-	const groupedByDate = Object.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
+			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, "");
+				if (options.since != null && dateStr < options.since) return false;
+				if (options.until != null && dateStr > options.until) return false;
+			}
+			return true;
 		});
-	}).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);
-	return sortOrder === "desc" ? sortedResults.desc((item) => new Date(item.date).getTime()) : sortedResults.asc((item) => new Date(item.date).getTime());
+		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();
+	}
 }
 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 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 = calculateCostForEntry(data, mode, modelPricing);
-			allEntries.push({
-				data,
-				sessionKey,
-				sessionId,
-				projectPath,
-				cost,
-				timestamp: data.timestamp
+	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,
+					model: data.message.model
+				});
+			} 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 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
+			}), {
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheCreationTokens: 0,
+				cacheReadTokens: 0,
+				totalCost: 0
 			});
-		} catch {}
-	}
-	const groupedBySessions = Object.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: formatDate(latestEntry.timestamp),
-			versions: Array.from(versionSet).sort()
+			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, "");
+				if (options.since != null && dateStr < options.since) return false;
+				if (options.until != null && dateStr > options.until) return false;
+			}
+			return true;
 		});
-		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;
-		}
-		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());
+		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();
+	}
 }
 async function loadMonthlyUsageData(options) {
 	const dailyData = await loadDailyUsageData(options);
-	const groupedByMonth = Object.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 groupedByMonth = groupBy(dailyData, (data) => data.date.substring(0, 7));
+	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, formatDate, getDefaultClaudePath, glob, loadDailyUsageData, loadMonthlyUsageData, loadSessionData };
+export { DailyUsageSchema, ModelBreakdownSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, __commonJS, __require, __toESM, calculateCostForEntry, formatCurrency, formatDate, formatModelsDisplay, formatNumber, getDefaultClaudePath, glob, loadDailyUsageData, loadMonthlyUsageData, loadSessionData, pushBreakdownRows, require_picocolors, require_usingCtx };