@jeffreyjyz/reqshape 0.0.0-stage → 0.1.1

package/src/measure/profile.ts

@@ -0,0 +1,114 @@
+import type { Ask, Bucket, Profile, Req, Shape, Stats } from "~/types.ts";
+import { sideProfiles } from "./sides.ts";
+import { emptyProfile, FIELDS, mean, reqProfile, stats } from "./stats.ts";
+
+const BUCKETS: Array<{ label: string; holds: (position: number) => boolean }> =
+	[
+		{ label: "1", holds: (position) => position === 1 },
+		{ label: "2-5", holds: (position) => position >= 2 && position <= 5 },
+		{ label: "6-20", holds: (position) => position >= 6 && position <= 20 },
+		{
+			label: "21-100",
+			holds: (position) => position >= 21 && position <= 100,
+		},
+		{ label: "101+", holds: (position) => position >= 101 },
+	];
+
+const STAT_FIELDS = { ...FIELDS, cost: (req: Req) => req.cost };
+
+/**
+ * One vote per conversation: average within each session, then across them, so
+ * a single vast session cannot outweigh every short chat in the history.
+ */
+function sessionProfile(sessions: Req[][]): Profile {
+	const profile = emptyProfile();
+	for (const [field, read] of Object.entries(FIELDS)) {
+		profile[field as keyof Profile] = mean(
+			sessions.map((session) => mean(session.map(read))),
+		);
+	}
+	return profile;
+}
+
+function bucketsOf(reqs: Req[]): Bucket[] {
+	const buckets: Bucket[] = [];
+	for (const { label, holds } of BUCKETS) {
+		const inside = reqs.filter((req) => holds(req.position));
+		if (inside.length === 0) continue;
+		buckets.push({
+			label,
+			reqs: inside.length,
+			input: mean(inside.map(FIELDS.input)),
+			output: mean(inside.map(FIELDS.output)),
+			cacheRead: mean(inside.map(FIELDS.cacheRead)),
+		});
+	}
+	return buckets;
+}
+
+function modelsOf(reqs: Req[]): {
+	list: Array<{ name: string; reqs: number }>;
+	total: number;
+} {
+	const counts = new Map<string, number>();
+	for (const req of reqs) {
+		const name = req.model || "unknown";
+		counts.set(name, (counts.get(name) ?? 0) + 1);
+	}
+	return {
+		list: [...counts.entries()]
+			.map(([name, count]) => ({ name, reqs: count }))
+			.sort((a, b) => b.reqs - a.reqs)
+			.slice(0, 8),
+		total: counts.size,
+	};
+}
+
+/**
+ * Measure the kept asks. Every req carries equal weight by default, because a
+ * req is the unit you are billed in; the per-conversation figure is measured
+ * alongside it, since the two can disagree by a factor of four.
+ */
+export function buildShape(asks: Ask[]): Shape {
+	const reqs: Req[] = [];
+	const bySession = new Map<string, Req[]>();
+	const directories = new Set<string>();
+	let first = 0;
+	let last = 0;
+
+	for (const ask of asks) {
+		const session = bySession.get(ask.sessionID) ?? [];
+		bySession.set(ask.sessionID, session);
+		for (const req of ask.reqs) {
+			reqs.push(req);
+			session.push(req);
+		}
+		if (ask.directory) directories.add(ask.directory);
+		if (ask.time > 0) {
+			first = first === 0 ? ask.time : Math.min(first, ask.time);
+			last = Math.max(last, ask.time);
+		}
+	}
+
+	const record = {} as Record<keyof Profile | "cost", Stats>;
+	for (const [field, read] of Object.entries(STAT_FIELDS)) {
+		record[field as keyof Profile | "cost"] = stats(reqs.map(read));
+	}
+
+	const models = modelsOf(reqs);
+	return {
+		reqs: reqs.length,
+		asks: asks.length,
+		sessions: bySession.size,
+		projects: directories.size,
+		first,
+		last,
+		stats: record,
+		perReq: reqProfile(reqs),
+		perSession: sessionProfile([...bySession.values()]),
+		sides: sideProfiles(reqs),
+		buckets: bucketsOf(reqs),
+		modelTotal: models.total,
+		models: models.list,
+	};
+}

package/src/measure/rows.ts

