ccusage 9.0.0 → 10.0.0

package/README.md

@@ -45,10 +45,12 @@ This tool helps you understand the value you're getting from your subscription b
 - 📊 **Model Breakdown**: View per-model cost breakdown with `--breakdown` flag
 - 📅 **Date Filtering**: Filter reports by date range using `--since` and `--until`
 - 📁 **Custom Path**: Support for custom Claude data directory locations
-- 🎨 **Beautiful Output**: Colorful table-formatted display
+- 🎨 **Beautiful Output**: Colorful table-formatted display with responsive width adjustment
 - 📄 **JSON Output**: Export data in structured JSON format with `--json`
 - 💰 **Cost Tracking**: Shows costs in USD for each day/month/session
 - 🔄 **Cache Token Support**: Tracks and displays cache creation and cache read tokens separately
+- 🌐 **Offline Mode**: Use pre-cached pricing data without network connectivity with `--offline` (Claude models only)
+- 📏 **Responsive Tables**: Automatic table width adjustment for narrow terminals with intelligent word wrapping
 
 ## Important Disclaimer
 
@@ -147,6 +149,10 @@ ccusage daily --order desc      # Show newest dates first (default)
 
 # Show per-model cost breakdown
 ccusage daily --breakdown       # Show cost breakdown by model (opus-4, sonnet-4, etc.)
+
+# Use offline mode (no network required)
+ccusage daily --offline         # Use pre-cached pricing data
+ccusage daily -O                # Short alias for --offline
 ```
 
 `ccusage` is an alias for `ccusage daily`, so you can run it without specifying the subcommand.
@@ -183,6 +189,10 @@ ccusage monthly --order desc      # Show newest months first (default)
 
 # Show per-model cost breakdown
 ccusage monthly --breakdown       # Show cost breakdown by model
+
+# Use offline mode (no network required)
+ccusage monthly --offline         # Use pre-cached pricing data
+ccusage monthly -O                # Short alias for --offline
 ```
 
 ### Session Report
@@ -214,8 +224,61 @@ ccusage session --order desc      # Show newest sessions first (default)
 
 # Show per-model cost breakdown
 ccusage session --breakdown       # Show cost breakdown by model
