@rizal72/oc-models-pro 0.1.1 → 0.1.3

package/package.json

@@ -1,8 +1,12 @@
 {
 	"name": "@rizal72/oc-models-pro",
-	"version": "0.1.1",
+	"version": "0.1.3",
 	"type": "module",
 	"description": "OpenCode v2 model picker with prices, context, intelligence, Go credit and the cost of a request",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/rizal72/opencode-plugins.git"
+	},
 	"license": "MIT",
 	"files": [
 		"*.ts",

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),
@@ -250,15 +245,27 @@ function modelRow(row: Row, mine: boolean, favourite: boolean, f: Fit): string {
 
 const TRACE = join(tmpdir(), "oc-models-pro.log")
 
+/** The tail is the part worth reading; the file is trimmed at startup, never during a session. */
+const TRACE_LINES = 1000
+
 function trace(message: string): void {
 	try {
 		appendFileSync(TRACE, new Date().toISOString() + " " + message + "\n")
 	} catch {}
 }
 
+/** Keeps the log to its last `TRACE_LINES` lines, so it neither grows without bound nor loses the recent past. */
+function trimTrace(): void {
+	try {
+		const lines = readFileSync(TRACE, "utf8").split("\n")
+		if (lines.length > TRACE_LINES) writeFileSync(TRACE, lines.slice(-TRACE_LINES).join("\n"))
+	} catch {}
+}
+
 export default Plugin.define({
 	id: "oc-models-pro",
 	setup(context: any) {
+		trimTrace()
 		const ui = context.ui
 		const themeColour = (...paths: string[][]): any => {
 			for (const path of paths) {
@@ -343,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]
@@ -355,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,
@@ -417,6 +426,13 @@ export default Plugin.define({
 		}
 
 		const Panel = (props: { panel: any }) => {
+			// Who had the focus before the panel took it: the prompt itself. The renderer can hand it back,
+			// and nothing else in the API can — no host command focuses the prompt from a plugin.
+			const previousFocus = context.renderer?.currentFocusedRenderable
+			trace(
+				"panel: previous focus=" +
+					(previousFocus ? (previousFocus.constructor?.name ?? "?") : "none"),
+			)
 			const [selected, setSelected] = createSignal<string | undefined>(undefined)
 			/** The panel's width, in columns, and the layout it buys — reactive: the host resizes it. */
 			const width = createMemo(() => Math.floor(Number(props.panel.width) || 0), undefined, { equals: Object.is })
@@ -448,8 +464,31 @@ export default Plugin.define({
 			let field: any
 			/** Diagnostic: more than one mount per open means the panel is being rebuilt under us. */
 			let inputMounts = 0
-			/** Whether the field holds the focus — the host resets it on some reflows. */
-			let focused = false
+			/**
+			 * Who the host's renderer has focus on: the truth the blur/refocus guessing could only infer.
+			 * Clicking a row or the field moves it without necessarily firing a blur on the input.
+			 */
+			const holdsField = (): boolean => Boolean(field) && context.renderer?.currentFocusedRenderable === field
+			/**
+			 * Hands the focus back to whoever held it before the panel opened — the prompt. The host does not
+			 * do it for a panel closed by a click, and there is no command that focuses the prompt: this is
+			 * the renderer's own method, and it is what makes a click on a row behave like `esc`.
+			 */
+			const focusPrompt = (): void => {
+				try {
+					if (!previousFocus || previousFocus.isDestroyed || !context.renderer?.focusRenderable) {
+						trace("focus: no target")
+						return
+					}
+					context.renderer.focusRenderable(previousFocus)
+					trace(
+						"focus: restored, current=" +
+							(context.renderer.currentFocusedRenderable === previousFocus ? "yes" : "no"),
+					)
+				} catch (error) {
+					fail("focus", error)
+				}
+			}
 			const clear = (): void => {
 				setQuery("")
 				if (field && !field.isDestroyed) field.value = ""
@@ -600,7 +639,13 @@ export default Plugin.define({
 					selectable().find((entry) => prefKey(entry.providerID, entry.modelID) === wanted)
 				if (!row) return
 				trace("choose: " + prefKey(row.providerID, row.modelID))
+				// Esc closes with the search field focused and the host hands the prompt its focus back; a
+				// click leaves it on the row, so the field takes it again before the panel goes away.
+				if (field && !field.isDestroyed) field.focus?.()
 				props.panel.close()
+				// The host returns the prompt's focus on its own only most of the time, and never while its
+				// unmount is still running: the saved renderable takes it back once the panel is gone.
+				if (props.panel.presentation === "panel") setTimeout(focusPrompt, 40)
 				void (async () => {
 					if (!(await selectModel(row))) {
 						// The native never fails here — it writes the selection itself — so this is the one
@@ -692,6 +737,8 @@ export default Plugin.define({
 						description: "",
 					})),
 				})) as string | undefined
+				// A dialog takes the focus and does not hand it back either: the same command, once it closed.
+				setTimeout(focusPrompt, 40)
 				// Cancelling leaves the model without a variant, and the question will come back, as in
 				// the native picker.
 				if (chosen === undefined) return
@@ -762,7 +809,8 @@ export default Plugin.define({
 				fitted()
 				hints()
 				const element = field
-				if (focused || !element || element.isDestroyed || !props.panel.focused) return
+				if (!element || element.isDestroyed || !props.panel.focused || holdsField()) return
+				trace("reflow: field takes the focus back")
 				element.focus()
 			})
 
@@ -824,6 +872,12 @@ export default Plugin.define({
 						borderColor={BORDER}
 						paddingLeft={1}
 						paddingRight={1}
+						onMouseDown={() => {
+							// A click inside the field moves the host's focus elsewhere; take it back a tick later.
+							setTimeout(() => {
+								if (field && !field.isDestroyed) field.focus()
+							}, 1)
+						}}
 					>
 						<input
 							ref={(element: any) => {
@@ -838,8 +892,6 @@ export default Plugin.define({
 									if (!element.isDestroyed) element.focus()
 								}, 1)
 							}}
-							onFocus={() => (focused = true)}
-							onBlur={() => (focused = false)}
 							placeholder="Search (ctrl+u clear)"
 							flexGrow={1}
 							placeholderColor={themeColour(["text", "faint"])}