@xynogen/pix-data 0.1.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

@@ -0,0 +1,31 @@
+# pix-data
+
+Pi coding agent extension — shared model data layer. Fetches and caches [models.dev](https://models.dev) metadata and [BenchLM](https://benchlm.ai) leaderboard data to `~/.cache/pi/` on session start, so other extensions can read them synchronously without redundant network calls.
+
+## What's included
+
+| Export | Description |
+|---|---|
+| `modelsDev` | `DataSource<ModelsDevApi>` — models.dev metadata (context, cost, modalities). TTL 24h → `~/.cache/pi/models.json` |
+| `benchmark` | `DataSource<BenchmarkEntry[]>` — BenchLM leaderboard (rank, score, pricing). TTL 24h → `~/.cache/pi/benchlm.json` |
+| `DataSource` | Generic cached data source class |
+| `CACHE_DIR` | Resolved cache directory (`~/.cache/pi`) |
+| `buildModelsDevIndex` | Build a lookup `Map` from a `ModelsDevApi` response |
+| `lookupInIndex` | Fuzzy-match a router model id against the index |
+| `lookupModelsDev` | Sync lookup by provider + id from in-memory cache |
+| `lookupBenchmark` | Fuzzy lookup a model by name from BenchLM cache |
+| `fetchModelsDevIndex` | Async — fetch models.dev and return built index |
+
+## Install
+
+```bash
+pi install git:github.com/xynogen/pix-data
+```
+
+## How it works
+
+On session start the extension fires two parallel background fetches (`modelsDev.get()` + `benchmark.get()`). If the cache is fresh the fetches are skipped. Both cache files live in `~/.cache/pi/` — any Pi extension using the same `DataSource` + cache paths will share data automatically.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@xynogen/pix-data",
+  "version": "0.1.0",
+  "description": "Pi extension — shared model data layer (models.dev + BenchLM), cached at ~/.cache/pi",
+  "type": "module",
+  "main": "src/index.ts",
+  "scripts": {
+    "test": "bun test"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": ["src/index.ts"]
+  },
+  "keywords": ["pi", "pi-package", "pi-extension", "models.dev", "benchlm"],
+  "author": "xynogen",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xynogen/pix-mono.git",
+    "directory": "packages/pix-data"
+  },
+  "homepage": "https://github.com/xynogen/pix-mono/tree/main/packages/pix-data#readme",
+  "bugs": {
+    "url": "https://github.com/xynogen/pix-mono/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  }
+}

package/src/data.test.ts

