ccusage 0.6.1 → 0.7.0

package/dist/data-loader-pCzn-ryX.d.ts

@@ -0,0 +1,180 @@
+import { ArraySchema, InferOutput, NumberSchema, ObjectSchema, OptionalSchema, PricingFetcher, RegexAction, SchemaWithPipe, StringSchema } from "./pricing-fetcher-Dq-OLBp4.js";
+
+//#region node_modules/type-fest/source/observable-like.d.ts
+declare global {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+  interface SymbolConstructor {
+    readonly observable: symbol;
+  }
+}
+
+/**
+@remarks
+The TC39 observable proposal defines a `closed` property, but some implementations (such as xstream) do not as of 10/08/2021.
+As well, some guidance on making an `Observable` to not include `closed` property.
+@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L129-L130
+@see https://github.com/staltz/xstream/blob/6c22580c1d84d69773ee4b0905df44ad464955b3/src/index.ts#L79-L85
+@see https://github.com/benlesh/symbol-observable#making-an-object-observable
+
+@category Observable
+*/
+
+//#endregion
+//#region node_modules/type-fest/source/tuple-to-union.d.ts
+/**
+Convert a tuple/array into a union type of its elements.
+
+This can be useful when you have a fixed set of allowed values and want a type defining only the allowed values, but do not want to repeat yourself.
+
+@example
+```
+import type {TupleToUnion} from 'type-fest';
+
+const destinations = ['a', 'b', 'c'] as const;
+
+type Destination = TupleToUnion<typeof destinations>;
+//=> 'a' | 'b' | 'c'
+
+function verifyDestination(destination: unknown): destination is Destination {
+	return destinations.includes(destination as any);
+}
+
+type RequestBody = {
+	deliverTo: Destination;
+};
+
+function verifyRequestBody(body: unknown): body is RequestBody {
+	const deliverTo = (body as any).deliverTo;
+	return typeof body === 'object' && body !== null && verifyDestination(deliverTo);
+}
+```
+
+Alternatively, you may use `typeof destinations[number]`. If `destinations` is a tuple, there is no difference. However if `destinations` is a string, the resulting type will the union of the characters in the string. Other types of `destinations` may result in a compile error. In comparison, TupleToUnion will return `never` if a tuple is not provided.
+
+@example
+```
+const destinations = ['a', 'b', 'c'] as const;
+
+type Destination = typeof destinations[number];
+//=> 'a' | 'b' | 'c'
+
+const erroringType = new Set(['a', 'b', 'c']);
+
+type ErroringType = typeof erroringType[number];
+//=> Type 'Set<string>' has no matching index signature for type 'number'. ts(2537)
+
+const numberBool: { [n: number]: boolean } = { 1: true };
+
+type NumberBool = typeof numberBool[number];
+//=> boolean
+```
+
+@category Array
+*/
+type TupleToUnion<ArrayType> = ArrayType extends readonly unknown[] ? ArrayType[number] : never;
+//#endregion
+//#region src/types.internal.d.ts
+declare const CostModes: readonly ["auto", "calculate", "display"];
+type CostMode = TupleToUnion<typeof CostModes>;
+declare const SortOrders: readonly ["desc", "asc"];
+type SortOrder = TupleToUnion<typeof SortOrders>;
+//#endregion
+//#region src/data-loader.d.ts
+declare function getDefaultClaudePath(): string;
+declare const UsageDataSchema: ObjectSchema<{
+  readonly timestamp: StringSchema<undefined>;
+  readonly version: OptionalSchema<StringSchema<undefined>, undefined>;
+  readonly message: ObjectSchema<{
+    readonly usage: ObjectSchema<{
+      readonly input_tokens: NumberSchema<undefined>;
+      readonly output_tokens: NumberSchema<undefined>;
+      readonly cache_creation_input_tokens: OptionalSchema<NumberSchema<undefined>, undefined>;
+      readonly cache_read_input_tokens: OptionalSchema<NumberSchema<undefined>, undefined>;
+    }, undefined>;
+    readonly model: OptionalSchema<StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly costUSD: OptionalSchema<NumberSchema<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>;
+  readonly outputTokens: NumberSchema<undefined>;
+  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<{
+  readonly sessionId: StringSchema<undefined>;
+  readonly projectPath: StringSchema<undefined>;
+  readonly inputTokens: NumberSchema<undefined>;
+  readonly outputTokens: NumberSchema<undefined>;
+  readonly cacheCreationTokens: NumberSchema<undefined>;
+  readonly cacheReadTokens: NumberSchema<undefined>;
+  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<{
+  readonly month: SchemaWithPipe<readonly [StringSchema<undefined>, RegexAction<string, undefined>]>;
+  readonly inputTokens: NumberSchema<undefined>;
+  readonly outputTokens: NumberSchema<undefined>;
+  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;
+declare function calculateCostForEntry(data: UsageData, mode: CostMode, fetcher: PricingFetcher): Promise<number>;
+type DateFilter = {
+  since?: string;
+  until?: string;
+};
+type LoadOptions = {
+  claudePath?: string;
+  mode?: CostMode;
+  order?: SortOrder;
+} & DateFilter;
+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, ModelBreakdown, ModelBreakdownSchema, MonthlyUsage, MonthlyUsageSchema, SessionUsage, SessionUsageSchema, UsageData, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadDailyUsageData, loadMonthlyUsageData, loadSessionData };

package/dist/data-loader.d.ts

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

package/dist/data-loader.js

@@ -1,6 +1,6 @@
-import { DailyUsageSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadDailyUsageData, loadMonthlyUsageData, loadSessionData } from "./data-loader-DP5qBPn6.js";
-import "./dist-C0-Tf5eD.js";
-import "./logger-DsQC4OvA.js";
-import "./pricing-fetcher-BPUgMrB_.js";
+import { DailyUsageSchema, ModelBreakdownSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadDailyUsageData, loadMonthlyUsageData, loadSessionData } from "./data-loader-nOFcMg_V.js";
+import "./dist-BEQ1tJCL.js";
+import "./logger-BPjA3VFO.js";
+import "./pricing-fetcher-CAeJvZnF.js";
 
-export { DailyUsageSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadDailyUsageData, loadMonthlyUsageData, loadSessionData };
+export { DailyUsageSchema, ModelBreakdownSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadDailyUsageData, loadMonthlyUsageData, loadSessionData };

package/dist/{debug-C_5Qx11m.js → debug-Bttss7TN.js}

@@ -1,44 +1,45 @@
-import { UsageDataSchema, glob } from "./data-loader-DP5qBPn6.js";
-import { safeParse } from "./dist-C0-Tf5eD.js";
-import { logger } from "./logger-DsQC4OvA.js";
-import { calculateCostFromTokens, fetchModelPricing, getModelPricing } from "./pricing-fetcher-BPUgMrB_.js";
+import { UsageDataSchema, __toESM, glob, require_usingCtx } from "./data-loader-nOFcMg_V.js";
+import { safeParse } from "./dist-BEQ1tJCL.js";
+import { logger } from "./logger-BPjA3VFO.js";
+import { PricingFetcher } from "./pricing-fetcher-CAeJvZnF.js";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
 
 //#region src/debug.ts
+var import_usingCtx = __toESM(require_usingCtx(), 1);
 const MATCH_THRESHOLD_PERCENT = .1;
 async function detectMismatches(claudePath) {
-	const claudeDir = claudePath ?? path.join(homedir(), ".claude", "projects");
-	const files = await glob(["**/*.jsonl"], {
-		cwd: claudeDir,
-		absolute: true
-	});
-	const modelPricing = await fetchModelPricing();
-	const stats = {
-		totalEntries: 0,
-		entriesWithBoth: 0,
-		matches: 0,
-		mismatches: 0,
-		discrepancies: [],
-		modelStats: /* @__PURE__ */ new Map(),
-		versionStats: /* @__PURE__ */ 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;
-			stats.totalEntries++;
-			if (data.costUSD !== void 0 && data.message.model != null && data.message.model !== "<synthetic>") {
-				stats.entriesWithBoth++;
-				const model = data.message.model;
-				const pricing = getModelPricing(model, modelPricing);
-				if (pricing != null) {
-					const calculatedCost = calculateCostFromTokens(data.message.usage, pricing);
+	try {
+		var _usingCtx = (0, import_usingCtx.default)();
+		const claudeDir = claudePath ?? path.join(homedir(), ".claude", "projects");
+		const files = await glob(["**/*.jsonl"], {
+			cwd: claudeDir,
+			absolute: true
+		});
+		const fetcher = _usingCtx.u(new PricingFetcher());
+		const stats = {
+			totalEntries: 0,
+			entriesWithBoth: 0,
+			matches: 0,
+			mismatches: 0,
+			discrepancies: [],
+			modelStats: /* @__PURE__ */ new Map(),
+			versionStats: /* @__PURE__ */ 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;
+				stats.totalEntries++;
+				if (data.costUSD !== void 0 && data.message.model != null && data.message.model !== "<synthetic>") {
+					stats.entriesWithBoth++;
+					const model = data.message.model;
+					const calculatedCost = await fetcher.calculateCostFromTokens(data.message.usage, model);
 					const difference = Math.abs(data.costUSD - calculatedCost);
 					const percentDiff = data.costUSD > 0 ? difference / data.costUSD * 100 : 0;
 					const modelStat = stats.modelStats.get(model) ?? {
@@ -81,10 +82,14 @@ async function detectMismatches(claudePath) {
 					modelStat.avgPercentDiff = (modelStat.avgPercentDiff * (modelStat.total - 1) + percentDiff) / modelStat.total;
 					stats.modelStats.set(model, modelStat);
 				}
-			}
-		} catch {}
+			} catch {}
+		}
+		return stats;
+	} catch (_) {
+		_usingCtx.e = _;
+	} finally {
+		_usingCtx.d();
 	}
-	return stats;
 }
 function printMismatchReport(stats, sampleCount = 5) {
 	if (stats.entriesWithBoth === 0) {

package/dist/debug.js

@@ -1,7 +1,7 @@
-import "./data-loader-DP5qBPn6.js";
-import "./dist-C0-Tf5eD.js";
-import "./logger-DsQC4OvA.js";
-import "./pricing-fetcher-BPUgMrB_.js";
-import { detectMismatches, printMismatchReport } from "./debug-C_5Qx11m.js";
+import "./data-loader-nOFcMg_V.js";
+import "./dist-BEQ1tJCL.js";
+import "./logger-BPjA3VFO.js";
+import "./pricing-fetcher-CAeJvZnF.js";
+import { detectMismatches, printMismatchReport } from "./debug-Bttss7TN.js";
 
 export { detectMismatches, printMismatchReport };

package/dist/{dist-C0-Tf5eD.js → dist-BEQ1tJCL.js}

@@ -73,18 +73,6 @@ function _joinExpects(values2, separator) {
 	if (list.length > 1) return `(${list.join(` ${separator} `)})`;
 	return list[0] ?? "never";
 }
-var ValiError = class extends Error {
-	/**
-	* Creates a Valibot error with useful information.
-	*
-	* @param issues The error issues.
-	*/
-	constructor(issues) {
-		super(issues[0].message);
-		this.name = "ValiError";
-		this.issues = issues;
-	}
-};
 /* @__NO_SIDE_EFFECTS__ */
 function description(description_) {
 	return {
@@ -360,11 +348,6 @@ function union(options, message2) {
 		}
 	};
 }
-function parse(schema, input, config2) {
-	const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config2));
-	if (dataset.issues) throw new ValiError(dataset.issues);
-	return dataset.value;
-}
 /* @__NO_SIDE_EFFECTS__ */
 function pipe(...pipe2) {
 	return {
@@ -397,4 +380,4 @@ function safeParse(schema, input, config2) {
 }
 
 //#endregion
-export { array, description, getDefault, literal, number, object, optional, parse, pipe, regex, safeParse, string, union };
+export { array, description, getDefault, literal, number, object, optional, pipe, regex, safeParse, string, union };

package/dist/{dist-LwbOR2Yw.js → dist-DAarI-SJ.js}

@@ -1,4 +1,4 @@
-import { getDefault } from "./dist-C0-Tf5eD.js";
+import { getDefault } from "./dist-BEQ1tJCL.js";
 
 //#region node_modules/@valibot/to-json-schema/dist/index.js
 /**

package/dist/{effect-WSjEuzC9-CJfWUy0j.js → effect-WSjEuzC9-ChJ5OQQf.js}

@@ -1,4 +1,4 @@
-import { tryImport } from "./index-CISmcbXk-DCA05NUL.js";
+import { tryImport } from "./index-CISmcbXk-x9eVmhGM.js";
 
 //#region node_modules/xsschema/dist/effect-WSjEuzC9.js
 const getToJsonSchemaFn = async () => {

package/dist/{index-CISmcbXk-DCA05NUL.js → index-CISmcbXk-x9eVmhGM.js}

@@ -10,10 +10,10 @@ const tryImport = async (result, name) => {
 const getToJsonSchemaFn = async (vendor) => {
 	switch (vendor) {
 		case "arktype": return import("./arktype-C-GObzDh-Bx7Fdrqj.js").then(async ({ getToJsonSchemaFn: getToJsonSchemaFn2 }) => getToJsonSchemaFn2());
-		case "effect": return import("./effect-WSjEuzC9-CJfWUy0j.js").then(async ({ getToJsonSchemaFn: getToJsonSchemaFn2 }) => getToJsonSchemaFn2());
-		case "sury": return import("./sury-DmrZ3_Oj-CCL_DlTt.js").then(async ({ getToJsonSchemaFn: getToJsonSchemaFn2 }) => getToJsonSchemaFn2());
-		case "valibot": return import("./valibot-CQk-M5rL-CkjrLVu1.js").then(async ({ getToJsonSchemaFn: getToJsonSchemaFn2 }) => getToJsonSchemaFn2());
-		case "zod": return import("./zod-Db63SLXj-Dyc_OWjq.js").then(async ({ getToJsonSchemaFn: getToJsonSchemaFn2 }) => getToJsonSchemaFn2());
+		case "effect": return import("./effect-WSjEuzC9-ChJ5OQQf.js").then(async ({ getToJsonSchemaFn: getToJsonSchemaFn2 }) => getToJsonSchemaFn2());
+		case "sury": return import("./sury-DmrZ3_Oj-l0qqtY-f.js").then(async ({ getToJsonSchemaFn: getToJsonSchemaFn2 }) => getToJsonSchemaFn2());
+		case "valibot": return import("./valibot-CQk-M5rL-BNHzwpA0.js").then(async ({ getToJsonSchemaFn: getToJsonSchemaFn2 }) => getToJsonSchemaFn2());
+		case "zod": return import("./zod-Db63SLXj-N1oN-yiY.js").then(async ({ getToJsonSchemaFn: getToJsonSchemaFn2 }) => getToJsonSchemaFn2());
 		default: throw new Error(`xsschema: Unsupported schema vendor "${vendor}". see https://xsai.js.org/docs/packages-top/xsschema#unsupported-schema-vendor`);
 	}
 };