aiblueprint-cli 1.1.4 → 1.1.8

package/claude-code-config/scripts/statusline/src/lib/formatters.ts

@@ -0,0 +1,218 @@
+import type { Separator, StatuslineConfig } from "../../statusline.config";
+import type { GitStatus } from "./git";
+
+export const colors = {
+	GREEN: "\x1b[0;32m",
+	RED: "\x1b[0;31m",
+	PURPLE: "\x1b[0;35m",
+	YELLOW: "\x1b[0;33m",
+	ORANGE: "\x1b[38;5;208m",
+	GRAY: "\x1b[0;90m",
+	LIGHT_GRAY: "\x1b[0;37m",
+	RESET: "\x1b[0m",
+} as const;
+
+export function formatBranch(
+	git: GitStatus,
+	gitConfig: StatuslineConfig["git"],
+): string {
+	let result = "";
+
+	if (gitConfig.showBranch) {
+		result = git.branch;
+	}
+
+	if (git.hasChanges) {
+		const changes: string[] = [];
+
+		if (gitConfig.showDirtyIndicator) {
+			result += `${colors.PURPLE}*${colors.RESET}`;
+		}
+
+		if (gitConfig.showChanges) {
+			const totalAdded = git.staged.added + git.unstaged.added;
+			const totalDeleted = git.staged.deleted + git.unstaged.deleted;
+
+			if (totalAdded > 0) {
+				changes.push(`${colors.GREEN}+${totalAdded}${colors.RESET}`);
+			}
+			if (totalDeleted > 0) {
+				changes.push(`${colors.RED}-${totalDeleted}${colors.RESET}`);
+			}
+		}
+
+		if (gitConfig.showStaged && git.staged.files > 0) {
+			changes.push(`${colors.GRAY}~${git.staged.files}${colors.RESET}`);
+		}
+
+		if (gitConfig.showUnstaged && git.unstaged.files > 0) {
+			changes.push(`${colors.YELLOW}~${git.unstaged.files}${colors.RESET}`);
+		}
+
+		if (changes.length > 0) {
+			result += ` ${changes.join(" ")}`;
+		}
+	}
+
+	return result;
+}
+
+export function formatPath(
+	path: string,
+	mode: "full" | "truncated" | "basename" = "truncated",
+): string {
+	const home = process.env.HOME || "";
+	let formattedPath = path;
+
+	if (home && path.startsWith(home)) {
+		formattedPath = `~${path.slice(home.length)}`;
+	}
+
+	if (mode === "basename") {
+		const segments = path.split("/").filter((s) => s.length > 0);
+		return segments[segments.length - 1] || path;
+	}
+
+	if (mode === "truncated") {
+		const segments = formattedPath.split("/").filter((s) => s.length > 0);
+		if (segments.length > 2) {
+			return `/${segments.slice(-2).join("/")}`;
+		}
+	}
+
+	return formattedPath;
+}
+
+export function formatCost(cost: number): string {
+	return cost.toFixed(2);
+}
+
+export function formatTokens(tokens: number, showDecimals = true): string {
+	if (tokens >= 1000000) {
+		const value = tokens / 1000000;
+		const number = showDecimals
+			? value.toFixed(1)
+			: Math.round(value).toString();
+		return `${number}${colors.GRAY}m${colors.LIGHT_GRAY}`;
+	}
+	if (tokens >= 1000) {
+		const value = tokens / 1000;
+		const number = showDecimals
+			? value.toFixed(1)
+			: Math.round(value).toString();
+		return `${number}${colors.GRAY}k${colors.LIGHT_GRAY}`;
+	}
+	return tokens.toString();
+}
+
+export function formatDuration(ms: number): string {
+	const minutes = Math.floor(ms / 60000);
+	const hours = Math.floor(minutes / 60);
+	const mins = minutes % 60;
+
+	if (hours > 0) {
+		return `${hours}h ${mins}m`;
+	}
+	return `${mins}m`;
+}
+
+export function formatResetTime(resetsAt: string): string {
+	try {
+		const resetDate = new Date(resetsAt);
+		const now = new Date();
+		const diffMs = resetDate.getTime() - now.getTime();
+
+		if (diffMs <= 0) {
+			return "now";
+		}
+
+		const hours = Math.floor(diffMs / 3600000);
+		const minutes = Math.floor((diffMs % 3600000) / 60000);
+
+		if (hours > 0) {
+			return `${hours}h${minutes}m`;
+		}
+		return `${minutes}m`;
+	} catch {
+		return "N/A";
+	}
+}
+
+export function formatProgressBar(
+	percentage: number,
+	length: number,
+	colorMode: "progressive" | "green" | "yellow" | "red",
+): string {
+	const filled = Math.round((percentage / 100) * length);
+	const empty = length - filled;
+
+	const filledBar = "█".repeat(filled);
+	const emptyBar = "░".repeat(empty);
+
+	let barColor: string;
+	if (colorMode === "progressive") {
+		if (percentage < 50) {
+			barColor = colors.GRAY;
+		} else if (percentage < 70) {
+			barColor = colors.YELLOW;
+		} else if (percentage < 90) {
+			barColor = colors.ORANGE;
+		} else {
+			barColor = colors.RED;
+		}
+	} else if (colorMode === "green") {
+		barColor = colors.GREEN;
+	} else if (colorMode === "yellow") {
+		barColor = colors.YELLOW;
+	} else {
+		barColor = colors.RED;
+	}
+
+	return `${barColor}${filledBar}${colors.GRAY}${emptyBar}${colors.RESET}`;
+}
+
+export interface SessionConfig {
+	infoSeparator: Separator | null;
+	showCost: boolean;
+	showTokens: boolean;
+	showMaxTokens: boolean;
+	showTokenDecimals: boolean;
+	showPercentage: boolean;
+}
+
+export function formatSession(
+	cost: string,
+	tokensUsed: number,
+	tokensMax: number,
+	percentage: number,
+	config: SessionConfig,
+): string {
+	const sessionItems: string[] = [];
+
+	if (config.showCost) {
+		sessionItems.push(`$${cost}`);
+	}
+	if (config.showTokens) {
+		const formattedUsed = formatTokens(tokensUsed, config.showTokenDecimals);
+		if (config.showMaxTokens) {
+			const formattedMax = formatTokens(tokensMax, config.showTokenDecimals);
+			sessionItems.push(
+				`${formattedUsed}${colors.GRAY}/${formattedMax}${colors.LIGHT_GRAY}`,
+			);
+		} else {
+			sessionItems.push(formattedUsed);
+		}
+	}
+	if (config.showPercentage) {
+		sessionItems.push(`${percentage}${colors.GRAY}%${colors.LIGHT_GRAY}`);
+	}
+
+	if (sessionItems.length === 0) {
+		return "";
+	}
+
+	const infoSep = config.infoSeparator
+		? ` ${colors.GRAY}${config.infoSeparator}${colors.LIGHT_GRAY} `
+		: " ";
+	return `${colors.GRAY}S:${colors.LIGHT_GRAY} ${sessionItems.join(infoSep)}`;
+}

