ccusage 0.4.1 → 0.4.2

package/dist/data-loader-DtCt7sNl.d.ts

@@ -0,0 +1,56 @@
+import { ArraySchema, InferOutput, NumberSchema, ObjectSchema, OptionalSchema, StringSchema } from "./index-Bazt8Nfd.js";
+import { ModelPricing } from "./pricing-fetcher-BqlslEH3.js";
+import { CostMode } from "./types-BfZ5dOy7.js";
+
+//#region src/data-loader.d.ts
+declare const 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 DailyUsageSchema: ObjectSchema<{
+  readonly date: StringSchema<undefined>;
+  readonly inputTokens: NumberSchema<undefined>;
+  readonly outputTokens: NumberSchema<undefined>;
+  readonly cacheCreationTokens: NumberSchema<undefined>;
+  readonly cacheReadTokens: NumberSchema<undefined>;
+  readonly totalCost: NumberSchema<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>;
+}, undefined>;
+type SessionUsage = InferOutput<typeof SessionUsageSchema>;
+declare const formatDate: (dateStr: string) => string;
+declare const calculateCostForEntry: (data: UsageData, mode: CostMode, modelPricing: Record<string, ModelPricing>) => number;
+interface DateFilter {
+  since?: string;
+  until?: string;
+}
+interface LoadOptions extends DateFilter {
+  claudePath?: string;
+  mode?: CostMode;
+}
+declare function loadUsageData(options?: LoadOptions): Promise<DailyUsage[]>;
+declare function loadSessionData(options?: LoadOptions): Promise<SessionUsage[]>;
+//#endregion
+export { DailyUsage, DailyUsageSchema as DailyUsageSchema$1, DateFilter, LoadOptions, SessionUsage, SessionUsageSchema as SessionUsageSchema$1, UsageData, UsageDataSchema as UsageDataSchema$1, calculateCostForEntry as calculateCostForEntry$1, formatDate as formatDate$1, getDefaultClaudePath as getDefaultClaudePath$1, loadSessionData as loadSessionData$1, loadUsageData as loadUsageData$1 };

package/dist/data-loader.d.ts

@@ -1,2 +1,5 @@
-import { DailyUsage, DailyUsageSchema$1 as DailyUsageSchema, DateFilter, LoadOptions, SessionUsage, SessionUsageSchema$1 as SessionUsageSchema, UsageData, UsageDataSchema$1 as UsageDataSchema, calculateCostForEntry$1 as calculateCostForEntry, formatDate$1 as formatDate, getDefaultClaudePath$1 as getDefaultClaudePath, loadSessionData$1 as loadSessionData, loadUsageData$1 as loadUsageData } from "./data-loader-D1LHcGfa.js";
+import "./index-Bazt8Nfd.js";
+import "./pricing-fetcher-BqlslEH3.js";
+import "./types-BfZ5dOy7.js";
+import { DailyUsage, DailyUsageSchema$1 as DailyUsageSchema, DateFilter, LoadOptions, SessionUsage, SessionUsageSchema$1 as SessionUsageSchema, UsageData, UsageDataSchema$1 as UsageDataSchema, calculateCostForEntry$1 as calculateCostForEntry, formatDate$1 as formatDate, getDefaultClaudePath$1 as getDefaultClaudePath, loadSessionData$1 as loadSessionData, loadUsageData$1 as loadUsageData } from "./data-loader-DtCt7sNl.js";
 export { DailyUsage, DailyUsageSchema, DateFilter, LoadOptions, SessionUsage, SessionUsageSchema, UsageData, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadSessionData, loadUsageData };

package/dist/data-loader.js

@@ -1,3 +1,6 @@
-import { DailyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadSessionData, loadUsageData } from "./data-loader-BBdPk24U.js";
+import { DailyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadSessionData, loadUsageData } from "./data-loader-B8mdiY5r.js";
+import "./dist-D6rk8Ra5.js";
+import "./logger-nCODI08N.js";
+import "./pricing-fetcher-bvi4lbXl.js";
 
 export { DailyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadSessionData, loadUsageData };