@@ -0,0 +1,125 @@
+import type { Database } from "bun:sqlite";
+
+export interface RawTokens {
+	input?: number;
+	output?: number;
+	reasoning?: number;
+	cache?: { read?: number; write?: number };
+}
+
+/** One row of the store, reduced to what the profiler needs. */
+export interface RawMessage {
+	sessionID: string;
+	/** Normalised: `user`, `assistant`, or a marker such as `synthetic`. */
+	kind: string;
+	time: number;
+	/** Prompt text, when the row carries any. */
+	text: string;
+	model: string;
+	/** Provider id, as `model.providerID` (v2) or `providerID` (legacy). */
+	provider: string;
+	/** Absent while a turn is still streaming. */
+	tokens: RawTokens | null;
+	cost: number;
+}
+
+export function object(value: unknown): Record<string, unknown> {
+	return value !== null && typeof value === "object"
+		? (value as Record<string, unknown>)
+		: {};
+}
+
+export function text(value: unknown): string {
+	return typeof value === "string" ? value : "";
+}
+
+function numberOr(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function parse(data: string): Record<string, unknown> | null {
+	try {
+		return object(JSON.parse(data));
+	} catch {
+		return null;
+	}
+}
+
+/** Does this store use v2's message table? */
+export function hasV2(db: Database): boolean {
+	return Boolean(
+		db
+			.query(
+				"SELECT 1 AS found FROM sqlite_master WHERE type = 'table' AND name = 'session_message'",
+			)
+			.get(),
+	);
+}
+
+/**
+ * v2 rows: `type` names the row, `data.model.id` the model, and only a
+ * completed turn carries `tokens`.
+ */
+export function readV2(db: Database): RawMessage[] {
+	const rows = db
+		.query(
+			`SELECT session_id, type, time_created, data FROM session_message
+			 ORDER BY session_id, seq`,
+		)
+		.all() as Array<{
+		session_id: string;
+		type: string;
+		time_created: number;
+		data: string;
+	}>;
+	const messages: RawMessage[] = [];
+	for (const row of rows) {
+		const data = parse(row.data);
+		if (!data) continue;
+		messages.push({
+			sessionID: row.session_id,
+			kind: row.type,
+			time: row.time_created,
+			text: text(data.text),
+			model: text(object(data.model).id),
+			provider: text(object(data.model).providerID),
+			tokens: (data.tokens as RawTokens | undefined) ?? null,
+			cost: numberOr(data.cost),
+		});
+	}
+	return messages;
+}
+
+/** Pre-v2 rows: `role` instead of `type`, and a flat `modelID`. */
+export function readLegacy(db: Database): RawMessage[] {
+	const rows = db
+		.query(
+			`SELECT session_id, time_created, data FROM message
+			 ORDER BY session_id, time_created`,
+		)
+		.all() as Array<{
+		session_id: string;
+		time_created: number;
+		data: string;
+	}>;
+	const messages: RawMessage[] = [];
+	for (const row of rows) {
+		const data = parse(row.data);
+		if (!data) continue;
+		const content = data.content;
+		messages.push({
+			sessionID: row.session_id,
+			kind: text(data.role),
+			time: row.time_created,
+			text:
+				text(data.text) || (typeof content === "string" ? content : ""),
+			model: text(data.modelID),
+			// The legacy payload records `providerID` too; hardcoding "" here
+			// made every legacy session emit no `sides` at all.
+			provider: text(data.providerID),
+			tokens: (data.tokens as RawTokens | undefined) ?? null,
+			cost: numberOr(data.cost),
+		});
+	}
+	return messages;
+}

package/src/measure/sides.ts

@@ -0,0 +1,28 @@
+import { CC_PREFIXES } from "~/constants/providers.ts";
+import type { Req, Side, SideShape } from "~/types.ts";
+import { reqProfile } from "./stats.ts";
+
+/** Which plan a provider id's traffic belongs to; null when it is neither. */
+export function sideOf(providerID: string): Side | null {
+	const id = providerID.toLowerCase();
+	if (CC_PREFIXES.some((prefix) => id.startsWith(prefix))) return "cc";
+	if (id.startsWith("opencode")) return "oc";
+	return null;
+}
+
+/**
+ * A profile per side. The two plans do not serve the same request — cache read
+ * per req differs by an order of magnitude between them — so pricing each on
+ * its own measured traffic is the point. A shared profile would hide that.
+ * Providers belonging to neither side (routers, local models) are left out
+ * rather than averaged into one.
+ */
+export function sideProfiles(reqs: Req[]): Partial<Record<Side, SideShape>> {
+	const sides: Partial<Record<Side, SideShape>> = {};
+	for (const side of ["oc", "cc"] as const) {
+		const inside = reqs.filter((req) => sideOf(req.provider) === side);
+		if (inside.length === 0) continue;
+		sides[side] = { reqs: inside.length, profile: reqProfile(inside) };
+	}
+	return sides;
+}

package/src/measure/stats.ts

@@ -0,0 +1,47 @@
+import type { Profile, Req, Stats } from "~/types.ts";
+
+export function mean(values: number[]): number {
+	if (values.length === 0) return 0;
+	let sum = 0;
+	for (const value of values) sum += value;
+	return sum / values.length;
+}
+
+/** One reader per measured field, so the metrics never drift apart anywhere. */
+export const FIELDS = {
+	input: (req: Req) => req.tokensIn,
+	output: (req: Req) => req.output,
+	reasoning: (req: Req) => req.reasoning,
+	cacheRead: (req: Req) => req.cacheRead,
+	cacheWrite: (req: Req) => req.cacheWrite,
+} satisfies Record<keyof Profile, (req: Req) => number>;
+
+export function emptyProfile(): Profile {
+	return { input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0 };
+}
+
+/** The mean of every measured field across these reqs. */
+export function reqProfile(reqs: Req[]): Profile {
+	const profile = emptyProfile();
+	for (const [field, read] of Object.entries(FIELDS)) {
+		profile[field as keyof Profile] = mean(reqs.map(read));
+	}
+	return profile;
+}
+
+/** Nearest-rank percentiles: the value at or below which that share of reqs fall. */
+export function stats(values: number[]): Stats {
+	if (values.length === 0) return { mean: 0, p10: 0, p50: 0, p90: 0, max: 0 };
+	const sorted = [...values].sort((a, b) => a - b);
+	const at = (p: number): number =>
+		sorted[
+			Math.min(sorted.length - 1, Math.floor((sorted.length - 1) * p))
+		] ?? 0;
+	return {
+		mean: mean(values),
+		p10: at(0.1),
+		p50: at(0.5),
+		p90: at(0.9),
+		max: sorted[sorted.length - 1] ?? 0,
+	};
+}

package/src/measure/store.ts

@@ -0,0 +1,93 @@
+import { Database } from "bun:sqlite";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { hasV2, type RawMessage, readLegacy, readV2, text } from "./rows.ts";
+
+/** Default location of opencode's store. */
+export function defaultStorePath(): string {
+	if (process.env.OPENCODE_DB) return process.env.OPENCODE_DB;
+	const base =
+		process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
+	return join(base, "opencode", "opencode.db");
+}
+
+export interface SessionRow {
+	child: boolean;
+	directory: string;
+}
+
+export interface Store {
+	layout: "v2" | "legacy";
+	sessions: Map<string, SessionRow>;
+	messages: RawMessage[];
+}
+
+/**
+ * opencode v2 appends to `session_message` and stopped writing the legacy
+ * `message` table at the migration, so both layouts are read here. Read-only:
+ * a running opencode is untouched.
+ */
+export function readStore(path: string): Store {
+	let db: Database;
+	try {
+		db = new Database(path, { readonly: true });
+	} catch {
+		throw new Error(`no opencode store at ${path}`);
+	}
+	try {
+		const v2 = hasV2(db);
+		return {
+			layout: v2 ? "v2" : "legacy",
+			sessions: readSessions(db),
+			messages: v2 ? readV2(db) : readLegacy(db),
+		};
+	} catch (error) {
+		throw new Error(
+			`cannot read ${path}: ${error instanceof Error ? error.message : String(error)}`,
+		);
+	} finally {
+		db.close();
+	}
+}
+
+/**
+ * Session metadata moved to its own typed table in v2, while `session` still
+ * holds rows from before the migration — only reading both attributes every
+ * session, and this session's own directory lives in the v2 table alone. v2
+ * wins on a collision. Directories and subagent flags are context rather than
+ * the point: a store with neither table still profiles.
+ */
+function readSessions(db: Database): Map<string, SessionRow> {
+	const sessions = new Map<string, SessionRow>();
+	for (const table of ["session", "session_v2"] as const) {
+		for (const row of readSessionTable(db, table)) {
+			if (!row.id) continue;
+			sessions.set(row.id, {
+				child: Boolean(row.parent_id),
+				directory: text(row.directory),
+			});
+		}
+	}
+	return sessions;
+}
+
+function readSessionTable(
+	db: Database,
+	table: "session" | "session_v2",
+): Array<{
+	id?: string;
+	parent_id?: string | null;
+	directory?: string | null;
+}> {
+	try {
+		return db
+			.query(`SELECT id, parent_id, directory FROM ${table}`)
+			.all() as Array<{
+			id?: string;
+			parent_id?: string | null;
+			directory?: string | null;
+		}>;
+	} catch {
+		return [];
+	}
+}

package/src/types.ts

@@ -0,0 +1,115 @@
+/**
+ * One model call. This is the same unit the opencode sidebar counts as a
+ * "req": a single `type = 'assistant'` row in opencode's store, i.e. one
+ * round trip to a provider.
+ */
+export interface Req {
+	/** Provider model id as the store recorded it, e.g. `deepseek/deepseek-v4.1-flash`. */
+	model: string;
+	/** Provider id as the store recorded it, e.g. `command-code-openai`. */
+	provider: string;
+	tokensIn: number;
+	output: number;
+	reasoning: number;
+	cacheRead: number;
+	cacheWrite: number;
+	/** Provider-reported spend; 0 for subscription models the harness did not price. */
+	cost: number;
+	/** 1-based position of this req within its session — the axis context grows along. */
+	position: number;
+}
+
+/** What opened an ask. Only `user` is a prompt a person typed. */
+export type AskKind =
+	| "user"
+	| "synthetic"
+	| "compaction"
+	| "shell"
+	| "system"
+	| "orphan";
+
+/**
+ * One prompt and the reqs it drove. An agentic ask is many reqs: the model
+ * calls a tool, is handed the result, and is called again until it stops.
+ */
+export interface Ask {
+	sessionID: string;
+	directory: string;
+	/** Subagent session (`session.parent_id` is set). */
+	child: boolean;
+	kind: AskKind;
+	/** The prompt that opened it; empty for non-user kinds. */
+	text: string;
+	/** Epoch ms of the opening prompt. */
+	time: number;
+	reqs: Req[];
+}
+
+/** A distribution in five numbers. */
+export interface Stats {
+	mean: number;
+	p10: number;
+	p50: number;
+	p90: number;
+	max: number;
+}
+
+/** A per-req token vector — what one request costs to serve. */
+export interface Profile {
+	input: number;
+	output: number;
+	reasoning: number;
+	cacheRead: number;
+	cacheWrite: number;
+}
+
+/**
+ * The two plans the pricing compares. Traffic divides between them by provider
+ * id, and each side serves a different shape of request.
+ */
+export type Side = "oc" | "cc";
+
+/** One plan's own traffic, measured on its own. */
+export interface SideShape {
+	reqs: number;
+	profile: Profile;
+}
+
+/** Reqs grouped by how far into their session they sit. */
+export interface Bucket {
+	label: string;
+	reqs: number;
+	input: number;
+	output: number;
+	cacheRead: number;
+}
+
+export interface DropCount {
+	reason: string;
+	asks: number;
+	reqs: number;
+}
+
+/** The measured profile, ready to be priced. */
+export interface Shape {
+	/** Reqs behind the profile, after filtering. */
+	reqs: number;
+	asks: number;
+	sessions: number;
+	projects: number;
+	/** Epoch ms span of the kept reqs. */
+	first: number;
+	last: number;
+	stats: Record<keyof Profile | "cost", Stats>;
+	/** Every req weighted equally — the default. */
+	perReq: Profile;
+	/** Mean of per-ask means, so one vast session cannot set the profile. */
+	perSession: Profile;
+	/** Per-side means, so each plan can be priced on its own traffic. */
+	sides: Partial<Record<Side, SideShape>>;
+	buckets: Bucket[];
+	/** Distinct models seen, before `models` is capped for display. */
+	modelTotal: number;
+	/** Top models by req count, capped at 8. */
+	models: Array<{ name: string; reqs: number }>;
+}

package/src/view/format.ts

@@ -0,0 +1,66 @@
+import { ANSI } from "~/constants/ansi.ts";
+
+let colored = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+
+export function setColorMode(on: boolean): void {
+	colored = on;
+}
+
+function wrap(code: string, text: string): string {
+	return colored ? `\u001b[${code}m${text}\u001b[0m` : text;
+}
+
+export const bold = (text: string): string => wrap("1", text);
+export const dim = (text: string): string => wrap("2", text);
+
+/** Pad to a visible width, truncating with an ellipsis rather than wrapping. */
+export function pad(
+	text: string,
+	width: number,
+	align: "left" | "right" = "left",
+): string {
+	const visible = text.replace(ANSI, "").length;
+	if (visible > width) return `${text.slice(0, Math.max(0, width - 1))}…`;
+	const fill = " ".repeat(width - visible);
+	return align === "right" ? fill + text : text + fill;
+}
+
+export function fmtCount(n: number): string {
+	if (!Number.isFinite(n)) return "∞";
+	if (n >= 1e9) return `${(n / 1e9).toFixed(1)}B`;
+	if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+	if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+	if (n >= 10) return n.toFixed(0);
+	return n.toFixed(1);
+}
+
+/** A count that is a count: `9 asks`, never `9.0 asks`, and grouped when long. */
+export function fmtInt(n: number): string {
+	if (!Number.isFinite(n)) return "∞";
+	return n.toLocaleString("en-US", { maximumFractionDigits: 0 });
+}
+
+/** The vendor prefix is noise in a report about shape: `deepseek/deepseek-v4.1-flash`. */
+export function prettyModel(id: string): string {
+	const trimmed = id.trim();
+	const slash = trimmed.indexOf("/");
+	return slash === -1 ? trimmed || "unknown" : trimmed.slice(slash + 1);
+}
+
+/** Fixed-point and trailing-zero trimmed; scientific notation reads terribly here. */
+export function fmtUsd(n: number): string {
+	if (n === 0) return "free";
+	if (!Number.isFinite(n)) return "∞";
+	const digits = n >= 0.01 ? 4 : n >= 1e-6 ? 8 : 11;
+	return `$${n.toFixed(digits).replace(/0+$/, "").replace(/\.$/, "")}`;
+}
+
+export function fmtDate(ms: number): string {
+	if (!ms) return "—";
+	return new Date(ms).toISOString().slice(0, 10);
+}
+
+/** `1.2K/21K` — a percentile pair. */
+export function fmtPair(low: number, high: number): string {
+	return `${fmtCount(low)}/${fmtCount(high)}`;
+}

package/src/view/json.ts

@@ -0,0 +1,51 @@
+import type { Projection } from "~/market/project.ts";
+import { providerName } from "~/market/rates.ts";
+import type { DropCount, Shape } from "~/types.ts";
+
+export interface JsonInput {
+	shape: Shape;
+	projections: Projection[];
+	drops: DropCount[];
+	weight: "turn" | "session";
+	layout: string;
+	/** The token vector every projection was priced against. */
+	profile: Record<string, number>;
+}
+
+/**
+ * Machine-readable output. `requestsPerMonth` is null when a model costs
+ * nothing per request, since JSON has no infinity — that is unbounded, not
+ * unknown.
+ */
+export function renderJson(input: JsonInput): string {
+	const payload = {
+		weight: input.weight,
+		store: input.layout,
+		profile: input.profile,
+		sides: input.shape.sides,
+		shape: input.shape,
+		drops: input.drops,
+		models: input.projections.map((projection) => ({
+			key: projection.entry.key,
+			model: projection.entry.model,
+			provider: projection.entry.provider,
+			providerName: providerName(projection.entry.provider),
+			plan: projection.entry.plan,
+			pricing: {
+				input: projection.entry.input,
+				output: projection.entry.output,
+				cacheRead: projection.entry.cacheRead,
+				cacheWrite: projection.entry.cacheWrite,
+			},
+			allowance: projection.entry.allowance,
+			costPerRequest: projection.costPerReq,
+			requestsPerMonth: projection.requestsPerMonth,
+			requestsPerFiveHour: projection.requestsPerFiveHour,
+			requestsPerWeek: projection.requestsPerWeek,
+			cacheAtInput: projection.cacheAtInput,
+			writeAtInput: projection.writeAtInput,
+			free: projection.entry.free,
+		})),
+	};
+	return `${JSON.stringify(payload, null, 2)}\n`;
+}