@jeffreyjyz/mpc 0.0.0-stage → 0.1.0

package/src/data/usage/log.ts

@@ -0,0 +1,89 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { normalizeKey } from "~/keys.ts";
+import type { UsageEntry } from "./parse.ts";
+
+interface LogLine {
+	ts?: string;
+	model?: string;
+	input?: number;
+	cacheRead?: number;
+	cacheWrite?: number;
+	output?: number;
+	reasoning?: number;
+	costUsd?: number;
+}
+
+/** Default path a per-request JSONL log lives at. */
+export function defaultUsageLog(): string {
+	if (process.env.MPC_USAGE_LOG) return process.env.MPC_USAGE_LOG;
+	const base = process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
+	return join(base, "mpc", "usage.jsonl");
+}
+
+/**
+ * Aggregate a per-request JSONL log. This is the complete opencode-side mix
+ * when opencode's own store is unavailable.
+ */
+export function readUsageLog(path: string, since?: Date): UsageEntry[] | null {
+	let text: string;
+	try {
+		text = readFileSync(path, "utf8");
+	} catch {
+		return null;
+	}
+	const byKey = new Map<string, UsageEntry>();
+	for (const raw of text.split("\n")) {
+		if (!raw.trim()) continue;
+		let line: LogLine;
+		try {
+			line = JSON.parse(raw) as LogLine;
+		} catch {
+			continue;
+		}
+		if (!line.model) continue;
+		if (since && line.ts && new Date(line.ts) < since) continue;
+		const key = normalizeKey(line.model);
+		const entry = byKey.get(key) ?? {
+			key,
+			name: line.model,
+			requests: 0,
+			tokensIn: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			tokensOut: 0,
+			reasoning: 0,
+			costUsd: 0,
+		};
+		entry.requests += 1;
+		entry.tokensIn += line.input ?? 0;
+		entry.cacheRead += line.cacheRead ?? 0;
+		entry.cacheWrite += line.cacheWrite ?? 0;
+		entry.tokensOut += line.output ?? 0;
+		entry.reasoning += line.reasoning ?? 0;
+		entry.costUsd += line.costUsd ?? 0;
+		byKey.set(key, entry);
+	}
+	return [...byKey.values()];
+}
+
+/** Sum two usage lists by model key. */
+export function mergeUsage(a: UsageEntry[], b: UsageEntry[]): UsageEntry[] {
+	const byKey = new Map(a.map((entry) => [entry.key, { ...entry }]));
+	for (const entry of b) {
+		const existing = byKey.get(entry.key);
+		if (!existing) {
+			byKey.set(entry.key, { ...entry });
+			continue;
+		}
+		existing.requests += entry.requests;
+		existing.tokensIn += entry.tokensIn;
+		existing.cacheRead += entry.cacheRead;
+		existing.cacheWrite += entry.cacheWrite;
+		existing.tokensOut += entry.tokensOut;
+		existing.reasoning += entry.reasoning;
+		existing.costUsd += entry.costUsd;
+	}
+	return [...byKey.values()];
+}

package/src/data/usage/logs.ts

