pi-free 1.0.8 → 2.0.0

package/usage/cumulative.ts

@@ -1,193 +0,0 @@
-/**
- * Cumulative usage persistence - disk storage for all-time stats
- */
-
-import { join } from "node:path";
-import { createJSONStore } from "../lib/json-persistence.ts";
-import { createLogger } from "../lib/logger.ts";
-
-const _logger = createLogger("usage:cumulative");
-
-const PI_DIR = join(process.env.HOME || process.env.USERPROFILE || "", ".pi");
-const USAGE_FILE = join(PI_DIR, "free-cumulative-usage.json");
-
-interface CumulativeProviderStats {
-	totalRequests: number;
-	totalTokensIn: number;
-	totalTokensOut: number;
-	totalCacheRead: number;
-	totalCacheWrite: number;
-	totalCost: number;
-	models: Record<
-		string,
-		{
-			count: number;
-			tokensIn: number;
-			tokensOut: number;
-			cacheRead: number;
-			cacheWrite: number;
-			cost: number;
-		}
-	>;
-	firstUsed: string;
-	lastUsed: string;
-}
-
-interface CumulativeUsage {
-	providers: Record<string, CumulativeProviderStats>;
-	grandTotalRequests: number;
-	grandTotalTokensIn: number;
-	grandTotalTokensOut: number;
-	grandTotalCacheRead: number;
-	grandTotalCacheWrite: number;
-	grandTotalCost: number;
-}
-
-const cumulativeStore = createJSONStore<CumulativeUsage>(USAGE_FILE, {
-	providers: {},
-	grandTotalRequests: 0,
-	grandTotalTokensIn: 0,
-	grandTotalTokensOut: 0,
-	grandTotalCacheRead: 0,
-	grandTotalCacheWrite: 0,
-	grandTotalCost: 0,
-});
-
-export function persistUsage(
-	provider: string,
-	modelId: string,
-	tokensIn: number,
-	tokensOut: number,
-	cacheRead: number,
-	cacheWrite: number,
-	cost: number,
-): void {
-	const data = cumulativeStore.load();
-	const now = new Date().toISOString();
-
-	let providerStats = data.providers[provider];
-	if (!providerStats) {
-		providerStats = {
-			totalRequests: 0,
-			totalTokensIn: 0,
-			totalTokensOut: 0,
-			totalCacheRead: 0,
-			totalCacheWrite: 0,
-			totalCost: 0,
-			models: {},
-			firstUsed: now,
-			lastUsed: now,
-		};
-		data.providers[provider] = providerStats;
-	}
-
-	providerStats.totalRequests++;
-	providerStats.totalTokensIn += tokensIn;
-	providerStats.totalTokensOut += tokensOut;
-	providerStats.totalCacheRead += cacheRead;
-	providerStats.totalCacheWrite += cacheWrite;
-	providerStats.totalCost += cost;
-	providerStats.lastUsed = now;
-
-	const modelStats = providerStats.models[modelId] ?? {
-		count: 0,
-		tokensIn: 0,
-		tokensOut: 0,
-		cacheRead: 0,
-		cacheWrite: 0,
-		cost: 0,
-	};
-	modelStats.count++;
-	modelStats.tokensIn += tokensIn;
-	modelStats.tokensOut += tokensOut;
-	modelStats.cacheRead += cacheRead;
-	modelStats.cacheWrite += cacheWrite;
-	modelStats.cost += cost;
-	providerStats.models[modelId] = modelStats;
-
-	data.grandTotalRequests++;
-	data.grandTotalTokensIn += tokensIn;
-	data.grandTotalTokensOut += tokensOut;
-	data.grandTotalCacheRead += cacheRead;
-	data.grandTotalCacheWrite += cacheWrite;
-	data.grandTotalCost += cost;
-
-	cumulativeStore.save(data);
-}
-
-export interface CumulativeUsageReport {
-	providers: Array<{
-		name: string;
-		totalRequests: number;
-		totalTokensIn: number;
-		totalTokensOut: number;
-		totalCacheRead: number;
-		totalCacheWrite: number;
-		totalCost: number;
-		modelCount: number;
-		firstUsed: string;
-		lastUsed: string;
-		topModels: Array<{
-			modelId: string;
-			count: number;
-			tokensIn: number;
-			tokensOut: number;
-			cacheRead: number;
-			cacheWrite: number;
-			cost: number;
-		}>;
-	}>;
-	grandTotalRequests: number;
-	grandTotalTokensIn: number;
-	grandTotalTokensOut: number;
-	grandTotalCacheRead: number;
-	grandTotalCacheWrite: number;
-	grandTotalCost: number;
-}
-
-export function getCumulativeUsage(): CumulativeUsageReport {
-	const data = cumulativeStore.load();
-
-	const providers: CumulativeUsageReport["providers"] = [];
-
-	for (const [name, stats] of Object.entries(data.providers)) {
-		const topModels = Object.entries(stats.models)
-			.map(([modelId, m]) => ({
-				modelId,
-				count: m.count,
-				tokensIn: m.tokensIn,
-				tokensOut: m.tokensOut,
-				cacheRead: m.cacheRead,
-				cacheWrite: m.cacheWrite,
-				cost: m.cost,
-			}))
-			.sort((a, b) => b.count - a.count)
-			.slice(0, 5);
-
-		providers.push({
-			name,
-			totalRequests: stats.totalRequests,
-			totalTokensIn: stats.totalTokensIn,
-			totalTokensOut: stats.totalTokensOut,
-			totalCacheRead: stats.totalCacheRead,
-			totalCacheWrite: stats.totalCacheWrite,
-			totalCost: stats.totalCost,
-			modelCount: Object.keys(stats.models).length,
-			firstUsed: stats.firstUsed,
-			lastUsed: stats.lastUsed,
-			topModels,
-		});
-	}
-
-	providers.sort((a, b) => b.totalRequests - a.totalRequests);
-
-	return {
-		providers,
-		grandTotalRequests: data.grandTotalRequests,
-		grandTotalTokensIn: data.grandTotalTokensIn,
-		grandTotalTokensOut: data.grandTotalTokensOut,
-		grandTotalCacheRead: data.grandTotalCacheRead,
-		grandTotalCacheWrite: data.grandTotalCacheWrite,
-		grandTotalCost: data.grandTotalCost,
-	};
-}

