ccusage 15.3.1 → 15.5.0

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-a9CiVyT5.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-DqK3z1AK.js → data-loader-BVwVxx4T.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-DpoTR8Md.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-B2yEbqCO.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-D7tlrIfv.js";
+import { logger } from "./logger-CZzaUNvP.js";
 import a, { readFile } from "node:fs/promises";
 import path, { posix } from "node:path";
 import process$1 from "node:process";
@@ -251,7 +251,7 @@ const unwrap = (...args) => {
 		const apply = (r) => {
 			if (isFailure(r)) {
 				if (hasDefault$1) return defaultValue$1;
-				throw new Error(String(r.error));
+				throw r.error;
 			}
 			return r.value;
 		};
@@ -263,7 +263,7 @@ const unwrap = (...args) => {
 		const apply = (r) => {
 			if (isFailure(r)) {
 				if (hasDefault) return defaultValue;
-				throw new Error(String(r.error));
+				throw r.error;
 			}
 			return r.value;
 		};
@@ -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) {
@@ -3518,16 +3543,26 @@ function extractUniqueModels(entries, getModel) {
 	return uniq(entries.map(getModel).filter((m$1) => m$1 != null && m$1 !== "<synthetic>"));
 }
 /**
+* Shared method for formatting dates with proper timezone handling
+* @param dateStr - Input date string
+* @param twoLine - Whether to format as two lines (true) or single line (false)
+* @returns Formatted date string
+*/
+function formatDateInternal(dateStr, twoLine) {
+	const date = new Date(dateStr);
+	const hasTimezone = /Z|[+-]\d{2}:\d{2}/.test(dateStr);
+	const year = hasTimezone ? date.getUTCFullYear() : date.getFullYear();
+	const month = String(hasTimezone ? date.getUTCMonth() + 1 : date.getMonth() + 1).padStart(2, "0");
+	const day = String(hasTimezone ? date.getUTCDate() : date.getDate()).padStart(2, "0");
+	return twoLine ? `${year}\n${month}-${day}` : `${year}-${month}-${day}`;
+}
+/**
 * Formats a date string to YYYY-MM-DD format
 * @param dateStr - Input date string
 * @returns Formatted date string in YYYY-MM-DD format
 */
 function formatDate(dateStr) {
-	const date = new Date(dateStr);
-	const year = date.getFullYear();
-	const month = String(date.getMonth() + 1).padStart(2, "0");
-	const day = String(date.getDate()).padStart(2, "0");
-	return `${year}-${month}-${day}`;
+	return formatDateInternal(dateStr, false);
 }
 /**
 * Formats a date string to compact format with year on first line and month-day on second
@@ -3535,11 +3570,7 @@ function formatDate(dateStr) {
 * @returns Formatted date string with newline separator (YYYY\nMM-DD)
 */
 function formatDateCompact(dateStr) {
-	const date = new Date(dateStr);
-	const year = date.getFullYear();
-	const month = String(date.getMonth() + 1).padStart(2, "0");
-	const day = String(date.getDate()).padStart(2, "0");
-	return `${year}\n${month}-${day}`;
+	return formatDateInternal(dateStr, true);
 }
 /**
 * Generic function to sort items by date based on sort order
@@ -3647,6 +3678,25 @@ function getUsageLimitResetTime(data) {
 	return resetTime;
 }
 /**
+* Glob files from multiple Claude paths in parallel
+* @param claudePaths - Array of Claude base paths
+* @returns Array of file paths with their base directories
+*/
+async function globUsageFiles(claudePaths) {
+	const filePromises = claudePaths.map(async (claudePath) => {
+		const claudeDir = path.join(claudePath, CLAUDE_PROJECTS_DIR_NAME);
+		const files = await glob([USAGE_DATA_GLOB_PATTERN], {
+			cwd: claudeDir,
+			absolute: true
+		}).catch(() => []);
+		return files.map((file) => ({
+			file,
+			baseDir: claudeDir
+		}));
+	});
+	return (await Promise.all(filePromises)).flat();
+}
+/**
 * Loads and aggregates Claude usage data by day
 * Processes all JSONL files in the Claude projects directory and groups usage by date
 * @param options - Optional configuration for loading and filtering data
@@ -3656,17 +3706,11 @@ async function loadDailyUsageData(options) {
 	try {
 		var _usingCtx = (0, import_usingCtx.default)();
 		const claudePaths = toArray(options?.claudePath ?? getClaudePaths());
-		const allFiles = [];
-		for (const claudePath of claudePaths) {
-			const claudeDir = path.join(claudePath, CLAUDE_PROJECTS_DIR_NAME);
-			const files = await glob([USAGE_DATA_GLOB_PATTERN], {
-				cwd: claudeDir,
-				absolute: true
-			});
-			allFiles.push(...files);
-		}
-		if (allFiles.length === 0) return [];
-		const sortedFiles = await sortFilesByTimestamp(allFiles);
+		const allFiles = await globUsageFiles(claudePaths);
+		const fileList = allFiles.map((f$1) => f$1.file);
+		if (fileList.length === 0) return [];
+		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();
@@ -3684,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);
@@ -3703,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 {
@@ -3724,21 +3777,11 @@ async function loadSessionData(options) {
 	try {
 		var _usingCtx3 = (0, import_usingCtx.default)();
 		const claudePaths = toArray(options?.claudePath ?? getClaudePaths());
-		const filesWithBase = [];
-		for (const claudePath of claudePaths) {
-			const claudeDir = path.join(claudePath, CLAUDE_PROJECTS_DIR_NAME);
-			const files = await glob([USAGE_DATA_GLOB_PATTERN], {
-				cwd: claudeDir,
-				absolute: true
-			});
-			for (const file of files) filesWithBase.push({
-				file,
-				baseDir: claudeDir
-			});
-		}
+		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) ?? ""
 		})));
@@ -3795,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 {
@@ -3811,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);
@@ -3840,7 +3889,8 @@ async function loadMonthlyUsageData(options) {
 			cacheReadTokens: totalCacheReadTokens,
 			totalCost,
 			modelsUsed: uniq(models),
-			modelBreakdowns
+			modelBreakdowns,
+			...project != null && { project }
 		};
 		monthlyArray.push(monthlyUsage);
 	}
@@ -3866,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();
@@ -3902,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, 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-a9CiVyT5.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
@@ -446,6 +458,19 @@ declare function calculateCostForEntry(data: UsageData, mode: CostMode, fetcher:
  * @returns Usage limit expiration date
  */
 declare function getUsageLimitResetTime(data: UsageData): Date | null;
+/**
+ * Result of glob operation with base directory information
+ */
+type GlobResult = {
+  file: string;
+  baseDir: string;
+};
+/**
+ * Glob files from multiple Claude paths in parallel
+ * @param claudePaths - Array of Claude base paths
+ * @returns Array of file paths with their base directories
+ */
+declare function globUsageFiles(claudePaths: string[]): Promise<GlobResult[]>;
 /**
  * Date range filter for limiting usage data by date
  */
@@ -462,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
@@ -492,4 +519,4 @@ declare function loadMonthlyUsageData(options?: LoadOptions): Promise<MonthlyUsa
  */
 declare function loadSessionBlockData(options?: LoadOptions): Promise<SessionBlock[]>;
 //#endregion
-export { DailyUsage, DateFilter, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, 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, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-a9CiVyT5.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, LoadOptions, ModelBreakdown, MonthlyUsage, SessionUsage, UsageData, calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, 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-DpoTR8Md.js";
+import "./pricing-fetcher-B2yEbqCO.js";
 import "./_token-utils-WjkbrjKv.js";
 import "./_types-BHFM59hI.js";
-import { calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema } from "./data-loader-DqK3z1AK.js";
-import "./logger-D7tlrIfv.js";
-export { calculateCostForEntry, createUniqueHash, dailyUsageSchema, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, 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-BVwVxx4T.js";
+import "./logger-CZzaUNvP.js";
+export { calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, formatDate, formatDateCompact, getClaudePaths, getEarliestTimestamp, getUsageLimitResetTime, globUsageFiles, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, modelBreakdownSchema, monthlyUsageSchema, sessionUsageSchema, sortFilesByTimestamp, usageDataSchema };

package/dist/{debug-Cby_QhQQ.js → debug-DtmspKbf.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-DpoTR8Md.js";
-import { getClaudePaths, glob, unwrap, usageDataSchema } from "./data-loader-DqK3z1AK.js";
-import { logger } from "./logger-D7tlrIfv.js";
+import { CLAUDE_PROJECTS_DIR_NAME, DEBUG_MATCH_THRESHOLD_PERCENT, PricingFetcher, USAGE_DATA_GLOB_PATTERN, __toESM, isFailure, require_usingCtx, try_ } from "./pricing-fetcher-B2yEbqCO.js";
+import { getClaudePaths, glob, unwrap, usageDataSchema } from "./data-loader-BVwVxx4T.js";
+import { logger } from "./logger-CZzaUNvP.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-DpoTR8Md.js";
+import "./pricing-fetcher-B2yEbqCO.js";
 import "./_token-utils-WjkbrjKv.js";
 import "./_types-BHFM59hI.js";
-import "./data-loader-DqK3z1AK.js";
-import "./logger-D7tlrIfv.js";
-import { detectMismatches, printMismatchReport } from "./debug-Cby_QhQQ.js";
+import "./data-loader-BVwVxx4T.js";
+import "./logger-CZzaUNvP.js";
+import { detectMismatches, printMismatchReport } from "./debug-DtmspKbf.js";
 export { detectMismatches, printMismatchReport };

package/dist/index.js

@@ -1,14 +1,13 @@
 #!/usr/bin/env node
-import { BLOCKS_COMPACT_WIDTH_THRESHOLD, BLOCKS_DEFAULT_TERMINAL_WIDTH, BLOCKS_WARNING_THRESHOLD, BURN_RATE_THRESHOLDS, CLAUDE_PROJECTS_DIR_NAME, 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, __commonJSMin, __require, __toESM, isFailure, require_usingCtx, try_ } from "./pricing-fetcher-DpoTR8Md.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-B2yEbqCO.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, glob, identifySessionBlocks, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, projectBlockUsage, sortFilesByTimestamp, uniq, usageDataSchema } from "./data-loader-DqK3z1AK.js";
-import { description, log, logger, name, version } from "./logger-D7tlrIfv.js";
-import { detectMismatches, printMismatchReport } from "./debug-Cby_QhQQ.js";
-import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-CFT0dcvs.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-BVwVxx4T.js";
+import { description, log, logger, name, version } from "./logger-CZzaUNvP.js";
+import { detectMismatches, printMismatchReport } from "./debug-DtmspKbf.js";
+import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-DRNUcHZe.js";
 import { readFile } from "node:fs/promises";
-import path from "node:path";
 import process$1 from "node:process";
 import { createServer } from "node:http";
 import { Http2ServerRequest } from "node:http2";
@@ -3205,14 +3204,11 @@ var LiveMonitor = class {
 	* Only reads new or modified files since last check
 	*/
 	async getActiveBlock() {
-		const claudeDir = path.join(this.config.claudePath, CLAUDE_PROJECTS_DIR_NAME);
-		const files = await glob([USAGE_DATA_GLOB_PATTERN], {
-			cwd: claudeDir,
-			absolute: true
-		});
-		if (files.length === 0) return null;
+		const results = await globUsageFiles(this.config.claudePaths);
+		const allFiles = results.map((r) => r.file);
+		if (allFiles.length === 0) return null;
 		const filesToRead = [];
-		for (const file of files) {
+		for (const file of allFiles) {
 			const timestamp = await getEarliestTimestamp(file);
 			const lastTimestamp = this.lastFileTimestamps.get(file);
 			if (timestamp != null && (lastTimestamp == null || timestamp.getTime() > lastTimestamp)) {
@@ -3745,7 +3741,7 @@ const DETAIL_COLUMN_WIDTHS = {
 function renderLiveDisplay(terminal, block, config) {
 	const width = terminal.width;
 	const now = /* @__PURE__ */ new Date();
-	const totalTokens = block.tokenCounts.inputTokens + block.tokenCounts.outputTokens;
+	const totalTokens = getTotalTokens(block.tokenCounts);
 	const elapsed = (now.getTime() - block.startTime.getTime()) / (1e3 * 60);
 	const remaining = (block.endTime.getTime() - now.getTime()) / (1e3 * 60);
 	if (width < 60) {
@@ -3952,7 +3948,7 @@ async function startLiveMonitoring(config) {
 		terminal.clearScreen();
 		terminal.hideCursor();
 		const monitor = _usingCtx.u(new LiveMonitor({
-			claudePath: config.claudePath,
+			claudePaths: config.claudePaths,
 			sessionDurationHours: config.sessionDurationHours,
 			mode: config.mode,
 			order: config.order
@@ -4052,8 +4048,7 @@ function formatModels(models) {
 * @returns Parsed token limit or undefined if invalid
 */
 function parseTokenLimit(value, maxFromAll) {
-	if (value == null || value === "") return void 0;
-	if (value === "max") return maxFromAll > 0 ? maxFromAll : void 0;
+	if (value == null || value === "" || value === "max") return maxFromAll > 0 ? maxFromAll : void 0;
 	const limit = Number.parseInt(value, 10);
 	return Number.isNaN(limit) ? void 0 : limit;
 }
@@ -4117,7 +4112,7 @@ const blocksCommand = define({
 			process$1.exit(0);
 		}
 		let maxTokensFromAll = 0;
-		if (ctx.values.tokenLimit === "max") {
+		if (ctx.values.tokenLimit === "max" || ctx.values.tokenLimit == null || ctx.values.tokenLimit === "") {
 			for (const block of blocks) if (!(block.isGap ?? false) && !block.isActive) {
 				const blockTokens = getTotalTokens(block.tokenCounts);
 				if (blockTokens > maxTokensFromAll) maxTokensFromAll = blockTokens;
@@ -4151,7 +4146,7 @@ const blocksCommand = define({
 				throw new Error("No valid Claude data directory found");
 			}
 			await startLiveMonitoring({
-				claudePath: paths[0],
+				claudePaths: paths,
 				tokenLimit: parseTokenLimit(tokenLimitValue, maxTokensFromAll),
 				refreshInterval: refreshInterval * 1e3,
 				sessionDurationHours: ctx.values.sessionLength,
@@ -4173,7 +4168,7 @@ const blocksCommand = define({
 					isGap: block.isGap ?? false,
 					entries: block.entries.length,
 					tokenCounts: block.tokenCounts,
-					totalTokens: block.tokenCounts.inputTokens + block.tokenCounts.outputTokens,
+					totalTokens: getTotalTokens(block.tokenCounts),
 					costUSD: block.costUSD,
 					models: block.models,
 					burnRate,
@@ -4334,11 +4329,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({
@@ -4346,7 +4492,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([]));
@@ -4359,7 +4507,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,
@@ -4369,7 +4520,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)
 			};
@@ -4415,7 +4567,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),
@@ -4474,6 +4665,7 @@ var Request = class extends GlobalRequest {
 		super(input, options);
 	}
 };
+var wrapBodyStream = Symbol("wrapBodyStream");
 var newRequestFromIncoming = (method, url, incoming, abortController) => {
 	const headerRecord = [];
 	const rawHeaders = incoming.rawHeaders;
@@ -4498,7 +4690,19 @@ var newRequestFromIncoming = (method, url, incoming, abortController) => {
 		controller.enqueue(incoming.rawBody);
 		controller.close();
 	} });
-	else init$1.body = Readable.toWeb(incoming);
+	else if (incoming[wrapBodyStream]) {
+		let reader;
+		init$1.body = new ReadableStream({ async pull(controller) {
+			try {
+				reader ||= Readable.toWeb(incoming).getReader();
+				const { done, value } = await reader.read();
+				if (done) controller.close();
+				else controller.enqueue(value);
+			} catch (error) {
+				controller.error(error);
+			}
+		} });
+	} else init$1.body = Readable.toWeb(incoming);
 	return new Request(url, init$1);
 };
 var getRequestCache = Symbol("getRequestCache");
@@ -4709,6 +4913,7 @@ global.fetch = (info$1, init$1) => {
 	};
 	return webFetch(info$1, init$1);
 };
+var outgoingEnded = Symbol("outgoingEnded");
 var regBuffer = /^no$/i;
 var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
 var handleRequestError = () => new Response(null, { status: 400 });
@@ -4737,8 +4942,9 @@ var responseViaCache = async (res, outgoing) => {
 	else if (body instanceof Blob) outgoing.end(new Uint8Array(await body.arrayBuffer()));
 	else {
 		flushHeaders(outgoing);
-		return writeFromReadableStream(body, outgoing)?.catch((e) => handleResponseError(e, outgoing));
+		await writeFromReadableStream(body, outgoing)?.catch((e) => handleResponseError(e, outgoing));
 	}
+	outgoing[outgoingEnded]?.();
 };
 var responseViaResponseObject = async (res, outgoing, options = {}) => {
 	if (res instanceof Promise) if (options.errorHandler) try {
@@ -4767,8 +4973,10 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
 		outgoing.writeHead(res.status, resHeaderRecord);
 		outgoing.end();
 	}
+	outgoing[outgoingEnded]?.();
 };
 var getRequestListener = (fetchCallback, options = {}) => {
+	const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
 	if (options.overrideGlobalObjects !== false && global.Request !== Request) {
 		Object.defineProperty(global, "Request", { value: Request });
 		Object.defineProperty(global, "Response", { value: Response2 });
@@ -4777,11 +4985,32 @@ var getRequestListener = (fetchCallback, options = {}) => {
 		let res, req;
 		try {
 			req = newRequest(incoming, options.hostname);
+			let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+			if (!incomingEnded) {
+				incoming[wrapBodyStream] = true;
+				incoming.on("end", () => {
+					incomingEnded = true;
+				});
+				if (incoming instanceof Http2ServerRequest) outgoing[outgoingEnded] = () => {
+					if (!incomingEnded) setTimeout(() => {
+						if (!incomingEnded) setTimeout(() => {
+							incoming.destroy();
+							outgoing.destroy();
+						});
+					});
+				};
+			}
 			outgoing.on("close", () => {
 				const abortController = req[abortControllerKey];
-				if (!abortController) return;
-				if (incoming.errored) req[abortControllerKey].abort(incoming.errored.toString());
-				else if (!outgoing.writableFinished) req[abortControllerKey].abort("Client connection prematurely closed.");
+				if (abortController) {
+					if (incoming.errored) req[abortControllerKey].abort(incoming.errored.toString());
+					else if (!outgoing.writableFinished) req[abortControllerKey].abort("Client connection prematurely closed.");
+				}
+				if (!incomingEnded) setTimeout(() => {
+					if (!incomingEnded) setTimeout(() => {
+						incoming.destroy();
+					});
+				});
 			});
 			res = fetchCallback(req, {
 				incoming,
@@ -4807,7 +5036,8 @@ var createAdaptorServer = (options) => {
 	const fetchCallback = options.fetch;
 	const requestListener = getRequestListener(fetchCallback, {
 		hostname: options.hostname,
-		overrideGlobalObjects: options.overrideGlobalObjects
+		overrideGlobalObjects: options.overrideGlobalObjects,
+		autoCleanupIncoming: options.autoCleanupIncoming
 	});
 	const createServer$1 = options.createServer || createServer;
 	const server = createServer$1(options.serverOptions || {}, requestListener);
@@ -5038,7 +5268,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-D7tlrIfv.js → logger-CZzaUNvP.js}

@@ -951,7 +951,7 @@ function _getDefaultLogLevel() {
 }
 const consola = createConsola$1();
 var name = "ccusage";
-var version = "15.3.1";
+var version = "15.5.0";
 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-D7tlrIfv.js";
+import { log, logger } from "./logger-CZzaUNvP.js";
 export { log, logger };

package/dist/{mcp-CFT0dcvs.js → mcp-DRNUcHZe.js}

@@ -1,9 +1,9 @@
-import { __commonJSMin, __toESM, require_usingCtx } from "./pricing-fetcher-DpoTR8Md.js";
+import { __commonJSMin, __toESM, require_usingCtx } from "./pricing-fetcher-B2yEbqCO.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-DqK3z1AK.js";
-import { name, version } from "./logger-D7tlrIfv.js";
+import { getClaudePaths, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData } from "./data-loader-BVwVxx4T.js";
+import { name, version } from "./logger-CZzaUNvP.js";
 import process from "node:process";
 const LATEST_PROTOCOL_VERSION = "2025-06-18";
 const SUPPORTED_PROTOCOL_VERSIONS = [
@@ -606,7 +606,7 @@ const ElicitRequestSchema = RequestSchema.extend({
 const ElicitResultSchema = ResultSchema.extend({
 	action: enumType([
 		"accept",
-		"reject",
+		"decline",
 		"cancel"
 	]),
 	content: optionalType(recordType(stringType(), unknownType()))
@@ -1054,7 +1054,7 @@ var HonoRequest = class {
 		return bodyCache[key] = raw$1[key]();
 	};
 	json() {
-		return this.#cachedBody("json");
+		return this.#cachedBody("text").then((text) => JSON.parse(text));
 	}
 	text() {
 		return this.#cachedBody("text");
@@ -8561,10 +8561,6 @@ var McpServer = class {
 			return registeredResourceTemplate;
 		}
 	}
-	/**
-	* Registers a resource with a config object and callback.
-	* For static resources, use a URI string. For dynamic resources, use a ResourceTemplate.
-	*/
 	registerResource(name$1, uriOrTemplate, config, readCallback) {
 		if (typeof uriOrTemplate === "string") {
 			if (this._registeredResources[uriOrTemplate]) throw new Error(`Resource ${uriOrTemplate} is already registered`);
@@ -8766,7 +8762,10 @@ var McpServer = class {
 		if (this.isConnected()) this.server.sendPromptListChanged();
 	}
 };
-const EMPTY_OBJECT_JSON_SCHEMA = { type: "object" };
+const EMPTY_OBJECT_JSON_SCHEMA = {
+	type: "object",
+	properties: {}
+};
 function isZodRawShape(obj) {
 	if (typeof obj !== "object" || obj === null) return false;
 	const isEmptyObject = Object.keys(obj).length === 0;

package/dist/mcp.d.ts

@@ -1,4 +1,4 @@
-import { LoadOptions } from "./data-loader-a9CiVyT5.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-DpoTR8Md.js";
+import "./pricing-fetcher-B2yEbqCO.js";
 import "./_token-utils-WjkbrjKv.js";
 import "./_types-BHFM59hI.js";
 import "./calculate-cost-BDqO4yWA.js";
-import "./data-loader-DqK3z1AK.js";
-import "./logger-D7tlrIfv.js";
-import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-CFT0dcvs.js";
+import "./data-loader-BVwVxx4T.js";
+import "./logger-CZzaUNvP.js";
+import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-DRNUcHZe.js";
 export { createMcpHttpApp, createMcpServer, startMcpServerStdio };

package/dist/{pricing-fetcher-DpoTR8Md.js → pricing-fetcher-B2yEbqCO.js}

@@ -1,5 +1,5 @@
 import { modelPricingSchema } from "./_types-BHFM59hI.js";
-import { logger } from "./logger-D7tlrIfv.js";
+import { logger } from "./logger-CZzaUNvP.js";
 import { createRequire } from "node:module";
 import path from "node:path";
 import F, { homedir } from "node:os";
@@ -47,6 +47,7 @@ const andThrough = (fn) => (result) => {
 	};
 	return isPromise(result) ? result.then(apply) : apply(result);
 };
+const isSuccess = (result) => "Success" === result.type;
 const succeed = (...args) => {
 	const value = args[0];
 	if (void 0 === value) return { type: "Success" };
@@ -71,7 +72,6 @@ const fail = (...args) => {
 		error
 	};
 };
-const isSuccess = (result) => "Success" === result.type;
 const inspect = (fn) => (result) => {
 	const apply = (r) => {
 		if (isSuccess(r)) fn(r.value);
@@ -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
 */
@@ -324,14 +346,6 @@ var PricingFetcher = class {
 	loadOfflinePricing = try_({
 		try: async () => {
 			const pricing = new Map(Object.entries({
-				"claude-instant-1": {
-					"input_cost_per_token": 163e-8,
-					"output_cost_per_token": 551e-8
-				},
-				"claude-instant-1.2": {
-					"input_cost_per_token": 163e-9,
-					"output_cost_per_token": 551e-9
-				},
 				"claude-2": {
 					"input_cost_per_token": 8e-6,
 					"output_cost_per_token": 24e-6
@@ -546,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-DpoTR8Md.js";
+import { PricingFetcher } from "./pricing-fetcher-B2yEbqCO.js";
 import "./_types-BHFM59hI.js";
-import "./logger-D7tlrIfv.js";
+import "./logger-CZzaUNvP.js";
 export { PricingFetcher };

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "ccusage",
-  "type": "module",
-  "version": "15.3.1",
+  "version": "15.5.0",
   "description": "Usage analysis tool for Claude Code",
-  "author": "ryoppippi",
-  "license": "MIT",
-  "funding": "https://github.com/ryoppippi/ccusage?sponsor=1",
   "homepage": "https://github.com/ryoppippi/ccusage#readme",
+  "bugs": {
+    "url": "https://github.com/ryoppippi/ccusage/issues"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ryoppippi/ccusage.git"
   },
-  "bugs": {
-    "url": "https://github.com/ryoppippi/ccusage/issues"
-  },
+  "funding": "https://github.com/ryoppippi/ccusage?sponsor=1",
+  "license": "MIT",
+  "author": "ryoppippi",
+  "type": "module",
   "exports": {
     ".": "./dist/index.js",
     "./calculate-cost": "./dist/calculate-cost.js",
@@ -32,6 +32,6 @@
     "dist"
   ],
   "engines": {
-    "node": ">=20.19.3"
+    "node": ">=20.19.4"
   }
 }