@@ -0,0 +1,117 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { normalizeKey } from "~/keys.ts";
+import type { UsageEntry } from "./parse.ts";
+
+interface Totals {
+	requests: number;
+	tokensIn: number;
+	cacheRead: number;
+	cacheWrite: number;
+	tokensOut: number;
+	reasoning: number;
+	costUsd: number;
+}
+
+function empty(): Totals {
+	return {
+		requests: 0,
+		tokensIn: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		tokensOut: 0,
+		// The CommandCode session-log usage block carries no reasoning counter.
+		reasoning: 0,
+		costUsd: 0,
+	};
+}
+
+function jsonlFiles(dir: string, out: string[]): string[] {
+	let entries: string[];
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return out;
+	}
+	for (const name of entries) {
+		const path = join(dir, name);
+		let stat: ReturnType<typeof statSync>;
+		try {
+			stat = statSync(path);
+		} catch {
+			continue;
+		}
+		if (stat.isDirectory()) jsonlFiles(path, out);
+		else if (
+			name.endsWith(".jsonl") &&
+			!name.endsWith(".checkpoints.jsonl")
+		) {
+			out.push(path);
+		}
+	}
+	return out;
+}
+
+interface Line {
+	timestamp?: string;
+	model?: string;
+	usage?: {
+		inputTokens?: number;
+		outputTokens?: number;
+		cacheReadTokens?: number;
+		cacheWriteTokens?: number;
+		costUsd?: number;
+	};
+}
+
+/**
+ * Aggregate per-model usage from the local CommandCode session logs. Unlike
+ * `cmduse model`, this honours a date window so it can match a billing period.
+ */
+export function scanLogs(
+	since?: Date,
+	root = join(homedir(), ".commandcode", "projects"),
+): UsageEntry[] {
+	const byModel = new Map<string, { name: string; totals: Totals }>();
+
+	for (const file of jsonlFiles(root, [])) {
+		let text: string;
+		try {
+			text = readFileSync(file, "utf8");
+		} catch {
+			continue;
+		}
+		for (const raw of text.split("\n")) {
+			if (!raw?.includes('"usage"')) continue;
+			let line: Line;
+			try {
+				line = JSON.parse(raw) as Line;
+			} catch {
+				continue;
+			}
+			if (!line.usage || !line.model) continue;
+			if (since && line.timestamp && new Date(line.timestamp) < since)
+				continue;
+			const key = normalizeKey(line.model);
+			const bucket = byModel.get(key) ?? {
+				name: line.model,
+				totals: empty(),
+			};
+			const t = bucket.totals;
+			t.requests += 1;
+			t.tokensIn += line.usage.inputTokens ?? 0;
+			t.tokensOut += line.usage.outputTokens ?? 0;
+			t.cacheRead += line.usage.cacheReadTokens ?? 0;
+			t.cacheWrite += line.usage.cacheWriteTokens ?? 0;
+			t.costUsd += line.usage.costUsd ?? 0;
+			byModel.set(key, bucket);
+		}
+	}
+
+	return [...byModel].map(([key, { name, totals }]) => ({
+		key,
+		name,
+		...totals,
+	}));
+}

package/src/data/usage/opencodeDb.ts

