aiblueprint-cli 1.4.81 → 1.4.82

package/agents-config/scripts/statusline/src/index.ts

@@ -1,8 +1,11 @@
 #!/usr/bin/env bun
 
-import { readFile } from "node:fs/promises";
+import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { defaultConfig, type StatuslineConfig } from "./lib/config";
+import {
+	loadConfig as loadStatuslineConfig,
+	type StatuslineConfig,
+} from "./lib/config";
 import { getContextData } from "./lib/context";
 import {
 	colors,
@@ -19,6 +22,45 @@ import {
 } from "./lib/render-pure";
 import type { HookInput } from "./lib/types";
 
+// Optional feature imports - just delete the folder to disable!
+let getUsageLimits: any = null;
+let normalizeResetsAt: any = null;
+let getPeriodCost: any = null;
+let getTodayCostV2: any = null;
+let saveSessionV2: any = null;
+
+try {
+	const limitsModule = await import("./lib/features/limits");
+	getUsageLimits = limitsModule.getUsageLimits;
+} catch {
+	// Limits feature not available - that's OK!
+}
+
+try {
+	const utilsModule = await import("./lib/utils");
+	normalizeResetsAt = utilsModule.normalizeResetsAt;
+} catch {
+	// Fallback normalizeResetsAt
+	normalizeResetsAt = (resetsAt: string) => resetsAt;
+}
+
+let getTodayRealCost: (() => number) | null = null;
+try {
+	const spendModule = await import("./lib/features/spend");
+	getPeriodCost = spendModule.getPeriodCost;
+	getTodayCostV2 = spendModule.getTodayCostV2;
+	saveSessionV2 = spendModule.saveSessionV2;
+} catch {
+	// Spend tracking feature not available - that's OK!
+}
+
+try {
+	const loggerModule = await import("./lib/features/spend/payload-logger");
+	getTodayRealCost = loggerModule.getTodayRealCost;
+} catch {
+	// Payload logger not available
+}
+
 // Re-export from render-pure for backwards compatibility
 export {
 	renderStatusline,
@@ -26,7 +68,12 @@ export {
 	type UsageLimit,
 } from "./lib/render-pure";
 
-const CONFIG_FILE_PATH = join(import.meta.dir, "..", "statusline.config.json");
+const LAST_PAYLOAD_PATH = join(
+	import.meta.dir,
+	"..",
+	"data",
+	"last_payload.txt",
+);
 const CLAUDE_SETTINGS_PATH = join(
 	process.env.HOME || "",
 	".claude",
@@ -48,21 +95,30 @@ async function loadClaudeSettings(): Promise<ClaudeSettings> {
 }
 
 async function loadConfig(): Promise<StatuslineConfig> {
-	try {
-		const content = await readFile(CONFIG_FILE_PATH, "utf-8");
-		return JSON.parse(content);
-	} catch {
-		return defaultConfig;
-	}
+	return loadStatuslineConfig();
 }
 
 async function main() {
 	try {
 		const input: HookInput = await Bun.stdin.json();
 
+		// Save last payload for debugging
+		await writeFile(LAST_PAYLOAD_PATH, JSON.stringify(input, null, 2));
+
 		const config = await loadConfig();
 		const claudeSettings = await loadClaudeSettings();
 
+		// Get usage limits (if feature exists)
+		const usageLimits = getUsageLimits
+			? await getUsageLimits()
+			: { five_hour: null, seven_day: null };
+		const currentResetsAt = usageLimits.five_hour?.resets_at ?? undefined;
+
+		// Save session with current period context (if feature exists)
+		if (saveSessionV2) {
+			await saveSessionV2(input, currentResetsAt);
+		}
+
 		const git = await getGitStatus();
 
 		let contextTokens: number | null;
@@ -102,6 +158,24 @@ async function main() {
 			contextPercentage = contextData.percentage;
 		}
 
+		// Get period cost from SQLite (if feature exists)
+		let periodCost: number | undefined;
+		let todayCost: number | undefined;
+
+		if (getPeriodCost && normalizeResetsAt) {
+			const normalizedPeriodId = currentResetsAt
+				? normalizeResetsAt(currentResetsAt)
+				: null;
+			periodCost = normalizedPeriodId ? getPeriodCost(normalizedPeriodId) : 0;
+		}
+
+		// Get today's cost from payloads (more accurate than DB)
+		if (getTodayRealCost) {
+			todayCost = getTodayRealCost();
+		} else if (getTodayCostV2) {
+			todayCost = getTodayCostV2();
+		}
+
 		const data: StatuslineData = {
 			branch: formatBranch(git, config.git),
 			dirPath: formatPath(input.workspace.current_dir, config.pathDisplayMode),
@@ -121,6 +195,23 @@ async function main() {
 			sessionDuration: formatDuration(input.cost.total_duration_ms),
 			contextTokens,
 			contextPercentage,
+			...(getUsageLimits && {
+				usageLimits: {
+					five_hour: usageLimits.five_hour
+						? {
+								utilization: usageLimits.five_hour.utilization,
+								resets_at: usageLimits.five_hour.resets_at,
+							}
+						: null,
+					seven_day: usageLimits.seven_day
+						? {
+								utilization: usageLimits.seven_day.utilization,
+								resets_at: usageLimits.seven_day.resets_at,
+							}
+						: null,
+				},
+			}),
+			...((getPeriodCost || getTodayCostV2) && { periodCost, todayCost }),
 			thinkingEnabled: claudeSettings.alwaysThinkingEnabled ?? true,
 		};
 

package/agents-config/scripts/statusline/src/lib/config.ts

@@ -10,11 +10,37 @@ export const defaultConfig: StatuslineConfig = JSON.parse(
 	readFileSync(DEFAULTS_PATH, "utf-8"),
 );
 
+function cloneDefaultConfig(): StatuslineConfig {
+	return JSON.parse(JSON.stringify(defaultConfig));
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function mergeConfigDefaults<T>(defaults: T, overrides: unknown): T {
+	if (!isRecord(defaults) || !isRecord(overrides)) {
+		return overrides === undefined ? defaults : (overrides as T);
+	}
+
+	const merged: Record<string, unknown> = { ...defaults };
+	for (const [key, value] of Object.entries(overrides)) {
+		merged[key] = mergeConfigDefaults(
+			(defaults as Record<string, unknown>)[key],
+			value,
+		);
+	}
+	return merged as T;
+}
+
 export function loadConfig(): StatuslineConfig {
 	try {
-		return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+		return mergeConfigDefaults(
+			defaultConfig,
+			JSON.parse(readFileSync(CONFIG_PATH, "utf-8")),
+		);
 	} catch {
-		return JSON.parse(JSON.stringify(defaultConfig));
+		return cloneDefaultConfig();
 	}
 }
 

package/agents-config/scripts/statusline/src/lib/features/limits/commands/weekly-analysis.ts

@@ -0,0 +1,108 @@
+#!/usr/bin/env bun
+
+import { colors, formatProgressBar } from "../../../formatters";
+import { getUsageLimits } from "../index";
+
+const WEEKLY_HOURS = 168; // 7 days * 24 hours
+
+function calculateTimeProgress(resetsAt: string | null): {
+	hoursRemaining: number;
+	hoursElapsed: number;
+	timeElapsedPercent: number;
+} {
+	if (!resetsAt) {
+		return {
+			hoursRemaining: 0,
+			hoursElapsed: WEEKLY_HOURS,
+			timeElapsedPercent: 100,
+		};
+	}
+
+	const resetDate = new Date(resetsAt);
+	const now = new Date();
+	const diffMs = resetDate.getTime() - now.getTime();
+	const hoursRemaining = Math.max(0, diffMs / 3600000);
+	const hoursElapsed = WEEKLY_HOURS - hoursRemaining;
+	const timeElapsedPercent = (hoursElapsed / WEEKLY_HOURS) * 100;
+
+	return { hoursRemaining, hoursElapsed, timeElapsedPercent };
+}
+
+function formatDelta(delta: number): string {
+	const sign = delta >= 0 ? "+" : "";
+	const value = `${sign}${delta.toFixed(1)}%`;
+
+	if (delta > 5) return colors.green(value);
+	if (delta > 0) return colors.lightGray(value);
+	if (delta > -5) return colors.yellow(value);
+	if (delta > -15) return colors.orange(value);
+	return colors.red(value);
+}
+
+async function main() {
+	const limits = await getUsageLimits();
+
+	console.log("");
+	console.log(colors.bold("📊 Weekly Usage Analysis"));
+	console.log(colors.gray("─".repeat(40)));
+
+	if (!limits.seven_day) {
+		console.log(colors.red("No weekly limit data available"));
+		return;
+	}
+
+	const { utilization, resets_at } = limits.seven_day;
+	const { timeElapsedPercent } = calculateTimeProgress(resets_at);
+
+	const expectedUsage = timeElapsedPercent;
+	const delta = utilization - expectedUsage;
+
+	console.log("");
+	console.log(colors.gray("Weekly Limits Overview"));
+	console.log(colors.gray("─".repeat(50)));
+	console.log("");
+
+	const usageBar = formatProgressBar({
+		percentage: utilization,
+		length: 20,
+		style: "filled",
+		colorMode: "blue",
+		background: "none",
+	});
+	console.log(
+		`${colors.blue("Usage")} ${usageBar} ${colors.lightGray(utilization.toFixed(1))}${colors.gray("%")}`,
+	);
+
+	const timeBar = formatProgressBar({
+		percentage: timeElapsedPercent,
+		length: 20,
+		style: "filled",
+		colorMode: "purple",
+		background: "none",
+	});
+	console.log(
+		`${colors.purple("Time ")} ${timeBar} ${colors.lightGray(timeElapsedPercent.toFixed(1))}${colors.gray("%")} ${colors.gray("·")} ${formatDelta(delta)}`,
+	);
+
+	console.log("");
+	console.log(colors.gray("─".repeat(50)));
+	console.log("");
+
+	if (limits.five_hour) {
+		console.log(colors.gray("─".repeat(40)));
+		console.log("");
+		console.log(colors.gray("Session Limit (5h):"));
+		console.log(
+			`  ${formatProgressBar({
+				percentage: limits.five_hour.utilization,
+				length: 15,
+				style: "filled",
+				colorMode: "progressive",
+				background: "none",
+			})} ${colors.lightGray(limits.five_hour.utilization.toString())}${colors.gray("%")}`,
+		);
+		console.log("");
+	}
+}
+
+main();

package/agents-config/scripts/statusline/src/lib/features/limits/index.ts

@@ -0,0 +1,164 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import type { CachedUsageLimits, UsageLimits } from "./types";
+
+const CACHE_DURATION_MS = 60 * 1000; // 1 minute
+const execFileAsync = promisify(execFile);
+
+function getCacheFilePath(): string {
+	const projectRoot = join(import.meta.dir, "..", "..", "..", "..");
+	return join(projectRoot, "data", "usage-limits-cache.json");
+}
+
+export async function getCredentials(): Promise<string | null> {
+	return (
+		(await getClaudeCodeTokenFromKeychain()) ?? getClaudeCodeTokenFromFile()
+	);
+}
+
+async function getClaudeCodeTokenFromKeychain(): Promise<string | null> {
+	if (process.platform !== "darwin") {
+		return null;
+	}
+
+	try {
+		const { stdout } = await execFileAsync("security", [
+			"find-generic-password",
+			"-s",
+			"Claude Code-credentials",
+			"-w",
+		]);
+
+		return parseClaudeCodeToken(stdout.trim());
+	} catch {
+		return null;
+	}
+}
+
+async function getClaudeCodeTokenFromFile(): Promise<string | null> {
+	try {
+		const credentialsPath = join(homedir(), ".claude", ".credentials.json");
+		if (!existsSync(credentialsPath)) {
+			return null;
+		}
+
+		const content = await readFile(credentialsPath, "utf-8");
+		return parseClaudeCodeToken(content);
+	} catch {
+		return null;
+	}
+}
+
+function parseClaudeCodeToken(content: string): string | null {
+	if (!content) {
+		return null;
+	}
+
+	try {
+		const credentials = JSON.parse(content);
+		return (
+			credentials.claudeAiOauth?.accessToken ?? credentials.accessToken ?? null
+		);
+	} catch {
+		return content.startsWith("sk-") ? content : null;
+	}
+}
+
+export async function fetchUsageLimits(
+	token: string,
+): Promise<UsageLimits | null> {
+	try {
+		const response = await fetch("https://api.anthropic.com/api/oauth/usage", {
+			method: "GET",
+			headers: {
+				Accept: "application/json, text/plain, */*",
+				"Content-Type": "application/json",
+				"User-Agent": "claude-code/2.0.31",
+				Authorization: `Bearer ${token}`,
+				"anthropic-beta": "oauth-2025-04-20",
+				"Accept-Encoding": "gzip, compress, deflate, br",
+			},
+		});
+
+		if (!response.ok) {
+			return null;
+		}
+
+		const data = await response.json();
+
+		return {
+			five_hour: data.five_hour || null,
+			seven_day: data.seven_day || null,
+		};
+	} catch {
+		return null;
+	}
+}
+
+async function loadCache(): Promise<CachedUsageLimits | null> {
+	try {
+		const cacheFile = getCacheFilePath();
+		if (!existsSync(cacheFile)) {
+			return null;
+		}
+
+		const content = await readFile(cacheFile, "utf-8");
+		const cached: CachedUsageLimits = JSON.parse(content);
+
+		const now = Date.now();
+		if (now - cached.timestamp < CACHE_DURATION_MS) {
+			return cached;
+		}
+
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+async function saveCache(data: UsageLimits): Promise<void> {
+	try {
+		const cacheFile = getCacheFilePath();
+		const cached: CachedUsageLimits = {
+			data,
+			timestamp: Date.now(),
+		};
+
+		await writeFile(cacheFile, JSON.stringify(cached, null, 2));
+	} catch {
+		// Fail silently
+	}
+}
+
+export async function getUsageLimits(): Promise<UsageLimits> {
+	try {
+		const cached = await loadCache();
+		if (cached) {
+			return cached.data;
+		}
+
+		const token = await getCredentials();
+
+		if (!token) {
+			return { five_hour: null, seven_day: null };
+		}
+
+		const limits = await fetchUsageLimits(token);
+
+		if (!limits) {
+			return { five_hour: null, seven_day: null };
+		}
+
+		await saveCache(limits);
+
+		return limits;
+	} catch {
+		return { five_hour: null, seven_day: null };
+	}
+}
+
+export type { CachedUsageLimits, UsageLimits } from "./types";

package/agents-config/scripts/statusline/src/lib/features/limits/types.ts

@@ -0,0 +1,15 @@
+export interface UsageLimits {
+	five_hour: {
+		utilization: number;
+		resets_at: string | null;
+	} | null;
+	seven_day: {
+		utilization: number;
+		resets_at: string | null;
+	} | null;
+}
+
+export interface CachedUsageLimits {
+	data: UsageLimits;
+	timestamp: number;
+}

package/agents-config/scripts/statusline/src/lib/features/spend/commands/migrate-to-sqlite.ts

@@ -0,0 +1,136 @@
+#!/usr/bin/env bun
+
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getDb, upsertPeriod, upsertSession } from "../database";
+
+interface OldSpendSession {
+	id: string;
+	cost: number;
+	date: string;
+	duration_ms: number;
+	lines_added: number;
+	lines_removed: number;
+	cwd: string;
+	last_resets_at?: string;
+}
+
+interface OldSpendData {
+	sessions: OldSpendSession[];
+}
+
+interface OldDailyUsageEntry {
+	date: string;
+	utilization: number;
+	resets_at: string;
+	timestamp: number;
+	period_cost: number;
+}
+
+async function loadOldSpendData(): Promise<OldSpendData | null> {
+	const projectRoot = join(import.meta.dir, "..", "..", "..", "..", "..");
+	const spendFile = join(projectRoot, "data", "spend.json");
+
+	if (!existsSync(spendFile)) {
+		console.log("No spend.json found, skipping session migration");
+		return null;
+	}
+
+	const content = await readFile(spendFile, "utf-8");
+	return JSON.parse(content);
+}
+
+async function loadOldDailyUsage(): Promise<OldDailyUsageEntry[]> {
+	const projectRoot = join(import.meta.dir, "..", "..", "..", "..", "..");
+	const dailyUsageFile = join(projectRoot, "data", "daily-usage.json");
+
+	if (!existsSync(dailyUsageFile)) {
+		console.log("No daily-usage.json found, skipping period migration");
+		return [];
+	}
+
+	const content = await readFile(dailyUsageFile, "utf-8");
+	return JSON.parse(content);
+}
+
+async function migrate() {
+	console.log("🔄 Starting migration to SQLite...\n");
+
+	const db = getDb();
+	console.log("✅ Database initialized\n");
+
+	const oldSpendData = await loadOldSpendData();
+	if (oldSpendData) {
+		console.log(`📦 Migrating ${oldSpendData.sessions.length} sessions...`);
+
+		let migrated = 0;
+		let skipped = 0;
+
+		for (const session of oldSpendData.sessions) {
+			try {
+				upsertSession({
+					session_id: session.id,
+					total_cost: session.cost,
+					cwd: session.cwd,
+					date: session.date,
+					duration_ms: session.duration_ms,
+					lines_added: session.lines_added,
+					lines_removed: session.lines_removed,
+					last_resets_at: session.last_resets_at ?? null,
+					cumulative_counted: 0,
+				});
+				migrated++;
+			} catch (error) {
+				console.error(`  ❌ Failed to migrate session ${session.id}:`, error);
+				skipped++;
+			}
+		}
+
+		console.log(`  ✅ Migrated: ${migrated}`);
+		console.log(`  ⚠️  Skipped: ${skipped}\n`);
+	}
+
+	const oldDailyUsage = await loadOldDailyUsage();
+	if (oldDailyUsage.length > 0) {
+		console.log(`📅 Migrating ${oldDailyUsage.length} period entries...`);
+
+		let migrated = 0;
+
+		for (const entry of oldDailyUsage) {
+			try {
+				upsertPeriod({
+					period_id: entry.resets_at,
+					total_cost: 0,
+					utilization: entry.utilization,
+					date: entry.date,
+				});
+				migrated++;
+			} catch (error) {
+				console.error(
+					`  ❌ Failed to migrate period ${entry.resets_at}:`,
+					error,
+				);
+			}
+		}
+
+		console.log(`  ✅ Migrated: ${migrated}\n`);
+	}
+
+	const sessionCount = db
+		.query<{ count: number }, []>("SELECT COUNT(*) as count FROM sessions")
+		.get();
+	const periodCount = db
+		.query<{ count: number }, []>("SELECT COUNT(*) as count FROM periods")
+		.get();
+
+	console.log("📊 Migration Summary:");
+	console.log(`  Sessions in DB: ${sessionCount?.count ?? 0}`);
+	console.log(`  Periods in DB: ${periodCount?.count ?? 0}`);
+	console.log("\n✅ Migration complete!");
+	console.log("\n⚠️  Note: Period costs have been reset to 0.");
+	console.log("   They will be recalculated correctly as you use Claude Code.");
+	console.log("   The old JSON files are preserved as backup.");
+}
+
+migrate().catch(console.error);

package/agents-config/scripts/statusline/src/lib/features/spend/commands/spend-day.ts

@@ -0,0 +1,79 @@
+#!/usr/bin/env bun
+
+import { table } from "table";
+import { formatCost, formatDuration } from "../../../formatters";
+import { getSessionsByDate } from "../database";
+
+function parseDate(input?: string): string {
+	if (!input) {
+		return new Date().toISOString().split("T")[0];
+	}
+
+	// Try parsing as YYYY-MM-DD
+	if (/^\d{4}-\d{2}-\d{2}$/.test(input)) {
+		return input;
+	}
+
+	// Try parsing as MM-DD (current year)
+	if (/^\d{2}-\d{2}$/.test(input)) {
+		const year = new Date().getFullYear();
+		return `${year}-${input}`;
+	}
+
+	// Try parsing as natural date
+	const parsed = new Date(input);
+	if (!Number.isNaN(parsed.getTime())) {
+		return parsed.toISOString().split("T")[0];
+	}
+
+	console.log(`⚠️  Invalid date format: "${input}". Using today.`);
+	return new Date().toISOString().split("T")[0];
+}
+
+function isToday(date: string): boolean {
+	return date === new Date().toISOString().split("T")[0];
+}
+
+async function main() {
+	const dateArg = process.env.DATE || process.argv[2];
+	const targetDate = parseDate(dateArg);
+	const sessions = getSessionsByDate(targetDate);
+
+	const dateLabel = isToday(targetDate) ? "Today" : targetDate;
+
+	if (sessions.length === 0) {
+		console.log(`📊 No sessions for ${dateLabel}`);
+		return;
+	}
+
+	const totalCost = sessions.reduce((sum, s) => sum + s.total_cost, 0);
+	const totalDuration = sessions.reduce((sum, s) => sum + s.duration_ms, 0);
+
+	console.log(`\n📊 Spend for ${dateLabel}\n`);
+	console.log(`Sessions: ${sessions.length}`);
+	console.log(`Total Cost: $${formatCost(totalCost)}`);
+	console.log(`Total Duration: ${formatDuration(totalDuration)}`);
+	console.log("\n📝 Sessions:\n");
+
+	const filteredSessions = sessions
+		.filter((session) => session.total_cost >= 0.1)
+		.sort((a, b) => b.total_cost - a.total_cost);
+
+	const tableData = [
+		["ID", "Cost", "Duration", "Changes", "Directory"],
+		...filteredSessions.map((session) => [
+			session.session_id.slice(0, 8),
+			`$${formatCost(session.total_cost)}`,
+			formatDuration(session.duration_ms),
+			`+${session.lines_added} -${session.lines_removed}`,
+			session.cwd.replace(
+				/^(?:\/Users\/[^/]+\/|[A-Z]:\\Users\\[^\\]+\\)/,
+				"~/",
+			),
+		]),
+	];
+
+	console.log(table(tableData));
+}
+
+main();