package/usage/formatters.ts

@@ -1,115 +0,0 @@
-/**
- * Usage report formatters - text formatting for display
- */
-
-import type { CumulativeUsageReport } from "./cumulative.ts";
-import { getFreeTierUsage, getLimitWarning } from "./limits.ts";
-import type { SessionUsageReport } from "./tracking.ts";
-// Types imported via limits.ts (which re-exports from types.ts)
-
-export function formatSessionUsage(report: SessionUsageReport): string {
-	if (report.providers.length === 0) {
-		return "No usage recorded in this session yet.";
-	}
-
-	const lines: string[] = [];
-	lines.push("━".repeat(50));
-	lines.push(`📊 Session Usage (${report.durationFormatted})`);
-	lines.push("━".repeat(50));
-	lines.push("");
-
-	for (const p of report.providers) {
-		const warning = getLimitWarning(p.name);
-		const statusEmoji = warning ? (warning.includes("⚠️") ? "🔴" : "🟡") : "🟢";
-		lines.push(`${statusEmoji} ${p.name}`);
-		lines.push(`   Requests: ${p.requests}`);
-		lines.push(
-			`   Tokens: ~${Math.round(p.tokensIn / 1000)}K in, ~${Math.round(p.tokensOut / 1000)}K out`,
-		);
-
-		if (p.topModels.length > 0) {
-			lines.push(`   Top models:`);
-			for (const m of p.topModels.slice(0, 3)) {
-				lines.push(`     • ${m.modelId.split("/").pop()}: ${m.count} req`);
-			}
-		}
-		lines.push("");
-	}
-
-	lines.push("━".repeat(50));
-	lines.push(
-		`📈 Totals: ${report.totalRequests} requests, ~${Math.round(report.totalTokensIn / 1000)}K tokens`,
-	);
-	lines.push("━".repeat(50));
-
-	return lines.join("\n");
-}
-
-export function formatCumulativeUsage(report: CumulativeUsageReport): string {
-	if (report.providers.length === 0) {
-		return "No cumulative usage data yet. Start using free models!";
-	}
-
-	const lines: string[] = [];
-	lines.push("━".repeat(50));
-	lines.push("📊 Total Usage (All Time)");
-	lines.push("━".repeat(50));
-	lines.push("");
-
-	for (const p of report.providers) {
-		lines.push(`🔹 ${p.name}`);
-		lines.push(`   Requests: ${p.totalRequests.toLocaleString()}`);
-		lines.push(
-			`   Tokens: ~${Math.round(p.totalTokensIn / 1000).toLocaleString()}K in, ~${Math.round(p.totalTokensOut / 1000).toLocaleString()}K out`,
-		);
-		lines.push(`   Models used: ${p.modelCount}`);
-
-		if (p.topModels.length > 0) {
-			lines.push(`   Top models:`);
-			for (const m of p.topModels.slice(0, 3)) {
-				lines.push(
-					`     • ${m.modelId.split("/").pop()}: ${m.count.toLocaleString()} req`,
-				);
-			}
-		}
-
-		lines.push(`   Active since: ${p.firstUsed.split("T")[0]}`);
-		lines.push("");
-	}
-
-	lines.push("━".repeat(50));
-	lines.push(`📈 Grand Totals:`);
-	lines.push(`   ${report.grandTotalRequests.toLocaleString()} requests`);
-	lines.push(
-		`   ~${Math.round(report.grandTotalTokensIn / 1000).toLocaleString()}K input tokens`,
-	);
-	lines.push(
-		`   ~${Math.round(report.grandTotalTokensOut / 1000).toLocaleString()}K output tokens`,
-	);
-	lines.push("━".repeat(50));
-
-	return lines.join("\n");
-}
-
-export function formatFreeTierStatus(provider: string): string {
-	const usage = getFreeTierUsage(provider);
-	const parts: string[] = [];
-
-	if (usage.limit.requestsPerHour) {
-		parts.push(`${usage.requestsThisHour}/${usage.limit.requestsPerHour}/h`);
-	}
-	if (usage.limit.requestsPerDay) {
-		parts.push(`${usage.requestsToday}/${usage.limit.requestsPerDay}/d`);
-	}
-	if (usage.limit.requestsPerMonth) {
-		parts.push(
-			`${usage.requestsThisMonth ?? 0}/${usage.limit.requestsPerMonth}/mo`,
-		);
-	}
-
-	if (parts.length === 0) {
-		return `${provider}: ${usage.limit.description}`;
-	}
-
-	return `${provider}: ${parts.join(" | ")}`;
-}

