@oh-my-pi/omp-stats 14.9.3 → 14.9.7

package/src/parser.ts

@@ -2,7 +2,8 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import { getSessionsDir, isEnoent } from "@oh-my-pi/pi-utils";
-import type { MessageStats, SessionEntry, SessionMessageEntry } from "./types";
+import type { MessageStats, SessionEntry, SessionMessageEntry, UserMessageLink, UserMessageStats } from "./types";
+import { computeUserMessageMetrics } from "./user-metrics";
 
 /**
  * Extract folder name from session filename.
@@ -26,6 +27,59 @@ function isAssistantMessage(entry: SessionEntry): entry is SessionMessageEntry {
 	return msgEntry.message?.role === "assistant";
 }
 
+/**
+ * Check if an entry is a user message (non-toolResult).
+ */
+function isUserMessage(entry: SessionEntry): entry is SessionMessageEntry {
+	if (entry.type !== "message") return false;
+	const msgEntry = entry as SessionMessageEntry;
+	return msgEntry.message?.role === "user";
+}
+
+/**
+ * Extract plain text from a user message content payload.
+ */
+function extractUserText(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	const parts: string[] = [];
+	for (const block of content) {
+		if (block && typeof block === "object" && (block as { type?: unknown }).type === "text") {
+			const text = (block as { text?: unknown }).text;
+			if (typeof text === "string") parts.push(text);
+		}
+	}
+	return parts.join("");
+}
+
+/**
+ * Build user-message stats from an entry. Returns null for empty/synthetic content.
+ */
+function extractUserStats(sessionFile: string, folder: string, entry: SessionMessageEntry): UserMessageStats | null {
+	const msg = entry.message as { role: "user"; content?: unknown; synthetic?: boolean };
+	if (msg.role !== "user" || msg.synthetic) return null;
+	const text = extractUserText(msg.content);
+	if (!text.trim()) return null;
+	const metrics = computeUserMessageMetrics(text);
+	const ts = Date.parse(entry.timestamp);
+	return {
+		sessionFile,
+		entryId: entry.id,
+		folder,
+		timestamp: Number.isFinite(ts) ? ts : 0,
+		model: null,
+		provider: null,
+		chars: metrics.chars,
+		words: metrics.words,
+		yelling: metrics.yelling,
+		profanity: metrics.profanity,
+		anguish: metrics.anguish,
+		negation: metrics.negation,
+		repetition: metrics.repetition,
+		blame: metrics.blame,
+	};
+}
+
 /**
  * Extract stats from an assistant message entry.
  */
