@xynogen/pix-models 0.1.16 → 0.1.17

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-models",
-	"version": "0.1.16",
+	"version": "0.1.17",
 	"description": "Pi extension — enhanced /models picker with BenchLM ranks",
 	"type": "module",
 	"main": "src/index.ts",

package/src/models.test.ts

@@ -1,5 +1,13 @@
 import { describe, expect, it } from "bun:test";
-import { benchStars, fmtCost, fmtCtx, sortModels } from "./models.ts";
+import {
+	benchStars,
+	filterModelItems,
+	fmtCost,
+	fmtCtx,
+	type ModelSearchLookup,
+	normalizeModelText,
+	sortModels,
+} from "./models.ts";
 
 describe("fmtCtx", () => {
 	it("formats 0 as 0", () => expect(fmtCtx(0)).toBe("0"));
@@ -120,3 +128,124 @@ describe("sortModels", () => {
 		expect(sorted.map((m) => m.name)).toEqual(["Alpha", "Delta", "Beta", "Gamma"]);
 	});
 });
+
+// ─── normalizeModelText ───────────────────────────────────────────────────────
+
+describe("normalizeModelText", () => {
+	it("lowercases", () => {
+		expect(normalizeModelText("GLM-5.2")).toBe("glm52");
+	});
+
+	it("strips hyphens", () => {
+		expect(normalizeModelText("claude-opus-4-8")).toBe("claudeopus48");
+	});
+
+	it("strips dots", () => {
+		expect(normalizeModelText("qwen3.7-max")).toBe("qwen37max");
+	});
+
+	it("strips all non-alphanumeric", () => {
+		expect(normalizeModelText("a!b@c#d$e%f^g&h")).toBe("abcdefgh");
+	});
+
+	it("handles plain alphanumeric", () => {
+		expect(normalizeModelText("abc123")).toBe("abc123");
+	});
+
+	it("handles empty string", () => {
+		expect(normalizeModelText("")).toBe("");
+	});
+});
+
+// ─── filterModelItems ─────────────────────────────────────────────────────────
+
+describe("filterModelItems", () => {
+	// Fixture: models with ids matching the acceptance criteria.
+	// Ranks are assigned so some overlap with digit-queries.
+	const mk = (id: string, rank?: number) => ({
+		value: `p/${id}`,
+		_rank: rank,
+	});
+
+	type Fixture = ReturnType<typeof mk>;
+
+	/** Build lookup maps exactly like production: haystack = `${id} ${name ?? ""}`. */
+	function buildLookup(items: Fixture[]): ModelSearchLookup {
+		const rankByValue = new Map<string, number>();
+		const searchTextByValue = new Map<string, string>();
+		const normalizedByValue = new Map<string, string>();
+		for (const it of items) {
+			// value is "p/glm-5.2" — extract the id part.
+			const id = it.value.split("/")[1] ?? "";
+			if (it._rank != null) rankByValue.set(it.value, it._rank);
+			const text = `${id} ${""}`; // no name in test fixture
+			searchTextByValue.set(it.value, text);
+			normalizedByValue.set(it.value, normalizeModelText(text));
+		}
+		return { rankByValue, searchTextByValue, normalizedByValue };
+	}
+
+	// Full fixture with ranks: glm-5.2→3, minimax-m3→8, claude-opus-4-8→2.
+	const allItems: Fixture[] = [
+		mk("glm-5.2", 3),
+		mk("glm-5.1"),
+		mk("minimax-m3", 8),
+		mk("claude-opus-4-8", 2),
+		mk("claude-sonnet-4-6"),
+		mk("qwen3.7-max"),
+	];
+	const allLookup = buildLookup(allItems);
+
+	function values(result: Fixture[]): string[] {
+		return result.map((it) => it.value);
+	}
+
+	it("empty query returns all items in original order", () => {
+		const result = filterModelItems(allItems, "", allLookup);
+		expect(values(result)).toEqual(allItems.map((it) => it.value));
+	});
+
+	it("query '52' includes glm-5.2 via normalized substring", () => {
+		const result = filterModelItems(allItems, "52", allLookup);
+		expect(values(result)).toContain("p/glm-5.2");
+	});
+
+	it("query 'm3' includes minimax-m3 first (substring priority over fuzzy noise)", () => {
+		const result = filterModelItems(allItems, "m3", allLookup);
+		expect(values(result)[0]).toBe("p/minimax-m3");
+	});
+
+	it("query '48' includes claude-opus-4-8", () => {
+		const result = filterModelItems(allItems, "48", allLookup);
+		expect(values(result)).toContain("p/claude-opus-4-8");
+	});
+
+	it("exact id query 'glm-5.2' still matches glm-5.2", () => {
+		const result = filterModelItems(allItems, "glm-5.2", allLookup);
+		expect(values(result)).toContain("p/glm-5.2");
+	});
+
+	it("digit query matching a rank returns that ranked item first", () => {
+		// glm-5.2 has rank 3 — query "3" should put it first.
+		const result = filterModelItems(allItems, "3", allLookup);
+		expect(values(result)[0]).toBe("p/glm-5.2");
+	});
+
+	it("dedupe: item matching both rank and substring appears once", () => {
+		// claude-opus-4-8 has rank 2; query "2" matches by rank AND
+		// normalized substring ("2" ⊂ "claudeopus48"). Should appear once.
+		const result = filterModelItems(allItems, "2", allLookup);
+		const occurrences = values(result).filter((v) => v === "p/claude-opus-4-8");
+		expect(occurrences.length).toBe(1);
+	});
+
+	it("digit query '8' (rank 8) returns minimax-m3 as rank match first", () => {
+		const result = filterModelItems(allItems, "8", allLookup);
+		expect(values(result)[0]).toBe("p/minimax-m3");
+	});
+
+	it("whitespace query is treated as empty", () => {
+		const result = filterModelItems(allItems, "   ", allLookup);
+		expect(values(result)).toEqual(allItems.map((it) => it.value));
+	});
+});