package/dist/debug-Oce2b5bO.js

@@ -0,0 +1,142 @@
+import { UsageDataSchema, glob } from "./data-loader-B8mdiY5r.js";
+import { safeParse } from "./dist-D6rk8Ra5.js";
+import { logger } from "./logger-nCODI08N.js";
+import { calculateCostFromTokens, fetchModelPricing, getModelPricing } from "./pricing-fetcher-bvi4lbXl.js";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+
+//#region src/debug.ts
+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: new Map(),
+		versionStats: 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 && data.message.model !== "<synthetic>") {
+				stats.entriesWithBoth++;
+				const model = data.message.model;
+				const pricing = getModelPricing(model, modelPricing);
+				if (pricing) {
+					const calculatedCost = calculateCostFromTokens(data.message.usage, pricing);
+					const difference = Math.abs(data.costUSD - calculatedCost);
+					const percentDiff = data.costUSD > 0 ? difference / data.costUSD * 100 : 0;
+					const modelStat = stats.modelStats.get(model) || {
+						total: 0,
+						matches: 0,
+						mismatches: 0,
+						avgPercentDiff: 0
+					};
+					modelStat.total++;
+					if (data.version) {
+						const versionStat = stats.versionStats.get(data.version) || {
+							total: 0,
+							matches: 0,
+							mismatches: 0,
+							avgPercentDiff: 0
+						};
+						versionStat.total++;
+						if (percentDiff < MATCH_THRESHOLD_PERCENT) versionStat.matches++;
+						else versionStat.mismatches++;
+						versionStat.avgPercentDiff = (versionStat.avgPercentDiff * (versionStat.total - 1) + percentDiff) / versionStat.total;
+						stats.versionStats.set(data.version, versionStat);
+					}
+					if (percentDiff < .1) {
+						stats.matches++;
+						modelStat.matches++;
+					} else {
+						stats.mismatches++;
+						modelStat.mismatches++;
+						stats.discrepancies.push({
+							file: path.basename(file),
+							timestamp: data.timestamp,
+							model,
+							originalCost: data.costUSD,
+							calculatedCost,
+							difference,
+							percentDiff,
+							usage: data.message.usage
+						});
+					}
+					modelStat.avgPercentDiff = (modelStat.avgPercentDiff * (modelStat.total - 1) + percentDiff) / modelStat.total;
+					stats.modelStats.set(model, modelStat);
+				}
+			}
+		} catch (e) {}
+	}
+	return stats;
+}
+function printMismatchReport(stats, sampleCount = 5) {
+	if (stats.entriesWithBoth === 0) {
+		logger.info("No pricing data found to analyze.");
+		return;
+	}
+	const matchRate = stats.matches / stats.entriesWithBoth * 100;
+	logger.info("\n=== Pricing Mismatch Debug Report ===");
+	logger.info(`Total entries processed: ${stats.totalEntries.toLocaleString()}`);
+	logger.info(`Entries with both costUSD and model: ${stats.entriesWithBoth.toLocaleString()}`);
+	logger.info(`Matches (within 0.1%): ${stats.matches.toLocaleString()}`);
+	logger.info(`Mismatches: ${stats.mismatches.toLocaleString()}`);
+	logger.info(`Match rate: ${matchRate.toFixed(2)}%`);
+	if (stats.mismatches > 0 && stats.modelStats.size > 0) {
+		logger.info("\n=== Model Statistics ===");
+		const sortedModels = Array.from(stats.modelStats.entries()).sort((a, b) => b[1].mismatches - a[1].mismatches);
+		for (const [model, modelStat] of sortedModels) if (modelStat.mismatches > 0) {
+			const modelMatchRate = modelStat.matches / modelStat.total * 100;
+			logger.info(`${model}:`);
+			logger.info(`  Total entries: ${modelStat.total.toLocaleString()}`);
+			logger.info(`  Matches: ${modelStat.matches.toLocaleString()} (${modelMatchRate.toFixed(1)}%)`);
+			logger.info(`  Mismatches: ${modelStat.mismatches.toLocaleString()}`);
+			logger.info(`  Avg % difference: ${modelStat.avgPercentDiff.toFixed(1)}%`);
+		}
+	}
+	if (stats.mismatches > 0 && stats.versionStats.size > 0) {
+		logger.info("\n=== Version Statistics ===");
+		const sortedVersions = Array.from(stats.versionStats.entries()).filter(([_, versionStat]) => versionStat.mismatches > 0).sort((a, b) => b[1].mismatches - a[1].mismatches);
+		for (const [version, versionStat] of sortedVersions) {
+			const versionMatchRate = versionStat.matches / versionStat.total * 100;
+			logger.info(`${version}:`);
+			logger.info(`  Total entries: ${versionStat.total.toLocaleString()}`);
+			logger.info(`  Matches: ${versionStat.matches.toLocaleString()} (${versionMatchRate.toFixed(1)}%)`);
+			logger.info(`  Mismatches: ${versionStat.mismatches.toLocaleString()}`);
+			logger.info(`  Avg % difference: ${versionStat.avgPercentDiff.toFixed(1)}%`);
+		}
+	}
+	if (stats.discrepancies.length > 0 && sampleCount > 0) {
+		logger.info(`\n=== Sample Discrepancies (first ${sampleCount}) ===`);
+		const samples = stats.discrepancies.slice(0, sampleCount);
+		for (const disc of samples) {
+			logger.info(`File: ${disc.file}`);
+			logger.info(`Timestamp: ${disc.timestamp}`);
+			logger.info(`Model: ${disc.model}`);
+			logger.info(`Original cost: $${disc.originalCost.toFixed(6)}`);
+			logger.info(`Calculated cost: $${disc.calculatedCost.toFixed(6)}`);
+			logger.info(`Difference: $${disc.difference.toFixed(6)} (${disc.percentDiff.toFixed(2)}%)`);
+			logger.info(`Tokens: ${JSON.stringify(disc.usage)}`);
+			logger.info("---");
+		}
+	}
+}
+
+//#endregion
+export { detectMismatches, printMismatchReport };