package/claude-code-config/scripts/statusline/src/lib/git.ts

@@ -0,0 +1,100 @@
+import { $ } from "bun";
+
+export interface GitStatus {
+	branch: string;
+	hasChanges: boolean;
+	staged: {
+		added: number;
+		deleted: number;
+		files: number;
+	};
+	unstaged: {
+		added: number;
+		deleted: number;
+		files: number;
+	};
+}
+
+export async function getGitStatus(): Promise<GitStatus> {
+	try {
+		const isGitRepo = await $`git rev-parse --git-dir`.quiet().nothrow();
+		if (isGitRepo.exitCode !== 0) {
+			return {
+				branch: "no-git",
+				hasChanges: false,
+				staged: { added: 0, deleted: 0, files: 0 },
+				unstaged: { added: 0, deleted: 0, files: 0 },
+			};
+		}
+
+		const branchResult = await $`git branch --show-current`.quiet().text();
+		const branch = branchResult.trim() || "detached";
+
+		const diffCheck = await $`git diff-index --quiet HEAD --`.quiet().nothrow();
+		const cachedCheck = await $`git diff-index --quiet --cached HEAD --`
+			.quiet()
+			.nothrow();
+
+		if (diffCheck.exitCode !== 0 || cachedCheck.exitCode !== 0) {
+			const unstagedDiff = await $`git diff --numstat`.quiet().text();
+			const stagedDiff = await $`git diff --cached --numstat`.quiet().text();
+			const stagedFilesResult = await $`git diff --cached --name-only`
+				.quiet()
+				.text();
+			const unstagedFilesResult = await $`git diff --name-only`.quiet().text();
+
+			const parseStats = (diff: string) => {
+				let added = 0;
+				let deleted = 0;
+				for (const line of diff.split("\n")) {
+					if (!line.trim()) continue;
+					const [a, d] = line
+						.split("\t")
+						.map((n) => Number.parseInt(n, 10) || 0);
+					added += a;
+					deleted += d;
+				}
+				return { added, deleted };
+			};
+
+			const unstagedStats = parseStats(unstagedDiff);
+			const stagedStats = parseStats(stagedDiff);
+
+			const stagedFilesCount = stagedFilesResult
+				.split("\n")
+				.filter((f) => f.trim()).length;
+			const unstagedFilesCount = unstagedFilesResult
+				.split("\n")
+				.filter((f) => f.trim()).length;
+
+			return {
+				branch,
+				hasChanges: true,
+				staged: {
+					added: stagedStats.added,
+					deleted: stagedStats.deleted,
+					files: stagedFilesCount,
+				},
+				unstaged: {
+					added: unstagedStats.added,
+					deleted: unstagedStats.deleted,
+					files: unstagedFilesCount,
+				},
+			};
+		}
+
+		return {
+			branch,
+			hasChanges: false,
+			staged: { added: 0, deleted: 0, files: 0 },
+			unstaged: { added: 0, deleted: 0, files: 0 },
+		};
+	} catch {
+		return {
+			branch: "no-git",
+			hasChanges: false,
+			staged: { added: 0, deleted: 0, files: 0 },
+			unstaged: { added: 0, deleted: 0, files: 0 },
+		};
+	}
+}

