@jeffreyjyz/mpc 0.0.0-stage → 0.1.1

package/src/data/shape.ts

@@ -0,0 +1,205 @@
+import {
+	SHAPE_AUTO,
+	SHAPE_GUARD_ENV,
+	SHAPE_MEASURED,
+	SHAPE_MIN_REQS,
+	SHAPE_OFF,
+} from "~/constants/shape.ts";
+import type { Workload } from "~/types.ts";
+import { runBinary } from "./cmduse.ts";
+
+interface Profile {
+	input?: number;
+	cacheRead?: number;
+	output?: number;
+	reasoning?: number;
+	cacheWrite?: number;
+}
+
+interface Payload {
+	profile?: Profile;
+	/** The full reqshape shape, which carries the sample size. */
+	shape?: { perReq?: Profile; reqs?: number };
+}
+
+/** reqshape to shell out to; override to test a dev build. */
+function reqshapeBin(): string {
+	return process.env.REQSHAPE_BIN || "reqshape";
+}
+
+function message(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+function round(value: number | undefined): number {
+	return Math.round(typeof value === "number" ? value : 0);
+}
+
+function count(value: number): string {
+	return value.toLocaleString("en-US");
+}
+
+/** `1,234 reqs` / `1 req` — the sample size with the right noun. */
+function reqWords(value: number): string {
+	return `${count(value)} ${value === 1 ? "req" : "reqs"}`;
+}
+
+/**
+ * The one measured per-req profile, as a Workload. reqshape emits it top-level
+ * (`profile` — the vector its own projections were priced against) and as
+ * `shape.perReq`; either works, and a payload with neither yields nothing
+ * rather than throwing. This is one shape for *both* plans, so the comparison
+ * isolates price and allowance from which traffic went where.
+ */
+export function workloadOf(json: string): Workload | undefined {
+	const parsed = JSON.parse(json) as Payload;
+	const profile = parsed.profile ?? parsed.shape?.perReq;
+	if (!profile) return undefined;
+	// Means are fractional; a token count is not, and rounding here keeps the
+	// footer and the priced workload showing the same numbers.
+	return {
+		input: round(profile.input),
+		cacheRead: round(profile.cacheRead),
+		output: round(profile.output),
+		reasoning: round(profile.reasoning),
+		cacheWrite: round(profile.cacheWrite),
+	};
+}
+
+/** Reqs behind the profile, when the payload carries the count. */
+export function reqsOf(json: string): number | undefined {
+	const reqs = (JSON.parse(json) as Payload).shape?.reqs;
+	return typeof reqs === "number" && Number.isFinite(reqs) ? reqs : undefined;
+}
+
+function safeWorkload(json: string): Workload | undefined {
+	try {
+		return workloadOf(json);
+	} catch {
+		return undefined;
+	}
+}
+
+/** The shape chosen for the run, plus the footer line that explains it. */
+export interface ShapeResolution {
+	/** The measured per-req profile to price with; absent means the fixed workload. */
+	workload?: Workload;
+	/** One footer line: the source, its sample and the alternative. */
+	note: string;
+}
+
+async function payloadOf(
+	source: string,
+	args: string[],
+	warn: boolean,
+): Promise<string | null> {
+	if (source !== SHAPE_MEASURED) {
+		try {
+			return await Bun.file(source).text();
+		} catch (error) {
+			if (warn) {
+				process.stderr.write(
+					`mpc: cannot read shape file "${source}": ${message(error)}; using the fixed workload\n`,
+				);
+			}
+			return null;
+		}
+	}
+	const result = await runBinary(reqshapeBin(), args, {
+		[SHAPE_GUARD_ENV]: "1",
+	});
+	if (!result.ok || !result.stdout.trim()) {
+		if (warn) {
+			process.stderr.write(
+				`mpc: reqshape unavailable: ${result.stderr.trim() || "no output"}; using the fixed workload\n`,
+			);
+		}
+		return null;
+	}
+	return result.stdout;
+}
+
+/**
+ * Resolve `--shape`. `auto` (the default) asks reqshape and uses its profile
+ * only once the sample reaches `SHAPE_MIN_REQS`, so a thin history falls back
+ * to the documented fixed workload; `measured` forces reqshape; `off` keeps the
+ * fixed workload; anything else is a saved reqshape JSON. Never throws — a
+ * missing binary or a bad payload degrades to the fixed workload. The returned
+ * `note` names which path was taken, so the footer can show whether reqshape
+ * was used and what the alternative flag is.
+ */
+export async function loadShapes(
+	spec: string,
+	since?: string,
+): Promise<ShapeResolution> {
+	const trimmed = spec.trim();
+	const args = ["--format", "json"];
+	if (since) args.push("--since", since);
+
+	// A nested mpc (reqshape runs `mpc --json`) must not measure again — that is
+	// the cycle. Callers that pass `--shape off` never reach here; this catches
+	// the ones that do not (a sibling still pinned to the old default).
+	if (
+		process.env[SHAPE_GUARD_ENV] &&
+		(trimmed === SHAPE_AUTO || trimmed === SHAPE_MEASURED)
+	) {
+		return {
+			note: "fixed workload · nested mpc (reqshape is already resolving the shape)",
+		};
+	}
+
+	if (trimmed === "" || trimmed === SHAPE_OFF) {
+		return {
+			note: "fixed workload · --shape measured to measure with reqshape",
+		};
+	}
+
+	if (trimmed === SHAPE_AUTO) {
+		const payload = await payloadOf(SHAPE_MEASURED, args, false);
+		if (!payload) {
+			return {
+				note: "fixed workload · reqshape unavailable · --shape measured to require it",
+			};
+		}
+		const reqs = reqsOf(payload);
+		const workload = safeWorkload(payload);
+		if (!workload || reqs === undefined || reqs < SHAPE_MIN_REQS) {
+			const seen = reqs === undefined ? "no req count" : reqWords(reqs);
+			return {
+				note: `fixed workload · reqshape: ${seen} (< ${count(SHAPE_MIN_REQS)}) · --shape measured to force`,
+			};
+		}
+		return {
+			workload,
+			note: `reqshape measured · ${reqWords(reqs)} (auto ≥ ${count(SHAPE_MIN_REQS)}) · --shape off to assume the fixed workload`,
+		};
+	}
+
+	const measured = trimmed === SHAPE_MEASURED;
+	const payload = await payloadOf(
+		measured ? SHAPE_MEASURED : trimmed,
+		args,
+		true,
+	);
+	if (!payload) {
+		return {
+			note: "fixed workload · shape source unavailable · --shape auto to fall back automatically",
+		};
+	}
+	const workload = safeWorkload(payload);
+	if (!workload) {
+		if (measured) {
+			process.stderr.write(
+				"mpc: reqshape reports no measured profile; using the fixed workload\n",
+			);
+		}
+		return { note: "fixed workload · the payload has no measured profile" };
+	}
+	if (!measured) return { workload, note: `measured from ${trimmed}` };
+	const reqs = reqsOf(payload);
+	const sample = reqs === undefined ? "" : ` · ${reqWords(reqs)}`;
+	return {
+		workload,
+		note: `reqshape measured (forced)${sample} · --shape off to assume the fixed workload`,
+	};
+}

package/src/data/sources/aa/api.ts

@@ -0,0 +1,54 @@
+import { API_URL } from "~/constants/sources.ts";
+import { parseAaApi } from "./parse.ts";
+
+/** Full catalog via the Artificial Analysis API. Needs a key. Paginated. */
+export async function loadAaApi(
+	key: string,
+): Promise<{ intelligence: Map<string, number>; tps: Map<string, number> }> {
+	const intelligence = new Map<string, number>();
+	const tps = new Map<string, number>();
+	const pageSize = 200;
+	const maxPages = 20;
+
+	for (let page = 1; page <= maxPages; page++) {
+		const res = await fetchTextWithKey(
+			`${API_URL}?page=${page}&page_size=${pageSize}`,
+			key,
+		);
+		const body = JSON.parse(res) as unknown;
+		mergeAaPage(parseAaApi(body), intelligence, tps);
+		const pagination = (body as { pagination?: { has_more?: boolean } })
+			.pagination;
+		if (!pagination?.has_more) break;
+	}
+
+	return { intelligence, tps };
+}
+
+async function fetchTextWithKey(url: string, key: string): Promise<string> {
+	const res = await fetch(url, {
+		headers: { "x-api-key": key, "user-agent": "mpc/0.1" },
+	});
+	if (!res.ok) {
+		throw new Error(
+			`Artificial Analysis API ${res.status}: set AA_API_KEY or use --bench cc / aa-web`,
+		);
+	}
+	return res.text();
+}
+
+/** Keep the best variant per key; AA lists a row per reasoning effort. */
+function mergeAaPage(
+	page: { intelligence: Map<string, number>; tps: Map<string, number> },
+	intelligence: Map<string, number>,
+	tps: Map<string, number>,
+): void {
+	for (const [key, value] of page.intelligence) {
+		if (!intelligence.has(key) || value > (intelligence.get(key) ?? 0)) {
+			intelligence.set(key, value);
+		}
+	}
+	for (const [key, value] of page.tps) {
+		if (!tps.has(key) || value > (tps.get(key) ?? 0)) tps.set(key, value);
+	}
+}

package/src/data/sources/aa/parse.ts

@@ -0,0 +1,66 @@
+import { normalizeKey } from "~/keys.ts";
+
+/** Pure parser over one AA API page, for tests and the loader. */
+export function parseAaApi(body: unknown): {
+	intelligence: Map<string, number>;
+	tps: Map<string, number>;
+} {
+	const root = (body ?? {}) as Record<string, unknown>;
+	const rows = Array.isArray(root.data)
+		? root.data
+		: Array.isArray(body)
+			? body
+			: Object.values(root).filter((v) => v && typeof v === "object");
+	const intelligence = new Map<string, number>();
+	const tps = new Map<string, number>();
+
+	for (const row of rows) {
+		if (!row || typeof row !== "object") continue;
+		const record = row as Record<string, unknown>;
+		const name = String(record.name ?? record.slug ?? record.id ?? "");
+		const slug = typeof record.slug === "string" ? record.slug : undefined;
+		const keys = [
+			slug ? normalizeKey(slug) : "",
+			normalizeKey(name),
+		].filter(Boolean);
+		if (keys.length === 0) continue;
+
+		const iq = findNumber(record, /intelligence_index/i);
+		if (iq !== null && iq > 0) {
+			for (const k of keys) {
+				if (!intelligence.has(k) || iq > (intelligence.get(k) ?? 0)) {
+					intelligence.set(k, iq);
+				}
+			}
+		}
+		// 0 means "not benchmarked", not "zero tokens per second".
+		const speed = findNumber(record, /tokens_per_second|(^|_)tps($|_)/i);
+		if (speed !== null && speed > 0) {
+			for (const k of keys) {
+				if (!tps.has(k) || speed > (tps.get(k) ?? 0)) tps.set(k, speed);
+			}
+		}
+	}
+	return { intelligence, tps };
+}
+
+/** Depth-first search for the first finite number under a matching key. */
+function findNumber(value: unknown, pattern: RegExp): number | null {
+	if (!value || typeof value !== "object") return null;
+	for (const [key, child] of Object.entries(
+		value as Record<string, unknown>,
+	)) {
+		if (
+			typeof child === "number" &&
+			Number.isFinite(child) &&
+			pattern.test(key)
+		) {
+			return child;
+		}
+	}
+	for (const child of Object.values(value as Record<string, unknown>)) {
+		const found = findNumber(child, pattern);
+		if (found !== null) return found;
+	}
+	return null;
+}

package/src/data/sources/aa/web.ts

@@ -0,0 +1,53 @@
+import { AA_MODELS_URL } from "~/constants/sources.ts";
+import { fetchText } from "~/data/scrape/index.ts";
+import { normalizeKey } from "~/keys.ts";
+
+/** A model label and its Artificial Analysis Intelligence Index. */
+interface Scored {
+	label: string;
+	slug?: string;
+	score: number;
+}
+
+/** Every `{label, intelligenceIndex, detailsUrl}` the models page embeds. */
+function parseEmbedded(html: string): Scored[] {
+	const re =
+		/"label":"([^"]+)","intelligenceIndex":([0-9.]+)(?:,"detailsUrl":"([^"]*)")?/g;
+	const out: Scored[] = [];
+	const seen = new Set<string>();
+	for (let match = re.exec(html); match !== null; match = re.exec(html)) {
+		const label = match[1] ?? "";
+		const score = Number(match[2]);
+		const slug = match[3]?.split("/").pop();
+		const id = `${label}|${slug ?? ""}`;
+		if (!label || !Number.isFinite(score) || seen.has(id)) continue;
+		seen.add(id);
+		out.push({ label, slug, score });
+	}
+	return out;
+}
+
+function toMap(scored: Scored[]): Map<string, number> {
+	const scores = new Map<string, number>();
+	for (const { label, slug, score } of scored) {
+		// slug is the more precise key; label is the fallback.
+		if (slug) scores.set(normalizeKey(slug), score);
+		const labelKey = normalizeKey(label);
+		if (labelKey && !scores.has(labelKey)) scores.set(labelKey, score);
+	}
+	return scores;
+}
+
+/** Keyless scrape of the Artificial Analysis models page. Only the models that
+ * page embeds (its chart top-N) are covered, so this is a fallback, not a full
+ * catalog.
+ */
+export async function loadAaWeb(): Promise<Map<string, number>> {
+	const html = await fetchText(AA_MODELS_URL);
+	return parseAaWeb(html);
+}
+
+/** Pure parser over the AA models page HTML, for tests and the scraper. */
+export function parseAaWeb(html: string): Map<string, number> {
+	return toMap(parseEmbedded(html));
+}

