pi-free 1.0.8 → 2.0.0

package/usage/metrics.ts

@@ -1,222 +0,0 @@
-/**
- * Provider usage metrics - tracks rate limits and usage for each provider.
- */
-
-import { OPENCODE_API_KEY, OPENROUTER_API_KEY } from "../config.ts";
-import {
-	BASE_URL_OPENROUTER,
-	BASE_URL_ZEN,
-	DEFAULT_FETCH_TIMEOUT_MS,
-} from "../constants.ts";
-import { fetchWithTimeout, logWarning } from "../lib/util.ts";
-
-// =============================================================================
-// Types
-// =============================================================================
-
-export interface ProviderMetrics {
-	provider: string;
-	rateLimit?: {
-		requestsPerMinute?: number;
-		requestsPerDay?: number;
-		remainingToday?: number;
-	};
-	balance?: number;
-	credits?: number;
-	requestsToday: number;
-	lastUpdated: number;
-}
-
-// =============================================================================
-// Request counting (in-memory per session)
-// =============================================================================
-
-const requestCounts: Map<string, number> = new Map();
-const dailyRequestCounts: Map<string, { count: number; date: string }> =
-	new Map();
-
-function getTodayDate(): string {
-	return new Date().toISOString().split("T")[0];
-}
-
-export function incrementRequestCount(provider: string): void {
-	const key = `${provider}_session`;
-	const count = requestCounts.get(key) || 0;
-	requestCounts.set(key, count + 1);
-
-	// Daily counter
-	const today = getTodayDate();
-	const dailyKey = `${provider}_daily`;
-	const daily = dailyRequestCounts.get(dailyKey);
-	if (daily && daily.date === today) {
-		daily.count++;
-	} else {
-		dailyRequestCounts.set(dailyKey, { count: 1, date: today });
-	}
-}
-
-export function getRequestCount(provider: string): number {
-	return requestCounts.get(`${provider}_session`) || 0;
-}
-
-export function getDailyRequestCount(provider: string): number {
-	const today = getTodayDate();
-	const daily = dailyRequestCounts.get(`${provider}_daily`);
-	return daily && daily.date === today ? daily.count : 0;
-}
-
-// =============================================================================
-// OpenRouter metrics
-// =============================================================================
-
-interface OpenRouterKeyResponse {
-	usage?: {
-		"24h": number;
-		"7d": number;
-		total: number;
-	};
-	limit?: {
-		"24h": number;
-		"7d": number;
-		total: number;
-	};
-	soft_limit?: boolean;
-}
-
-interface OpenRouterCreditsResponse {
-	data?: {
-		credits_purchased: number;
-		credits_used: number;
-	};
-}
-
-export async function fetchOpenRouterMetrics(): Promise<ProviderMetrics | null> {
-	if (!OPENROUTER_API_KEY) return null;
-
-	try {
-		// Fetch both key info and credits in parallel
-		const [keyResponse, creditsResponse] = await Promise.all([
-			fetchWithTimeout(
-				`${BASE_URL_OPENROUTER}/key`,
-				{
-					headers: {
-						Authorization: `Bearer ${OPENROUTER_API_KEY}`,
-						"User-Agent": "pi-free-providers",
-					},
-				},
-				DEFAULT_FETCH_TIMEOUT_MS,
-			),
-			fetchWithTimeout(
-				`${BASE_URL_OPENROUTER}/credits`,
-				{
-					headers: {
-						Authorization: `Bearer ${OPENROUTER_API_KEY}`,
-						"User-Agent": "pi-free-providers",
-					},
-				},
-				DEFAULT_FETCH_TIMEOUT_MS,
-			),
-		]);
-
-		let limit24h: number | undefined;
-		let usage24h: number | undefined;
-		let credits = 0;
-
-		if (keyResponse.ok) {
-			const keyData = (await keyResponse.json()) as OpenRouterKeyResponse;
-			limit24h = keyData.limit?.["24h"];
-			usage24h = keyData.usage?.["24h"];
-		}
-
-		if (creditsResponse.ok) {
-			const creditsData =
-				(await creditsResponse.json()) as OpenRouterCreditsResponse;
-			if (creditsData.data) {
-				credits =
-					creditsData.data.credits_purchased - creditsData.data.credits_used;
-			}
-		}
-
-		const dailyCount = getDailyRequestCount("openrouter");
-
-		return {
-			provider: "openrouter",
-			rateLimit: {
-				requestsPerMinute: 20, // Fixed for free models
-				requestsPerDay: limit24h,
-				remainingToday: limit24h && usage24h ? limit24h - usage24h : undefined,
-			},
-			credits,
-			requestsToday: dailyCount,
-			lastUpdated: Date.now(),
-		};
-	} catch (error) {
-		logWarning("openrouter", "Failed to fetch metrics", error);
-		return null;
-	}
-}
-
-// =============================================================================
-// OpenCode metrics (balance only - no rate limits known)
-// =============================================================================
-
-export async function fetchOpenCodeMetrics(): Promise<ProviderMetrics | null> {
-	if (!OPENCODE_API_KEY) return null;
-
-	try {
-		const response = await fetchWithTimeout(
-			`${BASE_URL_ZEN}/user`,
-			{
-				headers: {
-					Authorization: `Bearer ${OPENCODE_API_KEY}`,
-					"User-Agent": "pi-free-providers",
-				},
-			},
-			DEFAULT_FETCH_TIMEOUT_MS,
-		);
-
-		if (!response.ok) {
-			return null;
-		}
-
-		const data = (await response.json()) as {
-			balance?: number;
-			credits?: number;
-		};
-		const dailyCount = getDailyRequestCount("opencode");
-
-		return {
-			provider: "opencode",
-			balance: data.balance,
-			credits: data.credits,
-			requestsToday: dailyCount,
-			lastUpdated: Date.now(),
-		};
-	} catch (error) {
-		logWarning("opencode", "Failed to fetch metrics", error);
-		return null;
-	}
-}
-
-// =============================================================================
-// Cached metrics storage
-// =============================================================================
-
-const metricsCache: Map<string, { data: ProviderMetrics; timestamp: number }> =
-	new Map();
-const CACHE_TTL_MS = 60_000; // 1 minute cache
-
-export function getCachedMetrics(provider: string): ProviderMetrics | null {
-	const cached = metricsCache.get(provider);
-	if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
-		return cached.data;
-	}
-	return null;
-}
-
-export function setCachedMetrics(
-	provider: string,
-	metrics: ProviderMetrics,
-): void {
-	metricsCache.set(provider, { data: metrics, timestamp: Date.now() });
-}

