claudeup 6.6.0 → 6.8.0

package/src/__tests__/mate-catalog.test.ts

@@ -0,0 +1,295 @@
+/**
+ * Reading claudish's live model catalogue, and the one rule that matters most about it.
+ *
+ * This module's whole job is to be ADVISORY and to FAIL SILENT. So the tests that earn their
+ * place are the negative ones: what happens when claudish is missing, when it exits non-zero,
+ * when it prints a table this build has never seen. Every one of those has to end in "the
+ * catalogue is unknown" and nothing else — an advisory that fires hardest when it knows least
+ * is worse than no advisory at all.
+ *
+ * The fixture below is REAL output, captured from `claudish --models` (v9.3.0) rather than
+ * written from memory of the format. A parser tested against its author's idea of the format
+ * passes forever and tells you nothing about the format.
+ */
+import { describe, expect, test } from "bun:test";
+import {
+	type CatalogModel,
+	catalogIds,
+	clearMateCatalogCache,
+	loadMateCatalog,
+	parseModelsTable,
+	stalenessNote,
+	unknownBindings,
+} from "../services/mate-catalog.js";
+
+/** Verbatim `claudish --models`, trimmed in the middle. Header, rule, rows, legend, footer. */
+const REAL_OUTPUT = `
+Top 100 models from Firebase (pool: 384 eligible)
+
+  #    Model                          Provider    Pricing     Context  Caps  Released
+  ──────────────────────────────────────────────────────────────────────────────────────────
+    4  deepseek-v4.1-flash            deepseek   $0.75/1M   1M      TRV   2026-09-10
+    1  gpt-6-astra                    openai     $30.00/1M  1M      TRV   2026-09-03
+    3  gemini-3.8-flash               google     $2.25/1M   1M      TRV   2026-09-02
+   57  grok-4.6                       x-ai       $4.00/1M   500K    TRV   2026-08-12
+   15  kimi-k3                        moonshotai $9.00/1M   1M      TRV   2026-07-16
+    8  glm-5.3-fp8                    z-ai       FREE       1M      TR    2026-08-14
+   55  inkling-small                  thinking-machines $0.85/1M   1M      TRV   2026-07-30
+   68  mimo-v2.5                      xiaomi     FREE       1M      TRV   —
+   99  codex-mini-latest              openai     $3.75/1M   200K    TRV   —
+
+  Caps: T = tools  R = reasoning  V = vision
+
+Local providers
+  ──────────────────────────────────────────────────────────────────────
+  Ollama:    not running
+  LiteLLM:   not configured (set LITELLM_BASE_URL + LITELLM_API_KEY)
+
+Filter by provider: claudish --models --provider <slug>
+All providers:      claudish --providers
+`;
+
+const idsOf = (models: CatalogModel[]) => models.map((m) => m.id);
+
+describe("parseModelsTable", () => {
+	test("reads every model row out of real claudish output", () => {
+		expect(idsOf(parseModelsTable(REAL_OUTPUT))).toEqual([
+			"deepseek-v4.1-flash",
+			"gpt-6-astra",
+			"gemini-3.8-flash",
+			"grok-4.6",
+			"kimi-k3",
+			"glm-5.3-fp8",
+			"inkling-small",
+			"mimo-v2.5",
+			"codex-mini-latest",
+		]);
+	});
+
+	test("keeps the fields a binding and a picker need", () => {
+		const grok = parseModelsTable(REAL_OUTPUT).find((m) => m.id === "grok-4.6");
+		expect(grok).toEqual({
+			id: "grok-4.6",
+			provider: "x-ai",
+			pricing: "$4.00/1M",
+			context: "500K",
+			caps: "TRV",
+			released: "2026-08-12",
+		});
+	});
+
+	test("`FREE` is a pricing string like any other, not a missing field", () => {
+		const free = parseModelsTable(REAL_OUTPUT).find(
+			(m) => m.id === "glm-5.3-fp8",
+		);
+		expect(free?.pricing).toBe("FREE");
+		expect(free?.caps).toBe("TR");
+	});
+
+	test("an em-dash release date becomes empty, not a dash in a date field", () => {
+		// Carrying `—` through would put a glyph in a field every reader treats as a date,
+		// and anything that formats or sorts it would have to special-case the glyph.
+		const undated = parseModelsTable(REAL_OUTPUT).find(
+			(m) => m.id === "mimo-v2.5",
+		);
+		expect(undated?.released).toBe("");
+	});
+
+	test("the legend, the local-provider block and the footer are not models", () => {
+		const ids = idsOf(parseModelsTable(REAL_OUTPUT));
+		for (const notAModel of [
+			"Caps:",
+			"Ollama:",
+			"LiteLLM:",
+			"Local",
+			"Filter",
+			"Top",
+		]) {
+			expect(ids).not.toContain(notAModel);
+		}
+	});
+
+	/**
+	 * The defensive half of the seven-token rule.
+	 *
+	 * If claudish adds a column, every row stops matching and the catalogue comes back empty
+	 * — which means "unknown", which suppresses the advisory and changes nothing on screen.
+	 * The alternative (take the first seven of >= 7) would keep matching while reading the
+	 * wrong field into `id`, and would then report live models as retired. Silence beats
+	 * confident nonsense.
+	 */
+	test("an extra column makes the table unreadable rather than misread", () => {
+		const eightColumns =
+			"    4  deepseek-v4.1-flash  deepseek  $0.75/1M  1M  TRV  2026-09-10  extra";
+		expect(parseModelsTable(eightColumns)).toEqual([]);
+	});
+
+	test("never throws on junk, however shaped", () => {
+		for (const junk of ["", "\n\n\n", "error: command not found", "{}", "—"]) {
+			expect(() => parseModelsTable(junk)).not.toThrow();
+			expect(parseModelsTable(junk)).toEqual([]);
+		}
+	});
+
+	test("strips SGR sequences, so colour cannot ride into an id", () => {
+		// Measured: a piped `claudish --models` emits none today. This is about the day it
+		// starts colouring a pipe — an ESC left in the string would make a live model look
+		// retired, which is the one false positive this module must never produce.
+		const coloured =
+			"    57  grok-4.6  x-ai  $4.00/1M  500K  TRV  2026-08-12";
+		expect(idsOf(parseModelsTable(coloured))).toEqual(["grok-4.6"]);
+	});
+
+	test("a repeated id is listed once", () => {
+		const twice = `
+    57  grok-4.6  x-ai  $4.00/1M  500K  TRV  2026-08-12
+    58  grok-4.6  x-ai  $4.00/1M  500K  TRV  2026-08-12
+`;
+		expect(idsOf(parseModelsTable(twice))).toEqual(["grok-4.6"]);
+	});
+});
+
+describe("unknownBindings", () => {
+	const catalog = parseModelsTable(REAL_OUTPUT);
+
+	/**
+	 * THE load-bearing test in this file.
+	 *
+	 * An unread catalogue lists nothing, so a naive "not in the set" check would mark every
+	 * binding on the machine as retired the moment claudish was missing. The advisory has to
+	 * go quiet exactly when it knows least.
+	 */
+	test("says nothing at all when the catalogue could not be read", () => {
+		expect(unknownBindings(["grok-4.6", "totally-made-up"], [])).toEqual([]);
+	});
+
+	test("names an id the catalogue does not list", () => {
+		expect(unknownBindings(["grok-4.6", "gpt-4-turbo"], catalog)).toEqual([
+			"gpt-4-turbo",
+		]);
+	});
+
+	test("says nothing when every binding is live", () => {
+		expect(unknownBindings(["grok-4.6", "kimi-k3"], catalog)).toEqual([]);
+	});
+
+	test("exact match only — a neighbouring version is not a stand-in", () => {
+		// `grok-4.5` resolving a retired `grok-4.6` is the exact failure this exists to
+		// catch, wearing a helpful face. Same rule the image-model registry holds to.
+		expect(unknownBindings(["grok-4.5"], catalog)).toEqual(["grok-4.5"]);
+	});
+
+	test("reports a repeated unknown id once", () => {
+		expect(unknownBindings(["nope", "nope"], catalog)).toEqual(["nope"]);
+	});
+});
+
+describe("catalogIds", () => {
+	test("is every id, as a set", () => {
+		const ids = catalogIds(parseModelsTable(REAL_OUTPUT));
+		expect(ids.has("grok-4.6")).toBe(true);
+		expect(ids.has("gpt-4-turbo")).toBe(false);
+		expect(ids.size).toBe(9);
+	});
+});
+
+describe("stalenessNote", () => {
+	test("is null when there is nothing to say", () => {
+		expect(stalenessNote([])).toBeNull();
+	});
+
+	test("hedges, because absence from a TOP-N list is weak evidence", () => {
+		// `--models` prints the top 100 of a 384-model pool, so a missing id may simply sit
+		// below the cut. The note must not claim the model is gone.
+		const note = stalenessNote(["gpt-4-turbo"]);
+		expect(note).toContain("gpt-4-turbo");
+		expect(note).toContain("may");
+		expect(note).not.toContain("deleted");
+		expect(note).not.toContain("retired");
+	});
+
+	test("agrees with itself about number", () => {
+		expect(stalenessNote(["a"])).toContain(" is ");
+		expect(stalenessNote(["a", "b"])).toContain(" are ");
+	});
+});
+
+describe("loadMateCatalog", () => {
+	test("returns [] when claudish is not there to answer", async () => {
+		clearMateCatalogCache();
+		expect(await loadMateCatalog(async () => null)).toEqual([]);
+	});
+
+	test("returns [] when the fetcher throws, rather than propagating", async () => {
+		// Nothing above this module is allowed to see an exception from a catalogue read.
+		clearMateCatalogCache();
+		expect(
+			await loadMateCatalog(async () => {
+				throw new Error("claudish exploded");
+			}),
+		).toEqual([]);
+	});
+
+	test("parses what it is handed", async () => {
+		clearMateCatalogCache();
+		const models = await loadMateCatalog(async () => REAL_OUTPUT);
+		expect(idsOf(models)).toContain("grok-4.6");
+	});
+
+	test("caches, so one screen's lookup answers for the session", async () => {
+		clearMateCatalogCache();
+		let calls = 0;
+		const counting = async () => {
+			calls += 1;
+			return REAL_OUTPUT;
+		};
+		await loadMateCatalog(counting);
+		await loadMateCatalog(counting);
+		expect(calls).toBe(1);
+	});
+
+	/**
+	 * A FAILURE is cached too, and that is deliberate.
+	 *
+	 * The catalogue cannot change while claudeup is open, so a machine with no claudish would
+	 * otherwise pay the spawn — and its full timeout — once per screen that asks.
+	 */
+	test("caches the failure as well, so a missing claudish is paid for once", async () => {
+		clearMateCatalogCache();
+		let calls = 0;
+		const failing = async () => {
+			calls += 1;
+			return null;
+		};
+		await loadMateCatalog(failing);
+		await loadMateCatalog(failing);
+		expect(calls).toBe(1);
+	});
+
+	test("concurrent callers share one lookup", async () => {
+		clearMateCatalogCache();
+		let calls = 0;
+		const slow = async () => {
+			calls += 1;
+			await new Promise((r) => setTimeout(r, 10));
+			return REAL_OUTPUT;
+		};
+		await Promise.all([loadMateCatalog(slow), loadMateCatalog(slow)]);
+		expect(calls).toBe(1);
+	});
+
+	test("clearing the cache means the next call asks again", async () => {
+		// The negative control for all four cache tests above: without it, a `loadMateCatalog`
+		// that never called its fetcher at all would pass every one of them.
+		clearMateCatalogCache();
+		let calls = 0;
+		const counting = async () => {
+			calls += 1;
+			return REAL_OUTPUT;
+		};
+		await loadMateCatalog(counting);
+		clearMateCatalogCache();
+		await loadMateCatalog(counting);
+		expect(calls).toBe(2);
+	});
+});