package/src/data/sources/cc/catalog.ts

@@ -0,0 +1,71 @@
+import { CC_PLANS } from "~/constants/sources.ts";
+import {
+	extractCatalog,
+	fetchText,
+	parseRoleRows,
+	parseTables,
+} from "~/data/scrape/index.ts";
+import type { CatalogEntry } from "~/types.ts";
+
+/** Per-model token rates + monthly credit allowance for a CommandCode plan. */
+export async function loadCcCatalog(planId: string): Promise<CatalogEntry[]> {
+	const def = CC_PLANS[planId];
+	if (!def) throw new Error(`unknown CommandCode plan "${planId}"`);
+	const url = `https://commandcode.ai/docs/plans/${def.slug}`;
+	const html = await fetchText(url);
+
+	// The page shape is chosen by the plan, not inferred from the absence of a
+	// credit column. Go's list moved from a `role="row"` div grid to a real
+	// <table> while still publishing no per-model credits, so "no credit header"
+	// no longer means "grid" — inferring it sent Go down `parseRoleRows`, which
+	// matches no row, and the load threw.
+	const tables = def.grid
+		? await parseRoleRows(html)
+		: await parseTables(html);
+	const entries = extractCatalog(tables, {
+		provider: "cc",
+		plan: def.label,
+		creditHeader: def.creditHeader,
+		// A rate-only list (Go) bills every model against the plan's whole pool.
+		defaultAllowance: def.standardAllowance,
+	});
+	if (entries.length === 0) {
+		const shape = def.grid ? "row" : "table";
+		throw new Error(
+			`no model ${shape}s parsed from ${url} — docs layout may have changed`,
+		);
+	}
+	if (def.creditHeader && def.standardAllowance !== undefined) {
+		fillDeals(
+			entries,
+			extractCatalog(tables, {
+				provider: "cc",
+				plan: def.label,
+				defaultAllowance: def.standardAllowance,
+			}),
+		);
+	}
+	return entries;
+}
+
+/**
+ * Fold the rate-only pass into the priced one: it adds models the credits
+ * tables omit entirely (the free ones), and lends its promotion badges to
+ * entries that came from a credits table — those carry no badges, so without
+ * this a paid model silently loses the deal published beside its name.
+ */
+export function fillDeals(
+	entries: CatalogEntry[],
+	rateOnly: CatalogEntry[],
+): void {
+	const byKey = new Map(entries.map((entry) => [entry.key, entry]));
+	for (const entry of rateOnly) {
+		const existing = byKey.get(entry.key);
+		if (!existing) {
+			byKey.set(entry.key, entry);
+			entries.push(entry);
+			continue;
+		}
+		if (!existing.deal && entry.deal) existing.deal = entry.deal;
+	}
+}

