ccusage 12.3.2 → 13.0.0

package/LICENSE

@@ -2,6 +2,8 @@ MIT License
 
 Copyright (c) 2025 ryoppippi
 
+Logo and brand assets created by nyatinte are also licensed under MIT License.
+
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights

package/README.md

@@ -1,6 +1,8 @@
 # ccusage
 
-> **ccusage(claude-code-usage)**
+<div align="center">
+  <img src="docs/logo.png" alt="ccusage logo" width="256" height="256">
+</div>
 
 [![npm version](https://img.shields.io/npm/v/ccusage?color=yellow)](https://npmjs.com/package/ccusage)
 [![NPM Downloads](https://img.shields.io/npm/dy/ccusage)](https://tanstack.com/stats/npm?packageGroups=%5B%7B%22packages%22:%5B%7B%22name%22:%22ccusage%22%7D%5D%7D%5D&range=30-days&transform=none&binType=daily&showDataMode=all&height=400)
@@ -12,6 +14,8 @@
   <img src="https://github.com/ryoppippi/ccusage/blob/main/docs/screenshot.png?raw=true">
 </div>
 
+> **ccusage(claude-code-usage)**
+
 A CLI tool for analyzing Claude Code usage from local JSONL files.
 
 Inspired by [this article](https://note.com/milliondev/n/n1d018da2d769) about tracking Claude Code usage costs.
@@ -19,7 +23,7 @@ Inspired by [this article](https://note.com/milliondev/n/n1d018da2d769) about tr
 ## What is `ccusage` (by NotebookLM)
 
 <details>
- <summary>Podcact</summary>
+ <summary>Podcast</summary>
 
 # English
 
@@ -477,6 +481,10 @@ With `--breakdown` flag:
 
 MIT
 
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+The logo and brand assets are also licensed under the MIT License. Created by [@nyatinte](https://github.com/nyatinte).
+
 ## Author
 
 [@ryoppippi](https://github.com/ryoppippi)
@@ -492,6 +500,7 @@ While the original approach uses DuckDB for analysis, this tool provides a more
 some projects use `ccusage` internally and provide additional features:
 
 - [claude-usage-tracker-for-mac](https://github.com/penicillin0/claude-usage-tracker-for-mac) – macOS menu bar app to visualize Claude Code usage costs by [@penicillin0](https://github.com/penicillin0).
+- [ccusage Raycast Extension](https://www.raycast.com/nyatinte/ccusage) – Raycast extension to view Claude Code usage reports in Raycast by [@nyatinte](https://github.com/nyatinte).
 
 ## Acknowledgments
 

package/dist/calculate-cost.d.ts

@@ -1,5 +1,5 @@
-import "./pricing-fetcher-BkOpRIdx.js";
-import { DailyUsage, MonthlyUsage, SessionUsage } from "./data-loader-CBwn9vk0.js";
+import "./pricing-fetcher-A6FC8DhM.js";
+import { DailyUsage, MonthlyUsage, SessionUsage } from "./data-loader-BrxITdVN.js";
 
 //#region src/calculate-cost.d.ts
 /**

package/dist/calculate-cost.js

@@ -1,2 +1,3 @@
-import { calculateTotals, createTotalsObject, getTotalTokens } from "./calculate-cost-D3IraeGW.js";
+import "./types.internal-CX7kpidj.js";
+import { calculateTotals, createTotalsObject, getTotalTokens } from "./calculate-cost-CoS7we68.js";
 export { calculateTotals, createTotalsObject, getTotalTokens };

package/dist/{data-loader-i0_91kbD.js → data-loader-B8gFJPfi.js}

@@ -1,5 +1,6 @@
-import { PricingFetcher, __commonJSMin, __require, __toESM, arrayType, numberType, objectType, require_usingCtx, stringType } from "./pricing-fetcher-mFPZYGXl.js";
-import { logger } from "./logger-BfzGx5lS.js";
+import { CLAUDE_PROJECTS_DIR_NAME, DEFAULT_CLAUDE_CODE_PATH, DEFAULT_RECENT_DAYS, PricingFetcher, USAGE_DATA_GLOB_PATTERN, USER_HOME_DIR, __commonJSMin, __require, __toESM, require_usingCtx } from "./pricing-fetcher-Cx71zrV9.js";
+import { activityDateSchema, arrayType, createDailyDate, createMonthlyDate, createProjectPath, createSessionId, dailyDateSchema, isoTimestampSchema, messageIdSchema, modelNameSchema, monthlyDateSchema, numberType, objectType, projectPathSchema, requestIdSchema, sessionIdSchema, versionSchema } from "./types.internal-CX7kpidj.js";
+import { logger } from "./logger-B4PJ298G.js";
 import a, { readFile } from "node:fs/promises";
 import F, { homedir } from "node:os";
 import path, { posix } from "node:path";
@@ -244,6 +245,9 @@ function groupBy(arr, getKeyFromItem) {
 	}
 	return result;
 }
+function uniq(arr) {
+	return Array.from(new Set(arr));
+}
 var castComparer = function(comparer) {
 	return function(a$1, b$1, order) {
 		return comparer(a$1, b$1, order) * order;
@@ -3056,10 +3060,6 @@ async function glob(patternsOrOptions, options) {
 */
 const DEFAULT_SESSION_DURATION_HOURS = 5;
 /**
-* Default number of recent days to include when filtering blocks
-*/
-const DEFAULT_RECENT_DAYS = 3;
-/**
 * Identifies and creates session blocks from usage entries
 * Groups entries into time-based blocks (typically 5-hour periods) with gap detection
 * @param entries - Array of usage entries to process
@@ -3123,14 +3123,14 @@ function createBlock(startTime, entries, now, sessionDurationMs) {
 		cacheReadInputTokens: 0
 	};
 	let costUSD = 0;
-	const modelsSet = /* @__PURE__ */ new Set();
+	const models = [];
 	for (const entry of entries) {
 		tokenCounts.inputTokens += entry.usage.inputTokens;
 		tokenCounts.outputTokens += entry.usage.outputTokens;
 		tokenCounts.cacheCreationInputTokens += entry.usage.cacheCreationInputTokens;
 		tokenCounts.cacheReadInputTokens += entry.usage.cacheReadInputTokens;
 		costUSD += entry.costUSD ?? 0;
-		modelsSet.add(entry.model);
+		models.push(entry.model);
 	}
 	return {
 		id: startTime.toISOString(),
@@ -3141,7 +3141,7 @@ function createBlock(startTime, entries, now, sessionDurationMs) {
 		entries,
 		tokenCounts,
 		costUSD,
-		models: Array.from(modelsSet)
+		models: uniq(models)
 	};
 }
 /**
@@ -3233,22 +3233,18 @@ function filterRecentBlocks(blocks, days = DEFAULT_RECENT_DAYS) {
 }
 var import_usingCtx = __toESM(require_usingCtx(), 1);
 /**
-* Default Claude data directory path (~/.claude)
-*/
-const DEFAULT_CLAUDE_CODE_PATH = path.join(homedir(), ".claude");
-/**
 * Default path for Claude data directory
 * Uses environment variable CLAUDE_CONFIG_DIR if set, otherwise defaults to ~/.claude
 */
 function getDefaultClaudePath() {
 	const envClaudeCodePath = (process$1.env.CLAUDE_CONFIG_DIR ?? "").trim();
-	if (envClaudeCodePath === "") return DEFAULT_CLAUDE_CODE_PATH;
+	if (envClaudeCodePath === "") return path.join(USER_HOME_DIR, DEFAULT_CLAUDE_CODE_PATH);
 	if (!isDirectorySync(envClaudeCodePath)) throw new Error(`CLAUDE_CONFIG_DIR path is not a valid directory: ${envClaudeCodePath}. 
-Please set CLAUDE_CONFIG_DIR to a valid directory path, or ensure ${DEFAULT_CLAUDE_CODE_PATH} exists.
+Please set CLAUDE_CONFIG_DIR to a valid directory path, or ensure ${path.join(USER_HOME_DIR, DEFAULT_CLAUDE_CODE_PATH)} exists.
 			`.trim());
-	const claudeCodeProjectsPath = path.join(envClaudeCodePath, "projects");
+	const claudeCodeProjectsPath = path.join(envClaudeCodePath, CLAUDE_PROJECTS_DIR_NAME);
 	if (!isDirectorySync(claudeCodeProjectsPath)) throw new Error(`Claude data directory does not exist: ${claudeCodeProjectsPath}. 
-Please set CLAUDE_CONFIG_DIR to a valid path, or ensure ${DEFAULT_CLAUDE_CODE_PATH} exists.
+Please set CLAUDE_CONFIG_DIR to a valid path, or ensure ${path.join(USER_HOME_DIR, DEFAULT_CLAUDE_CODE_PATH)} exists.
 			`.trim());
 	return envClaudeCodePath;
 }
@@ -3256,8 +3252,8 @@ Please set CLAUDE_CONFIG_DIR to a valid path, or ensure ${DEFAULT_CLAUDE_CODE_PA
 * Zod schema for validating Claude usage data from JSONL files
 */
 const usageDataSchema = objectType({
-	timestamp: stringType(),
-	version: stringType().optional(),
+	timestamp: isoTimestampSchema,
+	version: versionSchema.optional(),
 	message: objectType({
 		usage: objectType({
 			input_tokens: numberType(),
@@ -3265,17 +3261,17 @@ const usageDataSchema = objectType({
 			cache_creation_input_tokens: numberType().optional(),
 			cache_read_input_tokens: numberType().optional()
 		}),
-		model: stringType().optional(),
-		id: stringType().optional()
+		model: modelNameSchema.optional(),
+		id: messageIdSchema.optional()
 	}),
 	costUSD: numberType().optional(),
-	requestId: stringType().optional()
+	requestId: requestIdSchema.optional()
 });
 /**
 * Zod schema for model-specific usage breakdown data
 */
 const modelBreakdownSchema = objectType({
-	modelName: stringType(),
+	modelName: modelNameSchema,
 	inputTokens: numberType(),
 	outputTokens: numberType(),
 	cacheCreationTokens: numberType(),
@@ -3286,42 +3282,42 @@ const modelBreakdownSchema = objectType({
 * Zod schema for daily usage aggregation data
 */
 const dailyUsageSchema = objectType({
-	date: stringType().regex(/^\d{4}-\d{2}-\d{2}$/),
+	date: dailyDateSchema,
 	inputTokens: numberType(),
 	outputTokens: numberType(),
 	cacheCreationTokens: numberType(),
 	cacheReadTokens: numberType(),
 	totalCost: numberType(),
-	modelsUsed: arrayType(stringType()),
+	modelsUsed: arrayType(modelNameSchema),
 	modelBreakdowns: arrayType(modelBreakdownSchema)
 });
 /**
 * Zod schema for session-based usage aggregation data
 */
 const sessionUsageSchema = objectType({
-	sessionId: stringType(),
-	projectPath: stringType(),
+	sessionId: sessionIdSchema,
+	projectPath: projectPathSchema,
 	inputTokens: numberType(),
 	outputTokens: numberType(),
 	cacheCreationTokens: numberType(),
 	cacheReadTokens: numberType(),
 	totalCost: numberType(),
-	lastActivity: stringType(),
-	versions: arrayType(stringType()),
-	modelsUsed: arrayType(stringType()),
+	lastActivity: activityDateSchema,
+	versions: arrayType(versionSchema),
+	modelsUsed: arrayType(modelNameSchema),
 	modelBreakdowns: arrayType(modelBreakdownSchema)
 });
 /**
 * Zod schema for monthly usage aggregation data
 */
 const monthlyUsageSchema = objectType({
-	month: stringType().regex(/^\d{4}-\d{2}$/),
+	month: monthlyDateSchema,
 	inputTokens: numberType(),
 	outputTokens: numberType(),
 	cacheCreationTokens: numberType(),
 	cacheReadTokens: numberType(),
 	totalCost: numberType(),
-	modelsUsed: arrayType(stringType()),
+	modelsUsed: arrayType(modelNameSchema),
 	modelBreakdowns: arrayType(modelBreakdownSchema)
 });
 /**
@@ -3439,7 +3435,7 @@ function markAsProcessed(uniqueHash, processedHashes) {
 * Extracts unique models from entries, excluding synthetic model
 */
 function extractUniqueModels(entries, getModel) {
-	return [...new Set(entries.map(getModel).filter((m$1) => m$1 != null && m$1 !== "<synthetic>"))];
+	return uniq(entries.map(getModel).filter((m$1) => m$1 != null && m$1 !== "<synthetic>"));
 }
 /**
 * Formats a date string to YYYY-MM-DD format
@@ -3564,8 +3560,8 @@ async function loadDailyUsageData(options) {
 	try {
 		var _usingCtx = (0, import_usingCtx.default)();
 		const claudePath = options?.claudePath ?? getDefaultClaudePath();
-		const claudeDir = path.join(claudePath, "projects");
-		const files = await glob(["**/*.jsonl"], {
+		const claudeDir = path.join(claudePath, CLAUDE_PROJECTS_DIR_NAME);
+		const files = await glob([USAGE_DATA_GLOB_PATTERN], {
 			cwd: claudeDir,
 			absolute: true
 		});
@@ -3604,7 +3600,7 @@ async function loadDailyUsageData(options) {
 			const totals = calculateTotals(entries, (entry) => entry.data.message.usage, (entry) => entry.cost);
 			const modelsUsed = extractUniqueModels(entries, (e) => e.model);
 			return {
-				date,
+				date: createDailyDate(date),
 				...totals,
 				modelsUsed,
 				modelBreakdowns
@@ -3628,8 +3624,8 @@ async function loadSessionData(options) {
 	try {
 		var _usingCtx3 = (0, import_usingCtx.default)();
 		const claudePath = options?.claudePath ?? getDefaultClaudePath();
-		const claudeDir = path.join(claudePath, "projects");
-		const files = await glob(["**/*.jsonl"], {
+		const claudeDir = path.join(claudePath, CLAUDE_PROJECTS_DIR_NAME);
+		const files = await glob([USAGE_DATA_GLOB_PATTERN], {
 			cwd: claudeDir,
 			absolute: true
 		});
@@ -3672,18 +3668,18 @@ async function loadSessionData(options) {
 		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 versions = [];
+			for (const entry of entries) if (entry.data.version != null) versions.push(entry.data.version);
 			const modelAggregates = aggregateByModel(entries, (entry) => entry.model, (entry) => entry.data.message.usage, (entry) => entry.cost);
 			const modelBreakdowns = createModelBreakdowns(modelAggregates);
 			const totals = calculateTotals(entries, (entry) => entry.data.message.usage, (entry) => entry.cost);
 			const modelsUsed = extractUniqueModels(entries, (e) => e.model);
 			return {
-				sessionId: latestEntry.sessionId,
-				projectPath: latestEntry.projectPath,
+				sessionId: createSessionId(latestEntry.sessionId),
+				projectPath: createProjectPath(latestEntry.projectPath),
 				...totals,
 				lastActivity: formatDate(latestEntry.timestamp),
-				versions: Array.from(versionSet).sort(),
+				versions: uniq(versions).sort(),
 				modelsUsed,
 				modelBreakdowns
 			};
@@ -3711,8 +3707,8 @@ async function loadMonthlyUsageData(options) {
 		const allBreakdowns = dailyEntries.flatMap((daily) => daily.modelBreakdowns);
 		const modelAggregates = aggregateModelBreakdowns(allBreakdowns);
 		const modelBreakdowns = createModelBreakdowns(modelAggregates);
-		const modelsSet = /* @__PURE__ */ new Set();
-		for (const data of dailyEntries) for (const model of data.modelsUsed) if (model !== "<synthetic>") modelsSet.add(model);
+		const models = [];
+		for (const data of dailyEntries) for (const model of data.modelsUsed) if (model !== "<synthetic>") models.push(model);
 		let totalInputTokens = 0;
 		let totalOutputTokens = 0;
 		let totalCacheCreationTokens = 0;
@@ -3726,13 +3722,13 @@ async function loadMonthlyUsageData(options) {
 			totalCost += daily.totalCost;
 		}
 		const monthlyUsage = {
-			month,
+			month: createMonthlyDate(month),
 			inputTokens: totalInputTokens,
 			outputTokens: totalOutputTokens,
 			cacheCreationTokens: totalCacheCreationTokens,
 			cacheReadTokens: totalCacheReadTokens,
 			totalCost,
-			modelsUsed: Array.from(modelsSet),
+			modelsUsed: uniq(models),
 			modelBreakdowns
 		};
 		monthlyArray.push(monthlyUsage);
@@ -3749,8 +3745,8 @@ async function loadSessionBlockData(options) {
 	try {
 		var _usingCtx4 = (0, import_usingCtx.default)();
 		const claudePath = options?.claudePath ?? getDefaultClaudePath();
-		const claudeDir = path.join(claudePath, "projects");
-		const files = await glob(["**/*.jsonl"], {
+		const claudeDir = path.join(claudePath, CLAUDE_PROJECTS_DIR_NAME);
+		const files = await glob([USAGE_DATA_GLOB_PATTERN], {
 			cwd: claudeDir,
 			absolute: true
 		});
@@ -3802,4 +3798,4 @@ async function loadSessionBlockData(options) {
 		_usingCtx4.d();
 	}
 }
-export { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, calculateCostForEntry, createUniqueHash, dailyUsageSchema, filterRecentBlocks, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, glob, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, projectBlockUsage, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };
+export { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, calculateCostForEntry, createUniqueHash, dailyUsageSchema, filterRecentBlocks, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, glob, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, projectBlockUsage, sessionUsageSchema, sortFilesByTimestamp, uniq, usageDataSchema };

package/dist/{data-loader-CBwn9vk0.d.ts → data-loader-BrxITdVN.d.ts}

@@ -1,4 +1,4 @@
-import { CostMode, PricingFetcher, SortOrder } from "./pricing-fetcher-BkOpRIdx.js";
+import { CostMode, PricingFetcher, SortOrder } from "./pricing-fetcher-A6FC8DhM.js";
 import { z } from "zod";
 
 //#region src/session-blocks.internal.d.ts
@@ -56,8 +56,8 @@ declare function getDefaultClaudePath(): string;
  * Zod schema for validating Claude usage data from JSONL files
  */
 declare const usageDataSchema: z.ZodObject<{
-  timestamp: z.ZodString;
-  version: z.ZodOptional<z.ZodString>;
+  timestamp: z.ZodBranded<z.ZodString, "ISOTimestamp">;
+  version: z.ZodOptional<z.ZodBranded<z.ZodString, "Version">>;
   message: z.ZodObject<{
     usage: z.ZodObject<{
       input_tokens: z.ZodNumber;
@@ -75,8 +75,8 @@ declare const usageDataSchema: z.ZodObject<{
       cache_creation_input_tokens?: number | undefined;
       cache_read_input_tokens?: number | undefined;
     }>;
-    model: z.ZodOptional<z.ZodString>;
-    id: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodBranded<z.ZodString, "ModelName">>;
+    id: z.ZodOptional<z.ZodBranded<z.ZodString, "MessageId">>;
   }, "strip", z.ZodTypeAny, {
     usage: {
       input_tokens: number;
@@ -84,8 +84,8 @@ declare const usageDataSchema: z.ZodObject<{
       cache_creation_input_tokens?: number | undefined;
       cache_read_input_tokens?: number | undefined;
     };
-    model?: string | undefined;
-    id?: string | undefined;
+    model?: string & z.BRAND<"ModelName"> | undefined;
+    id?: string & z.BRAND<"MessageId"> | undefined;
   }, {
     usage: {
       input_tokens: number;
@@ -97,10 +97,10 @@ declare const usageDataSchema: z.ZodObject<{
     id?: string | undefined;
   }>;
   costUSD: z.ZodOptional<z.ZodNumber>;
-  requestId: z.ZodOptional<z.ZodString>;
+  requestId: z.ZodOptional<z.ZodBranded<z.ZodString, "RequestId">>;
 }, "strip", z.ZodTypeAny, {
-  timestamp: string;
-  version?: string | undefined;
+  timestamp: string & z.BRAND<"ISOTimestamp">;
+  version?: string & z.BRAND<"Version"> | undefined;
   message: {
     usage: {
       input_tokens: number;
@@ -108,11 +108,11 @@ declare const usageDataSchema: z.ZodObject<{
       cache_creation_input_tokens?: number | undefined;
       cache_read_input_tokens?: number | undefined;
     };
-    model?: string | undefined;
-    id?: string | undefined;
+    model?: string & z.BRAND<"ModelName"> | undefined;
+    id?: string & z.BRAND<"MessageId"> | undefined;
   };
   costUSD?: number | undefined;
-  requestId?: string | undefined;
+  requestId?: string & z.BRAND<"RequestId"> | undefined;
 }, {
   timestamp: string;
   version?: string | undefined;
@@ -137,14 +137,14 @@ type UsageData = z.infer<typeof usageDataSchema>;
  * Zod schema for model-specific usage breakdown data
  */
 declare const modelBreakdownSchema: z.ZodObject<{
-  modelName: z.ZodString;
+  modelName: z.ZodBranded<z.ZodString, "ModelName">;
   inputTokens: z.ZodNumber;
   outputTokens: z.ZodNumber;
   cacheCreationTokens: z.ZodNumber;
   cacheReadTokens: z.ZodNumber;
   cost: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
-  modelName: string;
+  modelName: string & z.BRAND<"ModelName">;
   inputTokens: number;
   outputTokens: number;
   cacheCreationTokens: number;
@@ -166,22 +166,22 @@ type ModelBreakdown = z.infer<typeof modelBreakdownSchema>;
  * Zod schema for daily usage aggregation data
  */
 declare const dailyUsageSchema: z.ZodObject<{
-  date: z.ZodString;
+  date: z.ZodBranded<z.ZodString, "DailyDate">;
   inputTokens: z.ZodNumber;
   outputTokens: z.ZodNumber;
   cacheCreationTokens: z.ZodNumber;
   cacheReadTokens: z.ZodNumber;
   totalCost: z.ZodNumber;
-  modelsUsed: z.ZodArray<z.ZodString, "many">;
+  modelsUsed: z.ZodArray<z.ZodBranded<z.ZodString, "ModelName">, "many">;
   modelBreakdowns: z.ZodArray<z.ZodObject<{
-    modelName: z.ZodString;
+    modelName: z.ZodBranded<z.ZodString, "ModelName">;
     inputTokens: z.ZodNumber;
     outputTokens: z.ZodNumber;
     cacheCreationTokens: z.ZodNumber;
     cacheReadTokens: z.ZodNumber;
     cost: z.ZodNumber;
   }, "strip", z.ZodTypeAny, {
-    modelName: string;
+    modelName: string & z.BRAND<"ModelName">;
     inputTokens: number;
     outputTokens: number;
     cacheCreationTokens: number;
@@ -196,15 +196,15 @@ declare const dailyUsageSchema: z.ZodObject<{
     cost: number;
   }>, "many">;
 }, "strip", z.ZodTypeAny, {
-  date: string;
+  date: string & z.BRAND<"DailyDate">;
   inputTokens: number;
   outputTokens: number;
   cacheCreationTokens: number;
   cacheReadTokens: number;
   totalCost: number;
-  modelsUsed: string[];
+  modelsUsed: (string & z.BRAND<"ModelName">)[];
   modelBreakdowns: {
-    modelName: string;
+    modelName: string & z.BRAND<"ModelName">;
     inputTokens: number;
     outputTokens: number;
     cacheCreationTokens: number;
@@ -236,25 +236,25 @@ type DailyUsage = z.infer<typeof dailyUsageSchema>;
  * Zod schema for session-based usage aggregation data
  */
 declare const sessionUsageSchema: z.ZodObject<{
-  sessionId: z.ZodString;
-  projectPath: z.ZodString;
+  sessionId: z.ZodBranded<z.ZodString, "SessionId">;
+  projectPath: z.ZodBranded<z.ZodString, "ProjectPath">;
   inputTokens: z.ZodNumber;
   outputTokens: z.ZodNumber;
   cacheCreationTokens: z.ZodNumber;
   cacheReadTokens: z.ZodNumber;
   totalCost: z.ZodNumber;
-  lastActivity: z.ZodString;
-  versions: z.ZodArray<z.ZodString, "many">;
-  modelsUsed: z.ZodArray<z.ZodString, "many">;
+  lastActivity: z.ZodBranded<z.ZodString, "ActivityDate">;
+  versions: z.ZodArray<z.ZodBranded<z.ZodString, "Version">, "many">;
+  modelsUsed: z.ZodArray<z.ZodBranded<z.ZodString, "ModelName">, "many">;
   modelBreakdowns: z.ZodArray<z.ZodObject<{
-    modelName: z.ZodString;
+    modelName: z.ZodBranded<z.ZodString, "ModelName">;
     inputTokens: z.ZodNumber;
     outputTokens: z.ZodNumber;
     cacheCreationTokens: z.ZodNumber;
     cacheReadTokens: z.ZodNumber;
     cost: z.ZodNumber;
   }, "strip", z.ZodTypeAny, {
-    modelName: string;
+    modelName: string & z.BRAND<"ModelName">;
     inputTokens: number;
     outputTokens: number;
     cacheCreationTokens: number;
@@ -269,18 +269,18 @@ declare const sessionUsageSchema: z.ZodObject<{
     cost: number;
   }>, "many">;
 }, "strip", z.ZodTypeAny, {
-  sessionId: string;
-  projectPath: string;
+  sessionId: string & z.BRAND<"SessionId">;
+  projectPath: string & z.BRAND<"ProjectPath">;
   inputTokens: number;
   outputTokens: number;
   cacheCreationTokens: number;
   cacheReadTokens: number;
   totalCost: number;
-  lastActivity: string;
-  versions: string[];
-  modelsUsed: string[];
+  lastActivity: string & z.BRAND<"ActivityDate">;
+  versions: (string & z.BRAND<"Version">)[];
+  modelsUsed: (string & z.BRAND<"ModelName">)[];
   modelBreakdowns: {
-    modelName: string;
+    modelName: string & z.BRAND<"ModelName">;
     inputTokens: number;
     outputTokens: number;
     cacheCreationTokens: number;
@@ -315,22 +315,22 @@ type SessionUsage = z.infer<typeof sessionUsageSchema>;
  * Zod schema for monthly usage aggregation data
  */
 declare const monthlyUsageSchema: z.ZodObject<{
-  month: z.ZodString;
+  month: z.ZodBranded<z.ZodString, "MonthlyDate">;
   inputTokens: z.ZodNumber;
   outputTokens: z.ZodNumber;
   cacheCreationTokens: z.ZodNumber;
   cacheReadTokens: z.ZodNumber;
   totalCost: z.ZodNumber;
-  modelsUsed: z.ZodArray<z.ZodString, "many">;
+  modelsUsed: z.ZodArray<z.ZodBranded<z.ZodString, "ModelName">, "many">;
   modelBreakdowns: z.ZodArray<z.ZodObject<{
-    modelName: z.ZodString;
+    modelName: z.ZodBranded<z.ZodString, "ModelName">;
     inputTokens: z.ZodNumber;
     outputTokens: z.ZodNumber;
     cacheCreationTokens: z.ZodNumber;
     cacheReadTokens: z.ZodNumber;
     cost: z.ZodNumber;
   }, "strip", z.ZodTypeAny, {
-    modelName: string;
+    modelName: string & z.BRAND<"ModelName">;
     inputTokens: number;
     outputTokens: number;
     cacheCreationTokens: number;
@@ -345,15 +345,15 @@ declare const monthlyUsageSchema: z.ZodObject<{
     cost: number;
   }>, "many">;
 }, "strip", z.ZodTypeAny, {
-  month: string;
+  month: string & z.BRAND<"MonthlyDate">;
   inputTokens: number;
   outputTokens: number;
   cacheCreationTokens: number;
   cacheReadTokens: number;
   totalCost: number;
-  modelsUsed: string[];
+  modelsUsed: (string & z.BRAND<"ModelName">)[];
   modelBreakdowns: {
-    modelName: string;
+    modelName: string & z.BRAND<"ModelName">;
     inputTokens: number;
     outputTokens: number;
     cacheCreationTokens: number;

package/dist/data-loader.d.ts

@@ -1,3 +1,3 @@
-import "./pricing-fetcher-BkOpRIdx.js";
-import { DailyUsage, DateFilter, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-CBwn9vk0.js";
+import "./pricing-fetcher-A6FC8DhM.js";
+import { DailyUsage, DateFilter, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-BrxITdVN.js";
 export { DailyUsage, DateFilter, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };

package/dist/data-loader.js

@@ -1,4 +1,5 @@
-import "./pricing-fetcher-mFPZYGXl.js";
-import { calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-i0_91kbD.js";
-import "./logger-BfzGx5lS.js";
+import "./pricing-fetcher-Cx71zrV9.js";
+import "./types.internal-CX7kpidj.js";
+import { calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-B8gFJPfi.js";
+import "./logger-B4PJ298G.js";
 export { calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };

package/dist/{debug-DUZvOm08.js → debug-CL2Shx1n.js}

@@ -1,15 +1,10 @@
-import { PricingFetcher, __toESM, require_usingCtx } from "./pricing-fetcher-mFPZYGXl.js";
-import { glob, usageDataSchema } from "./data-loader-i0_91kbD.js";
-import { logger } from "./logger-BfzGx5lS.js";
+import { CLAUDE_PROJECTS_DIR_NAME, DEBUG_MATCH_THRESHOLD_PERCENT, DEFAULT_CLAUDE_CODE_PATH, PricingFetcher, USAGE_DATA_GLOB_PATTERN, USER_HOME_DIR, __toESM, require_usingCtx } from "./pricing-fetcher-Cx71zrV9.js";
+import { glob, usageDataSchema } from "./data-loader-B8gFJPfi.js";
+import { logger } from "./logger-B4PJ298G.js";
 import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
 import path from "node:path";
 var import_usingCtx = __toESM(require_usingCtx(), 1);
 /**
-* Threshold percentage for considering costs as matching (0.1% tolerance)
-*/
-const MATCH_THRESHOLD_PERCENT = .1;
-/**
 * Analyzes usage data to detect pricing mismatches between stored and calculated costs
 * Compares pre-calculated costUSD values with costs calculated from token usage
 * @param claudePath - Optional path to Claude data directory
@@ -18,8 +13,8 @@ const MATCH_THRESHOLD_PERCENT = .1;
 async function detectMismatches(claudePath) {
 	try {
 		var _usingCtx = (0, import_usingCtx.default)();
-		const claudeDir = claudePath ?? path.join(homedir(), ".claude", "projects");
-		const files = await glob(["**/*.jsonl"], {
+		const claudeDir = claudePath ?? path.join(USER_HOME_DIR, DEFAULT_CLAUDE_CODE_PATH, CLAUDE_PROJECTS_DIR_NAME);
+		const files = await glob([USAGE_DATA_GLOB_PATTERN], {
 			cwd: claudeDir,
 			absolute: true
 		});
@@ -63,7 +58,7 @@ async function detectMismatches(claudePath) {
 							avgPercentDiff: 0
 						};
 						versionStat.total++;
-						if (percentDiff < MATCH_THRESHOLD_PERCENT) versionStat.matches++;
+						if (percentDiff < DEBUG_MATCH_THRESHOLD_PERCENT) versionStat.matches++;
 						else versionStat.mismatches++;
 						versionStat.avgPercentDiff = (versionStat.avgPercentDiff * (versionStat.total - 1) + percentDiff) / versionStat.total;
 						stats.versionStats.set(data.version, versionStat);

package/dist/debug.js

@@ -1,5 +1,6 @@
-import "./pricing-fetcher-mFPZYGXl.js";
-import "./data-loader-i0_91kbD.js";
-import "./logger-BfzGx5lS.js";
-import { detectMismatches, printMismatchReport } from "./debug-DUZvOm08.js";
+import "./pricing-fetcher-Cx71zrV9.js";
+import "./types.internal-CX7kpidj.js";
+import "./data-loader-B8gFJPfi.js";
+import "./logger-B4PJ298G.js";
+import { detectMismatches, printMismatchReport } from "./debug-CL2Shx1n.js";
 export { detectMismatches, printMismatchReport };