@jeffreyjyz/mpc 0.0.0-stage → 0.1.0

package/src/view/schema.ts

@@ -0,0 +1,81 @@
+import type { CompareRow, PlanInfo, ProviderId, Workload } from "~/types.ts";
+
+export type Row = CompareRow;
+
+/** One table column. */
+export interface Column {
+	header: string;
+	value: (row: Row) => string;
+	right?: boolean;
+	/** Optional SGR code applied to the padded cell (green 32, dim 2, ...). */
+	style?: (row: Row) => string | undefined;
+	/** Lower values are dropped first when the table is too wide. */
+	drop?: number;
+	/** When false the cell is not padded to the column width. */
+	pad?: boolean;
+}
+
+export type GroupKey = "model" | "oc" | "cc" | "misc";
+
+export interface GroupLabel {
+	title: string;
+	color: string;
+}
+
+/** A contiguous run of columns belonging to one group. */
+export interface Segment {
+	key: GroupKey;
+	columns: Column[];
+	widths: number[];
+	/** Total printed width including the gaps between columns. */
+	width: number;
+}
+
+export interface FitResult {
+	ids: string[];
+	dropped: string[];
+	width: number;
+}
+
+export interface Tally {
+	/** Rows present on both sides. */
+	headToHead: number;
+	ocWins: number;
+	ccWins: number;
+	ties: number;
+	ocOnly: number;
+	ccOnly: number;
+}
+
+export interface ReportMeta {
+	ocPlan: PlanInfo;
+	ccPlan: PlanInfo;
+	/** The request shape actually priced — one per side when a shape was measured. */
+	workloads: Record<ProviderId, Workload>;
+	/** Ability source label, e.g. "CommandCode Intelligence". */
+	abilityLabel?: string;
+	abilityNote?: string;
+	/** Whether reqshape was used for the workload, and the alternative flags. */
+	shapeNote?: string;
+	/** Override for the rolling-window ratios, five-hour then weekly. */
+	window?: [number, number];
+}
+
+import { CC_COLUMNS } from "./columns/cc.ts";
+import { META_COLUMNS } from "./columns/meta.ts";
+import { OC_COLUMNS } from "./columns/oc.ts";
+
+/** Every column the table can render, keyed by the id used with --columns. */
+const COLUMNS: Record<string, Column> = {
+	...META_COLUMNS,
+	...OC_COLUMNS,
+	...CC_COLUMNS,
+};
+
+export function columns(ids: string[]): Column[] {
+	return ids.map((id) => {
+		const column = COLUMNS[id];
+		if (!column) throw new Error(`unknown column "${id}"`);
+		return column;
+	});
+}

package/src/view/text/export.ts