package/src/data/sources/cc/cmduse.ts

@@ -0,0 +1,24 @@
+import { runCmduse } from "~/data/cmduse.ts";
+
+interface CmdusePlan {
+	name: string;
+	price: string;
+	creditsMonthly: string;
+	fiveHour: string;
+	weekly: string;
+}
+
+export function money(value: string): number | null {
+	const m = value.match(/\$?\s*([0-9]+(?:\.[0-9]+)?)/);
+	return m ? Number(m[1]) : null;
+}
+
+export async function cmdusePlans(): Promise<CmdusePlan[]> {
+	const result = await runCmduse(["plans", "--json"]);
+	if (!result.ok) {
+		throw new Error(
+			`cmduse plans --json failed: ${result.stderr.trim() || "is the command-code CLI installed?"}`,
+		);
+	}
+	return JSON.parse(result.stdout) as CmdusePlan[];
+}

package/src/data/sources/cc/plans.ts

@@ -0,0 +1,29 @@
+import { CC_PLANS } from "~/constants/sources.ts";
+import type { PlanInfo } from "~/types.ts";
+import { cmdusePlans, money } from "./cmduse.ts";
+
+/** Plan price + windows for a CommandCode plan, from the official JSON. */
+export async function loadCcPlan(planId: string): Promise<PlanInfo> {
+	const def = CC_PLANS[planId];
+	if (!def) {
+		throw new Error(
+			`unknown CommandCode plan "${planId}" (have: ${Object.keys(CC_PLANS).join(", ")})`,
+		);
+	}
+	const plans = await cmdusePlans();
+	const match = plans.find((p) => p.name === def.cmduse);
+	if (!match) {
+		throw new Error(
+			`cmduse plans --json has no plan named "${def.cmduse}"`,
+		);
+	}
+	return {
+		provider: "cc",
+		id: planId,
+		label: def.label,
+		price: money(match.price) ?? 0,
+		credits: money(match.creditsMonthly) ?? 0,
+		fiveHour: money(match.fiveHour),
+		weekly: money(match.weekly),
+	};
+}

