ccusage 16.2.5 → 17.0.1

package/README.md

@@ -39,43 +39,38 @@ deno run -E -R=$HOME/.claude/projects/ -S=homedir -N='raw.githubusercontent.com:
 
 > 💡 **Tip**: We recommend using `bunx` instead of `npx` for a massive speed improvement!
 
-### Local Installation (Optional)
-
-Since ccusage has such a small bundle size, installation is entirely optional:
-
-```bash
-npm install -g ccusage
-```
-
 ## Usage
 
 ```bash
 # Basic usage
-ccusage          # Show daily report (default)
-ccusage daily    # Daily token usage and costs
-ccusage monthly  # Monthly aggregated report
-ccusage session  # Usage by conversation session
-ccusage blocks   # 5-hour billing windows
-ccusage statusline  # Compact status line for hooks (Beta)
+npx ccusage          # Show daily report (default)
+npx ccusage daily    # Daily token usage and costs
+npx ccusage monthly  # Monthly aggregated report
+npx ccusage session  # Usage by conversation session
+npx ccusage blocks   # 5-hour billing windows
+npx ccusage statusline  # Compact status line for hooks (Beta)
 
 # Live monitoring
-ccusage blocks --live  # Real-time usage dashboard
+npx ccusage blocks --live  # Real-time usage dashboard
 
 # Filters and options
-ccusage daily --since 20250525 --until 20250530
-ccusage daily --json  # JSON output
-ccusage daily --breakdown  # Per-model cost breakdown
-ccusage daily --timezone UTC  # Use UTC timezone
-ccusage daily --locale ja-JP  # Use Japanese locale for date/time formatting
+npx ccusage daily --since 20250525 --until 20250530
+npx ccusage daily --json  # JSON output
+npx ccusage daily --breakdown  # Per-model cost breakdown
+npx ccusage daily --timezone UTC  # Use UTC timezone
+npx ccusage daily --locale ja-JP  # Use Japanese locale for date/time formatting
 
 # Project analysis
-ccusage daily --instances  # Group by project/instance
-ccusage daily --project myproject  # Filter to specific project
-ccusage daily --instances --project myproject --json  # Combined usage
+npx ccusage daily --instances  # Group by project/instance
+npx ccusage daily --project myproject  # Filter to specific project
+npx ccusage daily --instances --project myproject --json  # Combined usage
 
 # Compact mode for screenshots/sharing
-ccusage --compact  # Force compact table mode
-ccusage monthly --compact  # Compact monthly report
+npx ccusage --compact  # Force compact table mode
+npx ccusage monthly --compact  # Compact monthly report
+
+# MCP Server (Model Context Protocol)
+npx @ccusage/mcp@latest  # Run MCP server for Claude Desktop integration
 ```
 
 ## Features

package/config-schema.json

@@ -657,39 +657,6 @@
 							},
 							"additionalProperties": false
 						},
