@oh-my-pi/omp-stats 6.9.69

package/src/client/types.ts

@@ -0,0 +1,82 @@
+/**
+ * Client-side type definitions.
+ * Duplicated from ../types.ts to avoid pulling in server dependencies.
+ */
+
+export interface Usage {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	totalTokens: number;
+	cost: {
+		input: number;
+		output: number;
+		cacheRead: number;
+		cacheWrite: number;
+		total: number;
+	};
+}
+
+export interface MessageStats {
+	id?: number;
+	sessionFile: string;
+	entryId: string;
+	folder: string;
+	model: string;
+	provider: string;
+	api: string;
+	timestamp: number;
+	duration: number | null;
+	ttft: number | null;
+	stopReason: string;
+	errorMessage: string | null;
+	usage: Usage;
+}
+
+export interface RequestDetails extends MessageStats {
+	messages: unknown[];
+	output: unknown;
+}
+
+export interface AggregatedStats {
+	totalRequests: number;
+	successfulRequests: number;
+	failedRequests: number;
+	errorRate: number;
+	totalInputTokens: number;
+	totalOutputTokens: number;
+	totalCacheReadTokens: number;
+	totalCacheWriteTokens: number;
+	cacheRate: number;
+	totalCost: number;
+	avgDuration: number | null;
+	avgTtft: number | null;
+	avgTokensPerSecond: number | null;
+	firstTimestamp: number;
+	lastTimestamp: number;
+}
+
+export interface ModelStats extends AggregatedStats {
+	model: string;
+	provider: string;
+}
+
+export interface FolderStats extends AggregatedStats {
+	folder: string;
+}
+
+export interface TimeSeriesPoint {
+	timestamp: number;
+	requests: number;
+	errors: number;
+	tokens: number;
+	cost: number;
+}
+
+export interface DashboardStats {
+	overall: AggregatedStats;
+	byModel: ModelStats[];
+	byFolder: FolderStats[];
+	timeSeries: TimeSeriesPoint[];
+}

package/src/db.ts