+
+# Use offline mode (no network required)
+ccusage session --offline         # Use pre-cached pricing data
+ccusage session -O                # Short alias for --offline
 ```
 
+### 5-Hour Blocks Report
+
+Shows usage grouped by Claude's 5-hour billing windows:
+
+```bash
+# Show all 5-hour blocks
+ccusage blocks
+
+# Show only the active block with detailed projections
+ccusage blocks --active
+
+# Show blocks from the last 3 days (including active)
+ccusage blocks --recent
+
+# Set a token limit to see if you'll exceed it
+ccusage blocks -t 500000
+
+# Use the highest previous block as the token limit
+ccusage blocks -t max
+
+# Combine options
+ccusage blocks --recent -t max
+
+# Output in JSON format
+ccusage blocks --json
+
+# Control cost calculation mode
+ccusage blocks --mode auto       # Use costUSD when available, calculate otherwise (default)
+ccusage blocks --mode calculate  # Always calculate costs from tokens
+ccusage blocks --mode display    # Always show pre-calculated costUSD values
+
+# Control sort order
+ccusage blocks --order asc       # Show oldest blocks first
+ccusage blocks --order desc      # Show newest blocks first (default)
+```
+
+The blocks report helps you understand Claude Code's 5-hour rolling session windows:
+
+- Sessions start with your first message and last for 5 hours
+- Shows active blocks with time remaining and burn rate projections
+- Helps track if you're approaching token limits within a session
+- The `-t max` option automatically uses your highest previous block as the limit
+
+#### Blocks-specific options:
+
+- `-t, --token-limit <number|max>`: Set token limit for quota warnings (use "max" for highest previous block)
+- `-a, --active`: Show only active block with detailed projections
+- `-r, --recent`: Show blocks from last 3 days (including active)
+
 ### Options
 
 All commands support the following options:
@@ -226,6 +289,7 @@ All commands support the following options:
 - `-m, --mode <mode>`: Cost calculation mode: `auto` (default), `calculate`, or `display`
 - `-o, --order <order>`: Sort order: `desc` (newest first, default) or `asc` (oldest first).
 - `-b, --breakdown`: Show per-model cost breakdown (splits usage by Opus, Sonnet, etc.)
+- `-O, --offline`: Use pre-cached pricing data for Claude models (no network connection required)
 - `-d, --debug`: Show pricing mismatch information for debugging
 - `--debug-samples <number>`: Number of sample discrepancies to show in debug output (default: 5)
 - `-h, --help`: Display help message

package/dist/calculate-cost.d.ts

@@ -1,5 +1,5 @@
 import "./pricing-fetcher-BkSZh4lR.js";
-import { DailyUsage, MonthlyUsage, SessionUsage } from "./data-loader-OGaMjZTD.js";
+import { DailyUsage, MonthlyUsage, SessionUsage } from "./data-loader-DPQaq8_n.js";
 
 //#region src/calculate-cost.d.ts
 type TokenData = {

package/dist/{data-loader-Ca8k_uX0.js → data-loader-Bp9KV0_a.js}

@@ -1,7 +1,7 @@
 import { __commonJS, __require, __toESM } from "./chunk-BLXvPPr8.js";
 import { array, number, object, optional, pipe, regex, safeParse, string } from "./dist-DCvt9hEv.js";
-import { logger } from "./logger-DKw-DPXD.js";
-import { PricingFetcher } from "./pricing-fetcher-BlxDpqFj.js";
+import { logger } from "./logger-C2GZVy1v.js";
+import { PricingFetcher } from "./pricing-fetcher-BxlbW4km.js";
 import fsPromises, { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
@@ -3041,6 +3041,144 @@ async function glob(patternsOrOptions, options) {
 	return crawl(opts, cwd, false);
 }
 
+//#endregion
+//#region src/five-hour-blocks.internal.ts
+const FIVE_HOURS_MS = 5 * 60 * 60 * 1e3;
+const DEFAULT_RECENT_DAYS = 3;
+function identifyFiveHourBlocks(entries) {
+	if (entries.length === 0) return [];
+	const blocks = [];
+	const sortedEntries = [...entries].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+	let currentBlockStart = null;
+	let currentBlockEntries = [];
+	const now = /* @__PURE__ */ new Date();
+	for (const entry of sortedEntries) {
+		const entryTime = entry.timestamp;
+		if (currentBlockStart == null) {
+			currentBlockStart = entryTime;
+			currentBlockEntries = [entry];
+		} else {
+			const timeSinceBlockStart = entryTime.getTime() - currentBlockStart.getTime();
+			const lastEntry = currentBlockEntries.at(-1);
+			if (lastEntry == null) continue;
+			const lastEntryTime = lastEntry.timestamp;
+			const timeSinceLastEntry = entryTime.getTime() - lastEntryTime.getTime();
+			if (timeSinceBlockStart > FIVE_HOURS_MS || timeSinceLastEntry > FIVE_HOURS_MS) {
+				const block = createBlock(currentBlockStart, currentBlockEntries, now);
+				blocks.push(block);
+				if (timeSinceLastEntry > FIVE_HOURS_MS) {
+					const gapBlock = createGapBlock(lastEntryTime, entryTime);
+					if (gapBlock != null) blocks.push(gapBlock);
+				}
+				currentBlockStart = entryTime;
+				currentBlockEntries = [entry];
+			} else currentBlockEntries.push(entry);
+		}
+	}
+	if (currentBlockStart != null && currentBlockEntries.length > 0) {
+		const block = createBlock(currentBlockStart, currentBlockEntries, now);
+		blocks.push(block);
+	}
+	return blocks;
+}
+function createBlock(startTime, entries, now) {
+	const endTime = new Date(startTime.getTime() + FIVE_HOURS_MS);
+	const lastEntry = entries[entries.length - 1];
+	const actualEndTime = lastEntry != null ? lastEntry.timestamp : startTime;
+	const isActive = now.getTime() - actualEndTime.getTime() < FIVE_HOURS_MS && now < endTime;
+	const tokenCounts = {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheCreationInputTokens: 0,
+		cacheReadInputTokens: 0
+	};
+	let costUSD = 0;
+	const modelsSet = /* @__PURE__ */ new Set();
+	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 != null ? entry.costUSD : 0;
+		modelsSet.add(entry.model);
+	}
+	return {
+		id: startTime.toISOString(),
+		startTime,
+		endTime,
+		actualEndTime,
+		isActive,
+		entries,
+		tokenCounts,
+		costUSD,
+		models: Array.from(modelsSet)
+	};
+}
+function createGapBlock(lastActivityTime, nextActivityTime) {
+	const gapDuration = nextActivityTime.getTime() - lastActivityTime.getTime();
+	if (gapDuration <= FIVE_HOURS_MS) return null;
+	const gapStart = new Date(lastActivityTime.getTime() + FIVE_HOURS_MS);
+	const gapEnd = nextActivityTime;
+	return {
+		id: `gap-${gapStart.toISOString()}`,
+		startTime: gapStart,
+		endTime: gapEnd,
+		isActive: false,
+		isGap: true,
+		entries: [],
+		tokenCounts: {
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheCreationInputTokens: 0,
+			cacheReadInputTokens: 0
+		},
+		costUSD: 0,
+		models: []
+	};
+}
+function calculateBurnRate(block) {
+	if (block.entries.length === 0 || (block.isGap ?? false)) return null;
+	const firstEntryData = block.entries[0];
+	const lastEntryData = block.entries[block.entries.length - 1];
+	if (firstEntryData == null || lastEntryData == null) return null;
+	const firstEntry = firstEntryData.timestamp;
+	const lastEntry = lastEntryData.timestamp;
+	const durationMinutes = (lastEntry.getTime() - firstEntry.getTime()) / (1e3 * 60);
+	if (durationMinutes <= 0) return null;
+	const totalTokens = block.tokenCounts.inputTokens + block.tokenCounts.outputTokens;
+	const tokensPerMinute = totalTokens / durationMinutes;
+	const costPerHour = block.costUSD / durationMinutes * 60;
+	return {
+		tokensPerMinute,
+		costPerHour
+	};
+}
+function projectBlockUsage(block) {
+	if (!block.isActive || (block.isGap ?? false)) return null;
+	const burnRate = calculateBurnRate(block);
+	if (burnRate == null) return null;
+	const now = /* @__PURE__ */ new Date();
+	const remainingTime = block.endTime.getTime() - now.getTime();
+	const remainingMinutes = Math.max(0, remainingTime / (1e3 * 60));
+	const currentTokens = block.tokenCounts.inputTokens + block.tokenCounts.outputTokens;
+	const projectedAdditionalTokens = burnRate.tokensPerMinute * remainingMinutes;
+	const totalTokens = currentTokens + projectedAdditionalTokens;
+	const projectedAdditionalCost = burnRate.costPerHour / 60 * remainingMinutes;
+	const totalCost = block.costUSD + projectedAdditionalCost;
+	return {
+		totalTokens: Math.round(totalTokens),
+		totalCost: Math.round(totalCost * 100) / 100,
+		remainingMinutes: Math.round(remainingMinutes)
+	};
+}
+function filterRecentBlocks(blocks, days = DEFAULT_RECENT_DAYS) {
+	const now = /* @__PURE__ */ new Date();
+	const cutoffTime = new Date(now.getTime() - days * 24 * 60 * 60 * 1e3);
+	return blocks.filter((block) => {
+		return block.startTime >= cutoffTime || block.isActive;
+	});
+}
+
 //#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) {
@@ -3553,6 +3691,63 @@ async function loadMonthlyUsageData(options) {
 	}
 	return sortByDate(monthlyArray, (item) => `${item.month}-01`, options?.order);
 }
+async function loadFiveHourBlockData(options) {
+	try {
+		var _usingCtx4 = (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 sortedFiles = await sortFilesByTimestamp(files);
+		const mode = options?.mode ?? "auto";
+		const fetcher = _usingCtx4.u(mode === "display" ? null : new PricingFetcher());
+		const processedHashes = /* @__PURE__ */ new Set();
+		const allEntries = [];
+		for (const file of sortedFiles) {
+			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 uniqueHash = createUniqueHash(data);
+				if (isDuplicateEntry(uniqueHash, processedHashes)) continue;
+				markAsProcessed(uniqueHash, processedHashes);
+				const cost = fetcher != null ? await calculateCostForEntry(data, mode, fetcher) : data.costUSD ?? 0;
+				allEntries.push({
+					timestamp: new Date(data.timestamp),
+					usage: {
+						inputTokens: data.message.usage.input_tokens,
+						outputTokens: data.message.usage.output_tokens,
+						cacheCreationInputTokens: data.message.usage.cache_creation_input_tokens ?? 0,
+						cacheReadInputTokens: data.message.usage.cache_read_input_tokens ?? 0
+					},
+					costUSD: cost,
+					model: data.message.model ?? "unknown",
+					version: data.version
+				});
+			} catch (error) {
+				logger.debug(`Skipping invalid JSON line in 5-hour blocks: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+		const blocks = identifyFiveHourBlocks(allEntries);
+		const filtered = options?.since != null && options.since !== "" || options?.until != null && options.until !== "" ? blocks.filter((block) => {
+			const blockDateStr = formatDate(block.startTime.toISOString()).replace(/-/g, "");
+			if (options.since != null && options.since !== "" && blockDateStr < options.since) return false;
+			if (options.until != null && options.until !== "" && blockDateStr > options.until) return false;
+			return true;
+		}) : blocks;
+		return sortByDate(filtered, (block) => block.startTime, options?.order);
+	} catch (_) {
+		_usingCtx4.e = _;
+	} finally {
+		_usingCtx4.d();
+	}
+}
 
 //#endregion
