@xynogen/pix-core 0.2.4 → 0.3.1

package/src/commands/update/update.ts

@@ -1,271 +0,0 @@
-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.code ?? 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.code ?? 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.code ?? 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.code ?? 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/index.ts

@@ -1,45 +0,0 @@
-/**
- * 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),
- *                 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 registerAgentSop from "./commands/agent-sop/agent-sop.ts";
-import registerClear from "./commands/clear/clear.ts";
-import registerDiff from "./commands/diff/diff.ts";
-import registerModels from "./commands/models/models.ts";
-import registerUpdate from "./commands/update/update.ts";
-import registerNudges from "./nudge/index.ts";
-import registerAsk from "./tool/ask/index.ts";
-import registerTodo from "./tool/todo/todo.ts";
-import registerToolbox from "./tool/toolbox/toolbox.ts";
-import registerDiagnostics from "./ui/diagnostics.ts";
-import registerFooter from "./ui/footer.ts";
-import registerWelcome from "./ui/welcome.ts";
-
-export default function (pi: ExtensionAPI): void {
-	registerAgentSop(pi);
-	registerWelcome(pi);
-	registerFooter(pi);
-	registerDiagnostics(pi);
-	registerModels(pi);
-	registerUpdate(pi);
-	registerDiff(pi);
-	registerClear(pi);
-	registerTodo(pi);
-	registerAsk(pi);
-	registerToolbox(pi);
-	registerNudges(pi);
-}

package/src/lib/data.ts

@@ -1,33 +0,0 @@
-/**
- * data.ts — model data layer (shim)
- *
- * Thin re-export of the shared data layer from @xynogen/pix-data
- * (github.com/xynogen/pix-mono/tree/main/packages/pix-data). Cache lives at
- * ~/.cache/pi/ and is shared across all Pi extensions — pix-data warms it on
- * session start; this extension reads from it.
- *
- * Consumers in this extension dir:
- *   footer.ts  — lookupModelsDev, lookupBenchmark, ModelsDevModel
- *   models.ts  — lookupModelsDev, lookupBenchmark
- */
-
-export type {
-	BenchmarkEntry,
-	ModelsDevApi,
-	ModelsDevModel,
-} from "../../../pix-data/src/index.ts";
-export {
-	benchmark,
-	buildModelsDevIndex,
-	CACHE_DIR,
-	DataSource,
-	fetchModelsDevIndex,
-	lookupBenchmark,
-	lookupInIndex,
-	lookupModelsDev,
-	modelsDev,
-} from "../../../pix-data/src/index.ts";
-
-export default function (_pi: unknown): void {
-	// pix-data warms this cache on startup — nothing to do here.
-}

package/src/nudge/capability.test.ts

