@xynogen/pix-commands 0.6.2 → 0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-commands",
-	"version": "0.6.2",
+	"version": "0.6.3",
 	"description": "Pi extension — slash commands for cache clearing and isolated side questions",
 	"type": "module",
 	"main": "src/index.ts",
@@ -13,6 +13,7 @@
 	},
 	"files": [
 		"src",
+		"!src/**/*.test.*",
 		"README.md",
 		"LICENSE"
 	],

package/src/btw/index.test.ts

@@ -1,46 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { registerBtw, shortModelName } from "./index.ts";
-
-describe("BTW display helpers", () => {
-	test("prefers model display name and falls back to id", () => {
-		expect(shortModelName({ id: "id", name: "Friendly" })).toBe("Friendly");
-		expect(shortModelName({ id: "id", name: "  " })).toBe("id");
-	});
-
-	test("registers a display-only entry renderer, never a context-bearing message renderer", () => {
-		let entryRenderer: string | undefined;
-		let messageRenderer: string | undefined;
-		const pi = {
-			on() {},
-			registerCommand() {},
-			registerEntryRenderer(name: string) {
-				entryRenderer = name;
-			},
-			registerMessageRenderer(name: string) {
-				messageRenderer = name;
-			},
-		} as any;
-		registerBtw(pi);
-
-		// pix-btw-answer must be a CustomEntry (display-only, never in LLM context),
-		// not a CustomMessageEntry — that is what lets the card land mid-stream.
-		expect(entryRenderer).toBe("pix-btw-answer");
-		expect(messageRenderer).toBeUndefined();
-	});
-
-	test("does not register a context handler (BTW cards never enter LLM context)", () => {
-		const events: string[] = [];
-		const pi = {
-			on(event: string) {
-				events.push(event);
-			},
-			registerCommand() {},
-			registerEntryRenderer() {},
-		} as any;
-		registerBtw(pi);
-
-		// A CustomEntry is ignored by buildSessionContext, so there is nothing to
-		// strip — the old pi.on("context", filterBtwMessages) hack is gone.
-		expect(events).not.toContain("context");
-	});
-});

package/src/btw/render.test.ts

