ccusage 15.4.0 → 15.5.1

package/README.md

@@ -62,6 +62,11 @@ ccusage blocks --live  # Real-time usage dashboard
 ccusage daily --since 20250525 --until 20250530
 ccusage daily --json  # JSON output
 ccusage daily --breakdown  # Per-model cost breakdown
+
+# 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
 ```
 
 ## Features
@@ -83,6 +88,7 @@ ccusage daily --breakdown  # Per-model cost breakdown
 - 🔄 **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)
 - 🔌 **MCP Integration**: Built-in Model Context Protocol server for integration with other tools
+- 🏗️ **Multi-Instance Support**: Group usage by project with `--instances` flag and filter by specific projects
 - 🚀 **Ultra-Small Bundle**: Unlike other CLI tools, we pay extreme attention to bundle size - incredibly small even without minification!
 
 ## Documentation

package/dist/calculate-cost.d.ts

@@ -1,4 +1,4 @@
-import { DailyUsage, MonthlyUsage, SessionUsage } from "./data-loader-7c4yXbqG.js";
+import { DailyUsage, MonthlyUsage, SessionUsage } from "./data-loader-CgvyDaQD.js";
 import "./pricing-fetcher-B3SvKOod.js";
 
 //#region src/_token-utils.d.ts

package/dist/{data-loader-BNrxyvc9.js → data-loader-BAp4u-7e.js}

@@ -1,7 +1,7 @@
-import { CLAUDE_CONFIG_DIR_ENV, CLAUDE_PROJECTS_DIR_NAME, DEFAULT_CLAUDE_CODE_PATH, DEFAULT_CLAUDE_CONFIG_PATH, DEFAULT_RECENT_DAYS, PricingFetcher, USAGE_DATA_GLOB_PATTERN, USER_HOME_DIR, __commonJSMin, __require, __toESM, isFailure, isPromise, require_usingCtx } from "./pricing-fetcher-KIIpXo8L.js";
+import { CLAUDE_CONFIG_DIR_ENV, CLAUDE_PROJECTS_DIR_NAME, DEFAULT_CLAUDE_CODE_PATH, DEFAULT_CLAUDE_CONFIG_PATH, DEFAULT_RECENT_DAYS, PricingFetcher, USAGE_DATA_GLOB_PATTERN, USER_HOME_DIR, __commonJSMin, __require, __toESM, isFailure, isPromise, require_usingCtx } from "./pricing-fetcher-eNV76BjF.js";
 import { getTotalTokens } from "./_token-utils-WjkbrjKv.js";
 import { activityDateSchema, arrayType, booleanType, createDailyDate, createMonthlyDate, createProjectPath, createSessionId, dailyDateSchema, isoTimestampSchema, messageIdSchema, modelNameSchema, monthlyDateSchema, numberType, objectType, projectPathSchema, requestIdSchema, sessionIdSchema, stringType, versionSchema } from "./_types-BHFM59hI.js";
-import { logger } from "./logger-mXUMXvyg.js";
+import { logger } from "./logger-COLgmk2z.js";
 import a, { readFile } from "node:fs/promises";
 import path, { posix } from "node:path";
 import process$1 from "node:process";
@@ -3327,6 +3327,19 @@ function getClaudePaths() {
 	return paths;
 }
 /**
+* Extract project name from Claude JSONL file path
+* @param jsonlPath - Absolute path to JSONL file
+* @returns Project name extracted from path, or "unknown" if malformed
+*/
+function extractProjectFromPath(jsonlPath) {
+	const normalizedPath = jsonlPath.replace(/[/\\]/g, path.sep);
+	const segments = normalizedPath.split(path.sep);
+	const projectsIndex = segments.findIndex((segment) => segment === CLAUDE_PROJECTS_DIR_NAME);
+	if (projectsIndex === -1 || projectsIndex + 1 >= segments.length) return "unknown";
+	const projectName = segments[projectsIndex + 1];
+	return projectName != null && projectName.trim() !== "" ? projectName : "unknown";
+}
+/**
 * Zod schema for validating Claude usage data from JSONL files
 */
 const usageDataSchema = objectType({
@@ -3369,7 +3382,8 @@ const dailyUsageSchema = objectType({
 	cacheReadTokens: numberType(),
 	totalCost: numberType(),
 	modelsUsed: arrayType(modelNameSchema),
-	modelBreakdowns: arrayType(modelBreakdownSchema)
+	modelBreakdowns: arrayType(modelBreakdownSchema),
+	project: stringType().optional()
 });
 /**
 * Zod schema for session-based usage aggregation data
@@ -3398,7 +3412,8 @@ const monthlyUsageSchema = objectType({
 	cacheReadTokens: numberType(),
 	totalCost: numberType(),
 	modelsUsed: arrayType(modelNameSchema),
-	modelBreakdowns: arrayType(modelBreakdownSchema)
+	modelBreakdowns: arrayType(modelBreakdownSchema),
+	project: stringType().optional()
 });
 /**
 * Aggregates token counts and costs by model name
@@ -3499,6 +3514,16 @@ function filterByDateRange(items, getDate, since, until) {
 	});
 }
 /**
+* Filters items by project name
+*/
+function filterByProject(items, getProject, projectFilter) {
+	if (projectFilter == null) return items;
+	return items.filter((item) => {
+		const projectName = getProject(item);
+		return projectName === projectFilter;
+	});
+}
+/**
 * Checks if an entry is a duplicate based on hash
 */
 function isDuplicateEntry(uniqueHash, processedHashes) {
@@ -3684,7 +3709,8 @@ async function loadDailyUsageData(options) {
 		const allFiles = await globUsageFiles(claudePaths);
 		const fileList = allFiles.map((f$1) => f$1.file);
 		if (fileList.length === 0) return [];
-		const sortedFiles = await sortFilesByTimestamp(fileList);
+		const projectFilteredFiles = filterByProject(fileList, (filePath) => extractProjectFromPath(filePath), options?.project);
+		const sortedFiles = await sortFilesByTimestamp(projectFilteredFiles);
 		const mode = options?.mode ?? "auto";
 		const fetcher = _usingCtx.u(mode === "display" ? null : new PricingFetcher(options?.offline));
 		const processedHashes = /* @__PURE__ */ new Set();
@@ -3702,17 +3728,24 @@ async function loadDailyUsageData(options) {
 				markAsProcessed(uniqueHash, processedHashes);
 				const date = formatDate(data.timestamp);
 				const cost = fetcher != null ? await calculateCostForEntry(data, mode, fetcher) : data.costUSD ?? 0;
+				const project = extractProjectFromPath(file);
 				allEntries.push({
 					data,
 					date,
 					cost,
-					model: data.message.model
+					model: data.message.model,
+					project
 				});
 			} catch {}
 		}
-		const groupedByDate = groupBy(allEntries, (entry) => entry.date);
-		const results = Object.entries(groupedByDate).map(([date, entries]) => {
+		const needsProjectGrouping = options?.groupByProject === true || options?.project != null;
+		const groupingKey = needsProjectGrouping ? (entry) => `${entry.date}\x00${entry.project}` : (entry) => entry.date;
+		const groupedData = groupBy(allEntries, groupingKey);
+		const results = Object.entries(groupedData).map(([groupKey, entries]) => {
 			if (entries == null) return void 0;
+			const parts = groupKey.split("\0");
+			const date = parts[0] ?? groupKey;
+			const project = parts.length > 1 ? parts[1] : void 0;
 			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);
@@ -3721,11 +3754,13 @@ async function loadDailyUsageData(options) {
 				date: createDailyDate(date),
 				...totals,
 				modelsUsed,
-				modelBreakdowns
+				modelBreakdowns,
+				...project != null && { project }
 			};
 		}).filter((item) => item != null);
-		const filtered = filterByDateRange(results, (item) => item.date, options?.since, options?.until);
-		return sortByDate(filtered, (item) => item.date, options?.order);
+		const dateFiltered = filterByDateRange(results, (item) => item.date, options?.since, options?.until);
+		const finalFiltered = filterByProject(dateFiltered, (item) => item.project, options?.project);
+		return sortByDate(finalFiltered, (item) => item.date, options?.order);
 	} catch (_) {
 		_usingCtx.e = _;
 	} finally {
@@ -3744,8 +3779,9 @@ async function loadSessionData(options) {
 		const claudePaths = toArray(options?.claudePath ?? getClaudePaths());
 		const filesWithBase = await globUsageFiles(claudePaths);
 		if (filesWithBase.length === 0) return [];
-		const fileToBaseMap = new Map(filesWithBase.map((f$1) => [f$1.file, f$1.baseDir]));
-		const sortedFilesWithBase = await sortFilesByTimestamp(filesWithBase.map((f$1) => f$1.file)).then((sortedFiles) => sortedFiles.map((file) => ({
+		const projectFilteredWithBase = filterByProject(filesWithBase, (item) => extractProjectFromPath(item.file), options?.project);
+		const fileToBaseMap = new Map(projectFilteredWithBase.map((f$1) => [f$1.file, f$1.baseDir]));
+		const sortedFilesWithBase = await sortFilesByTimestamp(projectFilteredWithBase.map((f$1) => f$1.file)).then((sortedFiles) => sortedFiles.map((file) => ({
 			file,
 			baseDir: fileToBaseMap.get(file) ?? ""
 		})));
@@ -3802,8 +3838,9 @@ async function loadSessionData(options) {
 				modelBreakdowns
 			};
 		}).filter((item) => item != null);
-		const filtered = filterByDateRange(results, (item) => item.lastActivity, options?.since, options?.until);
-		return sortByDate(filtered, (item) => item.lastActivity, options?.order);
+		const dateFiltered = filterByDateRange(results, (item) => item.lastActivity, options?.since, options?.until);
+		const sessionFiltered = filterByProject(dateFiltered, (item) => item.projectPath, options?.project);
+		return sortByDate(sessionFiltered, (item) => item.lastActivity, options?.order);
 	} catch (_) {
 		_usingCtx3.e = _;
 	} finally {
@@ -3818,10 +3855,15 @@ async function loadSessionData(options) {
 */
 async function loadMonthlyUsageData(options) {
 	const dailyData = await loadDailyUsageData(options);
-	const groupedByMonth = groupBy(dailyData, (data) => data.date.substring(0, 7));
+	const needsProjectGrouping = options?.groupByProject === true || options?.project != null;
+	const groupingKey = needsProjectGrouping ? (data) => `${data.date.substring(0, 7)}\x00${data.project ?? "unknown"}` : (data) => data.date.substring(0, 7);
+	const groupedByMonth = groupBy(dailyData, groupingKey);
 	const monthlyArray = [];
-	for (const [month, dailyEntries] of Object.entries(groupedByMonth)) {
+	for (const [groupKey, dailyEntries] of Object.entries(groupedByMonth)) {
 		if (dailyEntries == null) continue;
+		const parts = groupKey.split("\0");
+		const month = parts[0] ?? groupKey;
+		const project = parts.length > 1 ? parts[1] : void 0;
 		const allBreakdowns = dailyEntries.flatMap((daily) => daily.modelBreakdowns);
 		const modelAggregates = aggregateModelBreakdowns(allBreakdowns);
 		const modelBreakdowns = createModelBreakdowns(modelAggregates);
@@ -3847,7 +3889,8 @@ async function loadMonthlyUsageData(options) {
 			cacheReadTokens: totalCacheReadTokens,
 			totalCost,
 			modelsUsed: uniq(models),
-			modelBreakdowns
+			modelBreakdowns,
+			...project != null && { project }
 		};
 		monthlyArray.push(monthlyUsage);
 	}
@@ -3873,7 +3916,8 @@ async function loadSessionBlockData(options) {
 			allFiles.push(...files);
 		}
 		if (allFiles.length === 0) return [];
-		const sortedFiles = await sortFilesByTimestamp(allFiles);
+		const blocksFilteredFiles = filterByProject(allFiles, (filePath) => extractProjectFromPath(filePath), options?.project);
+		const sortedFiles = await sortFilesByTimestamp(blocksFilteredFiles);
 		const mode = options?.mode ?? "auto";
 		const fetcher = _usingCtx4.u(mode === "display" ? null : new PricingFetcher(options?.offline));
 		const processedHashes = /* @__PURE__ */ new Set();
@@ -3909,17 +3953,17 @@ async function loadSessionBlockData(options) {
 			}
 		}
 		const blocks = identifySessionBlocks(allEntries, options?.sessionDurationHours);
-		const filtered = options?.since != null && options.since !== "" || options?.until != null && options.until !== "" ? blocks.filter((block) => {
+		const dateFiltered = 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);
+		return sortByDate(dateFiltered, (block) => block.startTime, options?.order);
 	} catch (_) {
 		_usingCtx4.e = _;
 	} finally {
 		_usingCtx4.d();
 	}
 }
-export { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, calculateCostForEntry, createUniqueHash, dailyUsageSchema, filterRecentBlocks, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, glob, globUsageFiles, identifySessionBlocks, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, projectBlockUsage, sessionUsageSchema, sortFilesByTimestamp, uniq, unwrap, usageDataSchema };
+export { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, filterRecentBlocks, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, glob, globUsageFiles, identifySessionBlocks, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, projectBlockUsage, sessionUsageSchema, sortFilesByTimestamp, uniq, unwrap, usageDataSchema };

package/dist/{data-loader-7c4yXbqG.d.ts → data-loader-CgvyDaQD.d.ts}

@@ -55,6 +55,12 @@ type SessionBlock = {
  * @returns Array of valid Claude data directory paths
  */
 declare function getClaudePaths(): string[];
+/**
+ * Extract project name from Claude JSONL file path
+ * @param jsonlPath - Absolute path to JSONL file
+ * @returns Project name extracted from path, or "unknown" if malformed
+ */
+declare function extractProjectFromPath(jsonlPath: string): string;
 /**
  * Zod schema for validating Claude usage data from JSONL files
  */
@@ -220,6 +226,7 @@ declare const dailyUsageSchema: z.ZodObject<{
     cacheReadTokens: number;
     cost: number;
   }>, "many">;
+  project: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
   date: string & z.BRAND<"DailyDate">;
   inputTokens: number;
@@ -236,6 +243,7 @@ declare const dailyUsageSchema: z.ZodObject<{
     cacheReadTokens: number;
     cost: number;
   }[];
+  project?: string | undefined;
 }, {
   date: string;
   inputTokens: number;
@@ -252,6 +260,7 @@ declare const dailyUsageSchema: z.ZodObject<{
     cacheReadTokens: number;
     cost: number;
   }[];
+  project?: string | undefined;
 }>;
 /**
  * Type definition for daily usage aggregation
@@ -369,6 +378,7 @@ declare const monthlyUsageSchema: z.ZodObject<{
     cacheReadTokens: number;
     cost: number;
   }>, "many">;
+  project: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
   month: string & z.BRAND<"MonthlyDate">;
   inputTokens: number;
@@ -385,6 +395,7 @@ declare const monthlyUsageSchema: z.ZodObject<{
     cacheReadTokens: number;
     cost: number;
   }[];
+  project?: string | undefined;
 }, {
   month: string;
   inputTokens: number;
@@ -401,6 +412,7 @@ declare const monthlyUsageSchema: z.ZodObject<{
     cacheReadTokens: number;
     cost: number;
   }[];
+  project?: string | undefined;
 }>;
 /**
  * Type definition for monthly usage aggregation
@@ -475,6 +487,8 @@ type LoadOptions = {
   order?: SortOrder; // Sort order for dates
   offline?: boolean; // Use offline mode for pricing
   sessionDurationHours?: number; // Session block duration in hours
+  groupByProject?: boolean; // Group data by project instead of aggregating
+  project?: string; // Filter to specific project name
 } & DateFilter;
 /**
  * Loads and aggregates Claude usage data by day
@@ -505,4 +519,4 @@ declare function loadMonthlyUsageData(options?: LoadOptions): Promise<MonthlyUsa
  */
 declare function loadSessionBlockData(options?: LoadOptions): Promise<SessionBlock[]>;
 //#endregion
-export { DailyUsage, DateFilter, GlobResult, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };
+export { DailyUsage, DateFilter, GlobResult, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };

package/dist/data-loader.d.ts

@@ -1,3 +1,3 @@
-import { DailyUsage, DateFilter, GlobResult, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-7c4yXbqG.js";
+import { DailyUsage, DateFilter, GlobResult, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-CgvyDaQD.js";
 import "./pricing-fetcher-B3SvKOod.js";
-export { DailyUsage, DateFilter, GlobResult, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };
+export { DailyUsage, DateFilter, GlobResult, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };

package/dist/data-loader.js

@@ -1,6 +1,6 @@
-import "./pricing-fetcher-KIIpXo8L.js";
+import "./pricing-fetcher-eNV76BjF.js";
 import "./_token-utils-WjkbrjKv.js";
 import "./_types-BHFM59hI.js";
-import { calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-BNrxyvc9.js";
-import "./logger-mXUMXvyg.js";
-export { calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };
+import { calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-BAp4u-7e.js";
+import "./logger-COLgmk2z.js";
+export { calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };

package/dist/{debug-Brn3ODNf.js → debug-IQBgd8CJ.js}

@@ -1,6 +1,6 @@
-import { CLAUDE_PROJECTS_DIR_NAME, DEBUG_MATCH_THRESHOLD_PERCENT, PricingFetcher, USAGE_DATA_GLOB_PATTERN, __toESM, isFailure, require_usingCtx, try_ } from "./pricing-fetcher-KIIpXo8L.js";
-import { getClaudePaths, glob, unwrap, usageDataSchema } from "./data-loader-BNrxyvc9.js";
-import { logger } from "./logger-mXUMXvyg.js";
+import { CLAUDE_PROJECTS_DIR_NAME, DEBUG_MATCH_THRESHOLD_PERCENT, PricingFetcher, USAGE_DATA_GLOB_PATTERN, __toESM, isFailure, require_usingCtx, try_ } from "./pricing-fetcher-eNV76BjF.js";
+import { getClaudePaths, glob, unwrap, usageDataSchema } from "./data-loader-BAp4u-7e.js";
+import { logger } from "./logger-COLgmk2z.js";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 var import_usingCtx = __toESM(require_usingCtx(), 1);

package/dist/debug.js

@@ -1,7 +1,7 @@
-import "./pricing-fetcher-KIIpXo8L.js";
+import "./pricing-fetcher-eNV76BjF.js";
 import "./_token-utils-WjkbrjKv.js";
 import "./_types-BHFM59hI.js";
-import "./data-loader-BNrxyvc9.js";
-import "./logger-mXUMXvyg.js";
-import { detectMismatches, printMismatchReport } from "./debug-Brn3ODNf.js";
+import "./data-loader-BAp4u-7e.js";
+import "./logger-COLgmk2z.js";
+import { detectMismatches, printMismatchReport } from "./debug-IQBgd8CJ.js";
 export { detectMismatches, printMismatchReport };

package/dist/index.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import { BLOCKS_COMPACT_WIDTH_THRESHOLD, BLOCKS_DEFAULT_TERMINAL_WIDTH, BLOCKS_WARNING_THRESHOLD, BURN_RATE_THRESHOLDS, DEFAULT_RECENT_DAYS, DEFAULT_REFRESH_INTERVAL_SECONDS, MAX_REFRESH_INTERVAL_SECONDS, MCP_DEFAULT_PORT, MIN_REFRESH_INTERVAL_SECONDS, MIN_RENDER_INTERVAL_MS, PricingFetcher, __commonJSMin, __require, __toESM, isFailure, require_usingCtx, try_ } from "./pricing-fetcher-KIIpXo8L.js";
+import { BLOCKS_COMPACT_WIDTH_THRESHOLD, BLOCKS_DEFAULT_TERMINAL_WIDTH, BLOCKS_WARNING_THRESHOLD, BURN_RATE_THRESHOLDS, DEFAULT_RECENT_DAYS, DEFAULT_REFRESH_INTERVAL_SECONDS, MAX_REFRESH_INTERVAL_SECONDS, MCP_DEFAULT_PORT, MIN_REFRESH_INTERVAL_SECONDS, MIN_RENDER_INTERVAL_MS, PROJECT_ALIASES_ENV, PricingFetcher, __commonJSMin, __require, __toESM, isFailure, require_usingCtx, try_ } from "./pricing-fetcher-eNV76BjF.js";
 import { getTotalTokens } from "./_token-utils-WjkbrjKv.js";
 import { CostModes, SortOrders, filterDateSchema } from "./_types-BHFM59hI.js";
 import { calculateTotals, createTotalsObject } from "./calculate-cost-BDqO4yWA.js";
-import { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, calculateCostForEntry, createUniqueHash, filterRecentBlocks, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, identifySessionBlocks, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, projectBlockUsage, sortFilesByTimestamp, uniq, usageDataSchema } from "./data-loader-BNrxyvc9.js";
-import { description, log, logger, name, version } from "./logger-mXUMXvyg.js";
-import { detectMismatches, printMismatchReport } from "./debug-Brn3ODNf.js";
-import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-CQw7snVU.js";
+import { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, calculateCostForEntry, createUniqueHash, filterRecentBlocks, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, identifySessionBlocks, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, projectBlockUsage, sortFilesByTimestamp, uniq, usageDataSchema } from "./data-loader-BAp4u-7e.js";
+import { description, log, logger, name, version } from "./logger-COLgmk2z.js";
+import { detectMismatches, printMismatchReport } from "./debug-IQBgd8CJ.js";
+import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-Ta2UK9sc.js";
 import { readFile } from "node:fs/promises";
 import process$1 from "node:process";
 import { createServer } from "node:http";
@@ -3729,13 +3729,6 @@ function formatTokensShort(num) {
 	return num.toString();
 }
 /**
-* Column layout constants for detail rows
-*/
-const DETAIL_COLUMN_WIDTHS = {
-	col1: 46,
-	col2: 37
-};
-/**
 * Renders the live display for an active session block
 */
 function renderLiveDisplay(terminal, block, config) {
@@ -3744,6 +3737,9 @@ function renderLiveDisplay(terminal, block, config) {
 	const totalTokens = getTotalTokens(block.tokenCounts);
 	const elapsed = (now.getTime() - block.startTime.getTime()) / (1e3 * 60);
 	const remaining = (block.endTime.getTime() - now.getTime()) / (1e3 * 60);
+	const formatTokenDisplay = (tokens, useShort) => {
+		return useShort ? formatTokensShort(tokens) : formatNumber(tokens);
+	};
 	if (width < 60) {
 		renderCompactLiveDisplay(terminal, block, config, totalTokens, elapsed, remaining);
 		return;
@@ -3751,12 +3747,19 @@ function renderLiveDisplay(terminal, block, config) {
 	const boxWidth = Math.min(120, width - 2);
 	const boxMargin = Math.floor((width - boxWidth) / 2);
 	const marginStr = " ".repeat(boxMargin);
-	const labelWidth = 14;
-	const percentWidth = 7;
-	const shortLabelWidth = 20;
-	const barWidth = boxWidth - labelWidth - percentWidth - shortLabelWidth - 4;
 	const sessionDuration = elapsed + remaining;
 	const sessionPercent = elapsed / sessionDuration * 100;
+	const sessionRightText = `${sessionPercent.toFixed(1).padStart(6)}%`;
+	const tokenPercent = config.tokenLimit != null && config.tokenLimit > 0 ? totalTokens / config.tokenLimit * 100 : 0;
+	const usageRightText = config.tokenLimit != null && config.tokenLimit > 0 ? `${tokenPercent.toFixed(1).padStart(6)}% (${formatTokensShort(totalTokens)}/${formatTokensShort(config.tokenLimit)})` : `(${formatTokensShort(totalTokens)} tokens)`;
+	const projection = projectBlockUsage(block);
+	const projectedPercent = projection != null && config.tokenLimit != null && config.tokenLimit > 0 ? projection.totalTokens / config.tokenLimit * 100 : 0;
+	const projectionRightText = projection != null ? config.tokenLimit != null && config.tokenLimit > 0 ? `${projectedPercent.toFixed(1).padStart(6)}% (${formatTokensShort(projection.totalTokens)}/${formatTokensShort(config.tokenLimit)})` : `(${formatTokensShort(projection.totalTokens)} tokens)` : "";
+	const maxRightTextWidth = Math.max(stringWidth(sessionRightText), stringWidth(usageRightText), projection != null ? stringWidth(projectionRightText) : 0);
+	const labelWidth = 14;
+	const spacing = 4;
+	const boxPadding = 4;
+	const barWidth = boxWidth - labelWidth - maxRightTextWidth - spacing - boxPadding;
 	const sessionProgressBar = createProgressBar(elapsed, sessionDuration, barWidth, {
 		showPercentage: false,
 		fillChar: import_picocolors$5.default.cyan("█"),
@@ -3776,23 +3779,24 @@ function renderLiveDisplay(terminal, block, config) {
 		second: "2-digit",
 		hour12: true
 	});
+	const detailsIndent = 3;
+	const detailsSpacing = 2;
+	const detailsAvailableWidth = boxWidth - 3 - detailsIndent;
 	terminal.write(`${marginStr}┌${"─".repeat(boxWidth - 2)}┐\n`);
 	terminal.write(`${marginStr}│${import_picocolors$5.default.bold(centerText("CLAUDE CODE - LIVE TOKEN USAGE MONITOR", boxWidth - 2))}│\n`);
 	terminal.write(`${marginStr}├${"─".repeat(boxWidth - 2)}┤\n`);
 	terminal.write(`${marginStr}│${" ".repeat(boxWidth - 2)}│\n`);
 	const sessionLabel = import_picocolors$5.default.bold("⏱️ SESSION");
 	const sessionLabelWidth = stringWidth(sessionLabel);
-	const sessionBarStr = `${sessionLabel}${"".padEnd(Math.max(0, labelWidth - sessionLabelWidth))} ${sessionProgressBar} ${sessionPercent.toFixed(1).padStart(6)}%`;
+	const sessionBarStr = `${sessionLabel}${"".padEnd(Math.max(0, labelWidth - sessionLabelWidth))} ${sessionProgressBar} ${sessionRightText}`;
 	const sessionBarPadded = sessionBarStr + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(sessionBarStr)));
 	terminal.write(`${marginStr}│ ${sessionBarPadded}│\n`);
-	const col1 = `${import_picocolors$5.default.gray("Started:")} ${startTime}`;
-	const col2 = `${import_picocolors$5.default.gray("Elapsed:")} ${prettyMilliseconds(elapsed * 60 * 1e3, { compact: true })}`;
-	const col3 = `${import_picocolors$5.default.gray("Remaining:")} ${prettyMilliseconds(remaining * 60 * 1e3, { compact: true })} (${endTime})`;
-	const col1Visible = stringWidth(col1);
-	const col2Visible = stringWidth(col2);
-	const pad1 = " ".repeat(Math.max(0, DETAIL_COLUMN_WIDTHS.col1 - col1Visible));
-	const pad2 = " ".repeat(Math.max(0, DETAIL_COLUMN_WIDTHS.col2 - col2Visible));
-	const sessionDetails = `   ${col1}${pad1}${pad2}${col3}`;
+	const sessionCol1 = `${import_picocolors$5.default.gray("Started:")} ${startTime}`;
+	const sessionCol2 = `${import_picocolors$5.default.gray("Elapsed:")} ${prettyMilliseconds(elapsed * 60 * 1e3, { compact: true })}`;
+	const sessionCol3 = `${import_picocolors$5.default.gray("Remaining:")} ${prettyMilliseconds(remaining * 60 * 1e3, { compact: true })} (${endTime})`;
+	let sessionDetails = `${" ".repeat(detailsIndent)}${sessionCol1}${" ".repeat(detailsSpacing)}${sessionCol2}${" ".repeat(detailsSpacing)}${sessionCol3}`;
+	const sessionDetailsWidth = stringWidth(sessionCol1) + stringWidth(sessionCol2) + stringWidth(sessionCol3) + detailsSpacing * 2;
+	if (sessionDetailsWidth > detailsAvailableWidth) sessionDetails = `${" ".repeat(detailsIndent)}${sessionCol1}${" ".repeat(detailsSpacing)}${sessionCol3}`;
 	const sessionDetailsPadded = sessionDetails + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(sessionDetails)));
 	let usageLimitResetTimePadded = null;
 	if (block.usageLimitResetTime !== void 0 && now < block.usageLimitResetTime) {
@@ -3809,7 +3813,6 @@ function renderLiveDisplay(terminal, block, config) {
 	terminal.write(`${marginStr}│${" ".repeat(boxWidth - 2)}│\n`);
 	terminal.write(`${marginStr}├${"─".repeat(boxWidth - 2)}┤\n`);
 	terminal.write(`${marginStr}│${" ".repeat(boxWidth - 2)}│\n`);
-	const tokenPercent = config.tokenLimit != null && config.tokenLimit > 0 ? totalTokens / config.tokenLimit * 100 : 0;
 	let barColor = import_picocolors$5.default.green;
 	if (tokenPercent > 100) barColor = import_picocolors$5.default.red;
 	else if (tokenPercent > 80) barColor = import_picocolors$5.default.yellow;
@@ -3822,35 +3825,51 @@ function renderLiveDisplay(terminal, block, config) {
 	}) : `[${import_picocolors$5.default.green("█".repeat(Math.floor(barWidth * .1)))}${import_picocolors$5.default.gray("░".repeat(barWidth - Math.floor(barWidth * .1)))}]`;
 	const burnRate = calculateBurnRate(block);
 	const rateIndicator = getRateIndicator(burnRate);
-	const rateDisplay = burnRate != null ? `${import_picocolors$5.default.bold("Burn Rate:")} ${Math.round(burnRate.tokensPerMinute)} token/min ${rateIndicator}` : `${import_picocolors$5.default.bold("Burn Rate:")} N/A`;
+	const buildRateDisplay = (useShort) => {
+		if (burnRate == null) return `${import_picocolors$5.default.bold("Burn Rate:")} N/A`;
+		const rateValue = Math.round(burnRate.tokensPerMinute);
+		const formattedRate = useShort ? formatTokensShort(rateValue) : formatNumber(rateValue);
+		return `${import_picocolors$5.default.bold("Burn Rate:")} ${formattedRate} token/min ${rateIndicator}`;
+	};
 	const usageLabel = import_picocolors$5.default.bold("🔥 USAGE");
 	const usageLabelWidth = stringWidth(usageLabel);
-	const { usageBarStr, usageCol1, usageCol2, usageCol3 } = config.tokenLimit != null && config.tokenLimit > 0 ? {
-		usageBarStr: `${usageLabel}${"".padEnd(Math.max(0, labelWidth - usageLabelWidth))} ${usageBar} ${tokenPercent.toFixed(1).padStart(6)}% (${formatTokensShort(totalTokens)}/${formatTokensShort(config.tokenLimit)})`,
-		usageCol1: `${import_picocolors$5.default.gray("Tokens:")} ${formatNumber(totalTokens)} (${rateDisplay})`,
-		usageCol2: `${import_picocolors$5.default.gray("Limit:")} ${formatNumber(config.tokenLimit)} tokens`,
-		usageCol3: `${import_picocolors$5.default.gray("Cost:")} ${formatCurrency(block.costUSD)}`
-	} : {
-		usageBarStr: `${usageLabel}${"".padEnd(Math.max(0, labelWidth - usageLabelWidth))} ${usageBar} (${formatTokensShort(totalTokens)} tokens)`,
-		usageCol1: `${import_picocolors$5.default.gray("Tokens:")} ${formatNumber(totalTokens)} (${rateDisplay})`,
-		usageCol2: "",
-		usageCol3: `${import_picocolors$5.default.gray("Cost:")} ${formatCurrency(block.costUSD)}`
-	};
+	const usageBarStr = `${usageLabel}${"".padEnd(Math.max(0, labelWidth - usageLabelWidth))} ${usageBar} ${usageRightText}`;
+	let rateDisplay = buildRateDisplay(false);
+	let usageCol1 = `${import_picocolors$5.default.gray("Tokens:")} ${formatTokenDisplay(totalTokens, false)} (${rateDisplay})`;
+	let usageCol2 = config.tokenLimit != null && config.tokenLimit > 0 ? `${import_picocolors$5.default.gray("Limit:")} ${formatTokenDisplay(config.tokenLimit, false)} tokens` : "";
+	const usageCol3 = `${import_picocolors$5.default.gray("Cost:")} ${formatCurrency(block.costUSD)}`;
+	let totalWidth = stringWidth(usageCol1);
+	if (usageCol2.length > 0) totalWidth += detailsSpacing + stringWidth(usageCol2);
+	totalWidth += detailsSpacing + stringWidth(usageCol3);
+	let useTwoLineLayout = false;
+	if (totalWidth > detailsAvailableWidth) {
+		useTwoLineLayout = true;
+		rateDisplay = buildRateDisplay(true);
+		usageCol1 = `${import_picocolors$5.default.gray("Tokens:")} ${formatTokenDisplay(totalTokens, true)} (${rateDisplay})`;
+		if (usageCol2.length > 0) usageCol2 = `${import_picocolors$5.default.gray("Limit:")} ${formatTokenDisplay(config.tokenLimit, true)} tokens`;
+	}
 	const usageBarPadded = usageBarStr + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(usageBarStr)));
 	terminal.write(`${marginStr}│ ${usageBarPadded}│\n`);
-	const usageCol1Visible = stringWidth(usageCol1);
-	const usageCol2Visible = stringWidth(usageCol2);
-	const usagePad1 = " ".repeat(Math.max(0, DETAIL_COLUMN_WIDTHS.col1 - usageCol1Visible));
-	const usagePad2 = usageCol2.length > 0 ? " ".repeat(Math.max(0, DETAIL_COLUMN_WIDTHS.col2 - usageCol2Visible)) : " ".repeat(DETAIL_COLUMN_WIDTHS.col2);
-	const usageDetails = `   ${usageCol1}${usagePad1}${usageCol2}${usagePad2}${usageCol3}`;
-	const usageDetailsPadded = usageDetails + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(usageDetails)));
-	terminal.write(`${marginStr}│ ${usageDetailsPadded}│\n`);
+	if (useTwoLineLayout) {
+		const usageDetailsLine1 = `${" ".repeat(detailsIndent)}${usageCol1}`;
+		const usageDetailsLine1Padded = usageDetailsLine1 + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(usageDetailsLine1)));
+		terminal.write(`${marginStr}│ ${usageDetailsLine1Padded}│\n`);
+		let usageDetailsLine2;
+		if (usageCol2.length > 0) usageDetailsLine2 = `${" ".repeat(detailsIndent)}${usageCol2}${" ".repeat(detailsSpacing)}${usageCol3}`;
+		else usageDetailsLine2 = `${" ".repeat(detailsIndent)}${usageCol3}`;
+		const usageDetailsLine2Padded = usageDetailsLine2 + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(usageDetailsLine2)));
+		terminal.write(`${marginStr}│ ${usageDetailsLine2Padded}│\n`);
+	} else {
+		let usageDetails;
+		if (usageCol2.length > 0) usageDetails = `${" ".repeat(detailsIndent)}${usageCol1}${" ".repeat(detailsSpacing)}${usageCol2}${" ".repeat(detailsSpacing)}${usageCol3}`;
+		else usageDetails = `${" ".repeat(detailsIndent)}${usageCol1}${" ".repeat(detailsSpacing)}${usageCol3}`;
+		const usageDetailsPadded = usageDetails + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(usageDetails)));
+		terminal.write(`${marginStr}│ ${usageDetailsPadded}│\n`);
+	}
 	terminal.write(`${marginStr}│${" ".repeat(boxWidth - 2)}│\n`);
 	terminal.write(`${marginStr}├${"─".repeat(boxWidth - 2)}┤\n`);
 	terminal.write(`${marginStr}│${" ".repeat(boxWidth - 2)}│\n`);
-	const projection = projectBlockUsage(block);
 	if (projection != null) {
-		const projectedPercent = config.tokenLimit != null && config.tokenLimit > 0 ? projection.totalTokens / config.tokenLimit * 100 : 0;
 		let projBarColor = import_picocolors$5.default.green;
 		if (projectedPercent > 100) projBarColor = import_picocolors$5.default.red;
 		else if (projectedPercent > 80) projBarColor = import_picocolors$5.default.yellow;
@@ -3864,32 +3883,27 @@ function renderLiveDisplay(terminal, block, config) {
 		const limitStatus = config.tokenLimit != null && config.tokenLimit > 0 ? projectedPercent > 100 ? import_picocolors$5.default.red("❌ WILL EXCEED LIMIT") : projectedPercent > 80 ? import_picocolors$5.default.yellow("⚠️  APPROACHING LIMIT") : import_picocolors$5.default.green("✓ WITHIN LIMIT") : import_picocolors$5.default.green("✓ ON TRACK");
 		const projLabel = import_picocolors$5.default.bold("📈 PROJECTION");
 		const projLabelWidth = stringWidth(projLabel);
-		if (config.tokenLimit != null && config.tokenLimit > 0) {
-			const projBarStr = `${projLabel}${"".padEnd(Math.max(0, labelWidth - projLabelWidth))} ${projectionBar} ${projectedPercent.toFixed(1).padStart(6)}% (${formatTokensShort(projection.totalTokens)}/${formatTokensShort(config.tokenLimit)})`;
-			const projBarPadded = projBarStr + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(projBarStr)));
-			terminal.write(`${marginStr}│ ${projBarPadded}│\n`);
-			const col1$1 = `${import_picocolors$5.default.gray("Status:")} ${limitStatus}`;
-			const col2$1 = `${import_picocolors$5.default.gray("Tokens:")} ${formatNumber(projection.totalTokens)}`;
-			const col3$1 = `${import_picocolors$5.default.gray("Cost:")} ${formatCurrency(projection.totalCost)}`;
-			const col1Visible$1 = stringWidth(col1$1);
-			const col2Visible$1 = stringWidth(col2$1);
-			const pad1$1 = " ".repeat(Math.max(0, DETAIL_COLUMN_WIDTHS.col1 - col1Visible$1));
-			const pad2$1 = " ".repeat(Math.max(0, DETAIL_COLUMN_WIDTHS.col2 - col2Visible$1));
-			const projDetails = `   ${col1$1}${pad1$1}${col2$1}${pad2$1}${col3$1}`;
-			const projDetailsPadded = projDetails + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(projDetails)));
-			terminal.write(`${marginStr}│ ${projDetailsPadded}│\n`);
+		const projBarStr = `${projLabel}${"".padEnd(Math.max(0, labelWidth - projLabelWidth))} ${projectionBar} ${projectionRightText}`;
+		const projBarPadded = projBarStr + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(projBarStr)));
+		terminal.write(`${marginStr}│ ${projBarPadded}│\n`);
+		const projCol1 = `${import_picocolors$5.default.gray("Status:")} ${limitStatus}`;
+		let projCol2 = `${import_picocolors$5.default.gray("Tokens:")} ${formatTokenDisplay(projection.totalTokens, false)}`;
+		const projCol3 = `${import_picocolors$5.default.gray("Cost:")} ${formatCurrency(projection.totalCost)}`;
+		const projTotalWidth = stringWidth(projCol1) + stringWidth(projCol2) + stringWidth(projCol3) + detailsSpacing * 2;
+		let projUseTwoLineLayout = false;
+		if (projTotalWidth > detailsAvailableWidth) {
+			projUseTwoLineLayout = true;
+			projCol2 = `${import_picocolors$5.default.gray("Tokens:")} ${formatTokenDisplay(projection.totalTokens, true)}`;
+		}
+		if (projUseTwoLineLayout) {
+			const projDetailsLine1 = `${" ".repeat(detailsIndent)}${projCol1}`;
+			const projDetailsLine1Padded = projDetailsLine1 + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(projDetailsLine1)));
+			terminal.write(`${marginStr}│ ${projDetailsLine1Padded}│\n`);
+			const projDetailsLine2 = `${" ".repeat(detailsIndent)}${projCol2}${" ".repeat(detailsSpacing)}${projCol3}`;
+			const projDetailsLine2Padded = projDetailsLine2 + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(projDetailsLine2)));
+			terminal.write(`${marginStr}│ ${projDetailsLine2Padded}│\n`);
 		} else {
-			const projBarStr = `${projLabel}${"".padEnd(Math.max(0, labelWidth - projLabelWidth))} ${projectionBar} (${formatTokensShort(projection.totalTokens)} tokens)`;
-			const projBarPadded = projBarStr + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(projBarStr)));
-			terminal.write(`${marginStr}│ ${projBarPadded}│\n`);
-			const col1$1 = `${import_picocolors$5.default.gray("Status:")} ${limitStatus}`;
-			const col2$1 = `${import_picocolors$5.default.gray("Tokens:")} ${formatNumber(projection.totalTokens)}`;
-			const col3$1 = `${import_picocolors$5.default.gray("Cost:")} ${formatCurrency(projection.totalCost)}`;
-			const col1Visible$1 = stringWidth(col1$1);
-			const col2Visible$1 = stringWidth(col2$1);
-			const pad1$1 = " ".repeat(Math.max(0, DETAIL_COLUMN_WIDTHS.col1 - col1Visible$1));
-			const pad2$1 = " ".repeat(Math.max(0, DETAIL_COLUMN_WIDTHS.col2 - col2Visible$1));
-			const projDetails = `   ${col1$1}${pad1$1}${col2$1}${pad2$1}${col3$1}`;
+			const projDetails = `${" ".repeat(detailsIndent)}${projCol1}${" ".repeat(detailsSpacing)}${projCol2}${" ".repeat(detailsSpacing)}${projCol3}`;
 			const projDetailsPadded = projDetails + " ".repeat(Math.max(0, boxWidth - 3 - stringWidth(projDetails)));
 			terminal.write(`${marginStr}│ ${projDetailsPadded}│\n`);
 		}
@@ -3970,7 +3984,15 @@ async function startLiveMonitoring(config) {
 					}
 					renderActiveBlock(terminal, activeBlock, config);
 					lastRenderTime = Date.now();
-					await delayWithAbort(config.refreshInterval, abortController.signal);
+					let resizeEventHandler;
+					try {
+						await Promise.race([delayWithAbort(config.refreshInterval, abortController.signal), new Promise((resolve) => {
+							resizeEventHandler = resolve;
+							process$1.stdout.once("resize", resolve);
+						})]);
+					} finally {
+						if (resizeEventHandler != null) process$1.stdout.removeListener("resize", resizeEventHandler);
+					}
 				}
 			},
 			catch: (error) => error
@@ -4329,11 +4351,162 @@ const blocksCommand = define({
 		}
 	}
 });
+/**
+* Group daily usage data by project for JSON output
+*/
+function groupByProject(dailyData) {
+	const projects = {};
+	for (const data of dailyData) {
+		const projectName = data.project ?? "unknown";
+		if (projects[projectName] == null) projects[projectName] = [];
+		projects[projectName].push({
+			date: data.date,
+			inputTokens: data.inputTokens,
+			outputTokens: data.outputTokens,
+			cacheCreationTokens: data.cacheCreationTokens,
+			cacheReadTokens: data.cacheReadTokens,
+			totalTokens: getTotalTokens(data),
+			totalCost: data.totalCost,
+			modelsUsed: data.modelsUsed,
+			modelBreakdowns: data.modelBreakdowns
+		});
+	}
+	return projects;
+}
+/**
+* Group daily usage data by project for table display
+*/
+function groupDataByProject(dailyData) {
+	const projects = {};
+	for (const data of dailyData) {
+		const projectName = data.project ?? "unknown";
+		if (projects[projectName] == null) projects[projectName] = [];
+		projects[projectName].push(data);
+	}
+	return projects;
+}
+/**
+* Cache for parsed aliases to avoid repeated parsing
+*/
+let aliasCache = null;
+/**
+* Parse project aliases from environment variable
+* @returns Map of raw project names to their aliases
+*/
+function getProjectAliases() {
+	if (aliasCache !== null) return aliasCache;
+	aliasCache = /* @__PURE__ */ new Map();
+	const aliasEnv = (process$1.env[PROJECT_ALIASES_ENV] ?? "").trim();
+	if (aliasEnv === "") return aliasCache;
+	const pairs = aliasEnv.split(",").map((pair) => pair.trim()).filter((pair) => pair !== "");
+	for (const pair of pairs) {
+		const parts = pair.split("=").map((s) => s.trim());
+		const rawName = parts[0];
+		const alias = parts[1];
+		if (rawName != null && alias != null && rawName !== "" && alias !== "") aliasCache.set(rawName, alias);
+	}
+	return aliasCache;
+}
+/**
+* Extract meaningful project name from directory-style project paths
+* Uses improved heuristics to handle complex project structures
+*
+* @param projectName - Raw project name from directory path
+* @returns Cleaned and formatted project name
+*
+* @example
+* ```typescript
+* // Basic cleanup
+* parseProjectName('-Users-phaedrus-Development-ccusage')
+* // → 'ccusage'
+*
+* // Complex project with feature branch
+* parseProjectName('-Users-phaedrus-Development-adminifi-edugakko-api--feature-ticket-002-configure-dependabot')
+* // → 'configure-dependabot'
+*
+* // Handle unknown projects
+* parseProjectName('unknown')
+* // → 'Unknown Project'
+* ```
+*/
+function parseProjectName(projectName) {
+	if (projectName === "unknown" || projectName === "") return "Unknown Project";
+	let cleaned = projectName;
+	if (cleaned.match(/^[A-Z]:\\Users\\|^\\Users\\/) != null) {
+		const segments = cleaned.split("\\");
+		const userIndex = segments.findIndex((seg) => seg === "Users");
+		if (userIndex !== -1 && userIndex + 3 < segments.length) cleaned = segments.slice(userIndex + 3).join("-");
+	}
+	if (cleaned.startsWith("-Users-") || cleaned.startsWith("/Users/")) {
+		const separator = cleaned.startsWith("-Users-") ? "-" : "/";
+		const segments = cleaned.split(separator).filter((s) => s.length > 0);
+		const userIndex = segments.findIndex((seg) => seg === "Users");
+		if (userIndex !== -1 && userIndex + 3 < segments.length) cleaned = segments.slice(userIndex + 3).join("-");
+	}
+	if (cleaned === projectName) cleaned = projectName.replace(/^[/\\-]+|[/\\-]+$/g, "");
+	if (cleaned.match(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/i) != null) {
+		const parts = cleaned.split("-");
+		if (parts.length >= 5) cleaned = parts.slice(-2).join("-");
+	}
+	if (cleaned.includes("--")) {
+		const parts = cleaned.split("--");
+		if (parts.length >= 2 && parts[0] != null) cleaned = parts[0];
+	}
+	if (cleaned.includes("-") && cleaned.length > 20) {
+		const segments = cleaned.split("-");
+		const meaningfulSegments = segments.filter((seg) => seg.length > 2 && seg.match(/^(?:dev|development|feat|feature|fix|bug|test|staging|prod|production|main|master|branch)$/i) == null);
+		if (meaningfulSegments.length >= 2) {
+			const lastSegments = meaningfulSegments.slice(-2);
+			if (lastSegments.join("-").length >= 6) cleaned = lastSegments.join("-");
+			else if (meaningfulSegments.length >= 3) cleaned = meaningfulSegments.slice(-3).join("-");
+		}
+	}
+	cleaned = cleaned.replace(/^[/\\-]+|[/\\-]+$/g, "");
+	return cleaned !== "" ? cleaned : projectName !== "" ? projectName : "Unknown Project";
+}
+/**
+* Format project name for display with custom alias support
+*
+* @param projectName - Raw project name from directory path
+* @returns User-friendly project name with alias support
+*
+* @example
+* ```typescript
+* // Without aliases
+* formatProjectName('-Users-phaedrus-Development-ccusage')
+* // → 'ccusage'
+*
+* // With alias (when CCUSAGE_PROJECT_ALIASES="ccusage=Usage Tracker")
+* formatProjectName('-Users-phaedrus-Development-ccusage')
+* // → 'Usage Tracker'
+* ```
+*/
+function formatProjectName(projectName) {
+	const aliases = getProjectAliases();
+	if (aliases.has(projectName)) return aliases.get(projectName);
+	const parsed = parseProjectName(projectName);
+	if (aliases.has(parsed)) return aliases.get(parsed);
+	return parsed;
+}
 var import_picocolors$2 = __toESM(require_picocolors(), 1);
 const dailyCommand = define({
 	name: "daily",
 	description: "Show usage report grouped by date",
 	...sharedCommandConfig,
+	args: {
+		...sharedCommandConfig.args,
+		instances: {
+			type: "boolean",
+			short: "i",
+			description: "Show usage breakdown by project/instance",
+			default: false
+		},
+		project: {
+			type: "string",
+			short: "p",
+			description: "Filter to specific project name"
+		}
+	},
 	async run(ctx) {
 		if (ctx.values.json) logger.level = 0;
 		const dailyData = await loadDailyUsageData({
@@ -4341,7 +4514,9 @@ const dailyCommand = define({
 			until: ctx.values.until,
 			mode: ctx.values.mode,
 			order: ctx.values.order,
-			offline: ctx.values.offline
+			offline: ctx.values.offline,
+			groupByProject: ctx.values.instances,
+			project: ctx.values.project
 		});
 		if (dailyData.length === 0) {
 			if (ctx.values.json) log(JSON.stringify([]));
@@ -4354,7 +4529,10 @@ const dailyCommand = define({
 			printMismatchReport(mismatchStats, ctx.values.debugSamples);
 		}
 		if (ctx.values.json) {
-			const jsonOutput = {
+			const jsonOutput = ctx.values.instances && dailyData.some((d) => d.project != null) ? {
+				projects: groupByProject(dailyData),
+				totals: createTotalsObject(totals)
+			} : {
 				daily: dailyData.map((data) => ({
 					date: data.date,
 					inputTokens: data.inputTokens,
@@ -4364,7 +4542,8 @@ const dailyCommand = define({
 					totalTokens: getTotalTokens(data),
 					totalCost: data.totalCost,
 					modelsUsed: data.modelsUsed,
-					modelBreakdowns: data.modelBreakdowns
+					modelBreakdowns: data.modelBreakdowns,
+					...data.project != null && { project: data.project }
 				})),
 				totals: createTotalsObject(totals)
 			};
@@ -4410,7 +4589,46 @@ const dailyCommand = define({
 				],
 				compactThreshold: 100
 			});
-			for (const data of dailyData) {
+			if (ctx.values.instances && dailyData.some((d) => d.project != null)) {
+				const projectGroups = groupDataByProject(dailyData);
+				let isFirstProject = true;
+				for (const [projectName, projectData] of Object.entries(projectGroups)) {
+					if (!isFirstProject) table.push([
+						"",
+						"",
+						"",
+						"",
+						"",
+						"",
+						"",
+						""
+					]);
+					table.push([
+						import_picocolors$2.default.cyan(`Project: ${formatProjectName(projectName)}`),
+						"",
+						"",
+						"",
+						"",
+						"",
+						"",
+						""
+					]);
+					for (const data of projectData) {
+						table.push([
+							data.date,
+							formatModelsDisplayMultiline(data.modelsUsed),
+							formatNumber(data.inputTokens),
+							formatNumber(data.outputTokens),
+							formatNumber(data.cacheCreationTokens),
+							formatNumber(data.cacheReadTokens),
+							formatNumber(getTotalTokens(data)),
+							formatCurrency(data.totalCost)
+						]);
+						if (ctx.values.breakdown) pushBreakdownRows(table, data.modelBreakdowns);
+					}
+					isFirstProject = false;
+				}
+			} else for (const data of dailyData) {
 				table.push([
 					data.date,
 					formatModelsDisplayMultiline(data.modelsUsed),
@@ -5072,7 +5290,8 @@ const sessionCommand = define({
 					totalCost: data.totalCost,
 					lastActivity: data.lastActivity,
 					modelsUsed: data.modelsUsed,
-					modelBreakdowns: data.modelBreakdowns
+					modelBreakdowns: data.modelBreakdowns,
+					projectPath: data.projectPath
 				})),
 				totals: createTotalsObject(totals)
 			};

package/dist/{logger-mXUMXvyg.js → logger-COLgmk2z.js}

@@ -951,7 +951,7 @@ function _getDefaultLogLevel() {
 }
 const consola = createConsola$1();
 var name = "ccusage";
-var version = "15.4.0";
+var version = "15.5.1";
 var description = "Usage analysis tool for Claude Code";
 /**
 * Application logger instance with package name tag

package/dist/logger.js

@@ -1,2 +1,2 @@
-import { log, logger } from "./logger-mXUMXvyg.js";
+import { log, logger } from "./logger-COLgmk2z.js";
 export { log, logger };

package/dist/{mcp-CQw7snVU.js → mcp-Ta2UK9sc.js}

@@ -1,9 +1,9 @@
-import { __commonJSMin, __toESM, require_usingCtx } from "./pricing-fetcher-KIIpXo8L.js";
+import { __commonJSMin, __toESM, require_usingCtx } from "./pricing-fetcher-eNV76BjF.js";
 import { getTotalTokens } from "./_token-utils-WjkbrjKv.js";
 import { ZodFirstPartyTypeKind, ZodOptional, ZodType, arrayType, booleanType, discriminatedUnionType, enumType, filterDateSchema, literalType, numberType, objectType, optionalType, recordType, stringType, unionType, unknownType } from "./_types-BHFM59hI.js";
 import { calculateTotals, createTotalsObject } from "./calculate-cost-BDqO4yWA.js";
-import { getClaudePaths, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData } from "./data-loader-BNrxyvc9.js";
-import { name, version } from "./logger-mXUMXvyg.js";
+import { getClaudePaths, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData } from "./data-loader-BAp4u-7e.js";
+import { name, version } from "./logger-COLgmk2z.js";
 import process from "node:process";
 const LATEST_PROTOCOL_VERSION = "2025-06-18";
 const SUPPORTED_PROTOCOL_VERSIONS = [
@@ -1605,6 +1605,7 @@ var Protocol = class {
 		this._responseHandlers = /* @__PURE__ */ new Map();
 		this._progressHandlers = /* @__PURE__ */ new Map();
 		this._timeoutInfo = /* @__PURE__ */ new Map();
+		this._pendingDebouncedNotifications = /* @__PURE__ */ new Set();
 		this.setNotificationHandler(CancelledNotificationSchema, (notification) => {
 			const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
 			controller === null || controller === void 0 || controller.abort(notification.params.reason);
@@ -1679,6 +1680,7 @@ var Protocol = class {
 		const responseHandlers = this._responseHandlers;
 		this._responseHandlers = /* @__PURE__ */ new Map();
 		this._progressHandlers.clear();
+		this._pendingDebouncedNotifications.clear();
 		this._transport = void 0;
 		(_a = this.onclose) === null || _a === void 0 || _a.call(this);
 		const error = new McpError(ErrorCode.ConnectionClosed, "Connection closed");
@@ -1872,8 +1874,26 @@ var Protocol = class {
 	* Emits a notification, which is a one-way message that does not expect a response.
 	*/
 	async notification(notification, options) {
+		var _a, _b;
 		if (!this._transport) throw new Error("Not connected");
 		this.assertNotificationCapability(notification.method);
+		const debouncedMethods = (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.debouncedNotificationMethods) !== null && _b !== void 0 ? _b : [];
+		const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !(options === null || options === void 0 ? void 0 : options.relatedRequestId);
+		if (canDebounce) {
+			if (this._pendingDebouncedNotifications.has(notification.method)) return;
+			this._pendingDebouncedNotifications.add(notification.method);
+			Promise.resolve().then(() => {
+				var _a$1;
+				this._pendingDebouncedNotifications.delete(notification.method);
+				if (!this._transport) return;
+				const jsonrpcNotification$1 = {
+					...notification,
+					jsonrpc: "2.0"
+				};
+				(_a$1 = this._transport) === null || _a$1 === void 0 || _a$1.send(jsonrpcNotification$1, options).catch((error) => this._onerror(error));
+			});
+			return;
+		}
 		const jsonrpcNotification = {
 			...notification,
 			jsonrpc: "2.0"

package/dist/mcp.d.ts

@@ -1,4 +1,4 @@
-import { LoadOptions } from "./data-loader-7c4yXbqG.js";
+import { LoadOptions } from "./data-loader-CgvyDaQD.js";
 import "./pricing-fetcher-B3SvKOod.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { Hono } from "hono/tiny";

package/dist/mcp.js

@@ -1,8 +1,8 @@
-import "./pricing-fetcher-KIIpXo8L.js";
+import "./pricing-fetcher-eNV76BjF.js";
 import "./_token-utils-WjkbrjKv.js";
 import "./_types-BHFM59hI.js";
 import "./calculate-cost-BDqO4yWA.js";
-import "./data-loader-BNrxyvc9.js";
-import "./logger-mXUMXvyg.js";
-import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-CQw7snVU.js";
+import "./data-loader-BAp4u-7e.js";
+import "./logger-COLgmk2z.js";
+import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-Ta2UK9sc.js";
 export { createMcpHttpApp, createMcpServer, startMcpServerStdio };

package/dist/{pricing-fetcher-KIIpXo8L.js → pricing-fetcher-eNV76BjF.js}

@@ -1,5 +1,5 @@
 import { modelPricingSchema } from "./_types-BHFM59hI.js";
-import { logger } from "./logger-mXUMXvyg.js";
+import { logger } from "./logger-COLgmk2z.js";
 import { createRequire } from "node:module";
 import path from "node:path";
 import F, { homedir } from "node:os";
@@ -192,6 +192,28 @@ const DEFAULT_CLAUDE_CONFIG_PATH = `${XDG_CONFIG_DIR}/claude`;
 */
 const CLAUDE_CONFIG_DIR_ENV = "CLAUDE_CONFIG_DIR";
 /**
+* Environment variable for custom project name aliases
+*
+* Allows users to configure readable display names for cryptic or long project directory names.
+* This is particularly useful for:
+* - UUID-based project directories generated by Claude Code
+* - Long path-based project names that are hard to read in tables
+* - Custom branding of project names for organizational consistency
+*
+* Format: "raw-name=alias,another-name=other-alias"
+* Example: "a2cd99ed-a586-4fe4-8f59-b0026409ec09=My Project,long-project-name=Short"
+*
+* Environment variable approach is used because:
+* - No config file needed - simple and lightweight configuration
+* - Works in any shell/environment without file management
+* - Easy to set temporarily for specific invocations
+* - Follows Unix conventions for tool configuration
+* - Doesn't require file system permissions or config directory setup
+*
+* Used to override display names for project directories in all output formats.
+*/
+const PROJECT_ALIASES_ENV = "CCUSAGE_PROJECT_ALIASES";
+/**
 * Claude projects directory name within the data directory
 * Contains subdirectories for each project with usage data
 */
@@ -538,4 +560,4 @@ var PricingFetcher = class {
 		return cost;
 	}
 };
-export { BLOCKS_COMPACT_WIDTH_THRESHOLD, BLOCKS_DEFAULT_TERMINAL_WIDTH, BLOCKS_WARNING_THRESHOLD, BURN_RATE_THRESHOLDS, CLAUDE_CONFIG_DIR_ENV, CLAUDE_PROJECTS_DIR_NAME, DEBUG_MATCH_THRESHOLD_PERCENT, DEFAULT_CLAUDE_CODE_PATH, DEFAULT_CLAUDE_CONFIG_PATH, DEFAULT_RECENT_DAYS, DEFAULT_REFRESH_INTERVAL_SECONDS, MAX_REFRESH_INTERVAL_SECONDS, MCP_DEFAULT_PORT, MIN_REFRESH_INTERVAL_SECONDS, MIN_RENDER_INTERVAL_MS, PricingFetcher, USAGE_DATA_GLOB_PATTERN, USER_HOME_DIR, __commonJSMin, __require, __toESM, isFailure, isPromise, require_usingCtx, try_ };
+export { BLOCKS_COMPACT_WIDTH_THRESHOLD, BLOCKS_DEFAULT_TERMINAL_WIDTH, BLOCKS_WARNING_THRESHOLD, BURN_RATE_THRESHOLDS, CLAUDE_CONFIG_DIR_ENV, CLAUDE_PROJECTS_DIR_NAME, DEBUG_MATCH_THRESHOLD_PERCENT, DEFAULT_CLAUDE_CODE_PATH, DEFAULT_CLAUDE_CONFIG_PATH, DEFAULT_RECENT_DAYS, DEFAULT_REFRESH_INTERVAL_SECONDS, MAX_REFRESH_INTERVAL_SECONDS, MCP_DEFAULT_PORT, MIN_REFRESH_INTERVAL_SECONDS, MIN_RENDER_INTERVAL_MS, PROJECT_ALIASES_ENV, PricingFetcher, USAGE_DATA_GLOB_PATTERN, USER_HOME_DIR, __commonJSMin, __require, __toESM, isFailure, isPromise, require_usingCtx, try_ };

package/dist/pricing-fetcher.js

@@ -1,4 +1,4 @@
-import { PricingFetcher } from "./pricing-fetcher-KIIpXo8L.js";
+import { PricingFetcher } from "./pricing-fetcher-eNV76BjF.js";
 import "./_types-BHFM59hI.js";
-import "./logger-mXUMXvyg.js";
+import "./logger-COLgmk2z.js";
 export { PricingFetcher };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccusage",
-  "version": "15.4.0",
+  "version": "15.5.1",
   "description": "Usage analysis tool for Claude Code",
   "homepage": "https://github.com/ryoppippi/ccusage#readme",
   "bugs": {