@@ -1,258 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import registerCapabilityNudge, {
-	buildOrientation,
-	CAPABILITY_REMINDER,
-	countInvocableSkills,
-	graphifyHint,
-	partitionTools,
-} from "./capability.ts";
-
-// Minimal Skill-shaped fixtures (only fields the builder reads).
-const skill = (
-	name: string,
-	description: string,
-	disableModelInvocation = false,
-) =>
-	({
-		name,
-		description,
-		disableModelInvocation,
-		filePath: "",
-		baseDir: "",
-		sourceInfo: {} as never,
-	}) as never;
-
-// Minimal ToolInfo-shaped fixture.
-const tool = (name: string, source: string) =>
-	({
-		name,
-		description: `${name} desc.`,
-		parameters: {},
-		sourceInfo: { source, path: "", scope: "user", origin: "package" },
-	}) as never;
-
-describe("CAPABILITY_REMINDER", () => {
-	test("is terse — fires every turn, must stay cheap", () => {
-		expect(CAPABILITY_REMINDER.split(/\s+/).length).toBeLessThanOrEqual(28);
-	});
-
-	test("names the core capability surfaces", () => {
-		for (const cap of ["skill", "tool", "MCP", "web", "user"]) {
-			expect(CAPABILITY_REMINDER).toContain(cap);
-		}
-	});
-
-	test("steers away from improvising", () => {
-		expect(CAPABILITY_REMINDER.toLowerCase()).toContain("improvis");
-	});
-
-	test("nudges model to call read_skills() when a skill matches", () => {
-		expect(CAPABILITY_REMINDER).toContain("read_skills()");
-	});
-
-	test("does not mention user-only toolbox command", () => {
-		expect(CAPABILITY_REMINDER).not.toContain("/toolbox");
-		expect(CAPABILITY_REMINDER).not.toContain("toolbox(");
-	});
-});
-
-describe("countInvocableSkills", () => {
-	test("zero for undefined / empty", () => {
-		expect(countInvocableSkills(undefined)).toBe(0);
-		expect(countInvocableSkills([])).toBe(0);
-	});
-
-	test("excludes user-only skills", () => {
-		const n = countInvocableSkills([
-			skill("a", "."),
-			skill("b", ".", true),
-			skill("c", "."),
-		]);
-		expect(n).toBe(2);
-	});
-});
-
-describe("partitionTools", () => {
-	test("splits MCP-sourced from other tools by source", () => {
-		const { mcp, other } = partitionTools([
-			tool("read", "builtin"),
-			tool("context7-docs", "mcp:context7"),
-			tool("notion-search", "MCP server notion"),
-			tool("grep", "extension:pix-core"),
-		]);
-		expect(mcp).toBe(2);
-		expect(other).toBe(2);
-	});
-
-	test("handles undefined", () => {
-		expect(partitionTools(undefined)).toEqual({
-			mcp: 0,
-			other: 0,
-			active: 0,
-			gated: 0,
-		});
-	});
-
-	test("without an active set, every tool counts as active (gated 0)", () => {
-		const { active, gated } = partitionTools([
-			tool("read", "builtin"),
-			tool("find", "builtin"),
-		]);
-		expect(active).toBe(2);
-		expect(gated).toBe(0);
-	});
-
-	test("with an active set, splits active vs gated", () => {
-		const { active, gated } = partitionTools(
-			[
-				tool("read", "builtin"),
-				tool("grep", "builtin"),
-				tool("find", "builtin"),
-				tool("ls", "builtin"),
-			],
-			["read", "grep"],
-		);
-		expect(active).toBe(2);
-		expect(gated).toBe(2);
-	});
-});
-
-describe("buildOrientation", () => {
-	test("summarizes counts of tools, MCP tools, and skills", () => {
-		const out = buildOrientation(
-			[tool("read", "builtin"), tool("ctx", "mcp:context7")],
-			[skill("commit", "Commit changes."), skill("plan", "Plan work.")],
-		);
-		expect(out).toContain("1 tool");
-		expect(out).toContain("1 MCP tool");
-		expect(out).toContain("2 skills");
-	});
-
-	test("explains how to use read_skills() without user-only toolbox", () => {
-		const out = buildOrientation([tool("read", "builtin")], []);
-		expect(out).toContain("read_skills()");
-		expect(out).not.toContain("/toolbox");
-		expect(out).not.toContain("toolbox(");
-	});
-
-	test("calls out gated tools and points at toolbox to enable them", () => {
-		const out = buildOrientation(
-			[
-				tool("read", "builtin"),
-				tool("grep", "builtin"),
-				tool("find", "builtin"),
-				tool("ls", "builtin"),
-			],
-			[],
-			["read", "grep"], // active set: 2 gated out
-		);
-		expect(out).toContain("2 are gated");
-		expect(out).toContain("function definitions");
-	});
-
-	test("singular phrasing when exactly one tool is gated", () => {
-		const out = buildOrientation(
-			[tool("read", "builtin"), tool("find", "builtin")],
-			[],
-			["read"],
-		);
-		expect(out).toContain("1 is gated");
-		expect(out).toContain("function definitions");
-	});
-
-	test("no gate line when nothing is gated", () => {
-		const out = buildOrientation(
-			[tool("read", "builtin"), tool("grep", "builtin")],
-			[],
-			["read", "grep"],
-		);
-		expect(out).not.toContain("gated out of the prompt");
-	});
-
-	test("no gate line when active set is unknown", () => {
-		const out = buildOrientation(
-			[tool("read", "builtin"), tool("find", "builtin")],
-			[],
-		);
-		expect(out).not.toContain("gated out of the prompt");
-	});
-
-	test("lists invocable skill names, sorted, excluding user-only", () => {
-		const out = buildOrientation(
-			[],
-			[skill("zebra", "z."), skill("alpha", "a."), skill("hidden", "h.", true)],
-		);
-		expect(out).toContain("Skills: alpha, zebra.");
-		expect(out).not.toContain("hidden");
-	});
-
-	test("omits the skills line when no invocable skills", () => {
-		const out = buildOrientation(
-			[tool("read", "builtin")],
-			[skill("x", ".", true)],
-		);
-		expect(out).not.toContain("Skills:");
-	});
-
-	test("steers away from improvising", () => {
-		const out = buildOrientation([tool("read", "builtin")], []);
-		expect(out.toLowerCase()).toContain("improvis");
-	});
-
-	test("frames the block as non-actionable so the model acts on the prompt", () => {
-		const out = buildOrientation([tool("read", "builtin")], []);
-		const last = out.trim().split("\n").at(-1) ?? "";
-		expect(last.toLowerCase()).toContain("not a task");
-		expect(last.toLowerCase()).toContain("do not reply");
-	});
-});
-
-describe("registerCapabilityNudge", () => {
-	test("injects orientation into system prompt, not a custom message", async () => {
-		let handler: ((event: { systemPrompt?: string }) => unknown) | undefined;
-		const pi = {
-			on(event: string, fn: typeof handler) {
-				if (event === "before_agent_start") handler = fn;
-			},
-			getAllTools() {
-				return [tool("read", "builtin")];
-			},
-			getActiveTools() {
-				return ["read"];
-			},
-		} as never;
-
-		registerCapabilityNudge(pi);
-		const result = (await handler?.({ systemPrompt: "BASE" })) as {
-			systemPrompt?: string;
-			message?: unknown;
-		};
-
-		expect(result.message).toBeUndefined();
-		expect(result.systemPrompt).toStartWith("BASE\n\nToolbelt:");
-		expect(result.systemPrompt).toContain("Orientation only");
-	});
-});
-
-describe("graphifyHint", () => {
-	const tmpDir = join(import.meta.dir, ".graphify-hint-test-tmp");
-
-	test("returns undefined when graphify-out/graph.json absent", () => {
-		expect(graphifyHint(tmpDir)).toBeUndefined();
-	});
-
-	test("returns hint string when graphify-out/graph.json exists", () => {
-		try {
-			mkdirSync(join(tmpDir, "graphify-out"), { recursive: true });
-			writeFileSync(join(tmpDir, "graphify-out", "graph.json"), "{}");
-			const hint = graphifyHint(tmpDir);
-			expect(hint).toBeTypeOf("string");
-			expect(hint).toContain("graphify");
-			expect(hint).toContain("graphify query");
-		} finally {
-			rmSync(tmpDir, { recursive: true, force: true });
-		}
-	});
-});