package/usage/index.ts

@@ -1,46 +0,0 @@
-/**
- * Usage tracking module
- *
- * Exports:
- * - Commands: /free-sessionusage, /free-totalusage
- * - Tracking: per-model and per-provider usage counts
- * - Cumulative: persistent storage across sessions
- * - Formatters: display formatting with rate limits
- */
-
-// Commands
-export { registerUsageCommands } from "./commands.ts";
-// Cumulative (persistent)
-export {
-	type CumulativeUsageReport,
-	getCumulativeUsage,
-} from "./cumulative.ts";
-// Formatters
-export {
-	formatCumulativeUsage,
-	formatFreeTierStatus,
-	formatSessionUsage,
-} from "./formatters.ts";
-// Limits
-export {
-	FREE_TIER_LIMITS,
-	type FreeTierLimit,
-	type FreeTierUsage,
-	getFreeTierUsage,
-	getLimitWarning,
-	isApproachingLimit,
-} from "./limits.ts";
-// Metrics (internal)
-export { getDailyRequestCount, incrementRequestCount } from "./metrics.ts";
-// Tracking (runtime)
-export {
-	getModelUsage,
-	getProviderModelUsage,
-	getSessionUsage,
-	getTopModels,
-	incrementModelRequestCount,
-	logModelUsageReport,
-	type ModelUsageEntry,
-	resetUsageStats,
-	type SessionUsageReport,
-} from "./tracking.ts";

package/usage/limits.ts