package/usage/sessions.ts

@@ -1,355 +0,0 @@
-/**
- * Session file parsing - extracts historical usage data from Pi session files
- *
- * Pi stores sessions in ~/.pi/agent/sessions/{cwd-hash}/*.jsonl
- * Each line is a JSON entry with type "session" or "message"
- */
-
-import { readdir, readFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { createLogger } from "../lib/logger.ts";
-
-const _logger = createLogger("session-parser");
-
-export interface SessionMessage {
-	provider: string;
-	model: string;
-	tokensIn: number;
-	tokensOut: number;
-	cacheRead: number;
-	cacheWrite: number;
-	cost: number;
-	timestamp: number;
-}
-
-export interface ParsedSession {
-	sessionId: string;
-	messages: SessionMessage[];
-}
-
-function getSessionsDir(): string {
-	const agentDir =
-		process.env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent");
-	return join(agentDir, "sessions");
-}
-
-async function getAllSessionFiles(signal?: AbortSignal): Promise<string[]> {
-	const sessionsDir = getSessionsDir();
-	const files: string[] = [];
-
-	try {
-		const cwdDirs = await readdir(sessionsDir, { withFileTypes: true });
-		for (const dir of cwdDirs) {
-			if (signal?.aborted) return files;
-			if (!dir.isDirectory()) continue;
-			const cwdPath = join(sessionsDir, dir.name);
-			try {
-				const sessionFiles = await readdir(cwdPath);
-				for (const file of sessionFiles) {
-					if (file.endsWith(".jsonl")) {
-						files.push(join(cwdPath, file));
-					}
-				}
-			} catch {
-				// Skip directories we can't read
-			}
-		}
-	} catch {
-		// Return empty if we can't read sessions dir
-	}
-
-	return files;
-}
-
-async function parseSessionFile(
-	filePath: string,
-	seenHashes: Set<string>,
-	signal?: AbortSignal,
-): Promise<ParsedSession | null> {
-	try {
-		const content = await readFile(filePath, "utf8");
-		if (signal?.aborted) return null;
-
-		const lines = content.trim().split("\n");
-		const messages: SessionMessage[] = [];
-		let sessionId = "";
-
-		for (let i = 0; i < lines.length; i++) {
-			if (signal?.aborted) return null;
-			if (i % 500 === 0) {
-				await new Promise<void>((resolve) => setImmediate(resolve));
-			}
-
-			const line = lines[i]!;
-			if (!line.trim()) continue;
-
-			try {
-				const entry = JSON.parse(line);
-
-				if (entry.type === "session") {
-					sessionId = entry.id;
-				} else if (
-					entry.type === "message" &&
-					entry.message?.role === "assistant"
-				) {
-					const msg = entry.message;
-					if (msg.usage && msg.provider && msg.model) {
-						const tokensIn = msg.usage.input || 0;
-						const tokensOut = msg.usage.output || 0;
-						const cacheRead = msg.usage.cacheRead || 0;
-						const cacheWrite = msg.usage.cacheWrite || 0;
-						const cost = msg.usage.cost?.total || 0;
-
-						const fallbackTs = entry.timestamp
-							? new Date(entry.timestamp).getTime()
-							: 0;
-						const timestamp =
-							msg.timestamp || (Number.isNaN(fallbackTs) ? 0 : fallbackTs);
-
-						const totalTokens = tokensIn + tokensOut + cacheRead + cacheWrite;
-						const hash = `${timestamp}:${totalTokens}`;
-						if (seenHashes.has(hash)) continue;
-						seenHashes.add(hash);
-
-						messages.push({
-							provider: msg.provider,
-							model: msg.model,
-							tokensIn,
-							tokensOut,
-							cacheRead,
-							cacheWrite,
-							cost,
-							timestamp,
-						});
-					}
-				}
-			} catch {
-				// Skip malformed lines
-			}
-		}
-
-		return sessionId ? { sessionId, messages } : null;
-	} catch {
-		return null;
-	}
-}
-
-export type TimePeriod = "today" | "thisWeek" | "allTime";
-
-export interface TimeRange {
-	start: number;
-	end?: number;
-}
-
-export function getTimeRange(period: TimePeriod): TimeRange {
-	const now = Date.now();
-	const startOfToday = new Date();
-	startOfToday.setHours(0, 0, 0, 0);
-
-	switch (period) {
-		case "today":
-			return { start: startOfToday.getTime(), end: now };
-		case "thisWeek": {
-			const startOfWeek = new Date();
-			const dayOfWeek = startOfWeek.getDay();
-			const daysSinceMonday = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
-			startOfWeek.setDate(startOfWeek.getDate() - daysSinceMonday);
-			startOfWeek.setHours(0, 0, 0, 0);
-			return { start: startOfWeek.getTime(), end: now };
-		}
-		case "allTime":
-			return { start: 0, end: now };
-	}
-}
-
-export function filterByTimeRange(
-	messages: SessionMessage[],
-	range: TimeRange,
-): SessionMessage[] {
-	return messages.filter((m) => {
-		if (m.timestamp < range.start) return false;
-		if (range.end && m.timestamp > range.end) return false;
-		return true;
-	});
-}
-
-export interface ModelStats {
-	count: number;
-	tokensIn: number;
-	tokensOut: number;
-	cacheRead: number;
-	cacheWrite: number;
-	cost: number;
-}
-
-export interface ProviderStats {
-	messages: number;
-	tokensIn: number;
-	tokensOut: number;
-	cacheRead: number;
-	cacheWrite: number;
-	cost: number;
-	models: Record<string, ModelStats>;
-}
-
-export interface SessionFileStats {
-	totalMessages: number;
-	totalTokensIn: number;
-	totalTokensOut: number;
-	totalCacheRead: number;
-	totalCacheWrite: number;
-	totalCost: number;
-	providers: Record<string, ProviderStats>;
-	sessions: Set<string>;
-}
-
-export function createEmptyStats(): SessionFileStats {
-	return {
-		totalMessages: 0,
-		totalTokensIn: 0,
-		totalTokensOut: 0,
-		totalCacheRead: 0,
-		totalCacheWrite: 0,
-		totalCost: 0,
-		providers: {},
-		sessions: new Set(),
-	};
-}
-
-export function aggregateMessages(
-	messages: SessionMessage[],
-	sessionId: string,
-): SessionFileStats {
-	const stats = createEmptyStats();
-	stats.sessions.add(sessionId);
-
-	for (const msg of messages) {
-		stats.totalMessages++;
-		stats.totalTokensIn += msg.tokensIn;
-		stats.totalTokensOut += msg.tokensOut;
-		stats.totalCacheRead += msg.cacheRead;
-		stats.totalCacheWrite += msg.cacheWrite;
-		stats.totalCost += msg.cost;
-
-		if (!stats.providers[msg.provider]) {
-			stats.providers[msg.provider] = {
-				messages: 0,
-				tokensIn: 0,
-				tokensOut: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				cost: 0,
-				models: {},
-			};
-		}
-		const provider = stats.providers[msg.provider]!;
-		provider.messages++;
-		provider.tokensIn += msg.tokensIn;
-		provider.tokensOut += msg.tokensOut;
-		provider.cacheRead += msg.cacheRead;
-		provider.cacheWrite += msg.cacheWrite;
-		provider.cost += msg.cost;
-
-		if (!provider.models[msg.model]) {
-			provider.models[msg.model] = {
-				count: 0,
-				tokensIn: 0,
-				tokensOut: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				cost: 0,
-			};
-		}
-		const model = provider.models[msg.model]!;
-		model.count++;
-		model.tokensIn += msg.tokensIn;
-		model.tokensOut += msg.tokensOut;
-		model.cacheRead += msg.cacheRead;
-		model.cacheWrite += msg.cacheWrite;
-		model.cost += msg.cost;
-	}
-
-	return stats;
-}
-
-export async function collectSessionFileStats(
-	period: TimePeriod = "allTime",
-	signal?: AbortSignal,
-): Promise<SessionFileStats> {
-	const range = getTimeRange(period);
-	const allStats = createEmptyStats();
-
-	const sessionFiles = await getAllSessionFiles(signal);
-	if (signal?.aborted) return allStats;
-
-	const seenHashes = new Set<string>();
-
-	for (const filePath of sessionFiles) {
-		if (signal?.aborted) return allStats;
-
-		const parsed = await parseSessionFile(filePath, seenHashes, signal);
-		if (signal?.aborted) return allStats;
-		if (!parsed) continue;
-
-		const filteredMessages = filterByTimeRange(parsed.messages, range);
-		if (filteredMessages.length === 0) continue;
-
-		const fileStats = aggregateMessages(filteredMessages, parsed.sessionId);
-
-		allStats.sessions.add(parsed.sessionId);
-		allStats.totalMessages += fileStats.totalMessages;
-		allStats.totalTokensIn += fileStats.totalTokensIn;
-		allStats.totalTokensOut += fileStats.totalTokensOut;
-		allStats.totalCacheRead += fileStats.totalCacheRead;
-		allStats.totalCacheWrite += fileStats.totalCacheWrite;
-		allStats.totalCost += fileStats.totalCost;
-
-		for (const [providerName, providerStats] of Object.entries(
-			fileStats.providers,
-		)) {
-			if (!allStats.providers[providerName]) {
-				allStats.providers[providerName] = {
-					messages: 0,
-					tokensIn: 0,
-					tokensOut: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					cost: 0,
-					models: {},
-				};
-			}
-			const allProvider = allStats.providers[providerName]!;
-			allProvider.messages += providerStats.messages;
-			allProvider.tokensIn += providerStats.tokensIn;
-			allProvider.tokensOut += providerStats.tokensOut;
-			allProvider.cacheRead += providerStats.cacheRead;
-			allProvider.cacheWrite += providerStats.cacheWrite;
-			allProvider.cost += providerStats.cost;
-
-			for (const [modelName, modelStats] of Object.entries(
-				providerStats.models,
-			)) {
-				if (!allProvider.models[modelName]) {
-					allProvider.models[modelName] = {
-						count: 0,
-						tokensIn: 0,
-						tokensOut: 0,
-						cacheRead: 0,
-						cacheWrite: 0,
-						cost: 0,
-					};
-				}
-				const allModel = allProvider.models[modelName]!;
-				allModel.count += modelStats.count;
-				allModel.tokensIn += modelStats.tokensIn;
-				allModel.tokensOut += modelStats.tokensOut;
-				allModel.cacheRead += modelStats.cacheRead;
-				allModel.cacheWrite += modelStats.cacheWrite;
-				allModel.cost += modelStats.cost;
-			}
-		}
-	}
-
-	return allStats;
-}

package/usage/store.ts

@@ -1,99 +0,0 @@
-/**
- * Persistent cumulative usage tracking per provider.
- *
- * Stored at ~/./.pi/free-usage.json — survives across sessions.
- * Updated on each turn_end via provider-helper.ts.
- *
- * This answers: "how much free value have I gotten over time?"
- */
-
-import { join } from "node:path";
-import { createJSONStore } from "../lib/json-persistence.js";
-import { createLogger } from "../lib/logger.js";
-
-// =============================================================================
-// Types
-// =============================================================================
-
-export interface ProviderCumulativeUsage {
-	/** Total input tokens across all sessions. */
-	tokensIn: number;
-	/** Total output tokens across all sessions. */
-	tokensOut: number;
-	/** Total requests across all sessions. */
-	requests: number;
-	/** Total cost that would have been charged on a paid tier. */
-	costEquivalent: number;
-	/** ISO date of first tracked request. */
-	firstUsed: string;
-	/** ISO date of last tracked request. */
-	lastUsed: string;
-}
-
-export interface CumulativeUsageStore {
-	[provider: string]: ProviderCumulativeUsage;
-}
-
-// =============================================================================
-// Storage
-// =============================================================================
-
-const PI_DIR = join(process.env.HOME || process.env.USERPROFILE || "", ".pi");
-const USAGE_PATH = join(PI_DIR, "free-usage.json");
-
-const logger = createLogger("usage-store");
-
-const store = createJSONStore<CumulativeUsageStore>(USAGE_PATH, {});
-
-// =============================================================================
-// API
-// =============================================================================
-
-/** Record a turn's token usage for a provider. */
-export function recordTurn(
-	provider: string,
-	tokensIn: number,
-	tokensOut: number,
-	costEquivalent: number,
-): void {
-	const data = store.load();
-	const now = new Date().toISOString();
-	const existing = data[provider];
-
-	if (existing) {
-		existing.tokensIn += tokensIn;
-		existing.tokensOut += tokensOut;
-		existing.requests += 1;
-		existing.costEquivalent += costEquivalent;
-		existing.lastUsed = now;
-	} else {
-		data[provider] = {
-			tokensIn,
-			tokensOut,
-			requests: 1,
-			costEquivalent,
-			firstUsed: now,
-			lastUsed: now,
-		};
-	}
-
-	store.save(data);
-	logger.debug("recorded turn", {
-		provider,
-		tokensIn,
-		tokensOut,
-		costEquivalent,
-	});
-}
-
-/** Get cumulative usage for a specific provider. */
-export function getCumulativeUsage(
-	provider: string,
-): ProviderCumulativeUsage | null {
-	return store.load()[provider] ?? null;
-}
-
-/** Get all cumulative usage data. */
-export function getAllCumulativeUsage(): CumulativeUsageStore {
-	return store.load();
-}