@xynogen/pix-models 0.1.15 → 0.1.17

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-models",
-	"version": "0.1.15",
+	"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"));
@@ -16,8 +24,7 @@ describe("fmtCtx", () => {
 });
 
 describe("fmtCost", () => {
-	it("returns — for undefined entry", () =>
-		expect(fmtCost(undefined)).toBe("—"));
+	it("returns — for undefined entry", () => expect(fmtCost(undefined)).toBe("—"));
 	it("returns — when no cost field", () => expect(fmtCost({})).toBe("—"));
 	it("returns free when both 0", () => {
 		expect(fmtCost({ cost: { input: 0, output: 0 } })).toBe("free");
@@ -118,11 +125,127 @@ describe("sortModels", () => {
 			{ provider: "a", id: "m4", name: "Delta", score: 60, tier: 0 },
 		];
 		const sorted = sortModels(mixed);
-		expect(sorted.map((m) => m.name)).toEqual([
-			"Alpha",
-			"Delta",
-			"Beta",
-			"Gamma",
-		]);
+		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

@@ -8,10 +8,7 @@
  * Sorted by benchlm rank when available (best first), then alphabetical.
  */
 
-import type {
-	ExtensionAPI,
-	ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
 	fuzzyFilter,
 	Input,
@@ -20,11 +17,7 @@ import {
 	SelectList,
 	visibleWidth,
 } from "@earendil-works/pi-tui";
-import {
-	benchScoreColor,
-	lookupBenchmark,
-	lookupModelsDev,
-} from "@xynogen/pix-data";
+import { benchScoreColor, lookupBenchmark, lookupModelsDev } from "@xynogen/pix-data";
 import { icon } from "@xynogen/pix-pretty/icon-catalog";
 import { frameLines, modalWidth } from "@xynogen/pix-pretty/modal-frame";
 import { patchOutBuiltinModelCommand } from "./patch-builtin";
@@ -40,9 +33,7 @@ export function fmtCtx(n: number): string {
 	return `${Math.round(n / 1_000)}k`;
 }
 
-export function fmtCost(
-	entry: { cost?: { input?: number; output?: number } } | undefined,
-): string {
+export function fmtCost(entry: { cost?: { input?: number; output?: number } } | undefined): string {
 	if (!entry?.cost) return "\u2014";
 	const i = entry.cost.input ?? 0;
 	const o = entry.cost.output ?? 0;
@@ -96,10 +87,69 @@ export function sortModels<T extends SortableModel>(models: T[]): T[] {
 	});
 }
 
-async function showEnhancedPicker(
-	pi: ExtensionAPI,
-	ctx: ExtensionContext,
-): Promise<void> {
+/** 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
 	// reads whatever `this.models` was last loaded into — which, depending on
@@ -182,9 +232,7 @@ async function showEnhancedPicker(
 
 			// Find max rank width across all benchmarked rows for # padding
 			const maxRankWidth = Math.max(
-				...dedupedRows.map((r) =>
-					r.localRank ? String(r.localRank).length : 0,
-				),
+				...dedupedRows.map((r) => (r.localRank ? String(r.localRank).length : 0)),
 				1,
 			);
 
@@ -198,84 +246,85 @@ async function showEnhancedPicker(
 				if (localRank) rankByValue.set(`${m.provider}/${m.id}`, localRank);
 			}
 
-			const items: SelectItem[] = dedupedRows.map(
-				({ m, dev, bench, localRank }) => {
-					const isCurrent =
-						current && m.provider === current.provider && m.id === current.id;
-
-					// Label: marker + rank cell + accent-colored model name.
-					// Ranked models show muted '#' + colored rank. Unranked (no
-					// modelgrep entry) show a muted em-dash sized to the rank
-					// column, so the model name aligns across rows.
-					const marker = isCurrent ? theme.fg(accent, "▶") : " ";
-					let rankPrefix: string;
-					if (localRank) {
-						const rankStr = String(localRank).padEnd(maxRankWidth);
-						// Color rank by the model's bench score (same scale as ⚡score),
-						// not by list position — keeps the two colors consistent.
-						const rankColor = benchScoreColor(bench?.overallScore);
-						rankPrefix = mute("#") + theme.fg(rankColor, rankStr);
-					} else {
-						// Width = "#" + maxRankWidth chars (e.g. "#   " or "#——" for 2-digit ranks).
-						const dash = "—".padEnd(maxRankWidth, " ");
-						rankPrefix = mute("#") + mute(dash);
-					}
-					// Display model id only; m.provider is routing provider, not part of id.
-					const idColored = theme.fg(accent, m.id);
-					const label = `${marker} ${rankPrefix} ${idColored}`;
-
-					// Description: ctx · cost · score stars
-					// Colors: ctx muted · cost success (free muted) · score+stars warning
-					const ctxRaw = fmtCtx(dev?.limit?.context ?? 0);
-					const ctxStr = mute(ctxRaw.padStart(4));
-					const rawCost = fmtCost(dev);
-					let costSeg: string;
-					if (rawCost === "—") {
-						costSeg = theme.fg("dim", "—".padEnd(10));
-					} else if (rawCost === "free") {
-						costSeg = mute("free".padEnd(10));
-					} else {
-						costSeg = theme.fg("success", rawCost.padEnd(10));
-					}
-					let benchSeg = "";
-					if (bench) {
-						const score = bench.overallScore ?? "?";
-						const s = bench.overallScore;
-						const scoreColor = benchScoreColor(s);
-						let filled = 1;
-						if (typeof s === "number") {
-							if (s >= 90) filled = 5;
-							else if (s >= 80) filled = 4;
-							else if (s >= 70) filled = 3;
-							else if (s >= 50) filled = 2;
-						}
-						const starBar =
-							theme.fg(scoreColor, "★".repeat(filled)) +
-							mute("☆".repeat(5 - filled));
-						benchSeg = `⚡${theme.fg(scoreColor, String(score))} ${starBar}`;
+			// 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;
+
+				// Label: marker + rank cell + accent-colored model name.
+				// Ranked models show muted '#' + colored rank. Unranked (no
+				// modelgrep entry) show a muted em-dash sized to the rank
+				// column, so the model name aligns across rows.
+				const marker = isCurrent ? theme.fg(accent, "▶") : " ";
+				let rankPrefix: string;
+				if (localRank) {
+					const rankStr = String(localRank).padEnd(maxRankWidth);
+					// Color rank by the model's bench score (same scale as ⚡score),
+					// not by list position — keeps the two colors consistent.
+					const rankColor = benchScoreColor(bench?.overallScore);
+					rankPrefix = mute("#") + theme.fg(rankColor, rankStr);
+				} else {
+					// Width = "#" + maxRankWidth chars (e.g. "#   " or "#——" for 2-digit ranks).
+					const dash = "—".padEnd(maxRankWidth, " ");
+					rankPrefix = mute("#") + mute(dash);
+				}
+				// Display model id only; m.provider is routing provider, not part of id.
+				const idColored = theme.fg(accent, m.id);
+				const label = `${marker} ${rankPrefix} ${idColored}`;
+
+				// Description: ctx · cost · score stars
+				// Colors: ctx muted · cost success (free muted) · score+stars warning
+				const ctxRaw = fmtCtx(dev?.limit?.context ?? 0);
+				const ctxStr = mute(ctxRaw.padStart(4));
+				const rawCost = fmtCost(dev);
+				let costSeg: string;
+				if (rawCost === "—") {
+					costSeg = theme.fg("dim", "—".padEnd(10));
+				} else if (rawCost === "free") {
+					costSeg = mute("free".padEnd(10));
+				} else {
+					costSeg = theme.fg("success", rawCost.padEnd(10));
+				}
+				let benchSeg = "";
+				if (bench) {
+					const score = bench.overallScore ?? "?";
+					const s = bench.overallScore;
+					const scoreColor = benchScoreColor(s);
+					let filled = 1;
+					if (typeof s === "number") {
+						if (s >= 90) filled = 5;
+						else if (s >= 80) filled = 4;
+						else if (s >= 70) filled = 3;
+						else if (s >= 50) filled = 2;
 					}
-					const desc = [ctxStr, costSeg, benchSeg].filter(Boolean).join(sep);
+					const starBar = theme.fg(scoreColor, "★".repeat(filled)) + mute("☆".repeat(5 - filled));
+					benchSeg = `⚡${theme.fg(scoreColor, String(score))} ${starBar}`;
+				}
+				const desc = [ctxStr, costSeg, benchSeg].filter(Boolean).join(sep);
 
-					return {
-						value: `${m.provider}/${m.id}`,
-						label,
-						description: desc,
-					};
-				},
-			);
+				return {
+					value: `${m.provider}/${m.id}`,
+					label,
+					description: desc,
+				};
+			});
 
 			const currentIdx = current
-				? items.findIndex(
-						(it) => it.value === `${current.provider}/${current.id}`,
-					)
+				? items.findIndex((it) => it.value === `${current.provider}/${current.id}`)
 				: 0;
 
 			// Widest label (visible width, ANSI-stripped) so the model name
 			// column never truncates to "…". Add gap headroom.
-			const widestLabel = items.reduce(
-				(w, it) => Math.max(w, visibleWidth(it.label)),
-				0,
-			);
+			const widestLabel = items.reduce((w, it) => Math.max(w, visibleWidth(it.label)), 0);
 
 			const search = new Input();
 			const list = new SelectList(
@@ -306,33 +355,11 @@ async function showEnhancedPicker(
 					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();
@@ -343,21 +370,12 @@ async function showEnhancedPicker(
 					const mw = modalWidth(w);
 					const inner = mw - 4; // CHROME = 2 border + 2 padding
 					const lines: string[] = [
-						theme.fg(
-							accent,
-							theme.bold(`${icon("picker.model")}  Select model`),
-						),
-						theme.fg(
-							"dim",
-							"context · pricing · coding rank & score from modelgrep.com",
-						),
+						theme.fg(accent, theme.bold(`${icon("picker.model")}  Select model`)),
+						theme.fg("dim", "context · pricing · coding rank & score from modelgrep.com"),
 						theme.fg("muted", "Search:"),
 						...search.render(inner),
 						...list.render(inner),
-						theme.fg(
-							"dim",
-							"fuzzy search · ↑↓ navigate · enter select · esc cancel",
-						),
+						theme.fg("dim", "fuzzy search · ↑↓ navigate · enter select · esc cancel"),
 					];
 					return frameLines({
 						width: mw,

package/src/patch-builtin.test.ts

@@ -5,8 +5,7 @@ import { join } from "node:path";
 
 // Pure replacement tested in isolation (the exported fn resolves the host
 // package, which isn't present in the test sandbox).
-const MODEL_COMMAND_LINE =
-	'{ name: "model", description: "Select model (opens selector UI)" },';
+const MODEL_COMMAND_LINE = '{ name: "model", description: "Select model (opens selector UI)" },';
 
 function escapeRegExp(text: string): string {
 	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -14,10 +13,7 @@ function escapeRegExp(text: string): string {
 
 function patchSource(source: string): string {
 	if (!source.includes(MODEL_COMMAND_LINE)) return source;
-	return source.replace(
-		new RegExp(`[ \\t]*${escapeRegExp(MODEL_COMMAND_LINE)}\\n?`),
-		"",
-	);
+	return source.replace(new RegExp(`[ \\t]*${escapeRegExp(MODEL_COMMAND_LINE)}\\n?`), "");
 }
 
 const UNPATCHED = `export const BUILTIN_SLASH_COMMANDS = [

package/src/patch-builtin.ts

@@ -19,8 +19,7 @@ import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 
-const MODEL_COMMAND_LINE =
-	'{ name: "model", description: "Select model (opens selector UI)" },';
+const MODEL_COMMAND_LINE = '{ name: "model", description: "Select model (opens selector UI)" },';
 
 /** Candidate slash-commands.js paths, most-specific first. */
 function candidatePaths(): string[] {
@@ -51,14 +50,7 @@ function candidatePaths(): string[] {
 	];
 	for (const root of globalRoots) {
 		paths.push(
-			join(
-				root,
-				"@earendil-works",
-				"pi-coding-agent",
-				"dist",
-				"core",
-				"slash-commands.js",
-			),
+			join(root, "@earendil-works", "pi-coding-agent", "dist", "core", "slash-commands.js"),
 		);
 	}
 
@@ -99,10 +91,7 @@ export function patchOutBuiltinModelCommand(): void {
 
 	if (!source.includes(MODEL_COMMAND_LINE)) return; // already patched
 
-	const patched = source.replace(
-		new RegExp(`[ \\t]*${escapeRegExp(MODEL_COMMAND_LINE)}\\n?`),
-		"",
-	);
+	const patched = source.replace(new RegExp(`[ \\t]*${escapeRegExp(MODEL_COMMAND_LINE)}\\n?`), "");
 	if (patched === source) return;
 
 	try {