package/src/data/sources/opencode.ts

@@ -0,0 +1,48 @@
+import {
+	DOC_URL,
+	OC_MODELS_URL,
+	PRICE_PER_MONTH,
+} from "~/constants/sources.ts";
+import { extractCatalog, fetchText, parseTables } from "~/data/scrape/index.ts";
+import type { CatalogEntry, PlanInfo } from "~/types.ts";
+
+/** Per-model token rates + monthly usage limit for OpenCode Go. */
+export async function loadOcGoCatalog(peak = false): Promise<CatalogEntry[]> {
+	const html = await fetchText(DOC_URL);
+	const tables = await parseTables(html);
+	const entries = extractCatalog(tables, {
+		provider: "oc-go",
+		plan: "Go",
+		creditHeader: /monthly limit/i,
+		peak,
+	});
+	if (entries.length === 0) {
+		throw new Error(
+			`no model table parsed from ${DOC_URL} — docs layout may have changed`,
+		);
+	}
+	return entries;
+}
+
+/** OpenCode Go is a flat $10/mo; limits are per-model, so there is no shared pool. */
+export function ocGoPlan(entries: CatalogEntry[]): PlanInfo {
+	return {
+		provider: "oc-go",
+		id: "go",
+		label: "Go",
+		price: PRICE_PER_MONTH,
+		credits: entries.reduce((sum, e) => sum + e.allowance, 0),
+		fiveHour: null,
+		weekly: null,
+	};
+}
+
+/** Live model ids from the Go endpoint, for drift detection. */
+export async function loadOcGoModelIds(): Promise<string[]> {
+	const res = await fetch(OC_MODELS_URL, {
+		headers: { "user-agent": "mpc/0.1 (+model price compare)" },
+	});
+	if (!res.ok) throw new Error(`GET ${OC_MODELS_URL} -> ${res.status}`);
+	const body = (await res.json()) as { data?: { id: string }[] };
+	return (body.data ?? []).map((m) => m.id);
+}