package/claude-code-config/scripts/statusline/src/lib/spend.ts

@@ -0,0 +1,119 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { HookInput } from "./types";
+
+export interface SpendSession {
+	id: string;
+	cost: number;
+	date: string;
+	duration_ms: number;
+	lines_added: number;
+	lines_removed: number;
+	cwd: string;
+}
+
+export interface SpendData {
+	sessions: SpendSession[];
+}
+
+export function getSpendFilePath(): string {
+	// Use the project's data folder instead of ~/.claude
+	const projectRoot = join(import.meta.dir, "..", "..");
+	return join(projectRoot, "data", "spend.json");
+}
+
+export async function loadSpendData(): Promise<SpendData> {
+	const spendFile = getSpendFilePath();
+
+	if (!existsSync(spendFile)) {
+		return { sessions: [] };
+	}
+
+	try {
+		const content = await readFile(spendFile, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return { sessions: [] };
+	}
+}
+
+export async function saveSpendData(data: SpendData): Promise<void> {
+	const spendFile = getSpendFilePath();
+	const projectRoot = join(import.meta.dir, "..", "..");
+	const dataDir = join(projectRoot, "data");
+
+	if (!existsSync(dataDir)) {
+		mkdirSync(dataDir, { recursive: true });
+	}
+
+	await writeFile(spendFile, JSON.stringify(data, null, 2));
+}
+
+export async function saveSession(input: HookInput): Promise<void> {
+	if (
+		!input.session_id ||
+		input.cost.total_cost_usd === 0 ||
+		input.cost.total_cost_usd === null
+	) {
+		return;
+	}
+
+	const data = await loadSpendData();
+	const isoDate = new Date().toISOString().split("T")[0];
+
+	const session: SpendSession = {
+		id: input.session_id,
+		cost: input.cost.total_cost_usd,
+		date: isoDate,
+		duration_ms: input.cost.total_duration_ms,
+		lines_added: input.cost.total_lines_added,
+		lines_removed: input.cost.total_lines_removed,
+		cwd: input.cwd,
+	};
+
+	const existingIndex = data.sessions.findIndex(
+		(s) => s.id === input.session_id,
+	);
+
+	if (existingIndex !== -1) {
+		data.sessions[existingIndex] = session;
+	} else {
+		data.sessions.push(session);
+	}
+
+	await saveSpendData(data);
+}
+
+export function filterSessionsByDate(
+	sessions: SpendSession[],
+	startDate: Date,
+	endDate?: Date,
+): SpendSession[] {
+	return sessions.filter((session) => {
+		const sessionDate = new Date(session.date);
+		if (endDate) {
+			return sessionDate >= startDate && sessionDate <= endDate;
+		}
+		return sessionDate >= startDate;
+	});
+}
+
+export function calculateTotalCost(sessions: SpendSession[]): number {
+	return sessions.reduce((sum, session) => sum + session.cost, 0);
+}
+
+export function calculateTotalDuration(sessions: SpendSession[]): number {
+	return sessions.reduce((sum, session) => sum + session.duration_ms, 0);
+}
+
+export function getTodayStart(): Date {
+	const today = new Date();
+	today.setHours(0, 0, 0, 0);
+	return today;
+}
+
+export function getMonthStart(): Date {
+	const today = new Date();
+	return new Date(today.getFullYear(), today.getMonth(), 1);
+}

package/claude-code-config/scripts/statusline/src/lib/types.ts

@@ -0,0 +1,25 @@
+export interface HookInput {
+	session_id: string;
+	transcript_path: string;
+	cwd: string;
+	model: {
+		id: string;
+		display_name: string;
+	};
+	workspace: {
+		current_dir: string;
+		project_dir: string;
+	};
+	version: string;
+	output_style: {
+		name: string;
+	};
+	cost: {
+		total_cost_usd: number;
+		total_duration_ms: number;
+		total_api_duration_ms: number;
+		total_lines_added: number;
+		total_lines_removed: number;
+	};
+	exceeds_200k_tokens?: boolean;
+}

package/claude-code-config/scripts/statusline/src/lib/usage-limits.ts

@@ -0,0 +1,147 @@
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { $ } from "bun";
+
+export interface UsageLimits {
+	five_hour: {
+		utilization: number;
+		resets_at: string | null;
+	} | null;
+	seven_day: {
+		utilization: number;
+		resets_at: string | null;
+	} | null;
+}
+
+interface CachedUsageLimits {
+	data: UsageLimits;
+	timestamp: number;
+}
+
+const CACHE_DURATION_MS = 60 * 1000; // 1 minute
+
+function getCacheFilePath(): string {
+	const projectRoot = join(import.meta.dir, "..", "..");
+	return join(projectRoot, "data", "usage-limits-cache.json");
+}
+
+interface Credentials {
+	claudeAiOauth: {
+		accessToken: string;
+		refreshToken: string;
+		expiresAt: number;
+		scopes: string[];
+		subscriptionType: string;
+	};
+}
+
+export async function getCredentials(): Promise<string | null> {
+	try {
+		const result =
+			await $`security find-generic-password -s "Claude Code-credentials" -w`
+				.quiet()
+				.text();
+		const creds: Credentials = JSON.parse(result.trim());
+		return creds.claudeAiOauth.accessToken;
+	} catch {
+		return 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);
+
+		// Check if cache is still valid (< 1 minute old)
+		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 {
+		// Try to load from cache first
+		const cached = await loadCache();
+		if (cached) {
+			return cached.data;
+		}
+
+		// Cache miss or expired - fetch from API
+		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 };
+		}
+
+		// Save to cache
+		await saveCache(limits);
+
+		return limits;
+	} catch {
+		return { five_hour: null, seven_day: null };
+	}
+}