@xynogen/pix-models 0.2.0 → 0.2.2

package/README.md

@@ -4,7 +4,14 @@ Pi extension — enhanced `/models` picker with coding score/rank.
 
 ## What it does
 
-Registers a `/models` slash command that replaces Pi's built-in `/model` selector with a richer TUI picker. Each row shows the model id, context window, per-million-token cost, and a coding-focused score/rank (with star bar) when available. The list is sorted by coding score (best first), then alphabetically for unscored models. Fuzzy search filters the list as you type. Left/right changes the thinking level (`off` → `minimal` → `low` → `medium` → `high` → `xhigh`), with the effective level shown live in the picker header. Selecting a model switches the active model for the session. Model metadata is sourced from `~/.cache/pi/` via `pix-data`; the coding score/rank is computed locally from the modelgrep catalog (best = #1). Requires `@xynogen/pix-data` as a dependency.
+Registers a `/models` slash command — a richer TUI picker replacing Pi's built-in `/model` selector.
+
+- **Each row** — model id, context window, per-M-token cost, and a coding score/rank (star bar) when available.
+- **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.
+
+Model metadata comes from `~/.cache/pi/` via `pix-data`; the coding score/rank is computed locally from the modelgrep catalog (best = #1).
 
 ## Install
 

package/package.json

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

package/src/patch-builtin.test.ts

@@ -80,6 +80,17 @@ export const BUILTIN_SLASH_COMMANDS = [
 		expect(out).toContain('name: "login"');
 	});
 