package/src/models.ts

@@ -87,6 +87,68 @@ export function sortModels<T extends SortableModel>(models: T[]): T[] {
 	});
 }
 
+/** Lowercase and strip all non-alphanumerics: "glm-5.2" → "glm52". */
+export function normalizeModelText(s: string): string {
+	return s.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
+export type ModelSearchLookup = {
+	/** benchlm local rank per item value (ranked models only). */
+	rankByValue: Map<string, number>;
+	/** Clean haystack per value: `${id} ${name ?? ""}` (no ANSI, no rank cell). */
+	searchTextByValue: Map<string, string>;
+	/** normalizeModelText(haystack) per value — for family+version substring matches. */
+	normalizedByValue: Map<string, string>;
+};
+
+/**
+ * Filter+order picker items for a search query.
+ *  - "" → all items unchanged.
+ *  - digits-only → items whose benchlm rank equals the number, followed by
+ *    normalized-substring matches ("52" ⊂ "glm52") rank-sorted.
+ *  - otherwise → normalized-substring matches first (rank-sorted), then
+ *    fuzzy matches over the clean haystack (rank-sorted, stable), deduped.
+ */
+export function filterModelItems<T extends { value: string }>(
+	items: T[],
+	query: string,
+	lookup: ModelSearchLookup,
+): T[] {
+	const q = query.trim();
+	if (q.length === 0) return items;
+
+	const rankSort = (arr: T[]): T[] => {
+		return arr
+			.map((it, i) => ({ it, i }))
+			.sort((a, b) => {
+				const ra = lookup.rankByValue.get(a.it.value) ?? Infinity;
+				const rb = lookup.rankByValue.get(b.it.value) ?? Infinity;
+				if (ra !== rb) return ra - rb;
+				return a.i - b.i;
+			})
+			.map(({ it }) => it);
+	};
+
+	const nq = normalizeModelText(q);
+	const subMatches =
+		nq.length > 0
+			? items.filter((it) => (lookup.normalizedByValue.get(it.value) ?? "").includes(nq))
+			: [];
+
+	if (/^\d+$/.test(q)) {
+		const wanted = Number(q);
+		const rankMatches = items.filter((it) => lookup.rankByValue.get(it.value) === wanted);
+		const rankValues = new Set(rankMatches.map((it) => it.value));
+		const extraSub = rankSort(subMatches).filter((it) => !rankValues.has(it.value));
+		return [...rankMatches, ...extraSub];
+	}
+
+	const fuzzy = fuzzyFilter(items, q, (it) => lookup.searchTextByValue.get(it.value) ?? "");
+	const subValues = new Set(subMatches.map((it) => it.value));
+	const extraFuzzy = rankSort(fuzzy).filter((it) => !subValues.has(it.value));
+	return [...rankSort(subMatches), ...extraFuzzy];
+}
+
 async function showEnhancedPicker(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
 	// Mirror the built-in /model selector, which calls refresh() then awaits
 	// getAvailable() (see model-selector.js). Without refresh(), this extension
@@ -184,6 +246,17 @@ async function showEnhancedPicker(pi: ExtensionAPI, ctx: ExtensionContext): Prom
 				if (localRank) rankByValue.set(`${m.provider}/${m.id}`, localRank);
 			}
 
+			// Clean search haystacks — labels are ANSI-laden and carry the rank cell,
+			// so matching runs against raw id+name instead (see filterModelItems).
+			const searchTextByValue = new Map<string, string>();
+			const normalizedByValue = new Map<string, string>();
+			for (const { m } of dedupedRows) {
+				const value = `${m.provider}/${m.id}`;
+				const text = `${m.id} ${m.name ?? ""}`;
+				searchTextByValue.set(value, text);
+				normalizedByValue.set(value, normalizeModelText(text));
+			}
+
 			const items: SelectItem[] = dedupedRows.map(({ m, dev, bench, localRank }) => {
 				const isCurrent = current && m.provider === current.provider && m.id === current.id;
 
@@ -282,27 +355,11 @@ async function showEnhancedPicker(pi: ExtensionAPI, ctx: ExtensionContext): Prom
 					selectedIndex: number;
 					invalidate(): void;
 				};
-				const q = query.trim();
-				let next: SelectItem[];
-				if (q.length === 0) {
-					next = internal.items;
-				} else if (/^\d+$/.test(q)) {
-					// Pure number → match by benchlm rank, not name.
-					const wanted = Number(q);
-					next = internal.items.filter((it) => rankByValue.get(it.value) === wanted);
-				} else {
-					next = fuzzyFilter(internal.items, q, (it) => `${it.label} ${it.description ?? ""}`);
-					// Stable sort: ranked models (by rank asc) before unranked.
-					next = next
-						.map((it, i) => ({ it, i }))
-						.sort((a, b) => {
-							const ra = rankByValue.get(a.it.value) ?? Infinity;
-							const rb = rankByValue.get(b.it.value) ?? Infinity;
-							if (ra !== rb) return ra - rb;
-							return a.i - b.i;
-						})
-						.map(({ it }) => it);
-				}
+				const next = filterModelItems(internal.items, query, {
+					rankByValue,
+					searchTextByValue,
+					normalizedByValue,
+				});
 				internal.filteredItems = next;
 				internal.selectedIndex = 0;
 				internal.invalidate();