@@ -0,0 +1,396 @@
+import { Database } from "bun:sqlite";
+import { mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { AggregatedStats, FolderStats, MessageStats, ModelStats, TimeSeriesPoint } from "./types";
+
+const DB_PATH = join(homedir(), ".omp", "stats.db");
+
+let db: Database | null = null;
+
+/**
+ * Initialize the database and create tables.
+ */
+export async function initDb(): Promise<Database> {
+	if (db) return db;
+
+	// Ensure directory exists
+	await mkdir(join(homedir(), ".omp"), { recursive: true });
+
+	db = new Database(DB_PATH);
+	db.exec("PRAGMA journal_mode = WAL");
+
+	// Create tables
+	db.exec(`
+		CREATE TABLE IF NOT EXISTS messages (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			session_file TEXT NOT NULL,
+			entry_id TEXT NOT NULL,
+			folder TEXT NOT NULL,
+			model TEXT NOT NULL,
+			provider TEXT NOT NULL,
+			api TEXT NOT NULL,
+			timestamp INTEGER NOT NULL,
+			duration INTEGER,
+			ttft INTEGER,
+			stop_reason TEXT NOT NULL,
+			error_message TEXT,
+			input_tokens INTEGER NOT NULL,
+			output_tokens INTEGER NOT NULL,
+			cache_read_tokens INTEGER NOT NULL,
+			cache_write_tokens INTEGER NOT NULL,
+			total_tokens INTEGER NOT NULL,
+			cost_input REAL NOT NULL,
+			cost_output REAL NOT NULL,
+			cost_cache_read REAL NOT NULL,
+			cost_cache_write REAL NOT NULL,
+			cost_total REAL NOT NULL,
+			UNIQUE(session_file, entry_id)
+		);
+
+		CREATE INDEX IF NOT EXISTS idx_messages_timestamp ON messages(timestamp);
+		CREATE INDEX IF NOT EXISTS idx_messages_model ON messages(model);
+		CREATE INDEX IF NOT EXISTS idx_messages_folder ON messages(folder);
+		CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_file);
+
+		CREATE TABLE IF NOT EXISTS file_offsets (
+			session_file TEXT PRIMARY KEY,
+			offset INTEGER NOT NULL,
+			last_modified INTEGER NOT NULL
+		);
+	`);
+
+	return db;
+}
+
+/**
+ * Get the stored offset for a session file.
+ */
+export function getFileOffset(sessionFile: string): { offset: number; lastModified: number } | null {
+	if (!db) return null;
+
+	const stmt = db.prepare("SELECT offset, last_modified FROM file_offsets WHERE session_file = ?");
+	const row = stmt.get(sessionFile) as { offset: number; last_modified: number } | undefined;
+
+	return row ? { offset: row.offset, lastModified: row.last_modified } : null;
+}
+
+/**
+ * Update the stored offset for a session file.
+ */
+export function setFileOffset(sessionFile: string, offset: number, lastModified: number): void {
+	if (!db) return;
+
+	const stmt = db.prepare(`
+		INSERT OR REPLACE INTO file_offsets (session_file, offset, last_modified)
+		VALUES (?, ?, ?)
+	`);
+	stmt.run(sessionFile, offset, lastModified);
+}
+
+/**
+ * Insert message stats into the database.
+ */
+export function insertMessageStats(stats: MessageStats[]): number {
+	if (!db || stats.length === 0) return 0;
+
+	const stmt = db.prepare(`
+		INSERT OR IGNORE INTO messages (
+			session_file, entry_id, folder, model, provider, api, timestamp,
+			duration, ttft, stop_reason, error_message,
+			input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, total_tokens,
+			cost_input, cost_output, cost_cache_read, cost_cache_write, cost_total
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+	`);
+
+	let inserted = 0;
+	const insert = db.transaction(() => {
+		for (const s of stats) {
+			const result = stmt.run(
+				s.sessionFile,
+				s.entryId,
+				s.folder,
+				s.model,
+				s.provider,
+				s.api,
+				s.timestamp,
+				s.duration,
+				s.ttft,
+				s.stopReason,
+				s.errorMessage,
+				s.usage.input,
+				s.usage.output,
+				s.usage.cacheRead,
+				s.usage.cacheWrite,
+				s.usage.totalTokens,
+				s.usage.cost.input,
+				s.usage.cost.output,
+				s.usage.cost.cacheRead,
+				s.usage.cost.cacheWrite,
+				s.usage.cost.total,
+			);
+			if (result.changes > 0) inserted++;
+		}
+	});
+
+	insert();
+	return inserted;
+}
+
+/**
+ * Build aggregated stats from query results.
+ */
+function buildAggregatedStats(rows: any[]): AggregatedStats {
+	if (rows.length === 0) {
+		return {
+			totalRequests: 0,
+			successfulRequests: 0,
+			failedRequests: 0,
+			errorRate: 0,
+			totalInputTokens: 0,
+			totalOutputTokens: 0,
+			totalCacheReadTokens: 0,
+			totalCacheWriteTokens: 0,
+			cacheRate: 0,
+			totalCost: 0,
+			avgDuration: null,
+			avgTtft: null,
+			avgTokensPerSecond: null,
+			firstTimestamp: 0,
+			lastTimestamp: 0,
+		};
+	}
+
+	const row = rows[0];
+	const totalRequests = row.total_requests || 0;
+	const failedRequests = row.failed_requests || 0;
+	const successfulRequests = totalRequests - failedRequests;
+	const totalInputTokens = row.total_input_tokens || 0;
+	const totalCacheReadTokens = row.total_cache_read_tokens || 0;
+
+	return {
+		totalRequests,
+		successfulRequests,
+		failedRequests,
+		errorRate: totalRequests > 0 ? failedRequests / totalRequests : 0,
+		totalInputTokens,
+		totalOutputTokens: row.total_output_tokens || 0,
+		totalCacheReadTokens,
+		totalCacheWriteTokens: row.total_cache_write_tokens || 0,
+		cacheRate:
+			totalInputTokens + totalCacheReadTokens > 0
+				? totalCacheReadTokens / (totalInputTokens + totalCacheReadTokens)
+				: 0,
+		totalCost: row.total_cost || 0,
+		avgDuration: row.avg_duration,
+		avgTtft: row.avg_ttft,
+		avgTokensPerSecond: row.avg_tokens_per_second,
+		firstTimestamp: row.first_timestamp || 0,
+		lastTimestamp: row.last_timestamp || 0,
+	};
+}
+
+/**
+ * Get overall aggregated stats.
+ */
+export function getOverallStats(): AggregatedStats {
+	if (!db) return buildAggregatedStats([]);
+
+	const stmt = db.prepare(`
+		SELECT
+			COUNT(*) as total_requests,
+			SUM(CASE WHEN stop_reason = 'error' THEN 1 ELSE 0 END) as failed_requests,
+			SUM(input_tokens) as total_input_tokens,
+			SUM(output_tokens) as total_output_tokens,
+			SUM(cache_read_tokens) as total_cache_read_tokens,
+			SUM(cache_write_tokens) as total_cache_write_tokens,
+			SUM(cost_total) as total_cost,
+			AVG(duration) as avg_duration,
+			AVG(ttft) as avg_ttft,
+			AVG(CASE WHEN duration > 0 THEN output_tokens * 1000.0 / duration ELSE NULL END) as avg_tokens_per_second,
+			MIN(timestamp) as first_timestamp,
+			MAX(timestamp) as last_timestamp
+		FROM messages
+	`);
+
+	const rows = stmt.all();
+	return buildAggregatedStats(rows);
+}
+
+/**
+ * Get stats grouped by model.
+ */
+export function getStatsByModel(): ModelStats[] {
+	if (!db) return [];
+
+	const stmt = db.prepare(`
+		SELECT
+			model,
+			provider,
+			COUNT(*) as total_requests,
+			SUM(CASE WHEN stop_reason = 'error' THEN 1 ELSE 0 END) as failed_requests,
+			SUM(input_tokens) as total_input_tokens,
+			SUM(output_tokens) as total_output_tokens,
+			SUM(cache_read_tokens) as total_cache_read_tokens,
+			SUM(cache_write_tokens) as total_cache_write_tokens,
+			SUM(cost_total) as total_cost,
+			AVG(duration) as avg_duration,
+			AVG(ttft) as avg_ttft,
+			AVG(CASE WHEN duration > 0 THEN output_tokens * 1000.0 / duration ELSE NULL END) as avg_tokens_per_second,
+			MIN(timestamp) as first_timestamp,
+			MAX(timestamp) as last_timestamp
+		FROM messages
+		GROUP BY model, provider
+		ORDER BY total_requests DESC
+	`);
+
+	const rows = stmt.all() as any[];
+	return rows.map((row) => ({
+		model: row.model,
+		provider: row.provider,
+		...buildAggregatedStats([row]),
+	}));
+}
+
+/**
+ * Get stats grouped by folder.
+ */
+export function getStatsByFolder(): FolderStats[] {
+	if (!db) return [];
+
+	const stmt = db.prepare(`
+		SELECT
+			folder,
+			COUNT(*) as total_requests,
+			SUM(CASE WHEN stop_reason = 'error' THEN 1 ELSE 0 END) as failed_requests,
+			SUM(input_tokens) as total_input_tokens,
+			SUM(output_tokens) as total_output_tokens,
+			SUM(cache_read_tokens) as total_cache_read_tokens,
+			SUM(cache_write_tokens) as total_cache_write_tokens,
+			SUM(cost_total) as total_cost,
+			AVG(duration) as avg_duration,
+			AVG(ttft) as avg_ttft,
+			AVG(CASE WHEN duration > 0 THEN output_tokens * 1000.0 / duration ELSE NULL END) as avg_tokens_per_second,
+			MIN(timestamp) as first_timestamp,
+			MAX(timestamp) as last_timestamp
+		FROM messages
+		GROUP BY folder
+		ORDER BY total_requests DESC
+	`);
+
+	const rows = stmt.all() as any[];
+	return rows.map((row) => ({
+		folder: row.folder,
+		...buildAggregatedStats([row]),
+	}));
+}
+
+/**
+ * Get hourly time series data.
+ */
+export function getTimeSeries(hours = 24): TimeSeriesPoint[] {
+	if (!db) return [];
+
+	const cutoff = Date.now() - hours * 60 * 60 * 1000;
+
+	const stmt = db.prepare(`
+		SELECT
+			(timestamp / 3600000) * 3600000 as bucket,
+			COUNT(*) as requests,
+			SUM(CASE WHEN stop_reason = 'error' THEN 1 ELSE 0 END) as errors,
+			SUM(total_tokens) as tokens,
+			SUM(cost_total) as cost
+		FROM messages
+		WHERE timestamp >= ?
+		GROUP BY bucket
+		ORDER BY bucket ASC
+	`);
+
+	const rows = stmt.all(cutoff) as any[];
+	return rows.map((row) => ({
+		timestamp: row.bucket,
+		requests: row.requests,
+		errors: row.errors,
+		tokens: row.tokens,
+		cost: row.cost,
+	}));
+}
+
+/**
+ * Get total message count.
+ */
+export function getMessageCount(): number {
+	if (!db) return 0;
+	const stmt = db.prepare("SELECT COUNT(*) as count FROM messages");
+	const row = stmt.get() as { count: number };
+	return row.count;
+}
+
+/**
+ * Close the database connection.
+ */
+export function closeDb(): void {
+	if (db) {
+		db.close();
+		db = null;
+	}
+}
+
+function rowToMessageStats(row: any): MessageStats {
+	return {
+		id: row.id,
+		sessionFile: row.session_file,
+		entryId: row.entry_id,
+		folder: row.folder,
+		model: row.model,
+		provider: row.provider,
+		api: row.api,
+		timestamp: row.timestamp,
+		duration: row.duration,
+		ttft: row.ttft,
+		stopReason: row.stop_reason as any,
+		errorMessage: row.error_message,
+		usage: {
+			input: row.input_tokens,
+			output: row.output_tokens,
+			cacheRead: row.cache_read_tokens,
+			cacheWrite: row.cache_write_tokens,
+			totalTokens: row.total_tokens,
+			cost: {
+				input: row.cost_input,
+				output: row.cost_output,
+				cacheRead: row.cost_cache_read,
+				cacheWrite: row.cost_cache_write,
+				total: row.cost_total,
+			},
+		},
+	};
+}
+
+export function getRecentRequests(limit = 100): MessageStats[] {
+	if (!db) return [];
+	const stmt = db.prepare(`
+		SELECT * FROM messages 
+		ORDER BY timestamp DESC 
+		LIMIT ?
+	`);
+	return (stmt.all(limit) as any[]).map(rowToMessageStats);
+}
+
+export function getRecentErrors(limit = 100): MessageStats[] {
+	if (!db) return [];
+	const stmt = db.prepare(`
+		SELECT * FROM messages 
+		WHERE stop_reason = 'error'
+		ORDER BY timestamp DESC 
+		LIMIT ?
+	`);
+	return (stmt.all(limit) as any[]).map(rowToMessageStats);
+}
+
+export function getMessageById(id: number): MessageStats | null {
+	if (!db) return null;
+	const stmt = db.prepare("SELECT * FROM messages WHERE id = ?");
+	const row = stmt.get(id);
+	return row ? rowToMessageStats(row) : null;
+}

package/src/index.ts

@@ -0,0 +1,168 @@
+#!/usr/bin/env bun
+
+import { parseArgs } from "node:util";
+import { getDashboardStats, getTotalMessageCount, syncAllSessions } from "./aggregator";
+import { closeDb } from "./db";
+import { startServer } from "./server";
+
+export { getDashboardStats, getTotalMessageCount, syncAllSessions } from "./aggregator";
+export type {
+	AggregatedStats,
+	DashboardStats,
+	FolderStats,
+	MessageStats,
+	ModelStats,
+	TimeSeriesPoint,
+} from "./types";
+
+/**
+ * Format a number with appropriate suffix (K, M, etc.)
+ */
+function formatNumber(n: number): string {
+	if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+	if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
+	return n.toFixed(0);
+}
+
+/**
+ * Format cost in dollars.
+ */
+function formatCost(n: number): string {
+	if (n < 0.01) return `$${n.toFixed(4)}`;
+	if (n < 1) return `$${n.toFixed(3)}`;
+	return `$${n.toFixed(2)}`;
+}
+
+/**
+ * Format duration in ms to human-readable.
+ */
+function formatDuration(ms: number | null): string {
+	if (ms === null) return "-";
+	if (ms < 1000) return `${ms.toFixed(0)}ms`;
+	return `${(ms / 1000).toFixed(1)}s`;
+}
+
+/**
+ * Format percentage.
+ */
+function formatPercent(n: number): string {
+	return `${(n * 100).toFixed(1)}%`;
+}
+
+/**
+ * Print stats summary to console.
+ */
+async function printStats(): Promise<void> {
+	const stats = await getDashboardStats();
+	const { overall, byModel, byFolder } = stats;
+
+	console.log("\n=== AI Usage Statistics ===\n");
+
+	console.log("Overall:");
+	console.log(`  Requests: ${formatNumber(overall.totalRequests)} (${formatNumber(overall.failedRequests)} errors)`);
+	console.log(`  Error Rate: ${formatPercent(overall.errorRate)}`);
+	console.log(`  Total Tokens: ${formatNumber(overall.totalInputTokens + overall.totalOutputTokens)}`);
+	console.log(`  Cache Rate: ${formatPercent(overall.cacheRate)}`);
+	console.log(`  Total Cost: ${formatCost(overall.totalCost)}`);
+	console.log(`  Avg Duration: ${formatDuration(overall.avgDuration)}`);
+	console.log(`  Avg TTFT: ${formatDuration(overall.avgTtft)}`);
+	if (overall.avgTokensPerSecond !== null) {
+		console.log(`  Avg Tokens/s: ${overall.avgTokensPerSecond.toFixed(1)}`);
+	}
+
+	if (byModel.length > 0) {
+		console.log("\nBy Model:");
+		for (const m of byModel.slice(0, 10)) {
+			console.log(
+				`  ${m.model}: ${formatNumber(m.totalRequests)} reqs, ${formatCost(m.totalCost)}, ${formatPercent(m.cacheRate)} cache`,
+			);
+		}
+	}
+
+	if (byFolder.length > 0) {
+		console.log("\nBy Folder:");
+		for (const f of byFolder.slice(0, 10)) {
+			console.log(`  ${f.folder}: ${formatNumber(f.totalRequests)} reqs, ${formatCost(f.totalCost)}`);
+		}
+	}
+
+	console.log("");
+}
+
+/**
+ * Main CLI entry point.
+ */
+async function main(): Promise<void> {
+	const { values } = parseArgs({
+		options: {
+			port: { type: "string", short: "p", default: "3847" },
+			json: { type: "boolean", short: "j", default: false },
+			sync: { type: "boolean", short: "s", default: false },
+			help: { type: "boolean", short: "h", default: false },
+		},
+		allowPositionals: true,
+	});
+
+	if (values.help) {
+		console.log(`
+omp-stats - AI Usage Statistics Dashboard
+
+Usage:
+  omp-stats [options]
+
+Options:
+  -p, --port <port>  Port for the dashboard server (default: 3847)
+  -j, --json         Output stats as JSON and exit
+  -s, --sync         Sync session files and show summary
+  -h, --help         Show this help message
+
+Examples:
+  omp-stats              # Start dashboard server
+  omp-stats --json       # Print stats as JSON
+  omp-stats --port 8080  # Start on custom port
+  omp-stats --sync       # Sync and show summary
+`);
+		return;
+	}
+
+	try {
+		// Sync first
+		console.log("Syncing session files...");
+		const { processed, files } = await syncAllSessions();
+		const total = await getTotalMessageCount();
+		console.log(`Synced ${processed} new entries from ${files} files (${total} total)\n`);
+
+		if (values.json) {
+			const stats = await getDashboardStats();
+			console.log(JSON.stringify(stats, null, 2));
+			return;
+		}
+
+		if (values.sync) {
+			await printStats();
+			return;
+		}
+
+		// Start server
+		const port = parseInt(values.port || "3847", 10);
+		const { port: actualPort } = startServer(port);
+		console.log(`Dashboard available at: http://localhost:${actualPort}`);
+		console.log("Press Ctrl+C to stop\n");
+
+		// Keep process running
+		process.on("SIGINT", () => {
+			console.log("\nShutting down...");
+			closeDb();
+			process.exit(0);
+		});
+	} catch (error) {
+		console.error("Error:", error);
+		closeDb();
+		process.exit(1);
+	}
+}
+
+// Run if executed directly
+if (import.meta.main) {
+	main();
+}