@@ -0,0 +1,72 @@
+import { CSV_HEADER } from "~/constants/view.ts";
+import type { PlanInfo } from "~/types.ts";
+import type { Row, Tally } from "~/view/schema.ts";
+import { fmtAbility, fmtCount, fmtTps, planTitle } from "./format.ts";
+
+function csvCell(value: string | number): string {
+	const text = String(value);
+	return /[",\n]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+
+/** One line per model-provider entry, so a spreadsheet can pivot it. */
+export function renderCsv(rows: Row[], summary: Tally): string {
+	const lines = [CSV_HEADER.join(",")];
+	for (const row of rows) {
+		for (const entry of [row.oc, row.cc]) {
+			if (!entry) continue;
+			lines.push(
+				[
+					row.name,
+					entry.plan,
+					entry.allowance,
+					Number.isFinite(entry.requestsPerMonth)
+						? Math.round(entry.requestsPerMonth)
+						: "inf",
+					(entry.payPerRequest * 1000).toPrecision(6),
+					entry.payPerRequest.toPrecision(6),
+					entry.ability ?? "",
+					entry.tps ?? "",
+					100 - entry.index,
+					entry.valueIndex ?? "",
+				]
+					.map(csvCell)
+					.join(","),
+			);
+		}
+	}
+	lines.push(
+		`# head-to-head ${summary.headToHead} · OC ${summary.ocWins} · CC ${summary.ccWins} · tie ${summary.ties}`,
+	);
+	return `${lines.join("\n")}\n`;
+}
+
+/** Markdown table with the default columns. */
+export function renderMarkdown(
+	rows: Row[],
+	plans: [PlanInfo, PlanInfo],
+): string {
+	const lines = [
+		`# ${planTitle(plans[0])} vs ${planTitle(plans[1])}`,
+		"",
+		"| model | OC req/mo | OC $/1K | CC req/mo | CC $/1K | ability | tps | COST | VAL |",
+		"| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |",
+	];
+	const perK = (value: number): string => `$${fmtCount(value * 1000)}`;
+	for (const row of rows) {
+		const cells = [
+			row.name,
+			row.oc ? fmtCount(row.oc.requestsPerMonth) : "—",
+			row.oc ? perK(row.oc.payPerRequest) : "—",
+			row.cc ? fmtCount(row.cc.requestsPerMonth) : "—",
+			row.cc ? perK(row.cc.payPerRequest) : "—",
+			fmtAbility(row),
+			fmtTps(row),
+			String(100 - Math.max(row.oc?.index ?? -1, row.cc?.index ?? -1, 0)),
+			String(row.oc?.valueIndex ?? row.cc?.valueIndex ?? "—"),
+		];
+		lines.push(
+			`| ${cells.map((c) => c.replace(/\|/g, "\\|")).join(" | ")} |`,
+		);
+	}
+	return `${lines.join("\n")}\n`;
+}

package/src/view/text/format.ts

@@ -0,0 +1,79 @@
+import type { EntryMetrics } from "~/types.ts";
+import type { Row } from "~/view/schema.ts";
+
+export function fmtCount(n: number): string {
+	if (!Number.isFinite(n)) return "∞";
+	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);
+}
+
+export function fmtUsd(n: number): string {
+	if (n === 0) return "free";
+	// Stay in fixed-point for tiny per-request costs; scientific notation is
+	// hard to read at a glance. Trim trailing zeros so $0.000110 reads cleanly.
+	const digits = n >= 0.01 ? 4 : n >= 1e-6 ? 8 : 11;
+	const fixed = n.toFixed(digits).replace(/0+$/, "").replace(/\.$/, "");
+	return `$${fixed}`;
+}
+
+export function fmtRate(n: number): string {
+	if (n === 0) return "free";
+	return `$${Number(n.toFixed(4))}`;
+}
+
+export function fmtAllowance(m: EntryMetrics | undefined): string {
+	if (!m) return "—";
+	return m.free ? "free" : fmtRate(m.allowance);
+}
+
+/** Cost per 1,000 requests — the per-request figure scaled up to readable dollars. */
+export function fmtPerThousand(m: EntryMetrics | undefined): string {
+	if (!m) return "—";
+	return fmtUsd(m.payPerRequest * 1000);
+}
+
+/** Requests one dollar of subscription buys on this model. */
+export function fmtPerDollar(m: EntryMetrics | undefined): string {
+	if (!m) return "—";
+	if (m.free || m.payPerRequest === 0) return "∞";
+	return fmtCount(1 / m.payPerRequest);
+}
+
+export function fmtRequests(
+	value: number | undefined,
+	hasEntry: boolean,
+): string {
+	if (!hasEntry || value === undefined) return "—";
+	return fmtCount(value);
+}
+
+export function fmtAbility(row: Row): string {
+	const ability = row.oc?.ability ?? row.cc?.ability ?? null;
+	return ability === null ? "—" : ability.toFixed(1);
+}
+
+export function fmtTps(row: Row): string {
+	const tps = row.oc?.tps ?? row.cc?.tps ?? null;
+	return tps === null ? "—" : Math.round(tps).toString();
+}
+
+import type { ProviderId } from "~/types.ts";
+
+export function providerName(provider: ProviderId): string {
+	return provider === "oc-go" ? "OpenCode" : "CommandCode";
+}
+
+/** Short provider tag, for the WIN column. */
+export function shortProviderName(provider: ProviderId): string {
+	return provider === "oc-go" ? "OC" : "CC";
+}
+
+/** e.g. "OpenCode Go", "CommandCode GOAT". */
+export function planTitle(plan: {
+	provider: ProviderId;
+	label: string;
+}): string {
+	return `${providerName(plan.provider)} ${plan.label}`;
+}

package/src/view/text/index.ts

@@ -0,0 +1,54 @@
+import type { ColorMode } from "~/cli/options.ts";
+
+let color = true;
+
+/** Resolve a mode; "auto" follows the TTY and NO_COLOR. */
+export function setColorMode(mode: ColorMode): void {
+	if (mode === "always") color = true;
+	else if (mode === "never") color = false;
+	else color = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+}
+
+export function setColor(enabled: boolean): void {
+	color = enabled;
+}
+
+export function paint(code: string, text: string): string {
+	return color ? `\u001b[${code}m${text}\u001b[0m` : text;
+}
+
+export {
+	fmtAbility,
+	fmtAllowance,
+	fmtCount,
+	fmtPerDollar,
+	fmtPerThousand,
+	fmtRate,
+	fmtRequests,
+	fmtTps,
+	fmtUsd,
+	planTitle,
+	providerName,
+	shortProviderName,
+} from "./format.ts";
+export {
+	abilityStyle,
+	bestCost,
+	bestIndex,
+	bestValue,
+	ccRates,
+	cheaperSide,
+	costStyle,
+	enabledStyle,
+	freeCc,
+	freeOc,
+	ocRates,
+	pricingTriple,
+	setAbilityRange,
+	sideStyle,
+	tint,
+	tintOrFree,
+	valueStyle,
+	winner,
+	winnerStyle,
+} from "./styles.ts";

package/src/view/text/styles.ts

@@ -0,0 +1,151 @@
+import { PROVIDER_COLOR, PROVIDER_TINT, SGR } from "~/constants/view.ts";
+import type { EntryMetrics, ProviderId } from "~/types.ts";
+import type { Row } from "~/view/schema.ts";
+import { fmtRate, shortProviderName } from "./format.ts";
+
+/** Which side is cheaper per request on this row. */
+export function cheaperSide(row: Row): "oc" | "cc" | "tie" | "none" {
+	if (!row.oc || !row.cc) return "none";
+	if (row.oc.payPerRequest === row.cc.payPerRequest) return "tie";
+	return row.oc.payPerRequest < row.cc.payPerRequest ? "oc" : "cc";
+}
+
+export function winner(row: Row): string {
+	// One-sided rows are not wins; name the side that carries the model.
+	if (!row.oc) return `${shortProviderName("cc")} only`;
+	if (!row.cc) return `${shortProviderName("oc-go")} only`;
+	const side = cheaperSide(row);
+	if (side === "tie") return "tie";
+	return shortProviderName(side === "oc" ? "oc-go" : "cc");
+}
+
+export function bestIndex(row: Row): number {
+	return Math.max(row.oc?.index ?? -1, row.cc?.index ?? -1, 0);
+}
+
+function valueScores(row: Row): number[] {
+	return [row.oc?.valueIndex, row.cc?.valueIndex].filter(
+		(value): value is number => typeof value === "number",
+	);
+}
+
+export const bestValue = (r: Row): string => {
+	const scores = valueScores(r);
+	return scores.length === 0 ? "—" : Math.max(...scores).toString();
+};
+
+export const bestCost = (r: Row): string => (100 - bestIndex(r)).toString();
+
+export const pricingTriple = (m: EntryMetrics | undefined): string => {
+	if (!m) return "—";
+	const p = m.pricing;
+	return `${fmtRate(p.input)}/${fmtRate(p.output)}/${fmtRate(p.cacheRead)}`;
+};
+
+export const ocRates = (r: Row): string => pricingTriple(r.oc);
+export const ccRates = (r: Row): string => pricingTriple(r.cc);
+export const freeOc = (r: Row): boolean => Boolean(r.oc?.free);
+export const freeCc = (r: Row): boolean => Boolean(r.cc?.free);
+
+function entryOf(row: Row, provider: ProviderId): EntryMetrics | undefined {
+	return provider === "oc-go" ? row.oc : row.cc;
+}
+
+/**
+ * A provider's whole column set is tinted with its identity colour, so the two
+ * halves of the table read apart. An absent cell stays `dim` (dim = missing).
+ */
+export const tint =
+	(provider: ProviderId) =>
+	(row: Row): string | undefined =>
+		entryOf(row, provider) ? PROVIDER_TINT[provider] : SGR.dim;
+
+/** The tint, except a free model goes green (favourable). */
+export const tintOrFree =
+	(provider: ProviderId) =>
+	(row: Row): string | undefined => {
+		const entry = entryOf(row, provider);
+		if (!entry) return SGR.dim;
+		return entry.free ? SGR.green : PROVIDER_TINT[provider];
+	};
+
+/**
+ * The cheaper side's cell in its provider's **bold** colour, the other side in
+ * the quiet tint — so the win reads from brightness, and an OC win (cyan) never
+ * looks like a CC win (magenta).
+ */
+export function sideStyle(side: "oc" | "cc") {
+	const provider: ProviderId = side === "oc" ? "oc-go" : "cc";
+	return (row: Row): string | undefined => {
+		if (!entryOf(row, provider)) return SGR.dim;
+		return cheaperSide(row) === side
+			? PROVIDER_COLOR[provider]
+			: PROVIDER_TINT[provider];
+	};
+}
+
+/** WIN column: the winning side's own colour; a tie or a one-sided row plain. */
+export const winnerStyle = (row: Row): string | undefined => {
+	const side = cheaperSide(row);
+	if (side === "tie" || side === "none") return undefined;
+	return PROVIDER_COLOR[side === "oc" ? "oc-go" : "cc"];
+};
+
+let costCuts: [number, number] = [30, 60];
+let valCuts: [number, number] = [40, 70];
+
+/** Configure the green/yellow cut-offs for COST and VAL. */
+export function setThresholds(
+	cost: [number, number],
+	val: [number, number],
+): void {
+	costCuts = cost;
+	valCuts = val;
+}
+
+/**
+ * COST is inverted (0 = cheapest/best), so colour the other way round:
+ * green = cheap, yellow/orange = mid, red = the pricier rows.
+ */
+export const costStyle = (r: Row): string | undefined => {
+	const cost = 100 - bestIndex(r);
+	if (cost <= costCuts[0]) return SGR.green;
+	if (cost <= costCuts[1]) return SGR.yellow;
+	return SGR.red;
+};
+
+export const valueStyle = (row: Row): string | undefined => {
+	const scores = valueScores(row);
+	if (scores.length === 0) return SGR.dim;
+	const best = Math.max(...scores);
+	if (best >= valCuts[1]) return SGR.green;
+	if (best >= valCuts[0]) return SGR.yellow;
+	return SGR.red;
+};
+
+export const enabledStyle = (value: number | null): string | undefined =>
+	value === null ? SGR.dim : undefined;
+
+let abilityRange: [number, number] | null = null;
+
+/** The displayed ability range, so the column can rank like COST/VAL. */
+export function setAbilityRange(min: number, max: number): void {
+	abilityRange = [min, max];
+}
+
+/**
+ * Ability is an absolute benchmark index with a narrow band, so an absolute
+ * scale would be all-red; rank it across the table (min-max) and reuse the VAL
+ * cut-offs, exactly as COST/VAL are coloured.
+ */
+export const abilityStyle = (row: Row): string | undefined => {
+	const ability = row.oc?.ability ?? row.cc?.ability ?? null;
+	if (ability === null) return SGR.dim;
+	if (!abilityRange || abilityRange[1] <= abilityRange[0]) return undefined;
+	const score =
+		(100 * (ability - abilityRange[0])) /
+		(abilityRange[1] - abilityRange[0]);
+	if (score >= valCuts[1]) return SGR.green;
+	if (score >= valCuts[0]) return SGR.yellow;
+	return SGR.red;
+};