+	it("removes /model from Pi's minified bundle chunk", () => {
+		// Real form from dist/bundle/chunks/*.js: no `export const`, no spaces,
+		// array followed immediately by other bundled statements.
+		const minified = `var x=1;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"}];import path11 from"node:path";`;
+		const out = stripBuiltinModelCommand(minified);
+		expect(out).not.toContain('name:"model"');
+		expect(out).toContain('name:"settings"');
+		expect(out).toContain('name:"scoped-models"');
+		expect(out).toContain('import path11 from"node:path"');
+	});
+
 	it("round-trips through disk", () => {
 		const dir = mkdtempSync(join(tmpdir(), "pix-patch-"));
 		const file = join(dir, "slash-commands.js");

package/src/patch-builtin.ts

@@ -2,79 +2,130 @@
  * patch-builtin.ts — strip Pi's built-in /model slash command at load time.
  *
  * Built-in commands can't be removed via the extension API, so we edit Pi's
- * compiled slash-commands.js directly. Done on every load: idempotent and
+ * compiled slash-command source directly. Done on every load: idempotent and
  * self-healing across Pi upgrades, so no manual repatch is ever needed.
  *
- * Resolution strategy (in order):
- *   1. Locate the `pi` binary via PATH → infer package root from its realpath.
- *      The binary is always at <pkg>/dist/cli.js so ../../ is the package root.
- *   2. Probe well-known global install locations (bun, npm).
- *   3. Fall back to createRequire against the extension's own node_modules
- *      (works when pi and the extension share the same install tree).
+ * Pi's build layout has moved over time. Two forms are in the wild:
+ *   - legacy:  <pkg>/dist/core/slash-commands.js  (readable, one entry/line)
+ *   - bundled: <pkg>/dist/bundle/chunks/chunk-*.js (minified, hash-named)
+ * The bundled chunk is what the runtime actually executes; the legacy
+ * dist/core/ file may still exist as dead output. We therefore prefer the
+ * chunk that really contains the `BUILTIN_SLASH_COMMANDS=[...]` assignment and
+ * 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.
  */
 
-import { execSync } from "node:child_process";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import {
+	accessSync,
+	constants,
+	existsSync,
+	readdirSync,
+	readFileSync,
+	realpathSync,
+	writeFileSync,
+} from "node:fs";
 import { createRequire } from "node:module";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-
-// 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[] {
-	const paths: string[] = [];
+import { delimiter, join, sep } from "node:path";
+
+/** Locate `pi` on PATH (a pure-JS `which`), returning its real (symlink-resolved) path. */
+function resolvePiBinary(): string | undefined {
+	for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+		if (!dir) continue;
+		const candidate = join(dir, "pi");
+		try {
+			accessSync(candidate, constants.X_OK);
+			return realpathSync(candidate);
+		} catch {}
+	}
+	return undefined;
+}
 
-	// 1. Resolve via the running `pi` binary → its realpath gives the dist dir.
-	try {
-		const piReal = execSync("realpath $(which pi)", {
-			encoding: "utf8",
-			stdio: ["pipe", "pipe", "pipe"],
-		}).trim();
-		if (piReal) {
-			// piReal = /.../pi-coding-agent/dist/cli.js → dist/ → ../dist/core/
-			const distCore = resolve(dirname(piReal), "core");
-			paths.push(join(distCore, "slash-commands.js"));
-		}
-	} catch {
-		// `pi` not on PATH or `which`/`realpath` unavailable — skip
+// The assignment appears once per build. `\s*=\s*\[` avoids the `.map(...)`
+// references and tolerates both `= [` (pretty) and `=[` (minified) spacing.
+const BUILTIN_COMMANDS_ARRAY = /BUILTIN_SLASH_COMMANDS\s*=\s*\[/;
+// Match one flat (non-nested) command object whose stable `name` is exactly
+// "model", plus an optional trailing comma. No line anchors, so it works for
+// both minified inline entries and pretty multi-line ones. The `["']model["']`
+// requires a closing quote right after `model`, so `models`/`scoped-models`
+// never match.
+const BUILTIN_MODEL_COMMAND = /\{(?=[^{}]*\bname\s*:\s*["']model["'])[^{}]*\},?/g;
+
+/** Infer pi-coding-agent package roots, most-specific first. */
+function packageRoots(): string[] {
+	const roots: string[] = [];
+	const pushRoot = (r: string | undefined) => {
+		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));
 	}
 
 	// 2. Well-known global install locations.
 	const home = homedir();
-	const globalRoots = [
+	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",
-	];
-	for (const root of globalRoots) {
-		paths.push(
-			join(root, "@earendil-works", "pi-coding-agent", "dist", "core", "slash-commands.js"),
-		);
+	]) {
+		pushRoot(join(root, "@earendil-works", "pi-coding-agent"));
 	}
 
-	// 3. Fallback: createRequire from this file (works when extension is co-installed).
+	// 3. Fallback: createRequire from this file (co-installed extension).
 	try {
 		const require = createRequire(import.meta.url);
 		const entry = require.resolve("@earendil-works/pi-coding-agent");
-		paths.push(resolve(dirname(entry), "core", "slash-commands.js"));
+		const idx = entry.indexOf(`${sep}dist${sep}`);
+		if (idx >= 0) pushRoot(entry.slice(0, idx));
 	} catch {
 		// local resolution failed — skip
 	}
 
-	return paths;
+	return roots;
 }
 
-/** Locate the host's compiled slash-commands.js, or null if not found. */
+/** Candidate source files for a package root — live bundle chunks first. */
+function candidateFiles(root: string): string[] {
+	const files: string[] = [];
+	const chunkDir = join(root, "dist", "bundle", "chunks");
+	try {
+		for (const name of readdirSync(chunkDir)) {
+			if (name.endsWith(".js")) files.push(join(chunkDir, name));
+		}
+	} catch {
+		// no bundle dir on this host — legacy layout below
+	}
+	// Legacy readable output, kept as a fallback for older Pi builds.
+	files.push(join(root, "dist", "core", "slash-commands.js"));
+	return files;
+}
+
+/** All candidate paths across all roots (exported for tests). */
+function candidatePaths(): string[] {
+	return packageRoots().flatMap(candidateFiles);
+}
+
+/**
+ * Locate the source file that actually declares BUILTIN_SLASH_COMMANDS.
+ * Chunk filenames are content hashes, so we confirm by contents, not by name.
+ */
 function findSlashCommandsFile(): string | null {
 	for (const p of candidatePaths()) {
-		if (existsSync(p)) return p;
+		if (!existsSync(p)) continue;
+		try {
+			if (BUILTIN_COMMANDS_ARRAY.test(readFileSync(p, "utf8"))) return p;
+		} catch {
+			// unreadable — skip
+		}
 	}
 	return null;
 }