@@ -1,102 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { type ExtensionAPI, initTheme } from "@earendil-works/pi-coding-agent";
-import { type BtwMessageDetails, formatDuration, registerBtwRenderer } from "./render.ts";
-
-const stripAnsi = (text: string) => text.replace(/\x1b\[[0-9;]*m/g, "");
-
-function captureRenderer() {
-	let renderer: ((entry: unknown, options: unknown, theme: unknown) => unknown) | undefined;
-	const pi = {
-		registerEntryRenderer(_name: string, fn: typeof renderer) {
-			renderer = fn;
-		},
-	} as unknown as ExtensionAPI;
-	registerBtwRenderer(pi);
-	if (!renderer) throw new Error("renderer was not registered");
-	return renderer;
-}
-
-const backgrounds: string[] = [];
-const theme = {
-	fg: (_color: string, text: string) => text,
-	bg: (color: string, text: string) => {
-		backgrounds.push(color);
-		return text;
-	},
-	bold: (text: string) => text,
-};
-
-function render(details: BtwMessageDetails, expanded = false): string {
-	const renderer = captureRenderer();
-	const component = renderer(
-		{ type: "custom", customType: "pix-btw-answer", data: details },
-		{ expanded },
-		theme,
-	) as {
-		render(width: number): string[];
-	};
-	return stripAnsi(component.render(80).join("\n"));
-}
-
-describe("BTW renderer", () => {
-	test("formats durations compactly", () => {
-		expect(formatDuration(450)).toBe("450ms");
-		expect(formatDuration(2_100)).toBe("2.1s");
-		expect(formatDuration(65_000)).toBe("1m 5s");
-	});
-
-	test("renders metadata and question as distinct side-thread card chrome", () => {
-		backgrounds.length = 0;
-		const output = render({
-			question: "hello",
-			answer: "Hi!",
-			thinking: "",
-			model: "GPT-5.6",
-			thinkingLevel: "high",
-			durationMs: 2_100,
-			toolUses: 0,
-		});
-		expect(output).toContain("✓ BTW · GPT-5.6 · high · 2.1s");
-		expect(output).toContain("▐ hello");
-		expect(output).not.toContain("SIDE THREAD");
-		expect(backgrounds).toContain("selectedBg");
-		expect(backgrounds).not.toContain("customMessageBg");
-	});
-
-	test("renders the answer as Markdown", () => {
-		initTheme();
-		const output = render({
-			question: "show markdown",
-			answer: "## Heading\n\n- alpha\n- beta\n\n`code`",
-			thinking: "",
-			model: "Model",
-			thinkingLevel: "medium",
-			durationMs: 1_000,
-			toolUses: 1,
-		});
-		expect(output).toContain("Heading");
-		expect(output).toContain("alpha");
-		expect(output).toContain("beta");
-		expect(output).toContain("code");
-	});
-
-	test("hides reasoning by default and reveals it when expanded", () => {
-		initTheme();
-		const details: BtwMessageDetails = {
-			question: "why",
-			answer: "Because.",
-			thinking: "first I considered the mutex",
-			model: "Model",
-			thinkingLevel: "high",
-			durationMs: 1_000,
-			toolUses: 0,
-		};
-		const collapsed = render(details, false);
-		expect(collapsed).toContain("reasoning hidden");
-		expect(collapsed).not.toContain("first I considered the mutex");
-
-		const expanded = render(details, true);
-		expect(expanded).toContain("Reasoning");
-		expect(expanded).toContain("first I considered the mutex");
-	});
-});

package/src/btw/session.test.ts

@@ -1,128 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { Api, Model } from "@earendil-works/pi-ai";
-import type { LoadExtensionsResult } from "@earendil-works/pi-coding-agent";
-import {
-	BTW_CTX_TURNS,
-	BTW_SYSTEM_PROMPT,
-	buildContextPreamble,
-	lastAssistantText,
-	makeLeanExtensions,
-	selectBtwTools,
-	snapshotMainSettings,
-} from "./session.ts";
-
-describe("BTW system prompt", () => {
-	test("is the exact lean Pix identity", () => {
-		expect(BTW_SYSTEM_PROMPT).toBe(
-			"You are Pix Coding Agent. You help users accomplish any task they request.",
-		);
-	});
-});
-
-describe("snapshotMainSettings", () => {
-	test("captures model, thinking, cwd, and a defensive copy of active tools", () => {
-		const tools = ["read", "fetch"];
-		const model = { id: "model-id", name: "Model" } as Model<Api>;
-		const snapshot = snapshotMainSettings({ cwd: "/project", model } as never, "high", tools);
-		tools.push("write");
-		expect(snapshot.cwd).toBe("/project");
-		expect(snapshot.model).toBe(model);
-		expect(snapshot.thinkingLevel).toBe("high");
-		expect(snapshot.activeToolNames).toEqual(["read", "fetch"]);
-	});
-
-	test("rejects invocation when the main session has no model", () => {
-		expect(() =>
-			snapshotMainSettings({ cwd: "/project", model: undefined } as never, "medium", []),
-		).toThrow("No model is selected");
-	});
-});
-
-describe("selectBtwTools", () => {
-	test("uses the main active tools and removes duplicates without reordering", () => {
-		expect(selectBtwTools(["read", "fetch", "read", "agent"])).toEqual(["read", "fetch", "agent"]);
-	});
-});
-
-describe("makeLeanExtensions", () => {
-	test("removes discovered before_agent_start mutators but preserves inline override", () => {
-		const regularHandlers = new Map<string, never[]>([
-			["before_agent_start", []],
-			["tool_call", []],
-		]);
-		const inlineHandlers = new Map<string, never[]>([["before_agent_start", []]]);
-		const base = {
-			extensions: [
-				{ path: "/extensions/pix-prompts.ts", handlers: regularHandlers },
-				{ path: "<inline:1>", handlers: inlineHandlers },
-			],
-			errors: [],
-			runtime: {},
-		} as unknown as LoadExtensionsResult;
-
-		const result = makeLeanExtensions(base);
-		expect(result.extensions[0]?.handlers.has("before_agent_start")).toBe(false);
-		expect(result.extensions[0]?.handlers.has("tool_call")).toBe(true);
-		expect(result.extensions[1]?.handlers.has("before_agent_start")).toBe(true);
-		// Do not mutate the loader's original extension records.
-		expect(regularHandlers.has("before_agent_start")).toBe(true);
-	});
-});
-
-describe("buildContextPreamble", () => {
-	const msg = (role: string, text: string) => ({
-		type: "message",
-		message: { role, content: [{ type: "text", text }] },
-	});
-
-	test("flattens recent user/assistant turns into a labeled preamble", () => {
-		const out = buildContextPreamble([msg("user", "hi"), msg("assistant", "hello")]);
-		expect(out).toContain("User: hi");
-		expect(out).toContain("Assistant: hello");
-		expect(out).toContain("read-only context");
-	});
-
-	test("keeps only the last N turns", () => {
-		const entries = Array.from({ length: BTW_CTX_TURNS + 5 }, (_, i) => msg("user", `q${i}`));
-		const out = buildContextPreamble(entries);
-		expect(out).not.toContain("q0"); // dropped
-		expect(out).toContain(`q${BTW_CTX_TURNS + 4}`); // kept
-		expect(out).toContain(`most recent ${BTW_CTX_TURNS} turn`);
-	});
-
-	test("skips non-message entries, tool noise, and string content", () => {
-		const out = buildContextPreamble([
-			{ type: "model_change", message: undefined },
-			{ type: "message", message: { role: "tool", content: "ignored" } },
-			{ type: "message", message: { role: "user", content: "plain string" } },
-		]);
-		expect(out).toContain("User: plain string");
-		expect(out).not.toContain("ignored");
-	});
-
-	test("returns empty when there are no usable turns", () => {
-		expect(buildContextPreamble([{ type: "compaction", message: undefined }])).toBe("");
-		expect(buildContextPreamble([])).toBe("");
-	});
-});
-
-describe("lastAssistantText", () => {
-	test("returns text from the latest assistant response", () => {
-		const messages = [
-			{ role: "assistant", content: [{ type: "text", text: "old" }] },
-			{ role: "user", content: "question" },
-			{
-				role: "assistant",
-				content: [
-					{ type: "thinking", thinking: "hidden" },
-					{ type: "text", text: "latest" },
-				],
-			},
-		];
-		expect(lastAssistantText(messages)).toBe("latest");
-	});
-
-	test("returns an empty string when there is no assistant text", () => {
-		expect(lastAssistantText([{ role: "user", content: "hello" }])).toBe("");
-	});
-});

package/src/btw/widget.test.ts

@@ -1,119 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-	type BtwWidgetJob,
-	DEFAULT_LINGER_BASE_MS,
-	ERROR_LINGER_SCALE,
-	hasVisibleJobs,
-	lingerWindows,
-	OK_LINGER_SCALE,
-	renderBtwWidget,
-	shouldShowFinished,
-	type WidgetTheme,
-} from "./widget.ts";
-
-const theme: WidgetTheme = {
-	fg: (_color, text) => text,
-	bold: (text) => text,
-};
-
-function job(overrides: Partial<BtwWidgetJob>): BtwWidgetJob {
-	return {
-		id: 1,
-		model: "Model",
-		status: "running",
-		startedAt: 0,
-		activeTools: [],
-		text: "",
-		toolUses: 0,
-		turnCount: 0,
-		outputTokens: 0,
-		contextUsage: null,
-		...overrides,
-	};
-}
-
-const render = (jobs: BtwWidgetJob[], now = 1_000) =>
-	renderBtwWidget(jobs, theme, 0, now, 200).join("\n");
-
-describe("BTW widget layout", () => {
-	test("empty when there are no running or lingering jobs", () => {
-		expect(renderBtwWidget([], theme, 0, 1_000, 200)).toEqual([]);
-		const old = job({ status: "completed", completedAt: 0 });
-		expect(renderBtwWidget([old], theme, 0, 999_999, 200)).toEqual([]);
-	});
-
-	test("running heading is hollow and shows the running count", () => {
-		const out = render([job({ id: 7, model: "GPT" })]);
-		expect(out).toContain("\u25cb BTW (1)");
-		expect(out).toContain("#7");
-		expect(out).toContain("[GPT]");
-	});
-
-	test("uses primary identity, secondary activity, and tertiary metadata", () => {
-		const taggedTheme: WidgetTheme = {
-			fg: (color, text) => `<${color}>${text}</${color}>`,
-			bold: (text) => text,
-		};
-		const output = renderBtwWidget(
-			[job({ id: 7, model: "GPT", text: "Reading auth.ts", toolUses: 2 })],
-			taggedTheme,
-			0,
-			1_000,
-			500,
-		).join("\n");
-		expect(output).toContain("<accent>BTW</accent><muted> (1)</muted>");
-		expect(output).toContain("<toolTitle>#7</toolTitle>");
-		expect(output).toContain("<muted>[GPT]</muted>");
-		expect(output).toMatch(/<muted>[^<]*2 · 1\.0s<\/muted>/);
-		expect(output).toContain("<dim>Reading auth.ts</dim>");
-		expect(output).toContain("<muted>└─</muted>");
-	});
-
-	test("finished jobs linger with a check, then drop after the window", () => {
-		const done = job({ status: "completed", completedAt: 1_000, toolUses: 2, turnCount: 1 });
-		// Default base 10s × 3 = 30s ok-window.
-		expect(shouldShowFinished(done, 1_500)).toBe(true);
-		expect(shouldShowFinished(done, 40_000)).toBe(false); // 39s elapsed > 30s window
-
-		const out = render([done], 1_500);
-		expect(out).toContain("\u2713");
-		// All jobs finished → filled heading disk.
-		expect(out).toContain("\u25cf BTW (0)");
-	});
-
-	test("errors linger longer and show the message", () => {
-		const failed = job({ status: "error", completedAt: 1_000, error: "boom" });
-		// Default base 10s × 9 = 90s error-window; 40s elapsed is past ok (30s) but well inside error.
-		expect(shouldShowFinished(failed, 40_000)).toBe(true);
-		expect(render([failed], 40_000)).toContain("boom");
-	});
-
-	test("linger windows scale off the config collapse delay", () => {
-		// Defaults derive from the fallback base.
-		expect(lingerWindows()).toEqual({
-			ok: DEFAULT_LINGER_BASE_MS * OK_LINGER_SCALE,
-			error: DEFAULT_LINGER_BASE_MS * ERROR_LINGER_SCALE,
-		});
-		// A custom base (e.g. config collapse.delaySec = 4 → 4000ms) scales both.
-		expect(lingerWindows(4_000)).toEqual({ ok: 12_000, error: 36_000 });
-		// Non-positive base falls back to the default so windows never collapse to 0.
-		expect(lingerWindows(0)).toEqual(lingerWindows());
-
-		// shouldShowFinished honors the threaded base: a 4s base drops an ok job at 13s.
-		const done = job({ status: "completed", completedAt: 0 });
-		expect(shouldShowFinished(done, 11_000, 4_000)).toBe(true); // < 12s
-		expect(shouldShowFinished(done, 13_000, 4_000)).toBe(false); // > 12s
-	});
-
-	test("overflow collapses excess rows into a +N more line", () => {
-		const many = Array.from({ length: 20 }, (_, i) => job({ id: i + 1 }));
-		const lines = renderBtwWidget(many, theme, 0, 1_000, 200);
-		expect(lines.length).toBeLessThanOrEqual(12);
-		expect(lines.at(-1)).toContain("more");
-	});
-
-	test("hasVisibleJobs mirrors render visibility", () => {
-		expect(hasVisibleJobs([job({})], 1_000)).toBe(true);
-		expect(hasVisibleJobs([job({ status: "completed", completedAt: 0 })], 999_999)).toBe(false);
-	});
-});

