@xynogen/pix-models 0.2.7 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 xynogen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -10,6 +10,7 @@ Registers a `/models` slash command — a richer TUI picker replacing Pi's built
 - **Sorting** — by coding score (best first), then alphabetically for unscored models. Fuzzy search filters as you type.
 - **Thinking level** — left/right cycles `off` → `minimal` → `low` → `medium` → `high` → `xhigh`, shown live in the header.
 - **Select** — switches the active model for the session.
+- **Per-project prefs** — every model / thinking change is saved with `defaultProvider`, `defaultModel`, `defaultThinkingLevel` in one file: `<project>/.pi/settings.json` for trusted projects (created on first change), otherwise `~/.pi/agent/settings.json`. Pi merges the project file over the user file, so other projects fall back to user defaults. Each save shows a short notice with the target file.
 
 Model metadata comes from `~/.cache/pi/` via `pix-data`; the coding score/rank is computed locally from the modelgrep catalog (best = #1).
 
@@ -19,22 +20,22 @@ Model metadata comes from `~/.cache/pi/` via `pix-data`; the coding score/rank i
 pi install npm:@xynogen/pix-models
 ```
 
-> Also included in [`@xynogen/pix-core`](https://www.npmjs.com/package/@xynogen/pix-core):
->
-> ```bash
-> pi install npm:@xynogen/pix-core
-> ```
+> Bundled in [`@xynogen/pix-core`](https://www.npmjs.com/package/@xynogen/pix-core). Install it alone only if you do not use pix-core.
 
 ## Full distro
 
-Source: [github.com/xynogen/pix-mono](https://github.com/xynogen/pix-mono)
-
-To install the complete pix suite (all packages + Pi itself):
+This package is part of [Pix](https://github.com/xynogen/pix-mono). The installer sets up Pi and the full distro. See [Install](https://github.com/xynogen/pix-mono#install) for the notes for each OS.
 
 ```bash
+# Linux / macOS
 curl -fsSL https://raw.githubusercontent.com/xynogen/pix-mono/main/scripts/install.sh | sh
 ```
 
+```powershell
+# Windows
+irm https://raw.githubusercontent.com/xynogen/pix-mono/main/scripts/install.ps1 | iex
+```
+
 ## License
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-models",
-	"version": "0.2.7",
+	"version": "0.3.0",
 	"description": "Pi extension — enhanced /models picker with BenchLM ranks",
 	"type": "module",
 	"main": "src/index.ts",
@@ -43,9 +43,9 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@xynogen/pix-data": "^0.5.0",
-		"@xynogen/pix-pretty": "^1.11.2",
-		"@xynogen/pix-runtime": "^0.10.0"
+		"@xynogen/pix-data": "^0.5.3",
+		"@xynogen/pix-pretty": "^1.29.0",
+		"@xynogen/pix-runtime": "^0.12.2"
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-coding-agent": "*",

package/src/models.ts

@@ -18,7 +18,7 @@ import {
 	SelectList,
 	visibleWidth,
 } from "@earendil-works/pi-tui";
-import { benchScoreColor, lookupBenchmark, lookupModelsDev } from "@xynogen/pix-data";
+import { benchScoreColor, formatCost, lookupBenchmark, lookupModelsDev } from "@xynogen/pix-data";
 import { icon } from "@xynogen/pix-pretty/icon-catalog";
 import {
 	frameModal,
@@ -31,6 +31,7 @@ import {
 import { dotJoin } from "@xynogen/pix-pretty/utils";
 import { SPINNER } from "@xynogen/pix-pretty/widget-format";
 import { patchOutBuiltinModelCommand } from "./patch-builtin";
+import { registerProjectPrefs } from "./project-prefs";
 
 // ─── Pure logic (exported for tests) ─────────────────────────────────────────
 
@@ -57,12 +58,10 @@ export function fmtCtx(n: number): string {
 	return `${Math.round(n / 1_000)}k`;
 }
 
+/** Table cell: pix-data formatCost, or an em dash when the price is unknown. */
 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;
-	if (i === 0 && o === 0) return "free";
-	return `${i.toFixed(2)}/${o.toFixed(2)}`;
+	return formatCost(entry.cost.input ?? 0, entry.cost.output ?? 0) ?? "\u2014";
 }
 
 export function benchStars(score: number | null | undefined): {
@@ -111,6 +110,16 @@ export function sortModels<T extends SortableModel>(models: T[]): T[] {
 	});
 }
 
+/** Short protocol tag for a classifier model's api. */
+export function classifierProtocol(api: string): string {
+	if (api.endsWith("system-one")) return "System One";
+	if (api === "llama-cpp-classify") return "llama.cpp classify";
+	return api;
+}
+
+/** Picker value prefix for classifier rows. They cannot be chat models. */
+export const CLASSIFIER_VALUE_PREFIX = "classifier:";
+
 /** Lowercase and strip all non-alphanumerics: "glm-5.2" → "glm52". */
 export function normalizeModelText(s: string): string {
 	return s.toLowerCase().replace(/[^a-z0-9]/g, "");
@@ -236,9 +245,23 @@ async function showEnhancedPicker(pi: ExtensionAPI, ctx: ExtensionContext): Prom
 	const registry = ctx.modelRegistry as unknown as {
 		refresh?: () => void;
 		getAvailable(): AvailableModels | Promise<AvailableModels>;
+		getAvailableOfType?: (type: "classifier") => Promise<
+			readonly {
+				provider: string;
+				id: string;
+				name?: string;
+				api: string;
+				contextWindow?: number;
+			}[]
+		>;
 	};
+	// Classifier models (System One etc.) answer typed questions, not chat.
+	// Show them in their own section so they are visible but never picked as the chat model.
+	const loadClassifiers = async () =>
+		(await registry.getAvailableOfType?.("classifier").catch(() => [])) ?? [];
 	registry.refresh?.();
 	let available = await registry.getAvailable();
+	let classifiers = await loadClassifiers();
 	if (available.length === 0) {
 		ctx.ui.notify("No models with configured auth.", "warning");
 		return;
@@ -300,15 +323,11 @@ async function showEnhancedPicker(pi: ExtensionAPI, ctx: ExtensionContext): Prom
 				theme.fg("text", key) + theme.fg("muted", ` ${action}`);
 			const guideSep = theme.fg("muted", " · ");
 
-			const buildPickerData = (sourceRows: Row[]) => {
-				const maxRankWidth = Math.max(
-					...sourceRows.map((row) => (row.localRank ? String(row.localRank).length : 0)),
-					1,
-				);
-				const maxCostWidth = Math.max(
-					...sourceRows.map((row) => fmtCost(row.dev).length),
-					"free".length,
-				);
+			const buildPickerData = (sourceRows: Row[], classifierModels: typeof classifiers) => {
+				// Classifier rows continue the numbering after the last ranked chat row.
+				const firstClassifierRank = Math.max(0, ...sourceRows.map((row) => row.localRank ?? 0)) + 1;
+				const lastRank = firstClassifierRank - 1 + classifierModels.length;
+				const maxRankWidth = Math.max(String(lastRank).length, 1);
 				const rankByValue = new Map<string, number>();
 				const searchTextByValue = new Map<string, string>();
 				const normalizedByValue = new Map<string, string>();
@@ -320,13 +339,25 @@ async function showEnhancedPicker(pi: ExtensionAPI, ctx: ExtensionContext): Prom
 					normalizedByValue.set(value, normalizeModelText(text));
 				}
 
-				const items: SelectItem[] = sourceRows.map(({ m, dev, bench, localRank }) => {
+				const classifierRows = classifierModels.map((c) => ({
+					m: c,
+					dev: lookupModelsDev(c.provider, c.id),
+					bench: lookupBenchmark(c.id),
+				}));
+				const maxCostWidth = Math.max(
+					...[...sourceRows, ...classifierRows].map((row) => fmtCost(row.dev).length),
+					"free".length,
+				);
+				const renderRow = (
+					m: { provider: string; id: string; contextWindow?: number },
+					dev: Row["dev"],
+					bench: Row["bench"],
+					rankPrefix: string,
+					value: string,
+					kindMark?: string,
+				): SelectItem => {
 					const isCurrent = current && m.provider === current.provider && m.id === current.id;
 					const marker = isCurrent ? theme.fg(accent, "▶") : " ";
-					const rankPrefix = localRank
-						? mute("#") +
-							theme.fg(benchScoreColor(bench?.overallScore), String(localRank).padEnd(maxRankWidth))
-						: mute("#") + mute("—".padEnd(maxRankWidth, " "));
 					const nameColor = bench ? benchScoreColor(bench.overallScore) : accent;
 					const label = `${marker} ${rankPrefix} ${theme.fg(nameColor, m.id)}`;
 					const ctxRaw = fmtCtx(
@@ -348,10 +379,34 @@ async function showEnhancedPicker(pi: ExtensionAPI, ctx: ExtensionContext): Prom
 						benchSeg = `⚡${theme.fg(scoreColor, String(score))} ${stars}`;
 					}
 					return {
-						value: `${m.provider}/${m.id}`,
+						value,
 						label,
-						description: dotJoin([mute(ctxRaw.padStart(4)), costSeg, benchSeg], mute),
+						description: dotJoin(
+							[mute(ctxRaw.padStart(4)), costSeg, [benchSeg, kindMark].filter(Boolean).join(" ")],
+							mute,
+						),
 					};
+				};
+
+				const items: SelectItem[] = sourceRows.map(({ m, dev, bench, localRank }) => {
+					const rankPrefix = localRank
+						? mute("#") +
+							theme.fg(benchScoreColor(bench?.overallScore), String(localRank).padEnd(maxRankWidth))
+						: mute("#") + mute("—".padEnd(maxRankWidth, " "));
+					return renderRow(m, dev, bench, rankPrefix, `${m.provider}/${m.id}`);
+				});
+				// Classifier rows: same columns and numbering. The symbol takes the
+				// empty score slot at the end of the row.
+				const classifierMark = theme.fg("warning", icon("model.classifier"));
+				classifierRows.forEach(({ m: c, dev, bench }, i) => {
+					const rank = firstClassifierRank + i;
+					const value = `${CLASSIFIER_VALUE_PREFIX}${c.provider}/${c.id}`;
+					const text = `${c.id} ${c.name ?? ""} classifier ${classifierProtocol(c.api)}`;
+					rankByValue.set(value, rank);
+					searchTextByValue.set(value, text);
+					normalizedByValue.set(value, normalizeModelText(text));
+					const rankPrefix = mute("#") + mute(String(rank).padEnd(maxRankWidth));
+					items.push(renderRow(c, dev, bench, rankPrefix, value, classifierMark));
 				});
 				return {
 					items,
@@ -362,7 +417,7 @@ async function showEnhancedPicker(pi: ExtensionAPI, ctx: ExtensionContext): Prom
 				};
 			};
 
-			let pickerData = buildPickerData(buildRows(available));
+			let pickerData = buildPickerData(buildRows(available), classifiers);
 			const currentIdx = current
 				? pickerData.items.findIndex((item) => item.value === `${current.provider}/${current.id}`)
 				: 0;
@@ -427,7 +482,8 @@ async function showEnhancedPicker(pi: ExtensionAPI, ctx: ExtensionContext): Prom
 						return;
 					}
 					available = refreshed;
-					pickerData = buildPickerData(buildRows(available));
+					classifiers = await loadClassifiers();
+					pickerData = buildPickerData(buildRows(available), classifiers);
 					listInternal.items = pickerData.items;
 					listInternal.maxVisible = Math.max(1, pickerData.items.length);
 					listInternal.layout = {
@@ -565,6 +621,15 @@ async function showEnhancedPicker(pi: ExtensionAPI, ctx: ExtensionContext): Prom
 
 	if (!result) return;
 
+	if (result.startsWith(CLASSIFIER_VALUE_PREFIX)) {
+		const ref = result.slice(CLASSIFIER_VALUE_PREFIX.length);
+		ctx.ui.notify(
+			`${ref} is a classifier model, not a chat model. Call it with models.classify() in codemode or ctx.modelRegistry.classify().`,
+			"info",
+		);
+		return;
+	}
+
 	// Apply selection
 	const [provider, ...rest] = result.split("/");
 	const id = rest.join("/");
@@ -574,8 +639,11 @@ async function showEnhancedPicker(pi: ExtensionAPI, ctx: ExtensionContext): Prom
 		return;
 	}
 	const ok = await pi.setModel(picked);
-	if (ok) ctx.ui.notify(`Switched to ${picked.name ?? picked.id}`, "info");
-	else ctx.ui.notify(`Failed to switch to ${picked.id}`, "error");
+	if (!ok) {
+		ctx.ui.notify(`Failed to switch to ${picked.id}`, "error");
+		return;
+	}
+	// Persistence happens in project-prefs.ts via the model_select event.
 }
 
 export default function modelPickerExtension(pi: ExtensionAPI) {
@@ -586,6 +654,7 @@ export default function modelPickerExtension(pi: ExtensionAPI) {
 	const handler = async (_args: unknown, ctx: ExtensionContext) => {
 		await showEnhancedPicker(pi, ctx);
 	};
+	registerProjectPrefs(pi);
 	pi.registerCommand("models", {
 		description: "Enhanced model picker — shows benchlm rank + score",
 		handler,

package/src/patch-builtin.ts

@@ -14,17 +14,46 @@
  * only fall back to dist/core/ for older hosts that lack a bundle dir.
  *
  * Package-root resolution (in order):
- *   1. `pi` binary via PATH → realpath → split at /dist/ to get the pkg root.
- *   2. Well-known global install locations (bun, npm).
- *   3. createRequire against the extension's own node_modules.
+ *   1. The running CLI script (`process.argv[1]`) → split at /dist/.
+ *   2. Pi managed install: `<PI_MANAGED_INSTALL_ROOT | agentDir/install>/
+ *      releases/<current-version>/node_modules/@earendil-works/pi-coding-agent`.
+ *   3. `pi` binary via PATH → realpath → split at /dist/ to get the pkg root.
+ *   4. Well-known global install locations (bun, npm).
+ *   5. createRequire against the extension's own node_modules.
  */
 
 import { existsSync, readdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { homedir } from "node:os";
 import { join, sep } from "node:path";
+import { agentDir, homeDir } from "@xynogen/pix-runtime/paths";
 import { findExecutableSync } from "@xynogen/pix-runtime/which";
 
+const PI_PACKAGE = ["@earendil-works", "pi-coding-agent"] as const;
+
+/** Package root before `/dist/` in a path, if any. */
+function rootBeforeDist(path: string | undefined): string | undefined {
+	if (!path) return undefined;
+	const idx = path.indexOf(`${sep}dist${sep}`);
+	return idx >= 0 ? path.slice(0, idx) : undefined;
+}
+
+/**
+ * Package root of Pi's managed install (`releases-v1` layout), or undefined
+ * when the install dir or its `current-version` file is absent.
+ */
+export function managedInstallRoot(
+	installRoot: string = process.env.PI_MANAGED_INSTALL_ROOT || join(agentDir(), "install"),
+): string | undefined {
+	try {
+		const version = readFileSync(join(installRoot, "current-version"), "utf8").trim();
+		if (!/^[0-9A-Za-z._+-]+$/.test(version) || version === "." || version === "..")
+			return undefined;
+		return join(installRoot, "releases", version, "node_modules", ...PI_PACKAGE);
+	} catch {
+		return undefined;
+	}
+}
+
 /** Locate `pi` on PATH, returning its real (symlink-resolved) path. */
 function resolvePiBinary(): string | undefined {
 	const found = findExecutableSync("pi");
@@ -53,30 +82,34 @@ function packageRoots(): string[] {
 		if (r && !roots.includes(r)) roots.push(r);
 	};
 
-	// 1. Resolve via the `pi` binary on PATH → realpath → strip at /dist/.
-	const piReal = resolvePiBinary();
-	if (piReal) {
-		const idx = piReal.indexOf(`${sep}dist${sep}`);
-		if (idx >= 0) pushRoot(piReal.slice(0, idx));
+	// 1. The CLI script this process is running (most specific).
+	try {
+		pushRoot(rootBeforeDist(process.argv[1] ? realpathSync(process.argv[1]) : undefined));
+	} catch {
+		pushRoot(rootBeforeDist(process.argv[1]));
 	}
 
-	// 2. Well-known global install locations.
-	const home = homedir();
+	// 2. Pi managed install (pi on PATH is a launcher shim there).
+	pushRoot(managedInstallRoot());
+
+	// 3. Resolve via the `pi` binary on PATH → realpath → strip at /dist/.
+	pushRoot(rootBeforeDist(resolvePiBinary()));
+
+	// 4. Well-known global install locations.
+	const home = homeDir();
 	for (const root of [
 		join(home, ".bun", "install", "global", "node_modules"),
 		join(home, ".npm-global", "lib", "node_modules"),
 		"/usr/local/lib/node_modules",
 		"/usr/lib/node_modules",
 	]) {
-		pushRoot(join(root, "@earendil-works", "pi-coding-agent"));
+		pushRoot(join(root, ...PI_PACKAGE));
 	}
 
-	// 3. Fallback: createRequire from this file (co-installed extension).
+	// 5. Fallback: createRequire from this file (co-installed extension).
 	try {
 		const require = createRequire(import.meta.url);
-		const entry = require.resolve("@earendil-works/pi-coding-agent");
-		const idx = entry.indexOf(`${sep}dist${sep}`);
-		if (idx >= 0) pushRoot(entry.slice(0, idx));
+		pushRoot(rootBeforeDist(require.resolve("@earendil-works/pi-coding-agent")));
 	} catch {
 		// local resolution failed — skip
 	}

package/src/project-prefs.ts

@@ -0,0 +1,99 @@
+/**
+ * project-prefs.ts — persist model/provider/thinking per project.
+ *
+ * All three prefs live together in Pi's own project settings file
+ * (`<cwd>/.pi/settings.json`). Pi deep-merges that file over the user-level
+ * `<agentDir>/settings.json` at startup, so projects without their own prefs
+ * fall back to the user defaults with no extra loader.
+ *
+ * Untrusted projects (Pi refuses to read their settings) and a cwd whose
+ * `.pi` IS the user config root (cwd === home) write the user-level file.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { showTransientMessage } from "@xynogen/pix-pretty/transient-error";
+import { getErrorMessage } from "@xynogen/pix-pretty/utils";
+import { writeFileAtomicSync } from "@xynogen/pix-runtime/atomic-write";
+import { agentDir, projectDir } from "@xynogen/pix-runtime/paths";
+
+export type ModelPrefs = {
+	defaultProvider?: string;
+	defaultModel?: string;
+	defaultThinkingLevel?: string;
+};
+
+export type PrefsTarget = { path: string; scope: "project" | "user" };
+
+/** Pick the settings file that should own this cwd's prefs. */
+export function prefsTarget(cwd: string, trusted: boolean, agent = agentDir()): PrefsTarget {
+	const userFile = join(agent, "settings.json");
+	const project = projectDir(resolve(cwd));
+	// cwd/.pi is the parent of the agent dir → "project" file would be ~/.pi/settings.json,
+	// which is confusing and not a real project. Use the user file instead.
+	if (!trusted || resolve(project) === resolve(dirname(agent))) {
+		return { path: userFile, scope: "user" };
+	}
+	return { path: join(project, "settings.json"), scope: "project" };
+}
+
+/** Merge `prefs` into the JSON settings file at `path`. Returns true if it changed. */
+export function writePrefs(path: string, prefs: ModelPrefs): boolean {
+	let current: Record<string, unknown> = {};
+	if (existsSync(path)) {
+		const raw = readFileSync(path, "utf8").replace(/^\uFEFF/, "");
+		if (raw.trim()) {
+			const parsed: unknown = JSON.parse(raw);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+				current = parsed as Record<string, unknown>;
+			}
+		}
+	}
+	let changed = false;
+	for (const [key, value] of Object.entries(prefs)) {
+		if (value !== undefined && current[key] !== value) {
+			current[key] = value;
+			changed = true;
+		}
+	}
+	if (changed) writeFileAtomicSync(path, `${JSON.stringify(current, null, 2)}\n`, 0o644);
+	return changed;
+}
+
+/** Save prefs for ctx.cwd and surface where they went. */
+export function savePrefs(
+	ctx: ExtensionContext,
+	prefs: ModelPrefs,
+	label: string,
+): PrefsTarget | undefined {
+	const target = prefsTarget(ctx.cwd, ctx.isProjectTrusted());
+	try {
+		if (writePrefs(target.path, prefs) && ctx.hasUI) {
+			const where = target.scope === "project" ? ".pi/settings.json" : "user settings.json";
+			showTransientMessage(ctx.ui, `${label} saved to ${where}`, "info");
+		}
+		return target;
+	} catch (err) {
+		if (ctx.hasUI) {
+			const msg = getErrorMessage(err);
+			showTransientMessage(ctx.ui, `Failed to save ${label}: ${msg}`, "warning");
+		}
+		return undefined;
+	}
+}
+
+/** Persist every user-driven model / thinking change to the owning settings file. */
+export function registerProjectPrefs(pi: ExtensionAPI): void {
+	pi.on("model_select", (event, ctx) => {
+		// "restore" = session resume; not a user choice.
+		if (event.source === "restore") return;
+		const { provider, id } = event.model;
+		savePrefs(ctx, { defaultProvider: provider, defaultModel: id }, `Model ${provider}/${id}`);
+	});
+	pi.on("thinking_level_select", (event, ctx) => {
+		// Non-reasoning models force "off"; don't let that clobber the saved preference.
+		if (!ctx.model?.reasoning) return;
+		savePrefs(ctx, { defaultThinkingLevel: event.level }, `Thinking ${event.level}`);
+	});
+}