@oh-my-pi/omp-stats 14.9.8 → 15.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/omp-stats",
-	"version": "14.9.8",
+	"version": "15.0.0",
 	"description": "Local observability dashboard for pi AI usage statistics",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -37,8 +37,8 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "14.9.8",
-		"@oh-my-pi/pi-utils": "14.9.8",
+		"@oh-my-pi/pi-ai": "15.0.0",
+		"@oh-my-pi/pi-utils": "15.0.0",
 		"@tailwindcss/node": "^4.2.4",
 		"chart.js": "^4.5.1",
 		"date-fns": "^4.1.0",

package/src/aggregator.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import { isCompiledBinary } from "@oh-my-pi/pi-utils";
 import {
 	getRecentErrors as dbGetRecentErrors,
 	getRecentRequests as dbGetRecentRequests,
@@ -23,13 +24,15 @@ import {
 } from "./db";
 import { getSessionEntry, listAllSessionFiles, type ParseSessionResult } from "./parser";
 import type { SyncWorkerRequest, SyncWorkerResponse } from "./sync-worker";
-// `with { type: "file" }` resolves to the worker's absolute path at runtime
-// (dev) and survives bundling (the asset is copied alongside the build).
-// tsgo doesn't recognize Bun's file-URL import attribute and would raise
-// TS1192/TS5097 here; Bun honors it. Same suppression pattern lives in
-// `tab-supervisor.ts` and `context-manager.ts`.
-// @ts-expect-error -- Bun file-URL import (see comment above).
-import syncWorkerUrl from "./sync-worker.ts" with { type: "file" };
+// Worker entry. Bun's `--compile` bundler statically discovers the string
+// literal in `new Worker("./packages/stats/src/sync-worker.ts", …)` below and
+// emits the worker as an additional entrypoint (registered in
+// `packages/coding-agent/scripts/build-binary.ts`). In dev runs we resolve
+// the same source file through `import.meta.url`, so the literal only has to
+// be valid relative to the `--root` directory (repo root). Importing the
+// source as `with { type: "file" }` is NOT sufficient — that copies the file
+// as a raw asset and does not bundle the worker's relative imports, so the
+// worker would crash on first `import` (issue #1011, PR #1027).
 import type { BehaviorDashboardStats, DashboardStats, MessageStats, RequestDetails } from "./types";
 
 /**
@@ -85,8 +88,22 @@ interface WorkerHandle {
 	reject: ((err: Error) => void) | null;
 }
 
+/**
+ * Create a fresh sync worker. In a `--compile` binary the literal-string
+ * specifier is what Bun's static analyzer needs (the file is also listed as
+ * an additional `--compile` entrypoint in
+ * `packages/coding-agent/scripts/build-binary.ts`). In dev runs we resolve
+ * the source URL via `import.meta.url` so the worker survives `cwd` changes
+ * by callers.
+ */
+function createSyncWorker(): Worker {
+	return isCompiledBinary()
+		? new Worker("./packages/stats/src/sync-worker.ts", { type: "module" })
+		: new Worker(new URL("./sync-worker.ts", import.meta.url).href, { type: "module" });
+}
+
 function spawnWorker(): WorkerHandle {
-	const worker = new Worker(syncWorkerUrl, { type: "module" });
+	const worker = createSyncWorker();
 	const handle: WorkerHandle = { worker, busy: false, resolve: null, reject: null };
 	worker.onmessage = (event: MessageEvent<SyncWorkerResponse>) => {
 		const { resolve, reject } = handle;
@@ -94,8 +111,16 @@ function spawnWorker(): WorkerHandle {
 		handle.reject = null;
 		handle.busy = false;
 		if (!resolve || !reject) return;
-		if (event.data.ok) resolve(event.data.result);
-		else reject(new Error(event.data.error));
+		const data = event.data;
+		if (!data.ok) {
+			reject(new Error(data.error));
+			return;
+		}
+		if (data.kind === "pong") {
+			reject(new Error("sync worker: unexpected pong on parse channel"));
+			return;
+		}
+		resolve(data.result);
 	};
 	worker.onerror = (event: ErrorEvent) => {
 		const { reject } = handle;
@@ -119,6 +144,45 @@ function dispatch(handle: WorkerHandle, request: SyncWorkerRequest): Promise<Par
 	return promise;
 }
 
+/**
+ * Smoke test: spawns one sync worker, pings it, asserts the pong response,
+ * then terminates. Used by `omp --smoke-test` so the install-method CI jobs
+ * catch the silent worker-load failure that hit compiled binaries in #1011
+ * and #1027 — neither `--version` nor `stats --summary` exercises the worker
+ * spawn path on a fresh install (no session files = early return), so a
+ * dedicated probe is the only reliable signal.
+ *
+ * Resolves with the worker's `import.meta.url` (caller-visible diagnostics);
+ * rejects on transport error, error response, or timeout.
+ */
+export async function smokeTestSyncWorker({ timeoutMs = 5_000 }: { timeoutMs?: number } = {}): Promise<void> {
+	const worker = createSyncWorker();
+	const { promise, resolve, reject } = Promise.withResolvers<void>();
+	const timer = setTimeout(() => reject(new Error(`sync worker did not pong within ${timeoutMs}ms`)), timeoutMs);
+	worker.onmessage = (event: MessageEvent<SyncWorkerResponse>) => {
+		const data = event.data;
+		if (!data.ok) {
+			reject(new Error(data.error));
+			return;
+		}
+		if (data.kind !== "pong") {
+			reject(new Error(`sync worker: expected pong, got ${JSON.stringify(data)}`));
+			return;
+		}
+		resolve();
+	};
+	worker.onerror = (event: ErrorEvent) => {
+		reject(event.error instanceof Error ? event.error : new Error(event.message || "worker error"));
+	};
+	try {
+		worker.postMessage({ kind: "ping" } satisfies SyncWorkerRequest);
+		await promise;
+	} finally {
+		clearTimeout(timer);
+		worker.terminate();
+	}
+}
+
 /**
  * Sync all session files to the database.
  *

package/src/client/components/StatsGrid.tsx

@@ -1,4 +1,4 @@
-import { Activity, AlertCircle, BarChart3, Database, Server, Star, Zap } from "lucide-react";
+import { Activity, AlertCircle, BarChart3, Database, Download, Server, Star, Upload, Zap } from "lucide-react";
 import type { AggregatedStats } from "../types";
 
 interface StatsGridProps {
@@ -14,6 +14,12 @@ function formatCompactNumber(value: number): string {
 	return compactNumberFormatter.format(value);
 }
 
+function formatExactNumber(value: number): string {
+	return value.toLocaleString();
+}
+
+const totalPromptCompletionTokens = (stats: AggregatedStats) => stats.totalInputTokens + stats.totalOutputTokens;
+
 const statConfig = [
 	{
 		key: "requests",
@@ -38,7 +44,7 @@ const statConfig = [
 		title: "Premium Reqs",
 		icon: Star,
 		color: "var(--accent-amber)",
-		getValue: (s: AggregatedStats) => s.totalPremiumRequests.toLocaleString(),
+		getValue: (s: AggregatedStats) => formatExactNumber(s.totalPremiumRequests),
 		getDetail: (s: AggregatedStats) =>
 			s.totalRequests > 0 ? `${((s.totalPremiumRequests / s.totalRequests) * 100).toFixed(1)}% of requests` : "-",
 	},
@@ -50,6 +56,28 @@ const statConfig = [
 		getValue: (s: AggregatedStats) => `${(s.cacheRate * 100).toFixed(1)}%`,
 		getDetail: (s: AggregatedStats) => `${formatCompactNumber(s.totalCacheReadTokens)} cached tokens`,
 	},
+	{
+		key: "inputTokens",
+		title: "Input Tokens",
+		icon: Download,
+		color: "var(--accent-violet)",
+		getValue: (s: AggregatedStats) => formatExactNumber(s.totalInputTokens),
+		getDetail: (s: AggregatedStats) =>
+			totalPromptCompletionTokens(s) > 0
+				? `${((s.totalInputTokens / totalPromptCompletionTokens(s)) * 100).toFixed(1)}% of prompt+completion`
+				: "-",
+	},
+	{
+		key: "outputTokens",
+		title: "Output Tokens",
+		icon: Upload,
+		color: "var(--accent-pink)",
+		getValue: (s: AggregatedStats) => formatExactNumber(s.totalOutputTokens),
+		getDetail: (s: AggregatedStats) =>
+			totalPromptCompletionTokens(s) > 0
+				? `${((s.totalOutputTokens / totalPromptCompletionTokens(s)) * 100).toFixed(1)}% of prompt+completion`
+				: "-",
+	},
 	{
 		key: "errors",
 		title: "Error Rate",
@@ -64,7 +92,8 @@ const statConfig = [
 		icon: BarChart3,
 		color: "var(--accent-green)",
 		getValue: (s: AggregatedStats) => s.avgTokensPerSecond?.toFixed(1) ?? "-",
-		getDetail: (s: AggregatedStats) => `${(s.totalInputTokens + s.totalOutputTokens).toLocaleString()} total tokens`,
+		getDetail: (s: AggregatedStats) =>
+			`${formatCompactNumber(totalPromptCompletionTokens(s))} total prompt+completion`,
 	},
 	{
 		key: "ttft",
@@ -78,7 +107,7 @@ const statConfig = [
 
 export function StatsGrid({ stats }: StatsGridProps) {
 	return (
-		<div className="grid grid-cols-2 lg:grid-cols-3 xl:grid-cols-7 gap-4 mb-8">
+		<div className="grid grid-cols-2 lg:grid-cols-3 xl:grid-cols-9 gap-4 mb-8">
 			{statConfig.map(stat => {
 				const Icon = stat.icon;
 				return (

package/src/db.ts

@@ -34,6 +34,13 @@ interface CostBackfillRow {
 
 let db: Database | null = null;
 
+const BACKFILL_COMPLETE = "complete";
+const BACKFILL_PENDING = "pending";
+const USER_MESSAGES_BACKFILL_KEY = "user_messages_v5";
+const USER_MESSAGE_LINKS_REPAIR_KEY = "user_message_links_v1";
+function shouldResetBackfill(value: string | undefined): boolean {
+	return value !== BACKFILL_COMPLETE && value !== BACKFILL_PENDING;
+}
 /**
  * Initialize the database and create tables.
  */
@@ -720,8 +727,11 @@ export function getCostTimeSeries(days = 90, cutoff?: number | null): CostTimeSe
 
 /**
  * Reset `file_offsets` (and any existing `user_messages` rows) so the next
- * sync re-parses every session and re-derives behavioral metrics. Run once
- * per metric-definition bump; the meta sentinel records the version.
+ * successful sync re-parses every session and re-derives behavioral metrics.
+ * Run once per metric-definition bump; the meta sentinel is only marked
+ * complete after `syncAllSessions` finishes. Older timestamp sentinel values
+ * are treated as pending so a failed compiled-binary sync cannot permanently
+ * suppress the backfill.
  *
  * - v1: initial introduction of `user_messages`.
  * - v2: yelling-sentence metric replaces caps-word counts; existing rows are
@@ -738,16 +748,16 @@ export function getCostTimeSeries(days = 90, cutoff?: number | null): CostTimeSe
  * Existing `messages` rows are unaffected - `INSERT OR IGNORE` keeps them.
  */
 function backfillUserMessages(database: Database): void {
-	const row = database.prepare("SELECT value FROM meta WHERE key = 'user_messages_v5'").get() as
+	const row = database.prepare("SELECT value FROM meta WHERE key = ?").get(USER_MESSAGES_BACKFILL_KEY) as
 		| { value: string }
 		| undefined;
-	if (row) return;
+	if (!shouldResetBackfill(row?.value)) return;
 
 	database.exec("DELETE FROM user_messages");
 	database.exec("DELETE FROM file_offsets");
 	database
 		.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)")
-		.run("user_messages_v5", String(Date.now()));
+		.run(USER_MESSAGES_BACKFILL_KEY, BACKFILL_PENDING);
 }
 
 /**
@@ -759,15 +769,31 @@ function backfillUserMessages(database: Database): void {
  * sentinel row in `meta`.
  */
 function repairUserMessageLinks(database: Database): void {
-	const row = database.prepare("SELECT value FROM meta WHERE key = 'user_message_links_v1'").get() as
+	const row = database.prepare("SELECT value FROM meta WHERE key = ?").get(USER_MESSAGE_LINKS_REPAIR_KEY) as
 		| { value: string }
 		| undefined;
-	if (row) return;
+	if (!shouldResetBackfill(row?.value)) return;
 
 	database.exec("DELETE FROM file_offsets");
 	database
 		.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)")
-		.run("user_message_links_v1", String(Date.now()));
+		.run(USER_MESSAGE_LINKS_REPAIR_KEY, BACKFILL_PENDING);
+}
+
+export function markUserMessagesBackfillComplete(): void {
+	if (!db) return;
+	db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run(
+		USER_MESSAGES_BACKFILL_KEY,
+		BACKFILL_COMPLETE,
+	);
+}
+
+export function markUserMessageLinksRepairComplete(): void {
+	if (!db) return;
+	db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run(
+		USER_MESSAGE_LINKS_REPAIR_KEY,
+		BACKFILL_COMPLETE,
+	);
 }
 
 /**

package/src/index.ts

@@ -11,6 +11,7 @@ export {
 	getTotalMessageCount,
 	type SyncOptions,
 	type SyncProgress,
+	smokeTestSyncWorker,
 	syncAllSessions,
 } from "./aggregator";
 export { closeDb } from "./db";
@@ -52,6 +53,8 @@ async function printStats(): Promise<void> {
 	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(`  Input Tokens: ${formatNumber(overall.totalInputTokens)}`);
+	console.log(`  Output Tokens: ${formatNumber(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))}`);

package/src/sync-worker.ts

@@ -4,25 +4,34 @@
  * `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.
+ *
+ * A `{ kind: "ping" }` request is also accepted and replies with
+ * `{ ok: true, kind: "pong" }` — used by `smokeTestSyncWorker` to prove the
+ * worker actually spawns and runs in compiled binaries (regression coverage
+ * for issue #1011 / PR #1027, where the worker silently failed to load).
  */
 
 import { type ParseSessionResult, parseSessionFile } from "./parser";
 
-export interface SyncWorkerRequest {
-	sessionFile: string;
-	fromOffset: number;
-}
+export type SyncWorkerRequest = { kind?: "parse"; sessionFile: string; fromOffset: number } | { kind: "ping" };
 
-export type SyncWorkerResponse = { ok: true; result: ParseSessionResult } | { ok: false; error: string };
+export type SyncWorkerResponse =
+	| { ok: true; kind?: "parse"; result: ParseSessionResult }
+	| { ok: true; kind: "pong" }
+	| { ok: false; error: string };
 
 declare const self: Worker & {
 	onmessage: ((event: MessageEvent<SyncWorkerRequest>) => void) | null;
 };
 
 self.onmessage = async event => {
-	const { sessionFile, fromOffset } = event.data;
+	const request = event.data;
 	try {
-		const result = await parseSessionFile(sessionFile, fromOffset);
+		if (request.kind === "ping") {
+			self.postMessage({ ok: true, kind: "pong" } satisfies SyncWorkerResponse);
+			return;
+		}
+		const result = await parseSessionFile(request.sessionFile, request.fromOffset);
 		self.postMessage({ ok: true, result } satisfies SyncWorkerResponse);
 	} catch (err) {
 		const error = err instanceof Error ? (err.stack ?? err.message) : String(err);