@@ -0,0 +1,135 @@
+import { Database } from "bun:sqlite";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { normalizeKey } from "~/keys.ts";
+import { hasV2, readV2Turns, type Turn } from "./opencodeV2.ts";
+import type { UsageEntry } from "./parse.ts";
+
+/** Default location of opencode's message store. */
+export function defaultOpencodeDb(): 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");
+}
+
+interface AssistantData {
+	role?: string;
+	cost?: number;
+	modelID?: string;
+	providerID?: string;
+	tokens?: {
+		input?: number;
+		output?: number;
+		reasoning?: number;
+		cache?: { read?: number; write?: number };
+	};
+	time?: { created?: number; completed?: number };
+}
+
+function numberOr(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+export interface OpencodeDbUsage {
+	entries: UsageEntry[];
+	/** Providers seen, for the report's source line. */
+	providers: string[];
+	/** Total assistant records scanned, before de-duplication. */
+	records: number;
+}
+
+/**
+ * Aggregate per-model usage from opencode's own message store. This is the
+ * complete, backfilled record for every provider opencode ran — unlike the
+ * provider plugin's log, which only sees its own traffic.
+ *
+ * Reads v2's `session_message` when the store has it, and the legacy `message`
+ * table otherwise, so an upgraded opencode does not read as "no usage". Read-only
+ * so a running opencode is unaffected; returns null when the DB is unusable.
+ */
+export function readOpencodeDb(
+	path: string,
+	since?: Date,
+): OpencodeDbUsage | null {
+	let db: Database;
+	try {
+		db = new Database(path, { readonly: true });
+	} catch {
+		return null;
+	}
+	try {
+		const sinceMs = since ? since.getTime() : 0;
+		const turns = hasV2(db)
+			? readV2Turns(db, sinceMs)
+			: readLegacyTurns(db, sinceMs);
+
+		const byKey = new Map<string, UsageEntry>();
+		const seen = new Set<string>();
+		const providers = new Set<string>();
+		for (const turn of turns) {
+			if (seen.has(turn.id)) continue; // turn rows can be rewritten in place
+			seen.add(turn.id);
+			providers.add(turn.providerID);
+
+			const key = normalizeKey(turn.modelID);
+			const entry = byKey.get(key) ?? {
+				key,
+				name: turn.modelID,
+				requests: 0,
+				tokensIn: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				tokensOut: 0,
+				reasoning: 0,
+				costUsd: 0,
+			};
+			entry.requests += 1;
+			entry.tokensIn += numberOr(turn.tokens.input);
+			entry.cacheRead += numberOr(turn.tokens.cache?.read);
+			entry.cacheWrite += numberOr(turn.tokens.cache?.write);
+			entry.tokensOut += numberOr(turn.tokens.output);
+			entry.reasoning += numberOr(turn.tokens.reasoning);
+			entry.costUsd += numberOr(turn.cost);
+			byKey.set(key, entry);
+		}
+		return {
+			entries: [...byKey.values()],
+			providers: [...providers],
+			records: turns.length,
+		};
+	} catch {
+		return null;
+	} finally {
+		db.close();
+	}
+}
+
+/** The pre-v2 layout: `message.data` carries the model, cost and tokens flat. */
+function readLegacyTurns(db: Database, sinceMs: number): Turn[] {
+	const rows = db
+		.query(
+			`SELECT data FROM message
+			 WHERE data LIKE '%"tokens"%' AND time_created >= ?`,
+		)
+		.all(sinceMs) as Array<{ data: string }>;
+	const turns: Turn[] = [];
+	for (const row of rows) {
+		let data: AssistantData;
+		try {
+			data = JSON.parse(row.data) as AssistantData;
+		} catch {
+			continue;
+		}
+		if (data.role !== "assistant" || !data.modelID || !data.tokens)
+			continue;
+		turns.push({
+			id: `${data.modelID}@${(data.time?.created ?? 0) as number}`,
+			modelID: data.modelID,
+			providerID: data.providerID ?? "unknown",
+			cost: numberOr(data.cost),
+			tokens: data.tokens,
+		});
+	}
+	return turns;
+}

package/src/data/usage/opencodeV2.ts

@@ -0,0 +1,70 @@
+import type { Database } from "bun:sqlite";
+
+/** One assistant turn, normalised across the two store layouts. */
+export interface Turn {
+	id: string;
+	modelID: string;
+	providerID: string;
+	cost: number;
+	tokens: {
+		input?: number;
+		output?: number;
+		/** Separate counter, billed at the output rate on top of `output`. */
+		reasoning?: number;
+		cache?: { read?: number; write?: number };
+	};
+}
+
+/**
+ * Does this store have v2's tables? opencode v2 appends to `session_message`
+ * and stopped writing `message` at the migration, so the legacy query reads
+ * nothing for any session since — which is how this store looked empty.
+ */
+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 turns: a *completed* assistant row carries `model`, `cost` and `tokens`; an
+ * in-flight one carries only the model, so it is skipped until it finishes.
+ */
+export function readV2Turns(db: Database, sinceMs: number): Turn[] {
+	const rows = db
+		.query(
+			`SELECT id, data FROM session_message
+			 WHERE type = 'assistant' AND time_created >= ?`,
+		)
+		.all(sinceMs) as Array<{ id: string; data: string }>;
+	const turns: Turn[] = [];
+	for (const row of rows) {
+		let data: Record<string, unknown>;
+		try {
+			data = JSON.parse(row.data) as Record<string, unknown>;
+		} catch {
+			continue;
+		}
+		const model = (data.model ?? {}) as {
+			id?: unknown;
+			providerID?: unknown;
+		};
+		const tokens = data.tokens as Turn["tokens"] | undefined;
+		if (typeof model.id !== "string" || !tokens) continue;
+		turns.push({
+			id: row.id,
+			modelID: model.id,
+			providerID:
+				typeof model.providerID === "string"
+					? model.providerID
+					: "unknown",
+			cost: typeof data.cost === "number" ? data.cost : 0,
+			tokens,
+		});
+	}
+	return turns;
+}

package/src/data/usage/parse.ts

@@ -0,0 +1,85 @@
+import { runCmduse } from "~/data/cmduse.ts";
+import { normalizeKey } from "~/keys.ts";
+
+export interface UsageEntry {
+	key: string;
+	name: string;
+	requests: number;
+	tokensIn: number;
+	cacheRead: number;
+	cacheWrite: number;
+	tokensOut: number;
+	/** Reasoning tokens, billed at the output rate on top of `tokensOut`. */
+	reasoning: number;
+	costUsd: number;
+}
+
+export interface AccountSummary {
+	requests: number;
+	cost: number;
+	periodEnd?: string;
+}
+
+type CmduseModel = Omit<UsageEntry, "key" | "name"> & Record<string, number>;
+
+function entryFrom(id: string, row: CmduseModel): UsageEntry {
+	return {
+		key: normalizeKey(id),
+		name: id,
+		requests: Number(row.requests ?? 0),
+		tokensIn: Number(row.tokensIn ?? 0),
+		cacheRead: Number(row.cacheRead ?? 0),
+		cacheWrite: Number(row.cacheWrite ?? 0),
+		tokensOut: Number(row.tokensOut ?? 0),
+		reasoning: Number(row.reasoning ?? 0),
+		costUsd: Number(row.costUsd ?? 0),
+	};
+}
+
+/** Accepts the cmduse shape, `{entries: [...]}` or a bare array. */
+export function parseUsage(text: string): UsageEntry[] {
+	const body = JSON.parse(text) as unknown;
+	const rows: UsageEntry[] = [];
+	const push = (id: string, row: unknown): void => {
+		if (!id || !row || typeof row !== "object") return;
+		rows.push(entryFrom(id, row as CmduseModel));
+	};
+	if (Array.isArray(body)) {
+		for (const row of body) {
+			const record = (row ?? {}) as Record<string, unknown>;
+			push(String(record.model ?? record.name ?? ""), record);
+		}
+		return rows;
+	}
+	const record = (body ?? {}) as Record<string, unknown>;
+	if (record.models && typeof record.models === "object") {
+		for (const [id, row] of Object.entries(record.models)) push(id, row);
+		return rows;
+	}
+	if (Array.isArray(record.entries)) {
+		for (const row of record.entries) {
+			const item = (row ?? {}) as Record<string, unknown>;
+			push(String(item.model ?? item.name ?? ""), row);
+		}
+	}
+	return rows;
+}
+
+/** Best-effort account summary, used only for the coverage line. */
+export async function accountSummary(): Promise<AccountSummary | undefined> {
+	const result = await runCmduse(["-1", "--json", "-p"]);
+	if (!result.ok) return undefined;
+	try {
+		const body = JSON.parse(result.stdout) as {
+			summary?: { requests?: number; cost?: number };
+			periodEnd?: string;
+		};
+		return {
+			requests: Number(body.summary?.requests ?? 0),
+			cost: Number(body.summary?.cost ?? 0),
+			periodEnd: body.periodEnd,
+		};
+	} catch {
+		return undefined;
+	}
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env bun
+import { run } from "./cli/run.ts";
+
+try {
+	process.exitCode = await run(process.argv.slice(2));
+} catch (error) {
+	console.error(
+		`mpc: ${error instanceof Error ? error.message : String(error)}`,
+	);
+	process.exitCode = 1;
+}

package/src/keys.ts

@@ -0,0 +1,29 @@
+import { ALIASES, BOUNDARY } from "~/constants/data.ts";
+
+/**
+ * Collapse a model name from either catalog onto a shared key.
+ *
+ * "deepseek/deepseek-v4.1-flash" -> "deepseekv41flash"
+ * "DeepSeek V4.1 Flash (Off-Peak)" -> "deepseekv41flash"
+ * "Qwen/Qwen3.8-Max" -> "qwen38max"
+ */
+export function normalizeKey(name: string): string {
+	let s = name.trim().toLowerCase();
+	// Drop parenthetical qualifiers: (Off-Peak), (> 256K tokens), (latest), (exp).
+	s = s.replace(/\([^)]*\)/g, " ");
+	// Drop a vendor prefix like "deepseek/", "z-ai/", "opencode-go/".
+	const parts = s.split("/");
+	s = parts[parts.length - 1] ?? s;
+	s = s.replace(/[^a-z0-9]+/g, "");
+	return ALIASES[s] ?? s;
+}
+
+/** Display name: strip parentheticals and collapse whitespace. */
+export function displayName(name: string): string {
+	return name
+		.split(BOUNDARY)
+		.join(" ")
+		.replace(/\([^)]*\)/g, " ")
+		.replace(/\s+/g, " ")
+		.trim();
+}

