nemonix-cli 1.0.0

package/src/config/claude-code-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/src/config/claude-code-config/scripts/statusline/src/lib/features/limits/index.ts

@@ -0,0 +1,111 @@
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getClaudeCodeTokenSafe } from "../../../../../claude-code-ai/helper/credentials";
+import type { CachedUsageLimits, UsageLimits } from "./types";
+
+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");
+}
+
+export async function getCredentials(): Promise<string | null> {
+	return getClaudeCodeTokenSafe();
+}
+
+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/src/config/claude-code-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/src/config/claude-code-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/src/config/claude-code-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/src/config/claude-code-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/src/config/claude-code-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();