@f5-sales-demo/xcsh-stats 19.51.2

package/src/index.ts

@@ -0,0 +1,153 @@
+#!/usr/bin/env bun
+
+import { parseArgs } from "node:util";
+import { formatDuration, formatNumber, formatPercent } from "@f5xc-salesdemos/pi-utils";
+import { getDashboardStats, getTotalMessageCount, syncAllSessions } from "./aggregator";
+import { closeDb } from "./db";
+import { startServer } from "./server";
+
+export { getDashboardStats, getTotalMessageCount, syncAllSessions } from "./aggregator";
+export { closeDb } from "./db";
+export { startServer } from "./server";
+export type {
+	AggregatedStats,
+	DashboardStats,
+	FolderStats,
+	MessageStats,
+	ModelPerformancePoint,
+	ModelStats,
+	ModelTimeSeriesPoint,
+	TimeSeriesPoint,
+} from "./types";
+
+/**
+ * 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)}`;
+}
+
+function normalizePremiumRequests(n: number): number {
+	return Math.round((n + Number.EPSILON) * 100) / 100;
+}
+
+/**
+ * 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(`  Premium Requests: ${formatNumber(normalizePremiumRequests(overall.totalPremiumRequests ?? 0))}`);
+	console.log(`  Avg Duration: ${overall.avgDuration !== null ? formatDuration(overall.avgDuration) : "-"}`);
+	console.log(`  Avg TTFT: ${overall.avgTtft !== null ? 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(`
+xcsh-stats - AI Usage Statistics Dashboard
+
+Usage:
+  xcsh-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:
+  xcsh-stats              # Start dashboard server
+  xcsh-stats --json       # Print stats as JSON
+  xcsh-stats --port 8080  # Start on custom port
+  xcsh-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 } = await 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();
+}

package/src/parser.ts

@@ -0,0 +1,169 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { AssistantMessage } from "@f5xc-salesdemos/pi-ai";
+import { getSessionsDir, isEnoent } from "@f5xc-salesdemos/pi-utils";
+import type { MessageStats, SessionEntry, SessionMessageEntry } from "./types";
+
+/**
+ * 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 sessionsDir = getSessionsDir();
+	const rel = path.relative(sessionsDir, sessionPath);
+	const projectDir = rel.split(path.sep)[0];
+	// Convert --work--pi-- to /work/pi
+	return projectDir.replace(/^--/, "/").replace(/--/g, "/");
+}
+
+/**
+ * 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?.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,
+	};
+}
+
+const LF = 0x0a;
+
+function parseSessionEntriesLenient(bytes: Uint8Array): { entries: SessionEntry[]; read: number } {
+	const entries: SessionEntry[] = [];
+	let cursor = 0;
+
+	while (cursor < bytes.length) {
+		const { values, error, read, done } = Bun.JSONL.parseChunk(bytes, cursor, bytes.length);
+		if (values.length > 0) {
+			entries.push(...(values as SessionEntry[]));
+		}
+
+		if (error) {
+			const nextNewline = bytes.indexOf(LF, Math.max(read, cursor));
+			if (nextNewline === -1) break;
+			cursor = nextNewline + 1;
+			continue;
+		}
+
+		if (read <= cursor) break;
+		cursor = read;
+		if (done) break;
+	}
+
+	return { entries, read: cursor };
+}
+
+/**
+ * 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 }> {
+	let bytes: Uint8Array;
+	try {
+		bytes = await Bun.file(sessionPath).bytes();
+	} catch (err) {
+		if (isEnoent(err)) return { stats: [], newOffset: fromOffset };
+		throw err;
+	}
+
+	const folder = extractFolderFromPath(sessionPath);
+	const stats: MessageStats[] = [];
+	const start = Math.max(0, Math.min(fromOffset, bytes.length));
+	const unprocessed = bytes.subarray(start);
+	const { entries, read } = parseSessionEntriesLenient(unprocessed);
+	for (const entry of entries) {
+		if (isAssistantMessage(entry)) {
+			const msgStats = extractStats(sessionPath, folder, entry);
+			if (msgStats) stats.push(msgStats);
+		}
+	}
+
+	return { stats, newOffset: start + read };
+}
+
+/**
+ * List all session directories (folders).
+ */
+export async function listSessionFolders(): Promise<string[]> {
+	try {
+		const sessionsDir = getSessionsDir();
+		const entries = await fs.readdir(sessionsDir, { withFileTypes: true });
+		return entries.filter(e => e.isDirectory()).map(e => path.join(sessionsDir, e.name));
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * List all session files in a folder.
+ */
+export async function listSessionFiles(folderPath: string): Promise<string[]> {
+	try {
+		const entries = await fs.readdir(folderPath, { recursive: true, withFileTypes: true });
+		return entries.filter(e => e.isFile() && e.name.endsWith(".jsonl")).map(e => path.join(e.parentPath, 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;
+}
+
+/**
+ * Find a specific entry in a session file.
+ */
+export async function getSessionEntry(sessionPath: string, entryId: string): Promise<SessionEntry | null> {
+	let bytes: Uint8Array;
+	try {
+		bytes = await Bun.file(sessionPath).bytes();
+	} catch (err) {
+		if (isEnoent(err)) return null;
+		throw err;
+	}
+
+	const { entries } = parseSessionEntriesLenient(bytes);
+	for (const entry of entries) {
+		if ("id" in entry && entry.id === entryId) {
+			return entry;
+		}
+	}
+	return null;
+}

package/src/server.ts

@@ -0,0 +1,300 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { $ } from "bun";
+import {
+	getDashboardStats,
+	getRecentErrors,
+	getRecentRequests,
+	getRequestDetails,
+	getTotalMessageCount,
+	syncAllSessions,
+} from "./aggregator";
+import embeddedClientArchiveTxt from "./embedded-client.generated.txt";
+
+const getEmbeddedClientArchive = (() => {
+	const txt = embeddedClientArchiveTxt.replaceAll(/[\s\r\n]/g, "").trim();
+	if (!txt) return null;
+	return () => Buffer.from(txt, "base64");
+})();
+
+const CLIENT_DIR = path.join(import.meta.dir, "client");
+const STATIC_DIR = path.join(import.meta.dir, "..", "dist", "client");
+const IS_BUN_COMPILED =
+	Bun.env.PI_COMPILED ||
+	import.meta.url.includes("$bunfs") ||
+	import.meta.url.includes("~BUN") ||
+	import.meta.url.includes("%7EBUN");
+
+const COMPILED_CLIENT_DIR_ROOT = path.join(os.tmpdir(), "xcsh-stats-client");
+let compiledClientDirPromise: Promise<string> | null = null;
+
+function sanitizeArchivePath(archivePath: string): string | null {
+	const normalized = archivePath.replaceAll("\\", "/").replace(/^\.\//, "");
+	if (!normalized || normalized === ".") return null;
+	if (normalized.includes("..") || path.isAbsolute(normalized)) return null;
+	return normalized;
+}
+
+async function extractEmbeddedClientArchive(archiveBytes: Buffer, outputDir: string): Promise<void> {
+	const archive = new Bun.Archive(archiveBytes);
+	const files = await archive.files();
+	const extractRoot = path.resolve(outputDir);
+
+	for (const [archivePath, file] of files) {
+		const sanitizedPath = sanitizeArchivePath(archivePath);
+		if (!sanitizedPath) continue;
+		const destinationPath = path.resolve(extractRoot, sanitizedPath);
+		if (!destinationPath.startsWith(extractRoot + path.sep)) {
+			throw new Error(`Archive entry escapes extraction directory: ${archivePath}`);
+		}
+		await Bun.write(destinationPath, file);
+	}
+}
+
+async function getCompiledClientDir(): Promise<string> {
+	if (!IS_BUN_COMPILED) return STATIC_DIR;
+	if (compiledClientDirPromise) return compiledClientDirPromise;
+
+	const archiveBytes = getEmbeddedClientArchive?.();
+	if (!archiveBytes) {
+		throw new Error("Compiled stats client bundle missing. Rebuild binary with embedded stats assets.");
+	}
+
+	compiledClientDirPromise = (async () => {
+		const bundleHash = Bun.hash(archiveBytes).toString(16);
+		const outputDir = path.join(COMPILED_CLIENT_DIR_ROOT, bundleHash);
+		const markerPath = path.join(outputDir, "index.html");
+		try {
+			const marker = await fs.stat(markerPath);
+			if (marker.isFile()) return outputDir;
+		} catch {}
+
+		await fs.rm(outputDir, { recursive: true, force: true });
+		await fs.mkdir(outputDir, { recursive: true });
+		await extractEmbeddedClientArchive(archiveBytes, outputDir);
+		return outputDir;
+	})();
+
+	return compiledClientDirPromise;
+}
+
+async function getLatestMtime(dir: string): Promise<number> {
+	const entries = await fs.readdir(dir, { withFileTypes: true });
+
+	const promises = [];
+	for (const entry of entries) {
+		const fullPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			promises.push(getLatestMtime(fullPath));
+		} else if (entry.isFile()) {
+			promises.push(fs.stat(fullPath).then(stats => stats.mtimeMs));
+		}
+	}
+
+	let latest = 0;
+	await Promise.allSettled(promises).then(results => {
+		for (const result of results) {
+			if (result.status === "fulfilled") {
+				latest = Math.max(latest, result.value);
+			}
+		}
+	});
+	return latest;
+}
+
+const ensureClientBuild = async () => {
+	if (IS_BUN_COMPILED) return;
+	const indexPath = path.join(STATIC_DIR, "index.html");
+	const cssPath = path.join(STATIC_DIR, "styles.css");
+	const clientSourceMtime = await getLatestMtime(CLIENT_DIR);
+	const tailwindConfigPath = path.join(import.meta.dir, "..", "tailwind.config.js");
+	let tailwindConfigMtime = 0;
+	try {
+		const tailwindConfigStats = await fs.stat(tailwindConfigPath);
+		tailwindConfigMtime = tailwindConfigStats.mtimeMs;
+	} catch {}
+	const sourceMtime = Math.max(clientSourceMtime, tailwindConfigMtime);
+	let shouldBuild = true;
+	try {
+		const [indexStats, cssStats] = await Promise.all([fs.stat(indexPath), fs.stat(cssPath)]);
+		if (
+			indexStats.isFile() &&
+			cssStats.isFile() &&
+			indexStats.mtimeMs >= sourceMtime &&
+			cssStats.mtimeMs >= sourceMtime
+		) {
+			shouldBuild = false;
+		}
+	} catch {
+		shouldBuild = true;
+	}
+
+	if (!shouldBuild) return;
+
+	await fs.rm(STATIC_DIR, { recursive: true, force: true });
+
+	console.log("Building stats client...");
+	const packageRoot = path.join(import.meta.dir, "..");
+	const buildResult = await $`bun run build.ts`.cwd(packageRoot).quiet().nothrow();
+	if (buildResult.exitCode !== 0) {
+		const output = buildResult.text().trim();
+		const details = output ? `\n${output}` : "";
+		throw new Error(`Failed to build stats client (exit ${buildResult.exitCode})${details}`);
+	}
+
+	const indexHtml = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI Usage Statistics</title>
+    <link rel="stylesheet" href="styles.css">
+</head>
+<body>
+    <div id="root"></div>
+    <script src="index.js" type="module"></script>
+</body>
+</html>`;
+
+	await Bun.write(path.join(STATIC_DIR, "index.html"), indexHtml);
+};
+
+/**
+ * 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(requestPath: string): Promise<Response> {
+	const staticDir = IS_BUN_COMPILED ? await getCompiledClientDir() : STATIC_DIR;
+	const filePath = requestPath === "/" ? "/index.html" : requestPath;
+	const fullPath = path.join(staticDir, filePath);
+
+	const file = Bun.file(fullPath);
+	if (await file.exists()) {
+		return new Response(file);
+	}
+
+	// SPA fallback
+	const index = Bun.file(path.join(staticDir, "index.html"));
+	if (await index.exists()) {
+		return new Response(index);
+	}
+
+	return new Response("Not Found", { status: 404 });
+}
+
+/**
+ * Start the HTTP server.
+ */
+export async function startServer(port = 3847): Promise<{ port: number; stop: () => void }> {
+	await ensureClientBuild();
+
+	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(),
+	};
+}