@xynogen/pix-models 0.1.16 → 0.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-models",
-	"version": "0.1.16",
+	"version": "0.1.18",
 	"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();

package/src/patch-builtin.test.ts

@@ -2,19 +2,7 @@ import { describe, expect, it } from "bun:test";
 import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 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)" },';
-
-function escapeRegExp(text: string): string {
-	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-function patchSource(source: string): string {
-	if (!source.includes(MODEL_COMMAND_LINE)) return source;
-	return source.replace(new RegExp(`[ \\t]*${escapeRegExp(MODEL_COMMAND_LINE)}\\n?`), "");
-}
+import { stripBuiltinModelCommand } from "./patch-builtin.ts";
 
 const UNPATCHED = `export const BUILTIN_SLASH_COMMANDS = [
     { name: "settings", description: "Open settings menu" },
@@ -23,40 +11,80 @@ const UNPATCHED = `export const BUILTIN_SLASH_COMMANDS = [
 ];
 `;
 
+const CURRENT_PI = `export const BUILTIN_SLASH_COMMANDS = [
+    { name: "settings", description: "Open settings menu" },
+    { name: "model", description: "Select model (opens selector UI)", argumentHint: "<provider/model>" },
+    { name: "scoped-models", description: "Enable/disable models for Ctrl+P cycling" },
+];
+`;
+
 describe("patch-builtin /model removal", () => {
 	it("removes the built-in /model line and keeps neighbors", () => {
-		const out = patchSource(UNPATCHED);
+		const out = stripBuiltinModelCommand(UNPATCHED);
 		expect(out).not.toContain('name: "model"');
 		expect(out).toContain('name: "settings"');
 		expect(out).toContain('name: "login"');
 	});
 
 	it("is idempotent — second pass is a no-op", () => {
-		const once = patchSource(UNPATCHED);
-		const twice = patchSource(once);
+		const once = stripBuiltinModelCommand(UNPATCHED);
+		const twice = stripBuiltinModelCommand(once);
 		expect(twice).toBe(once);
 	});
 
 	it("leaves an already-clean file untouched", () => {
 		const clean = `export const X = [\n    { name: "login" },\n];\n`;
-		expect(patchSource(clean)).toBe(clean);
+		expect(stripBuiltinModelCommand(clean)).toBe(clean);
 	});
 
 	it("does not strip the plural /models entry", () => {
-		const withPlural = `[
+		const withPlural = `export const BUILTIN_SLASH_COMMANDS = [
     { name: "models", description: "Enhanced picker" },
     { name: "model", description: "Select model (opens selector UI)" },
-]`;
-		const out = patchSource(withPlural);
+];`;
+		const out = stripBuiltinModelCommand(withPlural);
 		expect(out).toContain('name: "models"');
 		expect(out).not.toContain('{ name: "model", description');
 	});
 
+	it("removes Pi's current /model form with an argument hint", () => {
+		const out = stripBuiltinModelCommand(CURRENT_PI);
+		expect(out).not.toContain('name: "model"');
+		expect(out).toContain('name: "settings"');
+		expect(out).toContain('name: "scoped-models"');
+	});
+
+	it("does not alter /model text outside the built-in command array", () => {
+		const source = `const source = '{ name: "model" }';
+export const BUILTIN_SLASH_COMMANDS = [
+    { name: "settings", description: "Open settings menu" },
+];
+`;
+		expect(stripBuiltinModelCommand(source)).toBe(source);
+	});
+
+	it("removes a multi-line /model command without touching adjacent entries", () => {
+		const multiline = `export const BUILTIN_SLASH_COMMANDS = [
+    { name: "settings", description: "Open settings menu" },
+    {
+        name: "model",
+        description: "Select model (opens selector UI)",
+        argumentHint: "<provider/model>",
+    },
+    { name: "login", description: "Configure provider authentication" },
+];
+`;
+		const out = stripBuiltinModelCommand(multiline);
+		expect(out).not.toContain('name: "model"');
+		expect(out).toContain('name: "settings"');
+		expect(out).toContain('name: "login"');
+	});
+
 	it("round-trips through disk", () => {
 		const dir = mkdtempSync(join(tmpdir(), "pix-patch-"));
 		const file = join(dir, "slash-commands.js");
-		writeFileSync(file, UNPATCHED, "utf8");
-		writeFileSync(file, patchSource(readFileSync(file, "utf8")), "utf8");
+		writeFileSync(file, CURRENT_PI, "utf8");
+		writeFileSync(file, stripBuiltinModelCommand(readFileSync(file, "utf8")), "utf8");
 		expect(readFileSync(file, "utf8")).not.toContain('name: "model"');
 	});
 });

package/src/patch-builtin.ts

@@ -19,7 +19,12 @@ 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)" },';
+// Pi has added fields to this object over time (for example, `argumentHint` in
+// v0.80). Match the command entry by its stable `name`, rather than an exact
+// serialized line, while limiting the match to a single non-nested object.
+const BUILTIN_COMMANDS_ARRAY = /export\s+const\s+BUILTIN_SLASH_COMMANDS[^=]*=\s*\[/;
+const BUILTIN_MODEL_COMMAND =
+	/^[ \t]*\{(?=[^{}]*\bname\s*:\s*["']model["'])[^{}]*\},?[ \t]*(?:\r?\n|$)/gm;
 
 /** Candidate slash-commands.js paths, most-specific first. */
 function candidatePaths(): string[] {
@@ -89,10 +94,8 @@ export function patchOutBuiltinModelCommand(): void {
 		return;
 	}
 
-	if (!source.includes(MODEL_COMMAND_LINE)) return; // already patched
-
-	const patched = source.replace(new RegExp(`[ \\t]*${escapeRegExp(MODEL_COMMAND_LINE)}\\n?`), "");
-	if (patched === source) return;
+	const patched = stripBuiltinModelCommand(source);
+	if (patched === source) return; // already patched, or host format is unknown
 
 	try {
 		writeFileSync(file, patched, "utf8");
@@ -101,8 +104,25 @@ export function patchOutBuiltinModelCommand(): void {
 	}
 }
 
-function escapeRegExp(text: string): string {
-	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+ * Remove Pi's built-in `/model` entry from compiled slash-command source.
+ *
+ * The command objects are static, flat literals. Matching the entry's `name`
+ * tolerates added properties and line wrapping without touching `/models`.
+ */
+export function stripBuiltinModelCommand(source: string): string {
+	const array = BUILTIN_COMMANDS_ARRAY.exec(source);
+	if (!array || array.index === undefined) return source;
+
+	const open = array.index + array[0].lastIndexOf("[");
+	const close = source.indexOf("];", open);
+	if (close < 0) return source;
+
+	const entries = source.slice(open + 1, close);
+	const patchedEntries = entries.replace(BUILTIN_MODEL_COMMAND, "");
+	if (patchedEntries === entries) return source;
+
+	return `${source.slice(0, open + 1)}${patchedEntries}${source.slice(close)}`;
 }
 
 // Export for tests