package/src/types.ts

@@ -0,0 +1,92 @@
+export type ProviderId = "oc-go" | "cc";
+
+/** Per-1M-token rates in USD. */
+export interface ModelPricing {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number | null;
+}
+
+/** One model's pricing + monthly credit allowance on one provider's plan. */
+export interface CatalogEntry {
+	provider: ProviderId;
+	plan: string;
+	/** Canonical cross-provider key (see normalize.ts). */
+	key: string;
+	/** Human display name. */
+	name: string;
+	pricing: ModelPricing;
+	/** Monthly credits ($) this plan devotes to this model. */
+	allowance: number;
+	/** Promotion CommandCode attaches to the row, when one is running. */
+	deal?: Deal;
+}
+
+/** A promotion chip on a model row: "-40%", "Free", "2x usage". */
+export interface Deal {
+	badge: string;
+	/** The expiry line the page prints beside it, verbatim. */
+	ends?: string;
+}
+
+export interface PlanInfo {
+	provider: ProviderId;
+	/** CLI id, e.g. "goat". */
+	id: string;
+	label: string;
+	/** Subscription USD per month. */
+	price: number;
+	/** Total monthly credits ($). */
+	credits: number;
+	fiveHour: number | null;
+	weekly: number | null;
+}
+
+/** Fixed per-request token counts used for every model on both providers. */
+export interface Workload {
+	input: number;
+	cacheRead: number;
+	output: number;
+	/** Reasoning tokens, billed at the output rate on top of `output`. */
+	reasoning: number;
+	/** Cache-write tokens, billed at the model's cache-write rate. */
+	cacheWrite: number;
+}
+
+export interface EntryMetrics {
+	provider: ProviderId;
+	plan: string;
+	pricing: ModelPricing;
+	allowance: number;
+	/** USD of list-rate spend for one request. */
+	costPerRequest: number;
+	/** Requests a month fits in this model's allowance. Infinity when free. */
+	requestsPerMonth: number;
+	/** Requests the plan's 5-hour window allows for this model. */
+	requestsPerFiveHour: number;
+	/** Requests the plan's weekly window allows for this model. */
+	requestsPerWeek: number;
+	/** What one request actually costs you on the plan. */
+	payPerRequest: number;
+	/** Allowance per dollar of subscription — "$usage per $paid". */
+	multiplier: number;
+	/** Benchmark score for the model, or null when unscored. */
+	ability: number | null;
+	/** Output tokens per second, or null when unknown. */
+	tps: number | null;
+	/** Promotion this entry's provider is running on the model, if any. */
+	deal?: Deal;
+	/** 0-100 blended value score, higher is better. */
+	index: number;
+	/** 0-100 ability-aware value score, null when the model is unscored. */
+	valueIndex: number | null;
+	free: boolean;
+}
+
+export interface CompareRow {
+	key: string;
+	name: string;
+	oc?: EntryMetrics;
+	cc?: EntryMetrics;
+}

