@xynogen/pix-core 0.1.0

package/src/commands/update/update.ts

@@ -0,0 +1,271 @@
+import type {
+	ExtensionAPI,
+	ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+// ─── Pure logic (exported for tests) ─────────────────────────────────────────
+
+export const PACKAGE_NAME = "@earendil-works/pi-coding-agent";
+
+export const TRANSIENT_PATTERNS = [
+	/eai_again/i,
+	/etimedout/i,
+	/econnreset/i,
+	/econnrefused/i,
+	/socket hang up/i,
+	/network/i,
+	/timeout/i,
+	/temporar/i,
+	/too many requests/i,
+	/\b429\b/,
+	/\b502\b/,
+	/\b503\b/,
+	/\b504\b/,
+];
+
+export type InstallMethod = "vp" | "bun" | "npm" | "brew" | "native";
+
+export type CommandSpec = {
+	command: string;
+	args: string[];
+	label: string;
+};
+
+export function isTransient(output: string): boolean {
+	return TRANSIENT_PATTERNS.some((pattern) => pattern.test(output));
+}
+
+export function commandFor(method: InstallMethod): CommandSpec | undefined {
+	switch (method) {
+		case "vp":
+			return {
+				command: "vp",
+				args: ["add", "-g", `${PACKAGE_NAME}@latest`],
+				label: `vp add -g ${PACKAGE_NAME}@latest`,
+			};
+		case "bun":
+			return {
+				command: "bun",
+				args: ["add", "-g", `${PACKAGE_NAME}@latest`],
+				label: `bun add -g ${PACKAGE_NAME}@latest`,
+			};
+		case "npm":
+			return {
+				command: "npm",
+				args: ["install", "-g", `${PACKAGE_NAME}@latest`],
+				label: `npm install -g ${PACKAGE_NAME}@latest`,
+			};
+		case "brew":
+			return {
+				command: "/bin/sh",
+				args: ["-lc", "brew upgrade pi-coding-agent || brew upgrade pi"],
+				label: "brew upgrade pi-coding-agent || brew upgrade pi",
+			};
+		case "native":
+			return undefined;
+	}
+}
+
+export function formatUpdateSummary(
+	before: string,
+	after: string,
+	attempts: number,
+): string {
+	const changed =
+		before !== after && before !== "unknown" && after !== "unknown";
+	const summary = changed
+		? `Pi updated: ${before} → ${after}`
+		: `Pi is up to date (${after}).`;
+	return attempts > 1
+		? `${summary} Retried ${attempts - 1} transient failure(s).`
+		: summary;
+}
+
+async function resolveCommand(command: string, pi: ExtensionAPI) {
+	const result = await pi.exec(
+		"/bin/sh",
+		["-lc", `command -v ${command} || true`],
+		{ timeout: 10_000 },
+	);
+	return result.stdout.trim().split("\n")[0] || undefined;
+}
+
+async function currentVersion(pi: ExtensionAPI) {
+	const result = await pi.exec("pi", ["--version"], { timeout: 10_000 });
+	return result.stdout.trim() || result.stderr.trim() || "unknown";
+}
+
+async function detectInstallMethod(pi: ExtensionAPI): Promise<InstallMethod> {
+	const piPath = await resolveCommand("pi", pi);
+	const realPiPath = piPath
+		? (
+				await pi.exec(
+					"/bin/sh",
+					["-lc", `realpath ${piPath} 2>/dev/null || printf %s ${piPath}`],
+					{ timeout: 10_000 },
+				)
+			).stdout.trim()
+		: undefined;
+
+	if (piPath?.includes("/.vite-plus/") || realPiPath?.includes("/.vite-plus/"))
+		return "vp";
+	if (piPath?.includes("/.bun/") || realPiPath?.includes("/.bun/"))
+		return "bun";
+	if (
+		piPath?.includes("/Homebrew/") ||
+		piPath?.includes("/homebrew/") ||
+		realPiPath?.includes("/Homebrew/") ||
+		realPiPath?.includes("/homebrew/")
+	)
+		return "brew";
+
+	if (piPath) {
+		const hasGlobalNpm = await pi.exec(
+			"/bin/sh",
+			[
+				"-lc",
+				`p=${piPath}; i=0; while [ $i -lt 5 ]; do d=$(dirname "$p"); [ -d "$d/node_modules/${PACKAGE_NAME}" ] && exit 0; p=$d; i=$((i+1)); done; exit 1`,
+			],
+			{ timeout: 10_000 },
+		);
+		if ((hasGlobalNpm.exitCode ?? 1) === 0) return "npm";
+	}
+
+	if (await resolveCommand("vp", pi)) return "vp";
+	if (await resolveCommand("bun", pi)) return "bun";
+	if (await resolveCommand("npm", pi)) return "npm";
+	if (await resolveCommand("brew", pi)) return "brew";
+	return "native";
+}
+
+async function runWithRetry(pi: ExtensionAPI, spec: CommandSpec) {
+	let lastOutput = "";
+	for (let attempt = 1; attempt <= 3; attempt++) {
+		const result = await pi.exec(spec.command, spec.args, { timeout: 180_000 });
+		lastOutput = [result.stdout, result.stderr]
+			.filter(Boolean)
+			.join("\n")
+			.trim();
+		if ((result.exitCode ?? 0) === 0)
+			return { ok: true, output: lastOutput, attempts: attempt };
+		if (attempt === 3 || !isTransient(lastOutput))
+			return { ok: false, output: lastOutput, attempts: attempt };
+		await new Promise((resolve) => setTimeout(resolve, attempt * 1500));
+	}
+	return { ok: false, output: lastOutput, attempts: 3 };
+}
+
+async function updatePi(pi: ExtensionAPI, ctx: ExtensionCommandContext) {
+	await (
+		ctx as ExtensionCommandContext & { waitForIdle?: () => Promise<void> }
+	).waitForIdle?.();
+
+	const before = await currentVersion(pi).catch(() => "unknown");
+	const method = await detectInstallMethod(pi);
+	const spec = commandFor(method);
+
+	if (!spec) {
+		ctx.ui.notify(
+			`Pi ${before}; install method appears native. Please update the native binary manually.`,
+			"warning",
+		);
+		return;
+	}
+
+	ctx.ui.notify(`Updating Pi via ${method}: ${spec.label}`, "info");
+	const result = await runWithRetry(pi, spec);
+	const after = await currentVersion(pi).catch(() => "unknown");
+
+	if (!result.ok) {
+		ctx.ui.notify(
+			`Pi update failed after ${result.attempts} attempt(s). ${result.output || "No output."}`,
+			"error",
+		);
+		return;
+	}
+
+	ctx.ui.notify(formatUpdateSummary(before, after, result.attempts), "info");
+}
+
+async function updateExtensions(
+	pi: ExtensionAPI,
+	ctx: ExtensionCommandContext,
+) {
+	ctx.ui.notify("Updating Pi extensions from dotfiles setup", "info");
+	const result = await pi.exec(
+		"/bin/sh",
+		["-lc", '"$HOME/dotfiles/ai_config/pi/setup.sh"'],
+		{ timeout: 240_000 },
+	);
+	const output = [result.stdout, result.stderr]
+		.filter(Boolean)
+		.join("\n")
+		.trim();
+	if ((result.exitCode ?? 0) !== 0) {
+		ctx.ui.notify(
+			`Pi extensions update failed. ${output || "No output."}`,
+			"error",
+		);
+		return;
+	}
+	ctx.ui.notify(
+		"Pi extensions updated. Please run /reload to apply changes.",
+		"warning",
+	);
+}
+
+async function updatePackages(pi: ExtensionAPI, ctx: ExtensionCommandContext) {
+	ctx.ui.notify("Updating pi packages (pi update --extensions)", "info");
+	const result = await pi.exec("pi", ["update", "--extensions"], {
+		timeout: 240_000,
+	});
+	const output = [result.stdout, result.stderr]
+		.filter(Boolean)
+		.join("\n")
+		.trim();
+	if ((result.exitCode ?? 0) !== 0) {
+		ctx.ui.notify(
+			`Pi package update failed. ${output || "No output."}`,
+			"error",
+		);
+		return;
+	}
+	ctx.ui.notify(
+		"Pi packages updated. Please run /reload to apply changes.",
+		"warning",
+	);
+}
+
+async function updateAll(pi: ExtensionAPI, ctx: ExtensionCommandContext) {
+	await updatePi(pi, ctx);
+	await updateExtensions(pi, ctx);
+	await updatePackages(pi, ctx);
+}
+
+export default function (pi: ExtensionAPI) {
+	(
+		pi as ExtensionAPI & {
+			registerFlag: (name: string, opts: unknown) => void;
+		}
+	).registerFlag("update", {
+		description: "Update Pi, dotfiles extensions, and pi packages",
+		type: "boolean",
+		default: false,
+	});
+
+	pi.registerCommand("update", {
+		description: "Update Pi, dotfiles extensions, and pi packages",
+		handler: async (_args, ctx) => {
+			await updateAll(pi, ctx);
+		},
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		const flags = pi as ExtensionAPI & {
+			getFlag?: (name: string) => boolean;
+			sendUserMessage?: (message: string, opts?: unknown) => void;
+		};
+		if (!flags.getFlag?.("update")) return;
+		flags.sendUserMessage?.("/update", { deliverAs: "followUp" });
+		ctx.ui.notify("Queued /update from --update", "info");
+	});
+}

package/src/commands/yeet/yeet.ts

@@ -0,0 +1,29 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const YEET_PROMPT = `Commit the current repository changes.
+
+Steps:
+1. Add all unstaged changes with \`git add -A\`.
+2. Inspect the staged changes and write a concise commit message that accurately summarizes them.
+3. Commit the changes with that message.
+   - If there are no staged changes, output "Nothing to commit" and stop.
+
+Keep the commit message concise. Do not push.`;
+
+export default function (pi: ExtensionAPI) {
+	pi.registerCommand("yeet", {
+		description: "Add and commit current repo changes (no push)",
+		handler: async (args, ctx) => {
+			const prompt = args?.trim()
+				? `${YEET_PROMPT}\n\nAdditional instructions from the user:\n${args.trim()}`
+				: YEET_PROMPT;
+
+			if (ctx.isIdle()) {
+				pi.sendUserMessage(prompt);
+			} else {
+				pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+				ctx.ui.notify("Queued /yeet as a follow-up", "info");
+			}
+		},
+	});
+}

package/src/index.ts

@@ -0,0 +1,49 @@
+/**
+ * pix-core — Pi extension bundle
+ *
+ * Layout (grouped by concern):
+ *   - ui/       — welcome (π banner + health checks), footer (status bar)
+ *   - commands/ — models (/models picker), update (/update self-update),
+ *                 lg (/lg), yeet (/yeet), copy-all (/copy-all), diff (/diff)
+ *   - tool/     — todo (durable execution checklist),
+ *                 toolbox (/toolbox command — user toggles tools on/off),
+ *                 lazy (lazy tool exposure — gates schemas out of the prompt)
+ *   - nudge/    — model-steering reminders (tools / capability+skills)
+ *   - lib/      — shared data layer (models.dev + BenchLM)
+ *
+ * Depends on pix-data (github.com/xynogen/pix-data) for shared
+ * models.dev + BenchLM cache at ~/.cache/pi/.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import registerWelcome from "./ui/welcome.ts";
+import registerFooter from "./ui/footer.ts";
+import registerDiagnostics from "./ui/diagnostics.ts";
+import registerModels from "./commands/models/models.ts";
+import registerUpdate from "./commands/update/update.ts";
+import registerLg from "./commands/lg/lg.ts";
+import registerYeet from "./commands/yeet/yeet.ts";
+import registerCopyAll from "./commands/copy-all/copy-all.ts";
+import registerDiff from "./commands/diff/diff.ts";
+import registerClear from "./commands/clear/clear.ts";
+import registerTodo from "./tool/todo/todo.ts";
+import registerAsk from "./tool/ask/ask.ts";
+import registerToolbox from "./tool/toolbox/toolbox.ts";
+import registerNudges from "./nudge/index.ts";
+
+export default function (pi: ExtensionAPI): void {
+	registerWelcome(pi);
+	registerFooter(pi);
+	registerDiagnostics(pi);
+	registerModels(pi);
+	registerUpdate(pi);
+	registerLg(pi);
+	registerYeet(pi);
+	registerCopyAll(pi);
+	registerDiff(pi);
+	registerClear(pi);
+	registerTodo(pi);
+	registerAsk(pi);
+	registerToolbox(pi);
+	registerNudges(pi);
+}

package/src/lib/data.ts

@@ -0,0 +1,241 @@
+/**
+ * data.ts — model data layer (shim)
+ *
+ * Re-exports shared data from pix-data (github.com/xynogen/pix-data).
+ * Cache lives at ~/.cache/pi/ and is shared across all Pi extensions.
+ *
+ * Consumers in this extension dir:
+ *   footer.ts  — lookupModelsDev, lookupBenchmark, ModelsDevModel
+ *   models.ts  — lookupModelsDev, lookupBenchmark
+ */
+
+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;
+}
+
+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
+		}
+		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 controller = new AbortController();
+			const timer = setTimeout(() => controller.abort(), this.opts.timeoutMs);
+			const response = await fetch(url, {
+				signal: controller.signal,
+				headers: this.opts.headers(),
+			}).finally(() => clearTimeout(timer));
+			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
+		}
+	}
+}
+
+// ── Cache dir ─────────────────────────────────────────────────────────────────
+
+const CACHE_DIR = join(
+	process.env.XDG_CACHE_HOME || join(homedir(), ".cache"),
+	"pi",
+);
+
+// ── Data sources (shared cache with pix-data) ─────────────────────────────────
+
+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: {},
+});
+
+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 ─────────────────────────────────────────────────────────────
+
+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;
+}
+
+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)))
+	);
+}
+
+export default function (_pi: unknown): void {
+	// pix-data warms this cache on startup — nothing to do here
+}