@@ -1,148 +0,0 @@
-/**
- * Free Tier Rate Limits and Usage Tracking
- *
- * Main entry point - delegates to specialized modules:
- * - usage/tracking.ts - runtime session tracking
- * - usage/cumulative.ts - persistent cumulative storage
- * - usage/formatters.ts - display formatting
- */
-
-import { createLogger } from "../lib/logger.ts";
-import { getDailyRequestCount } from "./metrics.ts";
-import type { FreeTierLimit, FreeTierUsage } from "./types.ts";
-
-export {
-	type CumulativeUsageReport,
-	getCumulativeUsage,
-} from "./cumulative.ts";
-export {
-	formatCumulativeUsage,
-	formatFreeTierStatus,
-	formatSessionUsage,
-} from "./formatters.ts";
-// Re-export from specialized modules
-export {
-	getModelUsage,
-	getProviderModelUsage,
-	getSessionUsage,
-	getTopModels,
-	incrementModelRequestCount,
-	logModelUsageReport,
-	resetUsageStats,
-	type SessionUsageReport,
-} from "./tracking.ts";
-// Re-export types for consumers
-export type { FreeTierLimit, FreeTierUsage } from "./types.ts";
-
-const _logger = createLogger("free-tier");
-
-// =============================================================================
-// Free Tier Limits Configuration
-// =============================================================================
-
-export const FREE_TIER_LIMITS: Record<string, FreeTierLimit> = {
-	kilo: {
-		provider: "kilo",
-		requestsPerHour: 200,
-		description: "200 requests/hour per IP (anonymous) or account",
-	},
-	openrouter: {
-		provider: "openrouter",
-		requestsPerDay: 1000,
-		description: "1000 requests/day for free tier (no API key)",
-	},
-	nvidia: {
-		provider: "nvidia",
-		requestsPerMonth: 1000,
-		description: "1000 requests/month for NIM free tier",
-	},
-	fireworks: {
-		provider: "fireworks",
-		requestsPerMonth: 1000,
-		description: "1000 requests/month for free tier",
-	},
-	zen: {
-		provider: "zen",
-		description: "Fair use policy - no hard limits",
-	},
-	cline: {
-		provider: "cline",
-		description: "Rate limited but limits undocumented",
-	},
-};
-
-// =============================================================================
-// Usage Status and Warnings
-// =============================================================================
-
-export function getFreeTierUsage(provider: string): FreeTierUsage {
-	const limit = FREE_TIER_LIMITS[provider];
-	if (!limit) {
-		return {
-			provider,
-			requestsToday: 0,
-			requestsThisHour: 0,
-			limit: { provider, description: "Unknown" },
-			percentUsed: 0,
-			status: "unknown",
-		};
-	}
-
-	const requestsToday = getDailyRequestCount(provider);
-	// For hour tracking, estimate based on session count (capped at 50)
-	const requestsThisHour = Math.min(requestsToday, 50);
-
-	let percentUsed = 0;
-	let status: FreeTierUsage["status"] = "ok";
-
-	if (limit.requestsPerHour) {
-		percentUsed = Math.max(
-			percentUsed,
-			(requestsThisHour / limit.requestsPerHour) * 100,
-		);
-	}
-	if (limit.requestsPerDay) {
-		percentUsed = Math.max(
-			percentUsed,
-			(requestsToday / limit.requestsPerDay) * 100,
-		);
-	}
-
-	if (percentUsed >= 90) status = "critical";
-	else if (percentUsed >= 70) status = "warning";
-
-	return {
-		provider,
-		requestsToday,
-		requestsThisHour,
-		limit,
-		remainingToday: limit.requestsPerDay
-			? limit.requestsPerDay - requestsToday
-			: undefined,
-		remainingThisHour: limit.requestsPerHour
-			? limit.requestsPerHour - requestsThisHour
-			: undefined,
-		percentUsed: Math.round(percentUsed),
-		status,
-	};
-}
-
-export function isApproachingLimit(provider: string): boolean {
-	const usage = getFreeTierUsage(provider);
-	return usage.status === "warning" || usage.status === "critical";
-}
-
-export function getLimitWarning(provider: string): string | null {
-	const usage = getFreeTierUsage(provider);
-
-	if (usage.status === "critical") {
-		const remaining = usage.remainingThisHour ?? usage.remainingToday ?? 0;
-		return `⚠️ ${provider}: ${usage.percentUsed}% of free tier used. ~${remaining} requests remaining.`;
-	}
-
-	if (usage.status === "warning") {
-		return `ℹ️ ${provider}: ${usage.percentUsed}% of free tier used.`;
-	}
-
-	return null;
-}