package/src/data/usage/index.ts

@@ -0,0 +1,118 @@
+import { runCmduse } from "~/data/cmduse.ts";
+import { defaultUsageLog, mergeUsage, readUsageLog } from "./log.ts";
+import { scanLogs } from "./logs.ts";
+import { defaultOpencodeDb, readOpencodeDb } from "./opencodeDb.ts";
+import {
+	type AccountSummary,
+	accountSummary,
+	parseUsage,
+	type UsageEntry,
+} from "./parse.ts";
+
+export type { AccountSummary, UsageEntry } from "./parse.ts";
+
+export interface UsageReportInput {
+	entries: UsageEntry[];
+	/** Where the numbers came from, for the header. */
+	label: string;
+	/** Window description, e.g. "period (since 2026-08-27)". */
+	window: string;
+	/** Account-level period totals, for the coverage cross-check. */
+	account?: AccountSummary;
+}
+
+export type UsageWindow = "period" | "all" | `${number}d`;
+
+/**
+ * Per-model usage from cmduse. Needs a cmduse that understands `--since`
+ * (0.6.x with the window feature); returns null on an older build so the
+ * caller can fall back to scanning the session logs itself.
+ */
+async function cmduseModel(since?: Date): Promise<UsageEntry[] | null> {
+	const args = ["model", "--json"];
+	if (since) args.push("--since", since.toISOString());
+	const result = await runCmduse(args);
+	if (!result.ok || !result.stdout.trim()) return null;
+	try {
+		return parseUsage(result.stdout);
+	} catch {
+		return null;
+	}
+}
+
+function sinceFor(
+	window: UsageWindow,
+	account?: AccountSummary,
+): Date | undefined {
+	if (window === "all") return undefined;
+	if (window.endsWith("d")) {
+		const days = Number(window.slice(0, -1));
+		if (Number.isFinite(days) && days > 0) {
+			return new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+		}
+	}
+	if (account?.periodEnd) {
+		const end = new Date(account.periodEnd);
+		const start = new Date(end);
+		start.setMonth(start.getMonth() - 1);
+		return start;
+	}
+	return new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+}
+
+function label(window: UsageWindow, since?: Date): string {
+	if (window === "all") return "all local logs";
+	if (!since) return window;
+	return `${window} (since ${since.toISOString().slice(0, 10)})`;
+}
+
+/** Load the user's real per-model usage for a window. No network. */
+export async function loadUsage(
+	source: string | undefined,
+	window: UsageWindow = "period",
+	logPath?: string,
+	dbPath?: string,
+	sessionRoot?: string,
+): Promise<UsageReportInput> {
+	if (source) {
+		const file = Bun.file(source);
+		if (!(await file.exists()))
+			throw new Error(`usage file not found: ${source}`);
+		return {
+			entries: parseUsage(await file.text()),
+			label: source,
+			window: "file",
+		};
+	}
+	const account = await accountSummary();
+	const since = sinceFor(window, account);
+	const fromCmduse = await cmduseModel(since);
+	const sessions = fromCmduse ?? scanLogs(since, sessionRoot);
+
+	// opencode's own store is complete and backfilled for every provider it
+	// ran, so it supersedes the provider plugin's log (a subset of it).
+	const db = readOpencodeDb(dbPath ?? defaultOpencodeDb(), since);
+	const log = db ? null : readUsageLog(logPath ?? defaultUsageLog(), since);
+
+	const sources: string[] = [];
+	if (db) {
+		sources.push(
+			`opencode db (${db.providers.length} providers, ${db.records} records)`,
+		);
+	}
+	if (log) sources.push("provider usage log");
+	if (sessions.length > 0) {
+		sources.push(fromCmduse ? "cmduse model --json" : "local session logs");
+	}
+
+	const entries = mergeUsage(
+		mergeUsage(db?.entries ?? [], log ?? []),
+		sessions,
+	);
+	return {
+		entries,
+		label: sources.join(" + ") || "no usage found",
+		window: label(window, since),
+		account,
+	};
+}