-export { DailyUsageSchema, ModelBreakdownSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, createUniqueHash, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, glob, loadDailyUsageData, loadMonthlyUsageData, loadSessionData, require_usingCtx, sortFilesByTimestamp };
+export { DailyUsageSchema, ModelBreakdownSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateBurnRate, calculateCostForEntry, createUniqueHash, filterRecentBlocks, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, glob, loadDailyUsageData, loadFiveHourBlockData, loadMonthlyUsageData, loadSessionData, projectBlockUsage, require_usingCtx, sortFilesByTimestamp };

package/dist/{data-loader-OGaMjZTD.d.ts → data-loader-DPQaq8_n.d.ts}

@@ -1,7 +1,38 @@
 import { ArraySchema, CostMode, InferOutput, NumberSchema, ObjectSchema, OptionalSchema, PricingFetcher, RegexAction, SchemaWithPipe, SortOrder, StringSchema } from "./pricing-fetcher-BkSZh4lR.js";
 
+//#region src/five-hour-blocks.internal.d.ts
+type LoadedUsageEntry = {
+  timestamp: Date;
+  usage: {
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationInputTokens: number;
+    cacheReadInputTokens: number;
+  };
+  costUSD: number | null;
+  model: string;
+  version?: string;
+};
+type TokenCounts = {
+  inputTokens: number;
+  outputTokens: number;
+  cacheCreationInputTokens: number;
+  cacheReadInputTokens: number;
+};
+type FiveHourBlock = {
+  id: string;
+  startTime: Date;
+  endTime: Date;
+  actualEndTime?: Date;
+  isActive: boolean;
+  isGap?: boolean;
+  entries: LoadedUsageEntry[];
+  tokenCounts: TokenCounts;
+  costUSD: number;
+  models: string[];
+};
+//#endregion
 //#region src/data-loader.d.ts