@@ -0,0 +1,196 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import {
+	buildModelsDevIndex,
+	lookupInIndex,
+	lookupModelsDev,
+	lookupBenchmark,
+	modelsDev,
+	benchmark,
+	type ModelsDevApi,
+	type ModelsDevModel,
+	type BenchmarkEntry,
+} from "./data.ts";
+
+// ── buildModelsDevIndex ──────────────────────────────────────────────────────
+
+describe("buildModelsDevIndex", () => {
+	const api: ModelsDevApi = {
+		anthropic: {
+			models: {
+				"claude-sonnet-4-5": { id: "claude-sonnet-4-5", name: "Claude Sonnet 4.5" },
+				"claude-opus-4": { id: "claude-opus-4", name: "Claude Opus 4", reasoning: true },
+			},
+		},
+		openai: {
+			models: {
+				"gpt-4o": { id: "gpt-4o", name: "GPT-4o", modalities: { input: ["text", "image"] } },
+			},
+		},
+	};
+
+	it("indexes all models by exact id", () => {
+		const idx = buildModelsDevIndex(api);
+		expect(idx.has("claude-sonnet-4-5")).toBe(true);
+		expect(idx.has("claude-opus-4")).toBe(true);
+		expect(idx.has("gpt-4o")).toBe(true);
+	});
+
+	it("indexes normalized id (strip date suffix)", () => {
+		const a: ModelsDevApi = {
+			anthropic: {
+				models: {
+					"claude-sonnet-4-5-20250514": { id: "claude-sonnet-4-5-20250514", name: "Claude Sonnet 4.5" },
+				},
+			},
+		};
+		const idx = buildModelsDevIndex(a);
+		expect(idx.has("claude-sonnet-4-5")).toBe(true);
+	});
+
+	it("handles empty api", () => {
+		expect(buildModelsDevIndex({}).size).toBe(0);
+	});
+
+	it("handles provider with no models key", () => {
+		expect(buildModelsDevIndex({ anthropic: {} }).size).toBe(0);
+	});
+
+	it("preserves first-seen on id collision", () => {
+		const a: ModelsDevApi = {
+			a: { models: { "gpt-4o": { id: "gpt-4o", name: "First" } } },
+			b: { models: { "gpt-4o": { id: "gpt-4o", name: "Second" } } },
+		};
+		expect(buildModelsDevIndex(a).get("gpt-4o")?.name).toBe("First");
+	});
+});
+
+// ── lookupInIndex ────────────────────────────────────────────────────────────
+
+describe("lookupInIndex", () => {
+	let index: Map<string, ModelsDevModel>;
+
+	beforeEach(() => {
+		index = buildModelsDevIndex({
+			anthropic: {
+				models: {
+					"claude-sonnet-4-5": { id: "claude-sonnet-4-5", name: "Claude Sonnet 4.5" },
+					"claude-opus-4": { id: "claude-opus-4", name: "Claude Opus 4" },
+				},
+			},
+			openai: {
+				models: {
+					"gpt-4o": { id: "gpt-4o", name: "GPT-4o" },
+					"o3-mini": { id: "o3-mini", name: "o3 mini" },
+				},
+			},
+		});
+	});
+
+	it("finds exact match", () => {
+		expect(lookupInIndex("claude-sonnet-4-5", index)?.name).toBe("Claude Sonnet 4.5");
+	});
+
+	it("strips provider prefix (provider/model)", () => {
+		expect(lookupInIndex("anthropic/claude-opus-4", index)?.name).toBe("Claude Opus 4");
+	});
+
+	it("strips deep prefix (cc/model)", () => {
+		expect(lookupInIndex("cc/claude-opus-4", index)?.name).toBe("Claude Opus 4");
+	});
+
+	it("strips date suffix", () => {
+		expect(lookupInIndex("claude-sonnet-4-5-20250514", index)?.name).toBe("Claude Sonnet 4.5");
+	});
+
+	it("strips provider prefix + date suffix", () => {
+		expect(lookupInIndex("anthropic/claude-sonnet-4-5-20250514", index)?.name).toBe("Claude Sonnet 4.5");
+	});
+
+	it("returns undefined for unknown model", () => {
+		expect(lookupInIndex("nonexistent-xyz", index)).toBeUndefined();
+	});
+
+	it("finds o3-mini", () => {
+		expect(lookupInIndex("o3-mini", index)?.name).toBe("o3 mini");
+	});
+});
+
+// ── lookupModelsDev ───────────────────────────────────────────────────────────
+
+describe("lookupModelsDev", () => {
+	beforeEach(() => {
+		// Seed in-memory cache directly
+		(modelsDev as any)._mem = {
+			anthropic: {
+				models: {
+					"claude-sonnet-4-5": { id: "claude-sonnet-4-5", name: "Claude Sonnet 4.5" },
+				},
+			},
+			openai: {
+				models: {
+					"gpt-4o": { id: "gpt-4o", name: "GPT-4o" },
+				},
+			},
+		};
+	});
+
+	afterEach(() => {
+		(modelsDev as any)._mem = null;
+	});
+
+	it("finds by exact provider + id", () => {
+		expect(lookupModelsDev("anthropic", "claude-sonnet-4-5")?.name).toBe("Claude Sonnet 4.5");
+	});
+
+	it("falls back across providers when provider miss", () => {
+		expect(lookupModelsDev("unknown-provider", "gpt-4o")?.name).toBe("GPT-4o");
+	});
+
+	it("strips path prefix from id", () => {
+		expect(lookupModelsDev("anthropic", "anthropic/claude-sonnet-4-5")?.name).toBe(
+			"Claude Sonnet 4.5",
+		);
+	});
+
+	it("returns undefined for unknown model", () => {
+		expect(lookupModelsDev("anthropic", "nonexistent-xyz")).toBeUndefined();
+	});
+});
+
+// ── lookupBenchmark ───────────────────────────────────────────────────────────
+
+describe("lookupBenchmark", () => {
+	const entries: BenchmarkEntry[] = [
+		{ rank: 1, model: "Claude Sonnet 4.5", creator: "Anthropic", overallScore: 95, inputPrice: 3, outputPrice: 15 },
+		{ rank: 2, model: "GPT-4o", creator: "OpenAI", overallScore: 90, inputPrice: 5, outputPrice: 15 },
+		{ rank: 3, model: "Gemini 1.5 Pro", creator: "Google", overallScore: 88, inputPrice: 3.5, outputPrice: 10.5 },
+	];
+
+	beforeEach(() => {
+		(benchmark as any)._mem = entries;
+	});
+
+	afterEach(() => {
+		(benchmark as any)._mem = null;
+	});
+
+	it("finds exact match (case-insensitive, normalized)", () => {
+		expect(lookupBenchmark("claude sonnet 4.5")?.rank).toBe(1);
+	});
+
+	it("finds with dashes normalized", () => {
+		expect(lookupBenchmark("claude-sonnet-4-5")?.rank).toBe(1);
+	});
+
+	it("finds partial match (needle in model)", () => {
+		expect(lookupBenchmark("gpt-4o")?.rank).toBe(2);
+	});
+
+	it("finds partial match (model in needle)", () => {
+		expect(lookupBenchmark("gemini 1.5 pro latest")?.rank).toBe(3);
+	});
+
+	it("returns undefined for unknown model", () => {
+		expect(lookupBenchmark("nonexistent-model-xyz")).toBeUndefined();
+	});
+});