-						"mcp": {
-							"type": "object",
-							"properties": {
-								"mode": {
-									"type": "string",
-									"enum": [
-										"auto",
-										"calculate",
-										"display"
-									],
-									"description": "Cost calculation mode: auto (use costUSD if exists, otherwise calculate), calculate (always calculate), display (always use costUSD)",
-									"markdownDescription": "Cost calculation mode: auto (use costUSD if exists, otherwise calculate), calculate (always calculate), display (always use costUSD)",
-									"default": "auto"
-								},
-								"type": {
-									"type": "string",
-									"enum": [
-										"stdio",
-										"http"
-									],
-									"description": "Transport type for MCP server",
-									"markdownDescription": "Transport type for MCP server",
-									"default": "stdio"
-								},
-								"port": {
-									"type": "number",
-									"description": "Port for HTTP transport (default: 8080)",
-									"markdownDescription": "Port for HTTP transport (default: 8080)",
-									"default": 8080
-								}
-							},
-							"additionalProperties": false
-						},
 						"statusline": {
 							"type": "object",
 							"properties": {

package/dist/_types-CV6z8-9_.js

@@ -0,0 +1,583 @@
+function getTotalTokens(tokenCounts) {
+	const cacheCreation = "cacheCreationInputTokens" in tokenCounts ? tokenCounts.cacheCreationInputTokens : tokenCounts.cacheCreationTokens;
+	const cacheRead = "cacheReadInputTokens" in tokenCounts ? tokenCounts.cacheReadInputTokens : tokenCounts.cacheReadTokens;
+	return tokenCounts.inputTokens + tokenCounts.outputTokens + cacheCreation + cacheRead;
+}
+var store;
+/* @__NO_SIDE_EFFECTS__ */
+function getGlobalConfig(config2) {
+	return {
+		lang: config2?.lang ?? store?.lang,
+		message: config2?.message,
+		abortEarly: config2?.abortEarly ?? store?.abortEarly,
+		abortPipeEarly: config2?.abortPipeEarly ?? store?.abortPipeEarly
+	};
+}
+var store2;
+/* @__NO_SIDE_EFFECTS__ */
+function getGlobalMessage(lang) {
+	return store2?.get(lang);
+}
+var store3;
+/* @__NO_SIDE_EFFECTS__ */
+function getSchemaMessage(lang) {
+	return store3?.get(lang);
+}
+var store4;
+/* @__NO_SIDE_EFFECTS__ */
+function getSpecificMessage(reference, lang) {
+	return store4?.get(reference)?.get(lang);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _stringify(input) {
+	const type = typeof input;
+	if (type === "string") return `"${input}"`;
+	if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
+	if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+	return type;
+}
+function _addIssue(context, label, dataset, config2, other) {
+	const input = other && "input" in other ? other.input : dataset.value;
+	const expected = other?.expected ?? context.expects ?? null;
+	const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+	const issue = {
+		kind: context.kind,
+		type: context.type,
+		input,
+		expected,
+		received,
+		message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+		requirement: context.requirement,
+		path: other?.path,
+		issues: other?.issues,
+		lang: config2.lang,
+		abortEarly: config2.abortEarly,
+		abortPipeEarly: config2.abortPipeEarly
+	};
+	const isSchema = context.kind === "schema";
+	const message2 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config2.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+	if (message2 !== void 0) issue.message = typeof message2 === "function" ? message2(issue) : message2;
+	if (isSchema) dataset.typed = false;
+	if (dataset.issues) dataset.issues.push(issue);
+	else dataset.issues = [issue];
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _getStandardProps(context) {
+	return {
+		version: 1,
+		vendor: "valibot",
+		validate(value2) {
+			return context["~run"]({ value: value2 }, /* @__PURE__ */ getGlobalConfig());
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _joinExpects(values2, separator) {
+	const list = [...new Set(values2)];
+	if (list.length > 1) return `(${list.join(` ${separator} `)})`;
+	return list[0] ?? "never";
+}
+/* @__NO_SIDE_EFFECTS__ */
+function getDotPath(issue) {
+	if (issue.path) {
+		let key = "";
+		for (const item of issue.path) if (typeof item.key === "string" || typeof item.key === "number") if (key) key += `.${item.key}`;
+		else key += item.key;
+		else return null;
+		return key;
+	}
+	return null;
+}
+var ValiError = class extends Error {
+	constructor(issues) {
+		super(issues[0].message);
+		this.name = "ValiError";
+		this.issues = issues;
+	}
+};
+/* @__NO_SIDE_EFFECTS__ */
+function brand(name) {
+	return {
+		kind: "transformation",
+		type: "brand",
+		reference: brand,
+		async: false,
+		name,
+		"~run"(dataset) {
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function check(requirement, message2) {
+	return {
+		kind: "validation",
+		type: "check",
+		reference: check,
+		async: false,
+		expects: null,
+		requirement,
+		message: message2,
+		"~run"(dataset, config2) {
+			if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "input", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function integer(message2) {
+	return {
+		kind: "validation",
+		type: "integer",
+		reference: integer,
+		async: false,
+		expects: null,
+		requirement: Number.isInteger,
+		message: message2,
+		"~run"(dataset, config2) {
+			if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "integer", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function maxValue(requirement, message2) {
+	return {
+		kind: "validation",
+		type: "max_value",
+		reference: maxValue,
+		async: false,
+		expects: `<=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
+		requirement,
+		message: message2,
+		"~run"(dataset, config2) {
+			if (dataset.typed && !(dataset.value <= this.requirement)) _addIssue(this, "value", dataset, config2, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function minLength(requirement, message2) {
+	return {
+		kind: "validation",
+		type: "min_length",
+		reference: minLength,
+		async: false,
+		expects: `>=${requirement}`,
+		requirement,
+		message: message2,
+		"~run"(dataset, config2) {
+			if (dataset.typed && dataset.value.length < this.requirement) _addIssue(this, "length", dataset, config2, { received: `${dataset.value.length}` });
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function minValue(requirement, message2) {
+	return {
+		kind: "validation",
+		type: "min_value",
+		reference: minValue,
+		async: false,
+		expects: `>=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
+		requirement,
+		message: message2,
+		"~run"(dataset, config2) {
+			if (dataset.typed && !(dataset.value >= this.requirement)) _addIssue(this, "value", dataset, config2, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function regex(requirement, message2) {
+	return {
+		kind: "validation",
+		type: "regex",
+		reference: regex,
+		async: false,
+		expects: `${requirement}`,
+		requirement,
+		message: message2,
+		"~run"(dataset, config2) {
+			if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "format", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function transform(operation) {
+	return {
+		kind: "transformation",
+		type: "transform",
+		reference: transform,
+		async: false,
+		operation,
+		"~run"(dataset) {
+			dataset.value = this.operation(dataset.value);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function trim() {
+	return {
+		kind: "transformation",
+		type: "trim",
+		reference: trim,
+		async: false,
+		"~run"(dataset) {
+			dataset.value = dataset.value.trim();
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function getFallback(schema, dataset, config2) {
+	return typeof schema.fallback === "function" ? schema.fallback(dataset, config2) : schema.fallback;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function flatten(issues) {
+	const flatErrors = {};
+	for (const issue of issues) if (issue.path) {
+		const dotPath = /* @__PURE__ */ getDotPath(issue);
+		if (dotPath) {
+			if (!flatErrors.nested) flatErrors.nested = {};
+			if (flatErrors.nested[dotPath]) flatErrors.nested[dotPath].push(issue.message);
+			else flatErrors.nested[dotPath] = [issue.message];
+		} else if (flatErrors.other) flatErrors.other.push(issue.message);
+		else flatErrors.other = [issue.message];
+	} else if (flatErrors.root) flatErrors.root.push(issue.message);
+	else flatErrors.root = [issue.message];
+	return flatErrors;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function getDefault(schema, dataset, config2) {
+	return typeof schema.default === "function" ? schema.default(dataset, config2) : schema.default;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function array(item, message2) {
+	return {
+		kind: "schema",
+		type: "array",
+		reference: array,
+		expects: "Array",
+		async: false,
+		item,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			const input = dataset.value;
+			if (Array.isArray(input)) {
+				dataset.typed = true;
+				dataset.value = [];
+				for (let key = 0; key < input.length; key++) {
+					const value2 = input[key];
+					const itemDataset = this.item["~run"]({ value: value2 }, config2);
+					if (itemDataset.issues) {
+						const pathItem = {
+							type: "array",
+							origin: "value",
+							input,
+							key,
+							value: value2
+						};
+						for (const issue of itemDataset.issues) {
+							if (issue.path) issue.path.unshift(pathItem);
+							else issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = itemDataset.issues;
+						if (config2.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					if (!itemDataset.typed) dataset.typed = false;
+					dataset.value.push(itemDataset.value);
+				}
+			} else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function boolean(message2) {
+	return {
+		kind: "schema",
+		type: "boolean",
+		reference: boolean,
+		expects: "boolean",
+		async: false,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (typeof dataset.value === "boolean") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function number(message2) {
+	return {
+		kind: "schema",
+		type: "number",
+		reference: number,
+		expects: "number",
+		async: false,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function object(entries2, message2) {
+	return {
+		kind: "schema",
+		type: "object",
+		reference: object,
+		expects: "Object",
+		async: false,
+		entries: entries2,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			const input = dataset.value;
+			if (input && typeof input === "object") {
+				dataset.typed = true;
+				dataset.value = {};
+				for (const key in this.entries) {
+					const valueSchema = this.entries[key];
+					if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+						const value2 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+						const valueDataset = valueSchema["~run"]({ value: value2 }, config2);
+						if (valueDataset.issues) {
+							const pathItem = {
+								type: "object",
+								origin: "value",
+								input,
+								key,
+								value: value2
+							};
+							for (const issue of valueDataset.issues) {
+								if (issue.path) issue.path.unshift(pathItem);
+								else issue.path = [pathItem];
+								dataset.issues?.push(issue);
+							}
+							if (!dataset.issues) dataset.issues = valueDataset.issues;
+							if (config2.abortEarly) {
+								dataset.typed = false;
+								break;
+							}
+						}
+						if (!valueDataset.typed) dataset.typed = false;
+						dataset.value[key] = valueDataset.value;
+					} else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+					else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+						_addIssue(this, "key", dataset, config2, {
+							input: void 0,
+							expected: `"${key}"`,
+							path: [{
+								type: "object",
+								origin: "key",
+								input,
+								key,
+								value: input[key]
+							}]
+						});
+						if (config2.abortEarly) break;
+					}
+				}
+			} else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function optional(wrapped, default_) {
+	return {
+		kind: "schema",
+		type: "optional",
+		reference: optional,
+		expects: `(${wrapped.expects} | undefined)`,
+		async: false,
+		wrapped,
+		default: default_,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (dataset.value === void 0) {
+				if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config2);
+				if (dataset.value === void 0) {
+					dataset.typed = true;
+					return dataset;
+				}
+			}
+			return this.wrapped["~run"](dataset, config2);
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function string(message2) {
+	return {
+		kind: "schema",
+		type: "string",
+		reference: string,
+		expects: "string",
+		async: false,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (typeof dataset.value === "string") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _subIssues(datasets) {
+	let issues;
+	if (datasets) for (const dataset of datasets) if (issues) issues.push(...dataset.issues);
+	else issues = dataset.issues;
+	return issues;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function union(options, message2) {
+	return {
+		kind: "schema",
+		type: "union",
+		reference: union,
+		expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
+		async: false,
+		options,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			let validDataset;
+			let typedDatasets;
+			let untypedDatasets;
+			for (const schema of this.options) {
+				const optionDataset = schema["~run"]({ value: dataset.value }, config2);
+				if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
+				else typedDatasets = [optionDataset];
+				else {
+					validDataset = optionDataset;
+					break;
+				}
+				else if (untypedDatasets) untypedDatasets.push(optionDataset);
+				else untypedDatasets = [optionDataset];
+			}
+			if (validDataset) return validDataset;
+			if (typedDatasets) {
+				if (typedDatasets.length === 1) return typedDatasets[0];
+				_addIssue(this, "type", dataset, config2, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
+				dataset.typed = true;
+			} else if (untypedDatasets?.length === 1) return untypedDatasets[0];
+			else _addIssue(this, "type", dataset, config2, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
+			return dataset;
+		}
+	};
+}
+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 {
+		...pipe2[0],
+		pipe: pipe2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			for (const item of pipe2) if (item.kind !== "metadata") {
+				if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+					dataset.typed = false;
+					break;
+				}
+				if (!dataset.issues || !config2.abortEarly && !config2.abortPipeEarly) dataset = item["~run"](dataset, config2);
+			}
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function safeParse(schema, input, config2) {
+	const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config2));
+	return {
+		typed: dataset.typed,
+		success: !dataset.issues,
+		output: dataset.value,
+		issues: dataset.issues
+	};
+}
+const modelNameSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ minLength(1, "Model name cannot be empty"), /* @__PURE__ */ brand("ModelName"));
+const sessionIdSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ minLength(1, "Session ID cannot be empty"), /* @__PURE__ */ brand("SessionId"));
+const requestIdSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ minLength(1, "Request ID cannot be empty"), /* @__PURE__ */ brand("RequestId"));
+const messageIdSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ minLength(1, "Message ID cannot be empty"), /* @__PURE__ */ brand("MessageId"));
+const isoTimestampSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/, "Invalid ISO timestamp"), /* @__PURE__ */ brand("ISOTimestamp"));
+const yyyymmddRegex = /^\d{4}-\d{2}-\d{2}$/;
+const dailyDateSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ regex(yyyymmddRegex, "Date must be in YYYY-MM-DD format"), /* @__PURE__ */ brand("DailyDate"));
+const activityDateSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ regex(yyyymmddRegex, "Date must be in YYYY-MM-DD format"), /* @__PURE__ */ brand("ActivityDate"));
+const monthlyDateSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ regex(/^\d{4}-\d{2}$/, "Date must be in YYYY-MM format"), /* @__PURE__ */ brand("MonthlyDate"));
+const weeklyDateSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ regex(yyyymmddRegex, "Date must be in YYYY-MM-DD format"), /* @__PURE__ */ brand("WeeklyDate"));
+const filterDateSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ regex(/^\d{8}$/, "Date must be in YYYYMMDD format"), /* @__PURE__ */ brand("FilterDate"));
+const projectPathSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ minLength(1, "Project path cannot be empty"), /* @__PURE__ */ brand("ProjectPath"));
+const versionSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ regex(/^\d+\.\d+\.\d+/, "Invalid version format"), /* @__PURE__ */ brand("Version"));
+const createSessionId = (value) => parse(sessionIdSchema, value);
+const createDailyDate = (value) => parse(dailyDateSchema, value);
+const createMonthlyDate = (value) => parse(monthlyDateSchema, value);
+const createWeeklyDate = (value) => parse(weeklyDateSchema, value);
+const createProjectPath = (value) => parse(projectPathSchema, value);
+function createBucket(value) {
+	const weeklyResult = /* @__PURE__ */ safeParse(weeklyDateSchema, value);
+	if (weeklyResult.success) return weeklyResult.output;
+	return createMonthlyDate(value);
+}
+const CostModes = [
+	"auto",
+	"calculate",
+	"display"
+];
+const SortOrders = ["desc", "asc"];
+const statuslineHookJsonSchema = /* @__PURE__ */ object({
+	session_id: /* @__PURE__ */ string(),
+	transcript_path: /* @__PURE__ */ string(),
+	cwd: /* @__PURE__ */ string(),
+	model: /* @__PURE__ */ object({
+		id: /* @__PURE__ */ string(),
+		display_name: /* @__PURE__ */ string()
+	}),
+	workspace: /* @__PURE__ */ object({
+		current_dir: /* @__PURE__ */ string(),
+		project_dir: /* @__PURE__ */ string()
+	}),
+	version: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	cost: /* @__PURE__ */ optional(/* @__PURE__ */ object({
+		total_cost_usd: /* @__PURE__ */ number(),
+		total_duration_ms: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+		total_api_duration_ms: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+		total_lines_added: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+		total_lines_removed: /* @__PURE__ */ optional(/* @__PURE__ */ number())
+	}))
+});
+export { CostModes, SortOrders, activityDateSchema, array, boolean, check, createBucket, createDailyDate, createMonthlyDate, createProjectPath, createSessionId, createWeeklyDate, dailyDateSchema, filterDateSchema, flatten, getTotalTokens, integer, isoTimestampSchema, maxValue, messageIdSchema, minValue, modelNameSchema, monthlyDateSchema, number, object, optional, parse, pipe, projectPathSchema, requestIdSchema, safeParse, sessionIdSchema, statuslineHookJsonSchema, string, transform, trim, union, versionSchema, weeklyDateSchema };

package/dist/{calculate-cost-BDqO4yWA.js → calculate-cost-CX9KwEZt.js}

@@ -1,4 +1,4 @@
-import { getTotalTokens } from "./_token-utils-WjkbrjKv.js";
+import { getTotalTokens } from "./_types-CV6z8-9_.js";
 function calculateTotals(data) {
 	return data.reduce((acc, item) => ({
 		inputTokens: acc.inputTokens + item.inputTokens,