-
 /**
  * Default path for Claude data directory
  * Uses environment variable CLAUDE_CONFIG_DIR if set, otherwise defaults to ~/.claude
@@ -120,5 +151,6 @@ type LoadOptions = {
 declare function loadDailyUsageData(options?: LoadOptions): Promise<DailyUsage[]>;
 declare function loadSessionData(options?: LoadOptions): Promise<SessionUsage[]>;
 declare function loadMonthlyUsageData(options?: LoadOptions): Promise<MonthlyUsage[]>;
+declare function loadFiveHourBlockData(options?: LoadOptions): Promise<FiveHourBlock[]>;
 //#endregion
-export { DailyUsage, DailyUsageSchema, DateFilter, LoadOptions, ModelBreakdown, ModelBreakdownSchema, MonthlyUsage, MonthlyUsageSchema, SessionUsage, SessionUsageSchema, UsageData, UsageDataSchema, calculateCostForEntry, createUniqueHash, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionData, sortFilesByTimestamp };
+export { DailyUsage, DailyUsageSchema, DateFilter, LoadOptions, ModelBreakdown, ModelBreakdownSchema, MonthlyUsage, MonthlyUsageSchema, SessionUsage, SessionUsageSchema, UsageData, UsageDataSchema, calculateCostForEntry, createUniqueHash, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadFiveHourBlockData, loadMonthlyUsageData, loadSessionData, sortFilesByTimestamp };

package/dist/data-loader.d.ts

@@ -1,3 +1,3 @@
 import "./pricing-fetcher-BkSZh4lR.js";
-import { DailyUsage, DailyUsageSchema, DateFilter, LoadOptions, ModelBreakdown, ModelBreakdownSchema, MonthlyUsage, MonthlyUsageSchema, SessionUsage, SessionUsageSchema, UsageData, UsageDataSchema, calculateCostForEntry, createUniqueHash, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionData, sortFilesByTimestamp } from "./data-loader-OGaMjZTD.js";
-export { DailyUsage, DailyUsageSchema, DateFilter, LoadOptions, ModelBreakdown, ModelBreakdownSchema, MonthlyUsage, MonthlyUsageSchema, SessionUsage, SessionUsageSchema, UsageData, UsageDataSchema, calculateCostForEntry, createUniqueHash, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionData, sortFilesByTimestamp };
+import { DailyUsage, DailyUsageSchema, DateFilter, LoadOptions, ModelBreakdown, ModelBreakdownSchema, MonthlyUsage, MonthlyUsageSchema, SessionUsage, SessionUsageSchema, UsageData, UsageDataSchema, calculateCostForEntry, createUniqueHash, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadFiveHourBlockData, loadMonthlyUsageData, loadSessionData, sortFilesByTimestamp } from "./data-loader-DPQaq8_n.js";
+export { DailyUsage, DailyUsageSchema, DateFilter, LoadOptions, ModelBreakdown, ModelBreakdownSchema, MonthlyUsage, MonthlyUsageSchema, SessionUsage, SessionUsageSchema, UsageData, UsageDataSchema, calculateCostForEntry, createUniqueHash, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadFiveHourBlockData, loadMonthlyUsageData, loadSessionData, sortFilesByTimestamp };

package/dist/data-loader.js

@@ -1,6 +1,6 @@
-import { DailyUsageSchema, ModelBreakdownSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, createUniqueHash, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionData, sortFilesByTimestamp } from "./data-loader-Ca8k_uX0.js";
+import { DailyUsageSchema, ModelBreakdownSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, createUniqueHash, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadFiveHourBlockData, loadMonthlyUsageData, loadSessionData, sortFilesByTimestamp } from "./data-loader-Bp9KV0_a.js";
 import "./dist-DCvt9hEv.js";
-import "./logger-DKw-DPXD.js";
-import "./pricing-fetcher-BlxDpqFj.js";
+import "./logger-C2GZVy1v.js";
+import "./pricing-fetcher-BxlbW4km.js";
 
-export { DailyUsageSchema, ModelBreakdownSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, createUniqueHash, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadMonthlyUsageData, loadSessionData, sortFilesByTimestamp };
+export { DailyUsageSchema, ModelBreakdownSchema, MonthlyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, createUniqueHash, formatDate, formatDateCompact, getDefaultClaudePath, getEarliestTimestamp, loadDailyUsageData, loadFiveHourBlockData, loadMonthlyUsageData, loadSessionData, sortFilesByTimestamp };

package/dist/{debug-zCcXwR8p.js → debug-bjc38_Gx.js}

@@ -1,8 +1,8 @@
 import { __toESM } from "./chunk-BLXvPPr8.js";
-import { UsageDataSchema, glob, require_usingCtx } from "./data-loader-Ca8k_uX0.js";
+import { UsageDataSchema, glob, require_usingCtx } from "./data-loader-Bp9KV0_a.js";
 import { safeParse } from "./dist-DCvt9hEv.js";
-import { logger } from "./logger-DKw-DPXD.js";
-import { PricingFetcher } from "./pricing-fetcher-BlxDpqFj.js";
+import { logger } from "./logger-C2GZVy1v.js";
+import { PricingFetcher } from "./pricing-fetcher-BxlbW4km.js";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";

package/dist/debug.js

@@ -1,7 +1,7 @@
-import "./data-loader-Ca8k_uX0.js";
+import "./data-loader-Bp9KV0_a.js";
 import "./dist-DCvt9hEv.js";
-import "./logger-DKw-DPXD.js";
-import "./pricing-fetcher-BlxDpqFj.js";
-import { detectMismatches, printMismatchReport } from "./debug-zCcXwR8p.js";
+import "./logger-C2GZVy1v.js";
+import "./pricing-fetcher-BxlbW4km.js";
+import { detectMismatches, printMismatchReport } from "./debug-bjc38_Gx.js";
 
 export { detectMismatches, printMismatchReport };

package/dist/index.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import { __commonJS, __toESM } from "./chunk-BLXvPPr8.js";
 import { calculateTotals, createTotalsObject, getTotalTokens } from "./calculate-cost-2IwHSzmi.js";
-import { formatDateCompact, getDefaultClaudePath, loadDailyUsageData, loadMonthlyUsageData, loadSessionData } from "./data-loader-Ca8k_uX0.js";
+import { calculateBurnRate, filterRecentBlocks, formatDateCompact, getDefaultClaudePath, loadDailyUsageData, loadFiveHourBlockData, loadMonthlyUsageData, loadSessionData, projectBlockUsage } from "./data-loader-Bp9KV0_a.js";
 import { safeParse } from "./dist-DCvt9hEv.js";
-import { description, log, logger, name, version } from "./logger-DKw-DPXD.js";
-import { CostModes, SortOrders, dateSchema } from "./pricing-fetcher-BlxDpqFj.js";
-import { detectMismatches, printMismatchReport } from "./debug-zCcXwR8p.js";
-import { ResponsiveTable } from "./utils.table-DRzF8vZJ.js";
+import { description, log, logger, name, version } from "./logger-C2GZVy1v.js";
+import { CostModes, SortOrders, dateSchema } from "./pricing-fetcher-BxlbW4km.js";
+import { detectMismatches, printMismatchReport } from "./debug-bjc38_Gx.js";
+import { ResponsiveTable } from "./utils.table-USks3NGv.js";
 import "./types-BlyCnKwN.js";
-import { createMcpServer } from "./mcp-BRFYI5rd.js";
+import { createMcpServer } from "./mcp-DVjQeqCy.js";
 import "./index-CISmcbXk-CW1Gj6Ab.js";
 import process$1 from "node:process";
 
@@ -1273,7 +1273,7 @@ const sharedArgs = {
 		type: "boolean",
 		negatable: true,
 		short: "O",
-		description: "Use cached data instead of fetching from API",
+		description: "Use cached pricing data for Claude models instead of fetching from API",
 		default: false
 	}
 };
@@ -1284,7 +1284,7 @@ const sharedCommandConfig = {
 
 //#endregion
 //#region src/utils.internal.ts
-var import_picocolors$3 = __toESM(require_picocolors(), 1);
+var import_picocolors$4 = __toESM(require_picocolors(), 1);
 function formatNumber(num) {
 	return num.toLocaleString("en-US");
 }
@@ -1313,12 +1313,294 @@ function pushBreakdownRows(table, breakdowns, extraColumns = 1, trailingColumns
 		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$3.default.gray(formatNumber(breakdown.inputTokens)), import_picocolors$3.default.gray(formatNumber(breakdown.outputTokens)), import_picocolors$3.default.gray(formatNumber(breakdown.cacheCreationTokens)), import_picocolors$3.default.gray(formatNumber(breakdown.cacheReadTokens)), import_picocolors$3.default.gray(formatNumber(totalTokens)), import_picocolors$3.default.gray(formatCurrency(breakdown.cost)));
+		row.push(import_picocolors$4.default.gray(formatNumber(breakdown.inputTokens)), import_picocolors$4.default.gray(formatNumber(breakdown.outputTokens)), import_picocolors$4.default.gray(formatNumber(breakdown.cacheCreationTokens)), import_picocolors$4.default.gray(formatNumber(breakdown.cacheReadTokens)), import_picocolors$4.default.gray(formatNumber(totalTokens)), import_picocolors$4.default.gray(formatCurrency(breakdown.cost)));
 		for (let i = 0; i < trailingColumns; i++) row.push("");
 		table.push(row);
 	}
 }
 
+//#endregion
+//#region src/commands/blocks.ts
+var import_picocolors$3 = __toESM(require_picocolors(), 1);
+const RECENT_DAYS_DEFAULT = 3;
+const WARNING_THRESHOLD = .8;
+const COMPACT_WIDTH_THRESHOLD = 120;
+const DEFAULT_TERMINAL_WIDTH = 120;
+function formatBlockTime(block, compact = false) {
+	const start = compact ? block.startTime.toLocaleString(void 0, {
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit"
+	}) : block.startTime.toLocaleString();
+	if (block.isGap ?? false) {
+		const end = compact ? block.endTime.toLocaleString(void 0, {
+			hour: "2-digit",
+			minute: "2-digit"
+		}) : block.endTime.toLocaleString();
+		const duration$1 = Math.round((block.endTime.getTime() - block.startTime.getTime()) / (1e3 * 60 * 60));
+		return compact ? `${start}-${end}\n(${duration$1}h gap)` : `${start} - ${end} (${duration$1}h gap)`;
+	}
+	const duration = block.actualEndTime != null ? Math.round((block.actualEndTime.getTime() - block.startTime.getTime()) / (1e3 * 60)) : 0;
+	if (block.isActive) {
+		const now = /* @__PURE__ */ new Date();
+		const elapsed = Math.round((now.getTime() - block.startTime.getTime()) / (1e3 * 60));
+		const remaining = Math.round((block.endTime.getTime() - now.getTime()) / (1e3 * 60));
+		const elapsedHours = Math.floor(elapsed / 60);
+		const elapsedMins = elapsed % 60;
+		const remainingHours = Math.floor(remaining / 60);
+		const remainingMins = remaining % 60;
+		if (compact) return `${start}\n(${elapsedHours}h${elapsedMins}m/${remainingHours}h${remainingMins}m)`;
+		return `${start} (${elapsedHours}h ${elapsedMins}m elapsed, ${remainingHours}h ${remainingMins}m remaining)`;
+	}
+	const hours = Math.floor(duration / 60);
+	const mins = duration % 60;
+	if (compact) return hours > 0 ? `${start}\n(${hours}h${mins}m)` : `${start}\n(${mins}m)`;
+	if (hours > 0) return `${start} (${hours}h ${mins}m)`;
+	return `${start} (${mins}m)`;
+}
+function formatModels(models, compact = false) {
+	if (models.length === 0) return "-";
+	return compact ? formatModelsDisplay(models) : formatModelsDisplay(models);
+}
+function parseTokenLimit(value, maxFromAll) {
+	if (value == null || value === "") return void 0;
+	if (value === "max") return maxFromAll > 0 ? maxFromAll : void 0;
+	const limit = Number.parseInt(value, 10);
+	return Number.isNaN(limit) ? void 0 : limit;
+}
+const blocksCommand = define({
+	name: "blocks",
+	description: "Show usage report grouped by 5-hour billing blocks",
+	args: {
+		...sharedCommandConfig.args,
+		active: {
+			type: "boolean",
+			short: "a",
+			description: "Show only active block with projections",
+			default: false
+		},
+		recent: {
+			type: "boolean",
+			short: "r",
+			description: `Show blocks from last ${RECENT_DAYS_DEFAULT} days (including active)`,
+			default: false
+		},
+		tokenLimit: {
+			type: "string",
+			short: "t",
+			description: "Token limit for quota warnings (e.g., 500000 or \"max\" for highest previous block)"
+		}
+	},
+	toKebab: true,
+	async run(ctx) {
+		if (ctx.values.json) logger.level = 0;
+		let blocks = await loadFiveHourBlockData({
+			since: ctx.values.since,
+			until: ctx.values.until,
+			claudePath: getDefaultClaudePath(),
+			mode: ctx.values.mode,
+			order: ctx.values.order
+		});
+		if (blocks.length === 0) {
+			if (ctx.values.json) log(JSON.stringify({ blocks: [] }));
+			else logger.warn("No Claude usage data found.");
+			process$1.exit(0);
+		}
+		let maxTokensFromAll = 0;
+		if (ctx.values.tokenLimit === "max") {
+			for (const block of blocks) if (!(block.isGap ?? false) && !block.isActive) {
+				const blockTokens = block.tokenCounts.inputTokens + block.tokenCounts.outputTokens;
+				if (blockTokens > maxTokensFromAll) maxTokensFromAll = blockTokens;
+			}
+			if (!ctx.values.json && maxTokensFromAll > 0) logger.info(`Using max tokens from previous sessions: ${formatNumber(maxTokensFromAll)}`);
+		}
+		if (ctx.values.recent) blocks = filterRecentBlocks(blocks, RECENT_DAYS_DEFAULT);
+		if (ctx.values.active) {
+			blocks = blocks.filter((block) => block.isActive);
+			if (blocks.length === 0) {
+				if (ctx.values.json) log(JSON.stringify({
+					blocks: [],
+					message: "No active block"
+				}));
+				else logger.info("No active 5-hour block found.");
+				process$1.exit(0);
+			}
+		}
+		if (ctx.values.json) {
+			const jsonOutput = { blocks: blocks.map((block) => {
+				const burnRate = block.isActive ? calculateBurnRate(block) : null;
+				const projection = block.isActive ? projectBlockUsage(block) : null;
+				return {
+					id: block.id,
+					startTime: block.startTime.toISOString(),
+					endTime: block.endTime.toISOString(),
+					actualEndTime: block.actualEndTime != null ? block.actualEndTime.toISOString() : null,
+					isActive: block.isActive,
+					isGap: block.isGap ?? false,
+					entries: block.entries.length,
+					tokenCounts: block.tokenCounts,
+					totalTokens: block.tokenCounts.inputTokens + block.tokenCounts.outputTokens,
+					costUSD: block.costUSD,
+					models: block.models,
+					burnRate,
+					projection,
+					tokenLimitStatus: projection != null && ctx.values.tokenLimit != null ? (() => {
+						const limit = parseTokenLimit(ctx.values.tokenLimit, maxTokensFromAll);
+						return limit != null ? {
+							limit,
+							projectedUsage: projection.totalTokens,
+							percentUsed: projection.totalTokens / limit * 100,
+							status: projection.totalTokens > limit ? "exceeds" : projection.totalTokens > limit * WARNING_THRESHOLD ? "warning" : "ok"
+						} : void 0;
+					})() : void 0
+				};
+			}) };
+			log(JSON.stringify(jsonOutput, null, 2));
+		} else if (ctx.values.active && blocks.length === 1) {
+			const block = blocks[0];
+			if (block == null) {
+				logger.warn("No active block found.");
+				process$1.exit(0);
+			}
+			const burnRate = calculateBurnRate(block);
+			const projection = projectBlockUsage(block);
+			logger.box("Current 5-Hour Block Status");
+			const now = /* @__PURE__ */ new Date();
+			const elapsed = Math.round((now.getTime() - block.startTime.getTime()) / (1e3 * 60));
+			const remaining = Math.round((block.endTime.getTime() - now.getTime()) / (1e3 * 60));
+			log(`Block Started: ${import_picocolors$3.default.cyan(block.startTime.toLocaleString())} (${import_picocolors$3.default.yellow(`${Math.floor(elapsed / 60)}h ${elapsed % 60}m`)} ago)`);
+			log(`Time Remaining: ${import_picocolors$3.default.green(`${Math.floor(remaining / 60)}h ${remaining % 60}m`)}\n`);
+			log(import_picocolors$3.default.bold("Current Usage:"));
+			log(`  Input Tokens:     ${formatNumber(block.tokenCounts.inputTokens)}`);
+			log(`  Output Tokens:    ${formatNumber(block.tokenCounts.outputTokens)}`);
+			log(`  Total Cost:       ${formatCurrency(block.costUSD)}\n`);
+			if (burnRate != null) {
+				log(import_picocolors$3.default.bold("Burn Rate:"));
+				log(`  Tokens/minute:    ${formatNumber(burnRate.tokensPerMinute)}`);
+				log(`  Cost/hour:        ${formatCurrency(burnRate.costPerHour)}\n`);
+			}
+			if (projection != null) {
+				log(import_picocolors$3.default.bold("Projected Usage (if current rate continues):"));
+				log(`  Total Tokens:     ${formatNumber(projection.totalTokens)}`);
+				log(`  Total Cost:       ${formatCurrency(projection.totalCost)}\n`);
+				if (ctx.values.tokenLimit != null) {
+					const limit = parseTokenLimit(ctx.values.tokenLimit, maxTokensFromAll);
+					if (limit != null && limit > 0) {
+						const currentTokens = block.tokenCounts.inputTokens + block.tokenCounts.outputTokens;
+						const remainingTokens = Math.max(0, limit - currentTokens);
+						const percentUsed = projection.totalTokens / limit * 100;
+						const status = percentUsed > 100 ? import_picocolors$3.default.red("EXCEEDS LIMIT") : percentUsed > WARNING_THRESHOLD * 100 ? import_picocolors$3.default.yellow("WARNING") : import_picocolors$3.default.green("OK");
+						log(import_picocolors$3.default.bold("Token Limit Status:"));
+						log(`  Limit:            ${formatNumber(limit)} tokens`);
+						log(`  Current Usage:    ${formatNumber(currentTokens)} (${(currentTokens / limit * 100).toFixed(1)}%)`);
+						log(`  Remaining:        ${formatNumber(remainingTokens)} tokens`);
+						log(`  Projected Usage:  ${percentUsed.toFixed(1)}% ${status}`);
+					}
+				}
+			}
+		} else {
+			logger.box("Claude Code Token Usage Report - 5-Hour Blocks");
+			const actualTokenLimit = parseTokenLimit(ctx.values.tokenLimit, maxTokensFromAll);
+			const tableHeaders = [
+				"Block Start",
+				"Duration/Status",
+				"Models",
+				"Tokens"
+			];
+			const tableAligns = [
+				"left",
+				"left",
+				"left",
+				"right"
+			];
+			if (actualTokenLimit != null && actualTokenLimit > 0) {
+				tableHeaders.push("%");
+				tableAligns.push("right");
+			}
+			tableHeaders.push("Cost");
+			tableAligns.push("right");
+			const table = new ResponsiveTable({
+				head: tableHeaders,
+				style: { head: ["cyan"] },
+				colAligns: tableAligns
+			});
+			const terminalWidth = process$1.stdout.columns || DEFAULT_TERMINAL_WIDTH;
+			const useCompactFormat = terminalWidth < COMPACT_WIDTH_THRESHOLD;
+			for (const block of blocks) if (block.isGap ?? false) {
+				const gapRow = [
+					import_picocolors$3.default.gray(formatBlockTime(block, useCompactFormat)),
+					import_picocolors$3.default.gray("(inactive)"),
+					import_picocolors$3.default.gray("-"),
+					import_picocolors$3.default.gray("-")
+				];
+				if (actualTokenLimit != null && actualTokenLimit > 0) gapRow.push(import_picocolors$3.default.gray("-"));
+				gapRow.push(import_picocolors$3.default.gray("-"));
+				table.push(gapRow);
+			} else {
+				const totalTokens = block.tokenCounts.inputTokens + block.tokenCounts.outputTokens;
+				const status = block.isActive ? import_picocolors$3.default.green("ACTIVE") : "";
+				const row = [
+					formatBlockTime(block, useCompactFormat),
+					status,
+					formatModels(block.models, useCompactFormat),
+					formatNumber(totalTokens)
+				];
+				if (actualTokenLimit != null && actualTokenLimit > 0) {
+					const percentage = totalTokens / actualTokenLimit * 100;
+					const percentText = `${percentage.toFixed(1)}%`;
+					row.push(percentage > 100 ? import_picocolors$3.default.red(percentText) : percentText);
+				}
+				row.push(formatCurrency(block.costUSD));
+				table.push(row);
+				if (block.isActive) {
+					if (actualTokenLimit != null && actualTokenLimit > 0) {
+						const currentTokens = block.tokenCounts.inputTokens + block.tokenCounts.outputTokens;
+						const remainingTokens = Math.max(0, actualTokenLimit - currentTokens);
+						const remainingText = remainingTokens > 0 ? formatNumber(remainingTokens) : import_picocolors$3.default.red("0");
+						const remainingPercent = (actualTokenLimit - currentTokens) / actualTokenLimit * 100;
+						const remainingPercentText = remainingPercent > 0 ? `${remainingPercent.toFixed(1)}%` : import_picocolors$3.default.red("0.0%");
+						const remainingRow = [
+							{
+								content: import_picocolors$3.default.gray(`(assuming ${formatNumber(actualTokenLimit)} token limit)`),
+								hAlign: "right"
+							},
+							import_picocolors$3.default.blue("REMAINING"),
+							"",
+							remainingText,
+							remainingPercentText,
+							""
+						];
+						table.push(remainingRow);
+					}
+					const projection = projectBlockUsage(block);
+					if (projection != null) {
+						const projectedTokens = formatNumber(projection.totalTokens);
+						const projectedText = actualTokenLimit != null && actualTokenLimit > 0 && projection.totalTokens > actualTokenLimit ? import_picocolors$3.default.red(projectedTokens) : projectedTokens;
+						const projectedRow = [
+							{
+								content: import_picocolors$3.default.gray("(assuming current burn rate)"),
+								hAlign: "right"
+							},
+							import_picocolors$3.default.yellow("PROJECTED"),
+							"",
+							projectedText
+						];
+						if (actualTokenLimit != null && actualTokenLimit > 0) {
+							const percentage = projection.totalTokens / actualTokenLimit * 100;
+							const percentText = `${percentage.toFixed(1)}%`;
+							projectedRow.push(percentText);
+						}
+						projectedRow.push(formatCurrency(projection.totalCost));
+						table.push(projectedRow);
+					}
+				}
+			}
+			log(table.toString());
+		}
+	}
+});
+
 //#endregion
 //#region src/commands/daily.ts
 var import_picocolors$2 = __toESM(require_picocolors(), 1);