package/src/data.ts

@@ -0,0 +1,285 @@
+/**
+ * data.ts — shared Pi model data layer
+ *
+ * Single source of truth for:
+ *   - models.dev metadata  (context, cost, modalities) → ~/.cache/pi/models.json   TTL 24h
+ *   - BenchLM leaderboard  (rank, score, pricing)      → ~/.cache/pi/benchlm.json  TTL 24h
+ *
+ * Cache files are shared across all Pi extensions — whichever extension loads
+ * first populates the cache; subsequent extensions read from disk.
+ *
+ * Usage:
+ *   import { modelsDev, benchmark } from "./data.ts";
+ *
+ *   const models  = await modelsDev.get();   // async, fetches if stale
+ *   const entries = await benchmark.get();
+ *
+ *   const models  = modelsDev.getCached();   // sync, disk-only, no fetch
+ *   const entries = benchmark.getCached();
+ *
+ *   import { lookupModelsDev, lookupBenchmark } from "./data.ts";
+ */
+
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export interface ModelsDevModel {
+	id: string;
+	name?: string;
+	reasoning?: boolean;
+	modalities?: { input?: string[]; output?: string[] };
+	limit?: { context?: number; output?: number };
+	cost?: {
+		input?: number;
+		output?: number;
+		cache_read?: number;
+		cache_write?: number;
+	};
+}
+
+export type ModelsDevApi = Record<
+	string,
+	{ models?: Record<string, ModelsDevModel> }
+>;
+
+export interface BenchmarkEntry {
+	rank: number;
+	model: string;
+	creator: string;
+	sourceType?: string;
+	overallScore: number | null;
+	categoryScores?: Record<string, number | null>;
+	inputPrice: number | null;
+	outputPrice: number | null;
+}
+
+interface BenchmarkResponse {
+	lastUpdated?: string;
+	mode?: string;
+	models: BenchmarkEntry[];
+}
+
+// ── DataSource ───────────────────────────────────────────────────────────────
+
+interface DataSourceOptions<T> {
+	url: string | (() => string);
+	headers?: () => Record<string, string> | undefined;
+	cachePath: string;
+	ttlMs?: number;
+	timeoutMs?: number;
+	parse: (raw: unknown) => T;
+	parseCache: (data: unknown) => T;
+	empty: T;
+	label: string;
+	skip?: () => boolean;
+}
+
+export class DataSource<T> {
+	private _mem: T | null = null;
+	private _inflight: Promise<T> | null = null;
+	private readonly opts: Required<DataSourceOptions<T>>;
+
+	constructor(opts: DataSourceOptions<T>) {
+		this.opts = {
+			ttlMs: 24 * 60 * 60 * 1000,
+			timeoutMs: 10_000,
+			headers: () => undefined,
+			skip: () => false,
+			...opts,
+		};
+	}
+
+	async get(): Promise<T> {
+		if (this._inflight) return this._inflight;
+		this._inflight = this._load().finally(() => {
+			this._inflight = null;
+		});
+		return this._inflight;
+	}
+
+	getCached(): T {
+		if (this._mem) return this._mem;
+		try {
+			if (existsSync(this.opts.cachePath)) {
+				const raw = JSON.parse(readFileSync(this.opts.cachePath, "utf-8")) as {
+					data: unknown;
+				};
+				this._mem = this.opts.parseCache(raw.data);
+				return this._mem;
+			}
+		} catch {
+			// No cache file or parse error — return empty, not fatal
+		}
+		return this.opts.empty;
+	}
+
+	private async _load(): Promise<T> {
+		if (this.opts.skip()) {
+			this._mem = this.opts.empty;
+			return this.opts.empty;
+		}
+		const cached = await this._readCache();
+		if (cached !== undefined && Date.now() - cached.ts < this.opts.ttlMs) {
+			const val = this.opts.parseCache(cached.data);
+			this._mem = val;
+			return val;
+		}
+		try {
+			const url =
+				typeof this.opts.url === "function" ? this.opts.url() : this.opts.url;
+			const response = await fetchWithTimeout(url, this.opts.timeoutMs, this.opts.headers());
+			if (!response.ok)
+				throw new Error(`${this.opts.label} fetch failed: ${response.status}`);
+			const raw = await response.json();
+			const val = this.opts.parse(raw);
+			this._mem = val;
+			void this._writeCache(raw);
+			return val;
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			if (cached !== undefined) {
+				console.warn(`${this.opts.label} fetch failed, using stale cache: ${msg}`);
+				const val = this.opts.parseCache(cached.data);
+				this._mem = val;
+				return val;
+			}
+			console.warn(`${this.opts.label} unavailable: ${msg}`);
+			return this.opts.empty;
+		}
+	}
+
+	private async _readCache(): Promise<{ ts: number; data: unknown } | undefined> {
+		try {
+			const raw = await readFile(this.opts.cachePath, "utf8");
+			const parsed = JSON.parse(raw) as { ts: number; data: unknown };
+			if (typeof parsed.ts !== "number") return undefined;
+			return parsed;
+		} catch {
+			return undefined;
+		}
+	}
+
+	private async _writeCache(data: unknown): Promise<void> {
+		try {
+			await mkdir(dirname(this.opts.cachePath), { recursive: true });
+			await writeFile(this.opts.cachePath, JSON.stringify({ ts: Date.now(), data }));
+		} catch {
+			// Write failure is non-fatal — stale cache used on next run
+		}
+	}
+}
+
+function fetchWithTimeout(
+	url: string,
+	timeoutMs: number,
+	headers?: Record<string, string>,
+): Promise<Response> {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	return fetch(url, { signal: controller.signal, headers }).finally(() =>
+		clearTimeout(timer),
+	);
+}
+
+// ── Cache dir ─────────────────────────────────────────────────────────────────
+
+export const CACHE_DIR = join(
+	process.env.XDG_CACHE_HOME || join(homedir(), ".cache"),
+	"pi",
+);
+
+// ── Data sources ──────────────────────────────────────────────────────────────
+
+export const modelsDev = new DataSource<ModelsDevApi>({
+	label: "models.dev",
+	url: "https://models.dev/api.json",
+	cachePath: join(CACHE_DIR, "models.json"),
+	parse: (raw) => raw as ModelsDevApi,
+	parseCache: (data) => (data as ModelsDevApi) ?? {},
+	empty: {},
+});
+
+export const benchmark = new DataSource<BenchmarkEntry[]>({
+	label: "benchlm",
+	url: "https://benchlm.ai/api/data/leaderboard",
+	cachePath: join(CACHE_DIR, "benchlm.json"),
+	parse: (raw) => (raw as BenchmarkResponse).models ?? [],
+	parseCache: (data) => (data as BenchmarkResponse)?.models ?? [],
+	empty: [],
+});
+
+// ── Lookup helpers ─────────────────────────────────────────────────────────────
+
+function normalize(id: string): string {
+	return id
+		.toLowerCase()
+		.replace(/[:@].*$/, "")
+		.replace(/-\d{8}$/, "");
+}
+
+function stripPrefix(id: string): string {
+	const i = id.lastIndexOf("/");
+	return i >= 0 ? id.slice(i + 1) : id;
+}
+
+export function buildModelsDevIndex(api: ModelsDevApi): Map<string, ModelsDevModel> {
+	const index = new Map<string, ModelsDevModel>();
+	for (const provider of Object.values(api)) {
+		if (!provider?.models) continue;
+		for (const [modelId, model] of Object.entries(provider.models)) {
+			const m: ModelsDevModel = { ...model, id: modelId };
+			if (!index.has(modelId)) index.set(modelId, m);
+			const norm = normalize(modelId);
+			if (!index.has(norm)) index.set(norm, m);
+		}
+	}
+	return index;
+}
+
+export function lookupInIndex(
+	id: string,
+	index: Map<string, ModelsDevModel>,
+): ModelsDevModel | undefined {
+	const stripped = stripPrefix(id);
+	const direct = index.get(stripped) ?? index.get(normalize(stripped));
+	if (direct) return direct;
+	const norm = normalize(stripped);
+	for (const [key, model] of index) {
+		if (key.startsWith(norm) || norm.startsWith(key)) return model;
+	}
+	return undefined;
+}
+
+export function lookupModelsDev(provider: string, id: string): ModelsDevModel | undefined {
+	const data = modelsDev.getCached();
+	const canonical = id.includes("/") ? id.slice(id.lastIndexOf("/") + 1) : id;
+	const exact = data[provider]?.models?.[canonical];
+	if (exact) return exact;
+	for (const p of Object.keys(data)) {
+		const hit = data[p]?.models?.[canonical];
+		if (hit) return hit;
+	}
+	return undefined;
+}
+
+export async function fetchModelsDevIndex(): Promise<Map<string, ModelsDevModel>> {
+	return buildModelsDevIndex(await modelsDev.get());
+}
+
+function normBench(s: string): string {
+	return s.toLowerCase().replace(/[-_.]+/g, " ").replace(/\s+/g, " ").trim();
+}
+
+export function lookupBenchmark(modelName: string): BenchmarkEntry | undefined {
+	const entries = benchmark.getCached();
+	const needle = normBench(modelName);
+	return (
+		entries.find((e) => normBench(e.model) === needle) ??
+		entries.find((e) => normBench(e.model).includes(needle)) ??
+		entries.find((e) => needle.includes(normBench(e.model)))
+	);
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+/**
+ * pix-data — Pi extension
+ *
+ * Warms the shared model data cache on session start so other extensions
+ * (pix-9router, models picker, footer) can read from ~/.cache/pi/* synchronously.
+ *
+ * Fetches in parallel, non-blocking — Pi session starts immediately.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { modelsDev, benchmark } from "./data.ts";
+
+export default function (_pi: ExtensionAPI): void {
+	void modelsDev.get();
+	void benchmark.get();
+}