package/src/extension.test.ts

@@ -1,74 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { createEventBus, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { icon } from "@xynogen/pix-pretty/icon-catalog";
-import { getUnattendedMode } from "@xynogen/pix-runtime";
-import extension from "./extension.ts";
-
-afterEach(() => {
-	delete (globalThis as { __pixOnce?: WeakMap<object, Set<string>> }).__pixOnce;
-});
-
-describe("pix-commands registration", () => {
-	function host() {
-		const commands: string[] = [];
-		const handlers = new Map<string, (args: string, ctx: never) => Promise<void>>();
-		const renderers: string[] = [];
-		const pi = {
-			events: createEventBus(),
-			registerCommand(
-				name: string,
-				options: { handler?: (args: string, ctx: never) => Promise<void> },
-			) {
-				commands.push(name);
-				if (options.handler) handlers.set(name, options.handler);
-			},
-			registerEntryRenderer(name: string) {
-				renderers.push(name);
-			},
-			on() {},
-		} as unknown as ExtensionAPI;
-		return { pi, commands, handlers, renderers };
-	}
-
-	test("registers /clear, /btw, /afk, /yolo, and the BTW renderer once per Pi instance", () => {
-		const { pi, commands, renderers } = host();
-		extension(pi);
-		extension(pi);
-		expect(commands).toEqual(["clear", "btw", "afk", "yolo"]);
-		expect(renderers).toEqual(["pix-btw-answer"]);
-	});
-
-	test("registers again for a fresh Pi session", () => {
-		const first = host();
-		const second = host();
-		extension(first.pi);
-		extension(second.pi);
-		expect(first.commands).toEqual(["clear", "btw", "afk", "yolo"]);
-		expect(second.commands).toEqual(["clear", "btw", "afk", "yolo"]);
-	});
-
-	test("/afk toggles shared state and status", async () => {
-		const { pi, handlers } = host();
-		extension(pi);
-		const statuses: Array<string | undefined> = [];
-		const notices: string[] = [];
-		const ctx = {
-			ui: {
-				theme: { fg: (color: string, text: string) => `<${color}>${text}</${color}>` },
-				setStatus: (_key: string, text: string | undefined) => statuses.push(text),
-				notify: (text: string) => notices.push(text),
-			},
-		};
-		const handler = handlers.get("afk");
-		if (!handler) throw new Error("/afk not registered");
-
-		await handler("", ctx as never);
-		expect(getUnattendedMode(pi.events)).toBe("afk");
-		expect(statuses.at(-1)).toBe(`<error>${icon("afk")} AFK</error>`);
-		expect(notices.at(-1)).toContain("yellow gates auto-allow");
-
-		await handler("", ctx as never);
-		expect(getUnattendedMode(pi.events)).toBe("off");
-		expect(statuses.at(-1)).toBeUndefined();
-	});
-});

package/src/unattended.test.ts

@@ -1,76 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { createEventBus } from "@earendil-works/pi-coding-agent";
-import {
-	confirmYoloConsent,
-	getMode,
-	modelScore,
-	setMode,
-	unattendedBanner,
-	YOLO_MIN_SCORE,
-} from "./unattended.ts";
-
-describe("unattended mode state", () => {
-	test("setMode updates one session", () => {
-		const events = createEventBus();
-		setMode(events, "afk");
-		expect(getMode(events)).toBe("afk");
-
-		setMode(events, "yolo");
-		expect(getMode(events)).toBe("yolo");
-
-		setMode(events, "off");
-		expect(getMode(events)).toBe("off");
-	});
-});
-
-describe("modelScore", () => {
-	test("returns null for an empty / off-catalog model", () => {
-		expect(modelScore({ model: undefined })).toBeNull();
-		expect(modelScore({ model: { id: "definitely-not-a-real-model-xyz" } })).toBeNull();
-	});
-});
-
-describe("unattendedBanner", () => {
-	test("off => no banner", () => {
-		const events = createEventBus();
-		setMode(events, "off");
-		expect(unattendedBanner(events)).toBeUndefined();
-	});
-
-	test("afk banner names auto-deny of red and root", () => {
-		const events = createEventBus();
-		setMode(events, "afk");
-		const b = unattendedBanner(events) ?? "";
-		expect(b).toContain('mode="afk"');
-		expect(b).toContain("auto-DENY");
-	});
-
-	test("yolo banner demands red/root self-justification", () => {
-		const events = createEventBus();
-		setMode(events, "yolo");
-		const b = unattendedBanner(events) ?? "";
-		expect(b).toContain('mode="yolo"');
-		expect(b).toContain("blast radius");
-		expect(b).toContain("reversible");
-	});
-});
-
-describe("YOLO score threshold", () => {
-	test("is a sane capability floor", () => {
-		expect(YOLO_MIN_SCORE).toBe(75);
-	});
-});
-
-describe("confirmYoloConsent (session gate)", () => {
-	test("short-circuits true once consent is recorded for the session", async () => {
-		const events = createEventBus();
-		const { setYoloConsent } = await import("@xynogen/pix-runtime");
-		setYoloConsent(events, true);
-		// No ui passed: if it did not short-circuit it would return false.
-		expect(await confirmYoloConsent(events, {})).toBe(true);
-	});
-
-	test("refuses when there is no ui to render the warning", async () => {
-		expect(await confirmYoloConsent(createEventBus(), {})).toBe(false);
-	});
-});