@@ -1701,6 +1983,7 @@ const subCommands = /* @__PURE__ */ new Map();
 subCommands.set("daily", dailyCommand);
 subCommands.set("monthly", monthlyCommand);
 subCommands.set("session", sessionCommand);
+subCommands.set("blocks", blocksCommand);
 subCommands.set("mcp", mcpCommand);
 const mainCommand = dailyCommand;
 await cli(process$1.argv.slice(2), mainCommand, {

package/dist/{logger-DKw-DPXD.js → logger-C2GZVy1v.js}

@@ -965,7 +965,7 @@ const consola = createConsola$1();
 //#endregion
 //#region package.json
 var name = "ccusage";
-var version = "9.0.0";
+var version = "10.0.0";
 var description = "Usage analysis tool for Claude Code";
 
 //#endregion

package/dist/logger.js

@@ -1,3 +1,3 @@
-import { log, logger } from "./logger-DKw-DPXD.js";
+import { log, logger } from "./logger-C2GZVy1v.js";
 
 export { log, logger };

package/dist/{mcp-BRFYI5rd.js → mcp-DVjQeqCy.js}

@@ -1,8 +1,8 @@
 import { __commonJS, __require, __toESM } from "./chunk-BLXvPPr8.js";
-import { getDefaultClaudePath, loadDailyUsageData, loadSessionData } from "./data-loader-Ca8k_uX0.js";
+import { getDefaultClaudePath, loadDailyUsageData, loadSessionData } from "./data-loader-Bp9KV0_a.js";
 import { description, literal, object, optional, pipe, union } from "./dist-DCvt9hEv.js";
-import { name, version } from "./logger-DKw-DPXD.js";
-import { CostModes, dateSchema } from "./pricing-fetcher-BlxDpqFj.js";
+import { name, version } from "./logger-C2GZVy1v.js";
+import { CostModes, dateSchema } from "./pricing-fetcher-BxlbW4km.js";
 import { anyType, arrayType, booleanType, discriminatedUnionType, enumType, literalType, numberType, objectType, optionalType, recordType, stringType, unionType, unknownType } from "./types-BlyCnKwN.js";
 import { toJsonSchema } from "./index-CISmcbXk-CW1Gj6Ab.js";
 import process$1 from "node:process";

package/dist/mcp.d.ts

@@ -1,5 +1,5 @@
 import "./pricing-fetcher-BkSZh4lR.js";
-import { LoadOptions } from "./data-loader-OGaMjZTD.js";
+import { LoadOptions } from "./data-loader-DPQaq8_n.js";
 import { FastMCP } from "fastmcp";
 
 //#region src/mcp.d.ts

package/dist/mcp.js

@@ -1,9 +1,9 @@
-import "./data-loader-Ca8k_uX0.js";
+import "./data-loader-Bp9KV0_a.js";
 import "./dist-DCvt9hEv.js";
-import "./logger-DKw-DPXD.js";
-import "./pricing-fetcher-BlxDpqFj.js";
+import "./logger-C2GZVy1v.js";
+import "./pricing-fetcher-BxlbW4km.js";
 import "./types-BlyCnKwN.js";
-import { createMcpServer } from "./mcp-BRFYI5rd.js";
+import { createMcpServer } from "./mcp-DVjQeqCy.js";
 import "./index-CISmcbXk-CW1Gj6Ab.js";
 
 export { createMcpServer };

package/dist/{pricing-fetcher-BlxDpqFj.js → pricing-fetcher-BxlbW4km.js}

@@ -1,5 +1,5 @@
 import { number, object, optional, pipe, regex, safeParse, string } from "./dist-DCvt9hEv.js";
-import { logger } from "./logger-DKw-DPXD.js";
+import { logger } from "./logger-C2GZVy1v.js";
 
 //#region src/consts.internal.ts
 const LITELLM_PRICING_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";

package/dist/pricing-fetcher.js

@@ -1,5 +1,5 @@
 import "./dist-DCvt9hEv.js";
-import "./logger-DKw-DPXD.js";
-import { PricingFetcher } from "./pricing-fetcher-BlxDpqFj.js";
+import "./logger-C2GZVy1v.js";
+import { PricingFetcher } from "./pricing-fetcher-BxlbW4km.js";
 
 export { PricingFetcher };

package/dist/{utils.table-DRzF8vZJ.js → utils.table-USks3NGv.js}

@@ -1769,7 +1769,10 @@ var ResponsiveTable = class {
 	toString() {
 		const terminalWidth = process$1.stdout.columns || 120;
 		const dataRows = this.rows.filter((row) => !this.isSeparatorRow(row));
-		const allRows = [this.head.map(String), ...dataRows.map((row) => row.map(String))];
+		const allRows = [this.head.map(String), ...dataRows.map((row) => row.map((cell) => {
+			if (typeof cell === "object" && cell != null && "content" in cell) return String(cell.content);
+			return String(cell ?? "");
+		}))];
 		const contentWidths = this.head.map((_, colIndex) => {
 			const maxLength = Math.max(...allRows.map((row) => stringWidth(String(row[colIndex] ?? ""))));
 			return maxLength;
@@ -1827,7 +1830,10 @@ var ResponsiveTable = class {
 		}
 	}
 	isSeparatorRow(row) {
-		return row.every((cell) => typeof cell === "string" && (cell === "" || /^─+$/.test(cell)));
+		return row.every((cell) => {
+			if (typeof cell === "object" && cell != null && "content" in cell) return cell.content === "" || /^─+$/.test(cell.content);
+			return typeof cell === "string" && (cell === "" || /^─+$/.test(cell));
+		});
 	}
 	isDateString(text) {
 		return /^\d{4}-\d{2}-\d{2}$/.test(text);

package/dist/utils.table.d.ts

@@ -1,5 +1,8 @@
 //#region src/utils.table.d.ts
-type TableRow = (string | number)[];
+type TableRow = (string | number | {
+  content: string;
+  hAlign?: 'left' | 'right' | 'center';
+})[];
 type TableOptions = {
   head: string[];
   colAligns?: ('left' | 'right' | 'center')[];

package/dist/utils.table.js

@@ -1,3 +1,3 @@
-import { ResponsiveTable } from "./utils.table-DRzF8vZJ.js";
+import { ResponsiveTable } from "./utils.table-USks3NGv.js";
 
 export { ResponsiveTable };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ccusage",
   "type": "module",
-  "version": "9.0.0",
+  "version": "10.0.0",
   "description": "Usage analysis tool for Claude Code",
   "author": "ryoppippi",
   "license": "MIT",