aiblueprint-cli 1.4.80 → 1.4.82

package/agents-config/claude-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/claude-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/claude-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/claude-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();

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

@@ -0,0 +1,66 @@
+#!/usr/bin/env bun
+
+import { table } from "table";
+import { formatCost, formatDuration } from "../../../formatters";
+import { getAllSessions } from "../database";
+import { getMonthStart } from "../index";
+import type { SessionRow } from "../types";
+
+async function main() {
+	const allSessions = getAllSessions();
+	const monthStart = getMonthStart();
+	const monthStartStr = monthStart.toISOString().split("T")[0];
+
+	const monthSessions = allSessions.filter((s) => s.date >= monthStartStr);
+
+	if (monthSessions.length === 0) {
+		console.log("📊 No sessions this month");
+		return;
+	}
+
+	const totalCost = monthSessions.reduce((sum, s) => sum + s.total_cost, 0);
+	const totalDuration = monthSessions.reduce(
+		(sum, s) => sum + s.duration_ms,
+		0,
+	);
+
+	const sessionsByDate = monthSessions.reduce(
+		(acc, session) => {
+			if (!acc[session.date]) {
+				acc[session.date] = [];
+			}
+			acc[session.date].push(session);
+			return acc;
+		},
+		{} as Record<string, SessionRow[]>,
+	);
+
+	const monthName = monthStart.toLocaleString("default", { month: "long" });
+
+	console.log(`\n📊 ${monthName}'s Spend\n`);
+	console.log(`Sessions: ${monthSessions.length}`);
+	console.log(`Total Cost: $${formatCost(totalCost)}`);
+	console.log(`Total Duration: ${formatDuration(totalDuration)}`);
+	console.log("\n📅 By Date:\n");
+
+	const sortedDates = Object.keys(sessionsByDate).sort();
+
+	const tableData = [
+		["Date", "Cost", "Duration", "Sessions"],
+		...sortedDates.map((date) => {
+			const sessions = sessionsByDate[date];
+			const dayCost = sessions.reduce((sum, s) => sum + s.total_cost, 0);
+			const dayDuration = sessions.reduce((sum, s) => sum + s.duration_ms, 0);
+			return [
+				date,
+				`$${formatCost(dayCost)}`,
+				formatDuration(dayDuration),
+				sessions.length.toString(),
+			];
+		}),
+	];
+
+	console.log(table(tableData));
+}
+
+main();

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

@@ -0,0 +1,85 @@
+#!/usr/bin/env bun
+
+import { table } from "table";
+import { formatCost, formatDuration } from "../../../formatters";
+import { getAllSessions } from "../database";
+
+function main() {
+	const projectName = process.argv[2];
+
+	if (!projectName) {
+		console.log("Usage: bun run spend:project <project-name>");
+		console.log('Example: bun run spend:project "statusline"');
+		process.exit(1);
+	}
+
+	const allSessions = getAllSessions();
+	const matchingSessions = allSessions.filter((session) =>
+		session.cwd.endsWith(projectName),
+	);
+
+	if (matchingSessions.length === 0) {
+		console.log(`\nNo sessions found for project ending with "${projectName}"`);
+		console.log("\nAvailable project paths:");
+		const uniquePaths = [...new Set(allSessions.map((s) => s.cwd))];
+		for (const path of uniquePaths.slice(0, 10)) {
+			console.log(
+				`  - ${path.replace(/^(?:\/Users\/[^/]+\/|[A-Z]:\\Users\\[^\\]+\\)/, "~/")}`,
+			);
+		}
+		return;
+	}
+
+	const totalCost = matchingSessions.reduce((sum, s) => sum + s.total_cost, 0);
+	const totalDuration = matchingSessions.reduce(
+		(sum, s) => sum + s.duration_ms,
+		0,
+	);
+	const totalLinesAdded = matchingSessions.reduce(
+		(sum, s) => sum + s.lines_added,
+		0,
+	);
+	const totalLinesRemoved = matchingSessions.reduce(
+		(sum, s) => sum + s.lines_removed,
+		0,
+	);
+
+	console.log(`\n📊 Spend for project: ${projectName}\n`);
+	console.log(`Sessions: ${matchingSessions.length}`);
+	console.log(`Total Cost: $${formatCost(totalCost)}`);
+	console.log(`Total Duration: ${formatDuration(totalDuration)}`);
+	console.log(`Total Changes: +${totalLinesAdded} -${totalLinesRemoved}`);
+	console.log("\n📝 Sessions by date:\n");
+
+	const sessionsByDate = matchingSessions.reduce(
+		(acc, session) => {
+			const date = session.date;
+			if (!acc[date]) {
+				acc[date] = { cost: 0, duration: 0, count: 0 };
+			}
+			acc[date].cost += session.total_cost;
+			acc[date].duration += session.duration_ms;
+			acc[date].count += 1;
+			return acc;
+		},
+		{} as Record<string, { cost: number; duration: number; count: number }>,
+	);
+
+	const sortedDates = Object.entries(sessionsByDate).sort(([a], [b]) =>
+		b.localeCompare(a),
+	);
+
+	const tableData = [
+		["Date", "Sessions", "Cost", "Duration"],
+		...sortedDates.map(([date, data]) => [
+			date,
+			String(data.count),
+			`$${formatCost(data.cost)}`,
+			formatDuration(data.duration),
+		]),
+	];
+
+	console.log(table(tableData));
+}
+
+main();