@oh-my-pi/omp-stats 6.9.69

package/src/parser.ts

@@ -0,0 +1,166 @@
+import { readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
+import type { MessageStats, SessionEntry, SessionMessageEntry } from "./types";
+
+const SESSIONS_DIR = join(homedir(), ".omp", "agent", "sessions");
+
+/**
+ * Extract folder name from session filename.
+ * Session files are named like: --work--pi--/timestamp_uuid.jsonl
+ * The folder part uses -- as path separator.
+ */
+function extractFolderFromPath(sessionPath: string): string {
+	const dir = basename(sessionPath.replace(/\/[^/]+\.jsonl$/, ""));
+	// Convert --work--pi-- to /work/pi
+	return dir.replace(/^--/, "/").replace(/--/g, "/");
+}
+
+/**
+ * Parse a single JSONL line into a session entry.
+ */
+function parseLine(line: string): SessionEntry | null {
+	const trimmed = line.trim();
+	if (!trimmed) return null;
+
+	try {
+		return JSON.parse(trimmed) as SessionEntry;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Check if an entry is an assistant message.
+ */
+function isAssistantMessage(entry: SessionEntry): entry is SessionMessageEntry {
+	if (entry.type !== "message") return false;
+	const msgEntry = entry as SessionMessageEntry;
+	return msgEntry.message?.role === "assistant";
+}
+
+/**
+ * Extract stats from an assistant message entry.
+ */
+function extractStats(sessionFile: string, folder: string, entry: SessionMessageEntry): MessageStats | null {
+	const msg = entry.message as AssistantMessage;
+	if (!msg || msg.role !== "assistant") return null;
+
+	return {
+		sessionFile,
+		entryId: entry.id,
+		folder,
+		model: msg.model,
+		provider: msg.provider,
+		api: msg.api,
+		timestamp: msg.timestamp,
+		duration: msg.duration ?? null,
+		ttft: msg.ttft ?? null,
+		stopReason: msg.stopReason,
+		errorMessage: msg.errorMessage ?? null,
+		usage: msg.usage,
+	};
+}
+
+/**
+ * Parse a session file and extract all assistant message stats.
+ * Uses incremental reading with offset tracking.
+ */
+export async function parseSessionFile(
+	sessionPath: string,
+	fromOffset = 0,
+): Promise<{ stats: MessageStats[]; newOffset: number }> {
+	const file = Bun.file(sessionPath);
+	const exists = await file.exists();
+	if (!exists) {
+		return { stats: [], newOffset: fromOffset };
+	}
+
+	const text = await file.text();
+	const lines = text.split("\n");
+	const folder = extractFolderFromPath(sessionPath);
+	const stats: MessageStats[] = [];
+
+	let currentOffset = 0;
+	for (const line of lines) {
+		const lineLength = line.length + 1; // +1 for newline
+		if (currentOffset >= fromOffset && line.trim()) {
+			const entry = parseLine(line);
+			if (entry && isAssistantMessage(entry)) {
+				const msgStats = extractStats(sessionPath, folder, entry);
+				if (msgStats) {
+					stats.push(msgStats);
+				}
+			}
+		}
+		currentOffset += lineLength;
+	}
+
+	return { stats, newOffset: currentOffset };
+}
+
+/**
+ * List all session directories (folders).
+ */
+export async function listSessionFolders(): Promise<string[]> {
+	try {
+		const entries = await readdir(SESSIONS_DIR, { withFileTypes: true });
+		return entries.filter((e) => e.isDirectory()).map((e) => join(SESSIONS_DIR, e.name));
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * List all session files in a folder.
+ */
+export async function listSessionFiles(folderPath: string): Promise<string[]> {
+	try {
+		const entries = await readdir(folderPath, { withFileTypes: true });
+		return entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => join(folderPath, e.name));
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * List all session files across all folders.
+ */
+export async function listAllSessionFiles(): Promise<string[]> {
+	const folders = await listSessionFolders();
+	const allFiles: string[] = [];
+
+	for (const folder of folders) {
+		const files = await listSessionFiles(folder);
+		allFiles.push(...files);
+	}
+
+	return allFiles;
+}
+
+/**
+ * Get session directory path.
+ */
+export function getSessionsDir(): string {
+	return SESSIONS_DIR;
+}
+
+/**
+ * Find a specific entry in a session file.
+ */
+export async function getSessionEntry(sessionPath: string, entryId: string): Promise<SessionEntry | null> {
+	const file = Bun.file(sessionPath);
+	if (!(await file.exists())) return null;
+
+	const text = await file.text();
+	const lines = text.split("\n");
+
+	for (const line of lines) {
+		const entry = parseLine(line);
+		if (entry && "id" in entry && entry.id === entryId) {
+			return entry;
+		}
+	}
+	return null;
+}

package/src/server.ts

@@ -0,0 +1,147 @@
+import { join } from "node:path";
+import {
+	getDashboardStats,
+	getRecentErrors,
+	getRecentRequests,
+	getRequestDetails,
+	getTotalMessageCount,
+	syncAllSessions,
+} from "./aggregator";
+
+const STATIC_DIR = join(import.meta.dir, "..", "dist", "client");
+
+/**
+ * Handle API requests.
+ */
+async function handleApi(req: Request): Promise<Response> {
+	const url = new URL(req.url);
+	const path = url.pathname;
+
+	// Sync sessions before returning stats
+	await syncAllSessions();
+
+	if (path === "/api/stats") {
+		const stats = await getDashboardStats();
+		return Response.json(stats);
+	}
+
+	if (path === "/api/stats/recent") {
+		const limit = url.searchParams.get("limit");
+		const stats = await getRecentRequests(limit ? parseInt(limit, 10) : undefined);
+		return Response.json(stats);
+	}
+
+	if (path === "/api/stats/errors") {
+		const limit = url.searchParams.get("limit");
+		const stats = await getRecentErrors(limit ? parseInt(limit, 10) : undefined);
+		return Response.json(stats);
+	}
+
+	if (path === "/api/stats/models") {
+		const stats = await getDashboardStats();
+		return Response.json(stats.byModel);
+	}
+
+	if (path === "/api/stats/folders") {
+		const stats = await getDashboardStats();
+		return Response.json(stats.byFolder);
+	}
+
+	if (path === "/api/stats/timeseries") {
+		const stats = await getDashboardStats();
+		return Response.json(stats.timeSeries);
+	}
+
+	if (path.startsWith("/api/request/")) {
+		const id = path.split("/").pop();
+		if (!id) return new Response("Bad Request", { status: 400 });
+		const details = await getRequestDetails(parseInt(id, 10));
+		if (!details) return new Response("Not Found", { status: 404 });
+		return Response.json(details);
+	}
+
+	if (path === "/api/sync") {
+		const result = await syncAllSessions();
+		const count = await getTotalMessageCount();
+		return Response.json({ ...result, totalMessages: count });
+	}
+
+	return new Response("Not Found", { status: 404 });
+}
+
+/**
+ * Handle static file requests.
+ */
+async function handleStatic(path: string): Promise<Response> {
+	const filePath = path === "/" ? "/index.html" : path;
+	const fullPath = join(STATIC_DIR, filePath);
+
+	const file = Bun.file(fullPath);
+	if (await file.exists()) {
+		return new Response(file);
+	}
+
+	// SPA fallback
+	const index = Bun.file(join(STATIC_DIR, "index.html"));
+	if (await index.exists()) {
+		return new Response(index);
+	}
+
+	return new Response("Not Found", { status: 404 });
+}
+
+/**
+ * Start the HTTP server.
+ */
+export function startServer(port = 3847): { port: number; stop: () => void } {
+	const server = Bun.serve({
+		port,
+		async fetch(req) {
+			const url = new URL(req.url);
+			const path = url.pathname;
+
+			// CORS headers for local development
+			const corsHeaders = {
+				"Access-Control-Allow-Origin": "*",
+				"Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+				"Access-Control-Allow-Headers": "Content-Type",
+			};
+
+			if (req.method === "OPTIONS") {
+				return new Response(null, { headers: corsHeaders });
+			}
+
+			try {
+				let response: Response;
+
+				if (path.startsWith("/api/")) {
+					response = await handleApi(req);
+				} else {
+					response = await handleStatic(path);
+				}
+
+				// Add CORS headers to all responses
+				const headers = new Headers(response.headers);
+				for (const [key, value] of Object.entries(corsHeaders)) {
+					headers.set(key, value);
+				}
+
+				return new Response(response.body, {
+					status: response.status,
+					headers,
+				});
+			} catch (error) {
+				console.error("Server error:", error);
+				return Response.json(
+					{ error: error instanceof Error ? error.message : "Unknown error" },
+					{ status: 500, headers: corsHeaders },
+				);
+			}
+		},
+	});
+
+	return {
+		port: server.port ?? port,
+		stop: () => server.stop(),
+	};
+}

package/src/types.ts

@@ -0,0 +1,139 @@
+import type { AssistantMessage, StopReason, Usage } from "@oh-my-pi/pi-ai";
+
+/**
+ * Extracted stats from an assistant message.
+ */
+export interface MessageStats {
+	/** Database ID */
+	id?: number;
+	/** Session file path */
+	sessionFile: string;
+	/** Entry ID within the session */
+	entryId: string;
+	/** Folder/project path (extracted from session filename) */
+	folder: string;
+	/** Model ID */
+	model: string;
+	/** Provider name */
+	provider: string;
+	/** API type */
+	api: string;
+	/** Unix timestamp in milliseconds */
+	timestamp: number;
+	/** Request duration in milliseconds */
+	duration: number | null;
+	/** Time to first token in milliseconds */
+	ttft: number | null;
+	/** Stop reason */
+	stopReason: StopReason;
+	/** Error message if stopReason is error */
+	errorMessage: string | null;
+	/** Token usage */
+	usage: Usage;
+}
+
+/**
+ * Full details of a request, including content.
+ */
+export interface RequestDetails extends MessageStats {
+	messages: any[]; // The full conversation history or just the last turn
+	output: any; // The model's response
+}
+
+/**
+ * Aggregated stats for a model or folder.
+ */
+export interface AggregatedStats {
+	/** Total number of requests */
+	totalRequests: number;
+	/** Number of successful requests */
+	successfulRequests: number;
+	/** Number of failed requests */
+	failedRequests: number;
+	/** Error rate (0-1) */
+	errorRate: number;
+	/** Total input tokens */
+	totalInputTokens: number;
+	/** Total output tokens */
+	totalOutputTokens: number;
+	/** Total cache read tokens */
+	totalCacheReadTokens: number;
+	/** Total cache write tokens */
+	totalCacheWriteTokens: number;
+	/** Cache hit rate (0-1) */
+	cacheRate: number;
+	/** Total cost */
+	totalCost: number;
+	/** Average duration in ms */
+	avgDuration: number | null;
+	/** Average TTFT in ms */
+	avgTtft: number | null;
+	/** Average tokens per second (output tokens / duration) */
+	avgTokensPerSecond: number | null;
+	/** Time range */
+	firstTimestamp: number;
+	lastTimestamp: number;
+}
+
+/**
+ * Stats grouped by model.
+ */
+export interface ModelStats extends AggregatedStats {
+	model: string;
+	provider: string;
+}
+
+/**
+ * Stats grouped by folder.
+ */
+export interface FolderStats extends AggregatedStats {
+	folder: string;
+}
+
+/**
+ * Time series data point.
+ */
+export interface TimeSeriesPoint {
+	/** Bucket timestamp (start of hour/day) */
+	timestamp: number;
+	/** Request count */
+	requests: number;
+	/** Error count */
+	errors: number;
+	/** Total tokens */
+	tokens: number;
+	/** Total cost */
+	cost: number;
+}
+
+/**
+ * Overall dashboard stats.
+ */
+export interface DashboardStats {
+	overall: AggregatedStats;
+	byModel: ModelStats[];
+	byFolder: FolderStats[];
+	timeSeries: TimeSeriesPoint[];
+}
+
+/**
+ * Session log entry types.
+ */
+export interface SessionHeader {
+	type: "session";
+	version: number;
+	id: string;
+	timestamp: string;
+	cwd: string;
+	title?: string;
+}
+
+export interface SessionMessageEntry {
+	type: "message";
+	id: string;
+	parentId: string | null;
+	timestamp: string;
+	message: AssistantMessage | { role: "user" | "toolResult" };
+}
+
+export type SessionEntry = SessionHeader | SessionMessageEntry | { type: string };