package/dist/debug.d.ts

@@ -0,0 +1,39 @@
+//#region src/debug.d.ts
+interface Discrepancy {
+  file: string;
+  timestamp: string;
+  model: string;
+  originalCost: number;
+  calculatedCost: number;
+  difference: number;
+  percentDiff: number;
+  usage: {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+  };
+}
+interface MismatchStats {
+  totalEntries: number;
+  entriesWithBoth: number;
+  matches: number;
+  mismatches: number;
+  discrepancies: Discrepancy[];
+  modelStats: Map<string, {
+    total: number;
+    matches: number;
+    mismatches: number;
+    avgPercentDiff: number;
+  }>;
+  versionStats: Map<string, {
+    total: number;
+    matches: number;
+    mismatches: number;
+    avgPercentDiff: number;
+  }>;
+}
+declare function detectMismatches(claudePath?: string): Promise<MismatchStats>;
+declare function printMismatchReport(stats: MismatchStats, sampleCount?: number): void;
+//#endregion
+export { detectMismatches, printMismatchReport };

package/dist/debug.js

@@ -0,0 +1,7 @@
+import "./data-loader-B8mdiY5r.js";
+import "./dist-D6rk8Ra5.js";
+import "./logger-nCODI08N.js";
+import "./pricing-fetcher-bvi4lbXl.js";
+import { detectMismatches, printMismatchReport } from "./debug-Oce2b5bO.js";
+
+export { detectMismatches, printMismatchReport };