@@ -80,31 +134,65 @@ function parseSessionEntriesLenient(bytes: Uint8Array): { entries: SessionEntry[
  * 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 }> {
+export interface ParseSessionResult {
+	stats: MessageStats[];
+	userStats: UserMessageStats[];
+	userLinks: UserMessageLink[];
+	newOffset: number;
+}
+
+export async function parseSessionFile(sessionPath: string, fromOffset = 0): Promise<ParseSessionResult> {
 	let bytes: Uint8Array;
 	try {
 		bytes = await Bun.file(sessionPath).bytes();
 	} catch (err) {
-		if (isEnoent(err)) return { stats: [], newOffset: fromOffset };
+		if (isEnoent(err)) return { stats: [], userStats: [], userLinks: [], newOffset: fromOffset };
 		throw err;
 	}
 
 	const folder = extractFolderFromPath(sessionPath);
 	const stats: MessageStats[] = [];
+	const userStats: UserMessageStats[] = [];
+	const userLinks: UserMessageLink[] = [];
+	const userByEntryId = new Map<string, UserMessageStats>();
 	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 (isUserMessage(entry)) {
+			const userMsg = extractUserStats(sessionPath, folder, entry);
+			if (userMsg) {
+				userStats.push(userMsg);
+				userByEntryId.set(entry.id, userMsg);
+			}
+			continue;
+		}
 		if (isAssistantMessage(entry)) {
 			const msgStats = extractStats(sessionPath, folder, entry);
 			if (msgStats) stats.push(msgStats);
+			// Link assistant's responding model back to the user message it answered.
+			const parentId = (entry as SessionMessageEntry).parentId;
+			if (parentId) {
+				const msg = entry.message as AssistantMessage;
+				if (msg.model && msg.provider) {
+					// Emit unconditionally. The aggregator's UPDATE is guarded by
+					// `model IS NULL` so this is idempotent: a no-op for already
+					// linked rows, a fix-up for fresh inserts (which start NULL
+					// because the user row is recorded before its reply lands) and
+					// for cross-pass orphans whose parent was committed by an
+					// earlier incremental sync.
+					userLinks.push({
+						sessionFile: sessionPath,
+						entryId: parentId,
+						model: msg.model,
+						provider: msg.provider,
+					});
+				}
+			}
 		}
 	}
 
-	return { stats, newOffset: start + read };
+	return { stats, userStats, userLinks, newOffset: start + read };
 }
 
 /**

package/src/server.ts

@@ -3,7 +3,11 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { $ } from "bun";
 import {
+	getBehaviorDashboardStats,
+	getCostDashboardStats,
 	getDashboardStats,
+	getModelDashboardStats,
+	getOverviewStats,
 	getRecentErrors,
 	getRecentRequests,
 	getRequestDetails,
@@ -167,11 +171,31 @@ async function handleApi(req: Request): Promise<Response> {
 	const url = new URL(req.url);
 	const path = url.pathname;
 
-	// Sync sessions before returning stats
-	await syncAllSessions();
+	// Stats reads are DB-only; explicit /api/sync does the expensive session scan.
+	const range = url.searchParams.get("range");
 
 	if (path === "/api/stats") {
-		const stats = await getDashboardStats();
+		const stats = await getDashboardStats(range);
+		return Response.json(stats);
+	}
+
+	if (path === "/api/stats/overview") {
+		const stats = await getOverviewStats(range);
+		return Response.json(stats);
+	}
+
+	if (path === "/api/stats/model-dashboard") {
+		const stats = await getModelDashboardStats(range);
+		return Response.json(stats);
+	}
+
+	if (path === "/api/stats/costs") {
+		const stats = await getCostDashboardStats(range);
+		return Response.json(stats);
+	}
+
+	if (path === "/api/stats/behavior") {
+		const stats = await getBehaviorDashboardStats(range);
 		return Response.json(stats);
 	}
 
@@ -188,17 +212,17 @@ async function handleApi(req: Request): Promise<Response> {
 	}
 
 	if (path === "/api/stats/models") {
-		const stats = await getDashboardStats();
+		const stats = await getDashboardStats(range);
 		return Response.json(stats.byModel);
 	}
 
 	if (path === "/api/stats/folders") {
-		const stats = await getDashboardStats();
+		const stats = await getDashboardStats(range);
 		return Response.json(stats.byFolder);
 	}
 
 	if (path === "/api/stats/timeseries") {
-		const stats = await getDashboardStats();
+		const stats = await getDashboardStats(range);
 		return Response.json(stats.timeSeries);
 	}
 

package/src/sync-worker.ts

@@ -0,0 +1,31 @@
+/**
+ * Stateless parse worker for `syncAllSessions`. The main thread owns the
+ * SQLite handle; workers receive `{ sessionFile, fromOffset }`, run
+ * `parseSessionFile` (which is pure I/O + CPU, no DB), and post the
+ * structured-clone-safe result back. One in-flight request per worker so
+ * the main thread can fan jobs out 1:1 with the pool size.
+ */
+
+import { type ParseSessionResult, parseSessionFile } from "./parser";
+
+export interface SyncWorkerRequest {
+	sessionFile: string;
+	fromOffset: number;
+}
+
+export type SyncWorkerResponse = { ok: true; result: ParseSessionResult } | { ok: false; error: string };
+
+declare const self: Worker & {
+	onmessage: ((event: MessageEvent<SyncWorkerRequest>) => void) | null;
+};
+
+self.onmessage = async event => {
+	const { sessionFile, fromOffset } = event.data;
+	try {
+		const result = await parseSessionFile(sessionFile, fromOffset);
+		self.postMessage({ ok: true, result } satisfies SyncWorkerResponse);
+	} catch (err) {
+		const error = err instanceof Error ? (err.stack ?? err.message) : String(err);
+		self.postMessage({ ok: false, error } satisfies SyncWorkerResponse);
+	}
+};

package/src/types.ts

@@ -195,3 +195,116 @@ export interface SessionMessageEntry {
 }
 
 export type SessionEntry = SessionHeader | SessionMessageEntry | { type: string };
+
+/**
+ * Behavioral stats extracted from a single user message.
+ */
+export interface UserMessageStats {
+	/** Database ID */
+	id?: number;
+	/** Session file path */
+	sessionFile: string;
+	/** Entry ID within the session */
+	entryId: string;
+	/** Folder/project path */
+	folder: string;
+	/** Unix timestamp in ms */
+	timestamp: number;
+	/** Model that responded to this user message, if linked */
+	model: string | null;
+	/** Provider that responded to this user message, if linked */
+	provider: string | null;
+	/** Total characters of message text */
+	chars: number;
+	/** Whitespace-delimited word count */
+	words: number;
+	/** Yelling sentences (> 50% uppercase letters) */
+	yelling: number;
+	/** Profanity hits */
+	profanity: number;
+	/** Catch-all upset signal: drama runs + `noooo`/`ughh`/... + `dude` + `..` */
+	anguish: number;
+	/** Corrective negation ("no", "nope", "thats not what i meant") */
+	negation: number;
+	/** User repeating themselves ("i meant", "still doesnt work", "like i said") */
+	repetition: number;
+	/** Second-person reproach ("you didnt", "you broke", "stop X-ing") */
+	blame: number;
+}
+
+/**
+ * Pair emitted by the parser when it sees an assistant message whose
+ * `parentId` points to a user message that wasn't parsed in the same pass
+ * (e.g. user prompt landed in an earlier incremental sync). The aggregator
+ * applies the link to the persisted `user_messages` row so it stops showing
+ * up in the "unknown" model bucket.
+ */
+export interface UserMessageLink {
+	sessionFile: string;
+	entryId: string;
+	model: string;
+	provider: string;
+}
+
+/**
+ * Behavior time-series point (daily bucket, per responding model).
+ */
+export interface BehaviorTimeSeriesPoint {
+	/** Bucket timestamp (start of day) */
+	timestamp: number;
+	/** Responding model ("unknown" if user msg never got a reply) */
+	model: string;
+	/** Responding provider */
+	provider: string;
+	/** Number of user messages in bucket */
+	messages: number;
+	/** Total yelling sentences in bucket */
+	yelling: number;
+	/** Total profanity hits in bucket */
+	profanity: number;
+	/** Total anguish signal in bucket */
+	anguish: number;
+	/** Total corrective-negation hits in bucket */
+	negation: number;
+	/** Total user-repeating-themselves hits in bucket */
+	repetition: number;
+	/** Total second-person blame hits in bucket */
+	blame: number;
+	/** Total characters in bucket */
+	chars: number;
+}
+
+export interface BehaviorOverallStats {
+	totalMessages: number;
+	totalYelling: number;
+	totalProfanity: number;
+	totalAnguish: number;
+	totalNegation: number;
+	totalRepetition: number;
+	totalBlame: number;
+	totalChars: number;
+	firstTimestamp: number;
+	lastTimestamp: number;
+}
+
+/**
+ * Per-model behavioral aggregate over the active range.
+ */
+export interface BehaviorModelStats {
+	model: string;
+	provider: string;
+	totalMessages: number;
+	totalYelling: number;
+	totalProfanity: number;
+	totalAnguish: number;
+	totalNegation: number;
+	totalRepetition: number;
+	totalBlame: number;
+	totalChars: number;
+	lastTimestamp: number;
+}
+export interface BehaviorDashboardStats {
+	overall: BehaviorOverallStats;
+	byModel: BehaviorModelStats[];
+	behaviorSeries: BehaviorTimeSeriesPoint[];
+}