package/src/view/columns/cc.ts

@@ -0,0 +1,50 @@
+import type { Column } from "~/view/schema.ts";
+import * as f from "~/view/text/index.ts";
+
+export const CC_COLUMNS: Record<string, Column> = {
+	"cc-rates": {
+		header: "rates",
+		value: f.ccRates,
+		style: f.tintOrFree("cc"),
+		drop: 1,
+	},
+	"cc-allow": {
+		header: "allow",
+		value: (r) => f.fmtAllowance(r.cc),
+		right: true,
+		style: f.tintOrFree("cc"),
+	},
+	"cc-req5h": {
+		header: "5h",
+		drop: 3,
+		value: (r) => f.fmtRequests(r.cc?.requestsPerFiveHour, Boolean(r.cc)),
+		right: true,
+		style: f.tint("cc"),
+	},
+	"cc-reqwk": {
+		header: "wk",
+		drop: 3,
+		value: (r) => f.fmtRequests(r.cc?.requestsPerWeek, Boolean(r.cc)),
+		right: true,
+		style: f.tint("cc"),
+	},
+	"cc-reqmo": {
+		header: "mo",
+		value: (r) => f.fmtRequests(r.cc?.requestsPerMonth, Boolean(r.cc)),
+		right: true,
+		style: f.tint("cc"),
+	},
+	"cc-per1k": {
+		header: "$/1K",
+		value: (r) => f.fmtPerThousand(r.cc),
+		right: true,
+		style: f.sideStyle("cc"),
+	},
+	"cc-reqdollar": {
+		header: "req/$",
+		value: (r) => f.fmtPerDollar(r.cc),
+		right: true,
+		style: f.sideStyle("cc"),
+		drop: 2,
+	},
+};