@xynogen/pix-models 0.1.17 → 0.1.19

package/package.json

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

package/src/models.test.ts

@@ -7,8 +7,56 @@ import {
 	type ModelSearchLookup,
 	normalizeModelText,
 	sortModels,
+	stepEffectiveThinkingLevel,
+	stepThinkingLevel,
+	THINKING_LEVELS,
 } from "./models.ts";
 
+describe("stepThinkingLevel", () => {
+	it("steps up one notch", () => {
+		expect(stepThinkingLevel("low", 1)).toBe("medium");
+		expect(stepThinkingLevel("off", 1)).toBe("minimal");
+	});
+	it("steps down one notch", () => {
+		expect(stepThinkingLevel("medium", -1)).toBe("low");
+		expect(stepThinkingLevel("xhigh", -1)).toBe("high");
+	});
+	it("clamps at the low end (no wrap)", () => {
+		expect(stepThinkingLevel("off", -1)).toBe("off");
+	});
+	it("clamps at the high end (no wrap)", () => {
+		expect(stepThinkingLevel("xhigh", 1)).toBe("xhigh");
+	});
+	it("falls back to a medium-anchored step for unknown input", () => {
+		expect(stepThinkingLevel("bogus", 1)).toBe("high");
+		expect(stepThinkingLevel("", -1)).toBe("low");
+	});
+	it("exposes the six canonical levels ascending", () => {
+		expect(THINKING_LEVELS).toEqual(["off", "minimal", "low", "medium", "high", "xhigh"]);
+	});
+	it("can walk the full ladder up and back down", () => {
+		let lvl: string = "off";
+		for (let i = 0; i < 10; i++) lvl = stepThinkingLevel(lvl, 1);
+		expect(lvl).toBe("xhigh");
+		for (let i = 0; i < 10; i++) lvl = stepThinkingLevel(lvl, -1);
+		expect(lvl).toBe("off");
+	});
+});
+
+describe("stepEffectiveThinkingLevel", () => {
+	it("skips levels that clamp back to the current level", () => {
+		const clamp = (requested: string) => {
+			if (requested === "minimal" || requested === "low") return "off";
+			return requested;
+		};
+		expect(stepEffectiveThinkingLevel("off", 1, clamp)).toBe("medium");
+	});
+
+	it("stays at an endpoint when every farther request clamps back", () => {
+		expect(stepEffectiveThinkingLevel("high", 1, () => "high")).toBe("high");
+	});
+});
+
 describe("fmtCtx", () => {
 	it("formats 0 as 0", () => expect(fmtCtx(0)).toBe("0"));
 	it("formats small numbers as-is", () => expect(fmtCtx(512)).toBe("512"));

package/src/models.ts

@@ -12,6 +12,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import {
 	fuzzyFilter,
 	Input,
+	Key,
 	matchesKey,
 	type SelectItem,
 	SelectList,
@@ -92,6 +93,49 @@ export function normalizeModelText(s: string): string {
 	return s.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
 
+// ─── Thinking level control ──────────────────────────────────────────────────
+
+/**
+ * Canonical thinking levels, ascending. Shift+←/→ in the picker steps through this
+ * list; pi.setThinkingLevel() clamps to what the active model actually supports,
+ * so visiting an unsupported rung is harmless (it lands on the nearest allowed).
+ */
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+
+export type ThinkingLevelName = (typeof THINKING_LEVELS)[number];
+
+/**
+ * Step the thinking level one notch. `dir` is -1 (←) or +1 (→). Clamps at the
+ * ends (no wraparound) so ← at "off" stays "off" and → at "xhigh" stays "xhigh".
+ * Unknown input falls back to "medium" as a neutral midpoint.
+ */
+export function stepThinkingLevel(current: string, dir: -1 | 1): ThinkingLevelName {
+	const idx = THINKING_LEVELS.indexOf(current as ThinkingLevelName);
+	const base = idx === -1 ? THINKING_LEVELS.indexOf("medium") : idx;
+	const next = Math.min(THINKING_LEVELS.length - 1, Math.max(0, base + dir));
+	return THINKING_LEVELS[next] as ThinkingLevelName;
+}
+
+/**
+ * Move one effective notch in a direction after the host clamps unsupported
+ * levels. Keeps trying farther rungs until the model's resolved level changes.
+ */
+export function stepEffectiveThinkingLevel(
+	current: string,
+	dir: -1 | 1,
+	apply: (level: ThinkingLevelName) => string,
+): ThinkingLevelName {
+	let candidate = stepThinkingLevel(current, dir);
+	while (candidate !== current) {
+		const effective = apply(candidate) as ThinkingLevelName;
+		if (effective !== current) return effective;
+		const farther = stepThinkingLevel(candidate, dir);
+		if (farther === candidate) break;
+		candidate = farther;
+	}
+	return current as ThinkingLevelName;
+}
+
 export type ModelSearchLookup = {
 	/** benchlm local rank per item value (ranked models only). */
 	rankByValue: Map<string, number>;
@@ -227,7 +271,7 @@ async function showEnhancedPicker(pi: ExtensionAPI, ctx: ExtensionContext): Prom
 	// items built inside the custom() factory so we have theme access for colors
 
 	const result = await ctx.ui.custom<string | null>(
-		(_tui, theme, _kb, done) => {
+		(tui, theme, _kb, done) => {
 			const accent = "accent";
 
 			// Find max rank width across all benchmarked rows for # padding
@@ -365,6 +409,27 @@ async function showEnhancedPicker(pi: ExtensionAPI, ctx: ExtensionContext): Prom
 				internal.invalidate();
 			};
 
+			// Live thinking-level readout. Shift+←/→ mutates the session immediately via
+			// pi.setThinkingLevel(); we mirror pi.getThinkingLevel() so the header
+			// reflects the clamped result (model may not support every rung).
+			//
+			// `local` shadows the level so the header updates even on builds/contexts
+			// where pi.getThinkingLevel() lags or is unavailable inside the overlay.
+			// We seed it from the getter, then advance it in lock-step with each
+			// setThinkingLevel() call and reconcile back to the getter when present.
+			let localLevel = pi.getThinkingLevel?.() ?? "";
+			const thinkLine = () => {
+				const live = pi.getThinkingLevel?.();
+				const resolved = live ?? localLevel;
+				const label = resolved || "—";
+				const coloredLabel = resolved
+					? theme.getThinkingBorderColor(resolved)(label)
+					: theme.fg("dim", label);
+				return (
+					theme.fg("muted", "Thinking: ") + coloredLabel + theme.fg("dim", "  (shift+←/→ adjust)")
+				);
+			};
+
 			return {
 				render(w: number) {
 					const mw = modalWidth(w);
@@ -372,10 +437,14 @@ async function showEnhancedPicker(pi: ExtensionAPI, ctx: ExtensionContext): Prom
 					const lines: string[] = [
 						theme.fg(accent, theme.bold(`${icon("picker.model")}  Select model`)),
 						theme.fg("dim", "context · pricing · coding rank & score from modelgrep.com"),
+						thinkLine(),
 						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 · shift+←/→ thinking · enter select · esc cancel",
+						),
 					];
 					return frameLines({
 						width: mw,
@@ -393,7 +462,23 @@ async function showEnhancedPicker(pi: ExtensionAPI, ctx: ExtensionContext): Prom
 					// SelectList uses. Arrows arrive as named keys ("up"/"down"),
 					// not raw escape sequences, so string-equality checks fail.
 					const isNav = matchesKey(data, "up") || matchesKey(data, "down");
-					if (isNav || matchesKey(data, "enter")) {
+					// Shift+←/→ tunes the ACTIVE session model's thinking level without
+					// stealing plain ←/→ cursor movement from search. setThinkingLevel clamps
+					// to model capability, so unsupported rungs land on the nearest allowed.
+					let dir: -1 | 1 | 0 = 0;
+					if (matchesKey(data, Key.shift(Key.left))) dir = -1;
+					else if (matchesKey(data, Key.shift(Key.right))) dir = 1;
+					if (dir !== 0) {
+						const cur = pi.getThinkingLevel?.() || localLevel || "medium";
+						localLevel = stepEffectiveThinkingLevel(cur, dir, (candidate) => {
+							pi.setThinkingLevel(candidate);
+							return pi.getThinkingLevel();
+						});
+						// setThinkingLevel doesn't repaint this overlay, so force a render
+						// now — otherwise the header shows a stale level until the next key.
+						tui.requestRender();
+						return;
+					} else if (isNav || matchesKey(data, "enter")) {
 						list.handleInput?.(data);
 					} else if (matchesKey(data, "escape")) {
 						done(null);

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