@jeremyy_prt/cc-config 1.0.0

package/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/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/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 };
+	}
+}

package/scripts/statusline/statusline.config.ts

@@ -0,0 +1,125 @@
+export type Separator =
+	| "|"
+	| "•"
+	| "·"
+	| "⋅"
+	| "●"
+	| "◆"
+	| "▪"
+	| "▸"
+	| "›"
+	| "→";
+
+export interface StatuslineConfig {
+	// Number of lines to display (1, 2, or 3)
+	// - 1: Everything on one line (separated by separator)
+	// - 2: Path+git on first line, session+limits on second line
+	// - 3: Path on first line, session on second line, limits on third line
+	numberOfLines: 1 | 2 | 3;
+
+	// Show model name even when using Sonnet (default model)
+	showSonnetModel: boolean;
+
+	// Path display mode:
+	// - "full": Show complete path with ~ substitution
+	// - "truncated": Show only last 2 segments
+	// - "basename": Show only the directory name
+	pathDisplayMode: "full" | "truncated" | "basename";
+
+	// Git display configuration
+	git: {
+		// Show current branch name
+		showBranch: boolean;
+		// Show * indicator when branch has changes
+		showDirtyIndicator: boolean;
+		// Show added/deleted lines count
+		showChanges: boolean;
+		// Show staged files count (gray color)
+		showStaged: boolean;
+		// Show unstaged files count (yellow color)
+		showUnstaged: boolean;
+	};
+
+	// Separator character between sections
+	// Options: "|", "•", "·", "⋅", "●", "◆", "▪", "▸", "›", "→"
+	separator: Separator;
+
+	// Session display configuration
+	session: {
+		// Separator character between session info (cost, tokens, percentage)
+		// Options: "|", "•", "·", "⋅", "●", "◆", "▪", "▸", "›", "→"
+		// Use null for single space separator
+		infoSeparator: Separator | null;
+		// Show session cost in USD
+		showCost: boolean;
+		// Show token count
+		showTokens: boolean;
+		// Show max tokens (e.g., "192k/200k" vs "192k")
+		showMaxTokens: boolean;
+		// Show decimals in token count (e.g., "192.1k" vs "192k")
+		showTokenDecimals: boolean;
+		// Show context percentage
+		showPercentage: boolean;
+	};
+
+	// Context display configuration
+	context: {
+		// Maximum context window size (Claude's hard limit)
+		maxContextTokens: number;
+		// Autocompact buffer size (reserved for safety)
+		autocompactBufferTokens: number;
+		// Use only usable context (includes autocompact buffer in display) vs just transcript
+		useUsableContextOnly: boolean;
+		// Approximate tokens overhead for system (prompts, tools, memory files)
+		// Default ~20k includes: system prompts (~3k) + tools (~12k) + memory (~5k)
+		// Set to 0 to show only transcript tokens
+		overheadTokens: number;
+	};
+
+	// Limits display configuration
+	limits: {
+		// Show progress bar instead of just percentage
+		showProgressBar: boolean;
+		// Progress bar length (number of characters)
+		progressBarLength: 5 | 10;
+		// Progress bar color mode:
+		// - "progressive": Changes color based on usage (gray < 50%, yellow < 70%, orange < 90%, red >= 90%)
+		// - "green": Always green
+		// - "yellow": Always yellow
+		// - "red": Always red
+		color: "progressive" | "green" | "yellow" | "red";
+	};
+}
+
+export const defaultConfig: StatuslineConfig = {
+	numberOfLines: 3,
+	showSonnetModel: false,
+	pathDisplayMode: "full",
+	git: {
+		showBranch: true,
+		showDirtyIndicator: true,
+		showChanges: false,
+		showStaged: true,
+		showUnstaged: true,
+	},
+	separator: "•",
+	session: {
+		infoSeparator: null,
+		showCost: false,
+		showTokens: false,
+		showMaxTokens: false,
+		showTokenDecimals: false,
+		showPercentage: true,
+	},
+	context: {
+		maxContextTokens: 200000,
+		autocompactBufferTokens: 45000,
+		useUsableContextOnly: true,
+		overheadTokens: 0,
+	},
+	limits: {
+		showProgressBar: true,
+		progressBarLength: 5,
+		color: "progressive",
+	},
+};

package/scripts/statusline/test.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env bun
+
+import { join } from "node:path";
+import { $ } from "bun";
+
+const fixtureFile = process.argv[2] || "fixtures/test-input.json";
+const fixtureFullPath = join(import.meta.dir, fixtureFile);
+
+console.log(`\n📝 Testing with fixture: ${fixtureFile}\n`);
+
+try {
+	const content = await Bun.file(fixtureFullPath).text();
+	const result = await $`echo ${content} | bun run src/index.ts`.text();
+
+	console.log(result);
+	console.log("\n✅ Test completed successfully!\n");
+} catch (error) {
+	console.error("❌ Test failed:", error);
+	process.exit(1);
+}

package/scripts/statusline/tsconfig.json

@@ -0,0 +1,27 @@
+{
+	"compilerOptions": {
+		// Enable latest features
+		"lib": ["ESNext", "DOM"],
+		"target": "ESNext",
+		"module": "ESNext",
+		"moduleDetection": "force",
+		"jsx": "react-jsx",
+		"allowJs": true,
+
+		// Bundler mode
+		"moduleResolution": "bundler",
+		"allowImportingTsExtensions": true,
+		"verbatimModuleSyntax": true,
+		"noEmit": true,
+
+		// Best practices
+		"strict": true,
+		"skipLibCheck": true,
+		"noFallthroughCasesInSwitch": true,
+
+		// Some stricter flags (disabled by default)
+		"noUnusedLocals": false,
+		"noUnusedParameters": false,
+		"noPropertyAccessFromIndexSignature": false
+	}
+}