@rizal72/oc-models-pro 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rizal72/oc-models-pro",
-	"version": "0.1.2",
+	"version": "0.1.3",
 	"type": "module",
 	"description": "OpenCode v2 model picker with prices, context, intelligence, Go credit and the cost of a request",
 	"repository": {

package/tags.ts

@@ -0,0 +1,127 @@
+// Two letters per provider, so a row says where its model comes from without spending a column.
+//
+// The host's own two providers keep a tag chosen by hand, and those two are reserved: they exist in
+// every installation, so nobody else may take their letters. Everything else is derived from the
+// provider's display name — the only place where a merged name still keeps its seams ("DeepSeek" is
+// Deep·Seek; the id `deepseek` no longer says so).
+//
+// Runnable standalone for its self-check: node plugins/oc-models-pro/tags.ts --self-check
+
+/** Tags that belong to the host's own providers, present or not. */
+const RESERVED: Record<string, string> = {
+	opencode: "OC",
+	"opencode-go": "GO",
+}
+
+/**
+ * The words of a display name: `OpenCode Go` is two, `OpenRouter` is two as well — but a camelCase
+ * split only when the name has no separator, so a brand like `GitHub Copilot` keeps `GitHub` whole.
+ */
+export function words(name: string): string[] {
+	const split = name.split(/[^A-Za-z0-9]+/).filter(Boolean)
+	if (split.length > 1) return split
+	const camel = (split[0] ?? "").replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(" ").filter(Boolean)
+	return camel.length > 1 ? camel : split
+}
+
+/** What the name asks for: the initials of its words, or two letters of a single one. */
+function preferred(name: string): string {
+	const parts = words(name)
+	const letters = parts.length > 1 ? parts.map((part) => part[0]).join("") : (parts[0] ?? "?")
+	return letters.toUpperCase().padEnd(2, "?").slice(0, 2)
+}
+
+/**
+ * A tag per provider id, unique and order-independent. Derived in alphabetical order of id, so the
+ * same catalogue always yields the same tags whatever order the providers arrive in.
+ */
+export function tagsFor(providers: Array<{ id: string; name: string }>): Map<string, string> {
+	const taken = new Set(Object.values(RESERVED))
+	const tags = new Map<string, string>()
+	const order = [...providers].sort((a, b) => a.id.localeCompare(b.id))
+
+	for (const provider of order) {
+		const fixed = RESERVED[provider.id]
+		if (fixed) tags.set(provider.id, fixed)
+	}
+
+	for (const provider of order) {
+		if (tags.has(provider.id)) continue
+		const letters = (words(provider.name).join("") || "?").toUpperCase()
+		const first = letters[0] ?? "?"
+		let tag = preferred(provider.name)
+		if (taken.has(tag)) {
+			// Walk the name for a free pair, so `Google` steps aside from the reserved GO.
+			tag = ""
+			for (const letter of letters.slice(1)) {
+				// A doubled letter reads as a typo ("GG"): prefer anything else.
+				if (letter === first) continue
+				const candidate = first + letter
+				if (!taken.has(candidate)) {
+					tag = candidate
+					break
+				}
+			}
+		}
+		if (taken.has(tag) || !tag) {
+			tag = ""
+			for (let digit = 2; digit <= 9; digit++) {
+				if (!taken.has(first + digit)) {
+					tag = first + digit
+					break
+				}
+			}
+		}
+		if (!tag) tag = "?" + (tags.size % 10)
+		taken.add(tag)
+		tags.set(provider.id, tag)
+	}
+	return tags
+}
+
+// Self-check: node plugins/oc-models-pro/tags.ts --self-check
+if (process.argv[2] === "--self-check") {
+	const fail = (message: string): never => {
+		throw new Error("self-check: " + message)
+	}
+	const at = (providers: Array<{ id: string; name: string }>, id: string): string =>
+		tagsFor(providers).get(id) ?? fail("no tag for " + id)
+
+	if (at([{ id: "opencode", name: "anything" }], "opencode") !== "OC") fail("opencode must stay OC")
+	if (at([{ id: "opencode-go", name: "whatever" }], "opencode-go") !== "GO") fail("opencode-go must stay GO")
+	if (at([{ id: "openrouter", name: "OpenRouter" }], "openrouter") !== "OR") fail("OpenRouter must be OR")
+	if (at([{ id: "deepseek", name: "DeepSeek" }], "deepseek") !== "DS") fail("DeepSeek must be DS")
+	if (at([{ id: "github-copilot", name: "GitHub Copilot" }], "github-copilot") !== "GC") {
+		fail("GitHub Copilot must be GC")
+	}
+	// Reserved letters are reserved even when the host's provider is not in the list.
+	if (at([{ id: "google", name: "Google" }], "google") !== "GL") fail("Google must step aside from GO")
+
+	const twins = tagsFor([
+		{ id: "acme-one", name: "Acme" },
+		{ id: "acme-two", name: "Acme" },
+	])
+	if (new Set(twins.values()).size !== 2) fail("two providers share a tag")
+
+	const forward = tagsFor([
+		{ id: "beta", name: "Beta" },
+		{ id: "alpha", name: "Alpha" },
+		{ id: "google", name: "Google" },
+	])
+	const backward = tagsFor([
+		{ id: "google", name: "Google" },
+		{ id: "alpha", name: "Alpha" },
+		{ id: "beta", name: "Beta" },
+	])
+	if ([...forward].map(String).sort().join() !== [...backward].map(String).sort().join()) {
+		fail("the input order changes the tags")
+	}
+
+	console.log(
+		"self-check ok: " +
+			[...forward].map(([id, tag]) => id + "=" + tag).join(" ") +
+			" (" +
+			words("OpenCode Go").join("|") +
+			")",
+	)
+}

package/tui.tsx

@@ -15,12 +15,15 @@ import { join } from "node:path"
 import { benchFor, benchIndex, type Bench } from "./bench.ts"
 import { credits, goPlan, key, type Credits } from "./multipliers.ts"
 import { LEGEND_MIN, fit, hintLines, rowWidth, type Fit } from "./fit.ts"
+import { tagsFor } from "./tags.ts"
 
 interface Row {
 	name: string
 	providerID: string
 	modelID: string
 	provider: string
+	/** Two letters from `tags.ts`: the provider's, unique in the catalogue. */
+	tag: string
 	/** Undefined when the catalogue has no price for the model: an unknown figure, not a free one. */
 	input?: number
 	output?: number
@@ -179,17 +182,9 @@ function cell(text: string, width: number, align: "start" | "end" = "end"): stri
 	return align === "end" ? cut.padStart(width) : cut.padEnd(width)
 }
 
-/** Two letters, so a row carries its provider without a column that eats the width. */
-const TAGS: Record<string, string> = {
-	opencode: "OC",
-	"opencode-go": "GO",
-	openrouter: "OR",
-	deepseek: "DS",
-}
-
-function tag(providerID: string): string {
-	// Always four characters, even for a one-letter provider id, or the name column shifts left.
-	return ((TAGS[providerID] ?? providerID.slice(0, 2)).toUpperCase().padEnd(2) + "  ").slice(0, 4)
+/** Two letters and the gap after them: always four characters, or the name column shifts left. */
+function padTag(letters: string): string {
+	return (letters.padEnd(2) + "  ").slice(0, 4)
 }
 
 /**
@@ -235,7 +230,7 @@ function modelRow(row: Row, mine: boolean, favourite: boolean, f: Fit): string {
 	const notes = [row.peak ? "peak*" + row.peak : "", row.promo ? "+" + row.promo + "x" : ""].filter(Boolean)
 	return [
 		(mine ? "●" : " ") + (favourite ? "*" : " "),
-		tag(row.providerID),
+		padTag(row.tag),
 		label(row.name, f.name),
 		price(row.input, 6),
 		price(row.output, 6),
@@ -355,6 +350,7 @@ export default Plugin.define({
 			const providers = new Map<string, string>(
 				listProviders().map((provider: any) => [provider.id, provider.name]),
 			)
+			const tags = tagsFor([...providers].map(([id, name]) => ({ id, name })))
 			const result: Row[] = []
 			for (const model of listModels()) {
 				const cost = (model.cost ?? []).find((entry: any) => !entry.tier) ?? model.cost?.[0]
@@ -367,6 +363,7 @@ export default Plugin.define({
 					// The host names an account-bound provider `<account> / <Provider>`, which in a group
 					// header reads as if the account were the thing: provider first, account in brackets.
 					provider: (providers.get(model.providerID) ?? model.providerID).replace(/^(.+?) \/ (.+)$/, "$2 ($1)"),
+					tag: tags.get(model.providerID) ?? model.providerID.slice(0, 2).toUpperCase(),
 					// A missing figure stays missing: a 0 here would put an unknown model at the top of the
 					// cheapest list and claim a context window it never declared.
 					input: typeof cost?.input === "number" ? cost.input : undefined,