@howaboua/pi-ask 0.0.4 → 0.0.6

package/changelog.ts

@@ -0,0 +1,337 @@
+// Generated extension packages copy this file during changelog:extensions.
+
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+	DynamicBorder,
+	type ExtensionAPI,
+	getAgentDir,
+	getMarkdownTheme,
+} from "@earendil-works/pi-coding-agent";
+import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
+
+const ENTRY_TYPE = "@howaboua/pi-stuff/changelog";
+const REGISTRATION_CHANNEL = "@howaboua/pi-stuff/changelog/register/v1";
+const STATE_FILENAME = "howaboua-pi-stuff-changelog.json";
+const SUPPRESS_KEY = "suppress";
+const LOCK_STALE_MS = 30_000;
+const LOCK_TIMEOUT_MS = 2_000;
+
+interface PackageMetadata {
+	name: string;
+	version: string;
+}
+
+interface PackageRegistration extends PackageMetadata {
+	changelogPath: string;
+}
+
+interface RegistrationEvent {
+	accept: () => void;
+	registration: PackageRegistration;
+}
+
+interface ChangelogEntry {
+	content: string;
+	version: string;
+}
+
+interface ChangelogEntryData {
+	markdown: string;
+}
+
+type ChangelogState = Record<string, boolean | string>;
+
+function packageRegistration(): PackageRegistration {
+	const packageDirectory = fileURLToPath(new URL(".", import.meta.url));
+	const metadata = JSON.parse(
+		readFileSync(join(packageDirectory, "package.json"), "utf8"),
+	) as Partial<PackageMetadata>;
+	if (typeof metadata.name !== "string" || typeof metadata.version !== "string")
+		throw new Error(`Invalid package metadata in ${packageDirectory}`);
+	return {
+		name: metadata.name,
+		version: metadata.version,
+		changelogPath: join(packageDirectory, "CHANGELOG.md"),
+	};
+}
+
+function isRegistrationEvent(value: unknown): value is RegistrationEvent {
+	if (!value || typeof value !== "object") return false;
+	const event = value as Partial<RegistrationEvent>;
+	return (
+		typeof event.accept === "function" &&
+		typeof event.registration?.name === "string" &&
+		typeof event.registration.version === "string" &&
+		typeof event.registration.changelogPath === "string"
+	);
+}
+
+function parseChangelog(markdown: string): ChangelogEntry[] {
+	const entries: ChangelogEntry[] = [];
+	let currentLines: string[] = [];
+	let currentVersion: string | undefined;
+
+	for (const line of markdown.split("\n")) {
+		const version = line.match(/^##\s+\[?(\d+\.\d+\.\d+)\]?(?:\s.*)?$/)?.[1];
+		if (version) {
+			if (currentVersion)
+				entries.push({
+					content: currentLines.join("\n").trim(),
+					version: currentVersion,
+				});
+			currentVersion = version;
+			currentLines = [line];
+		} else if (currentVersion) {
+			currentLines.push(line);
+		}
+	}
+
+	if (currentVersion)
+		entries.push({
+			content: currentLines.join("\n").trim(),
+			version: currentVersion,
+		});
+	return entries;
+}
+
+function compareVersions(left: string, right: string): number {
+	const leftParts = left.split(".").map(Number);
+	const rightParts = right.split(".").map(Number);
+	for (let index = 0; index < 3; index++) {
+		const difference = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	return 0;
+}
+
+function isStableVersion(version: string): boolean {
+	return /^\d+\.\d+\.\d+$/.test(version);
+}
+
+function statePath(): string {
+	return join(getAgentDir(), STATE_FILENAME);
+}
+
+async function readState(path: string): Promise<ChangelogState> {
+	let text: string;
+	try {
+		text = await readFile(path, "utf8");
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+		throw error;
+	}
+	const parsed = JSON.parse(text) as unknown;
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+		throw new Error(`${path} must contain a JSON object`);
+	for (const [name, value] of Object.entries(parsed)) {
+		if (name === SUPPRESS_KEY) {
+			if (typeof value !== "boolean")
+				throw new Error(`${path} ${SUPPRESS_KEY} must be a boolean`);
+		} else if (typeof value !== "string") {
+			throw new Error(`${path} version for ${name} must be a string`);
+		}
+	}
+	return parsed as ChangelogState;
+}
+
+async function acquireLock(path: string): Promise<() => Promise<void>> {
+	const deadline = Date.now() + LOCK_TIMEOUT_MS;
+	while (true) {
+		try {
+			await mkdir(path);
+			return () => rm(path, { force: true, recursive: true });
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+			const info = await stat(path).catch(() => undefined);
+			if (info && Date.now() - info.mtimeMs > LOCK_STALE_MS) {
+				await rm(path, { force: true, recursive: true });
+				continue;
+			}
+			if (Date.now() >= deadline)
+				throw new Error(`Timed out waiting for ${path}`);
+			await new Promise((resolve) => setTimeout(resolve, 20));
+		}
+	}
+}
+
+async function writeState(path: string, state: ChangelogState): Promise<void> {
+	await mkdir(dirname(path), { mode: 0o700, recursive: true });
+	const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		const ordered = Object.fromEntries(
+			Object.entries(state).sort(([left], [right]) =>
+				left.localeCompare(right),
+			),
+		);
+		await writeFile(temporaryPath, `${JSON.stringify(ordered, null, 2)}\n`, {
+			encoding: "utf8",
+			mode: 0o600,
+		});
+		await rename(temporaryPath, path);
+	} catch (error) {
+		await rm(temporaryPath, { force: true });
+		throw error;
+	}
+}
+
+function packageMarkdown(
+	registration: PackageRegistration,
+	entries: ChangelogEntry[],
+): string {
+	const body = (entry: ChangelogEntry) =>
+		entry.content
+			.replace(/^##[^\n]*\n*/, "")
+			.replace(/^###\s+(?:Changes|Minor Changes|Patch Changes)\s*\n*/gim, "")
+			.replace(/^###\s+(.+)$/gm, "**$1**");
+	if (entries.length === 1) {
+		const [entry] = entries;
+		if (!entry) return "";
+		return `## ${registration.name} ${entry.version}\n\n${body(entry)}`;
+	}
+	return [
+		`## ${registration.name}`,
+		...entries.map((entry) => `**${entry.version}**\n\n${body(entry)}`),
+	].join("\n\n");
+}
+
+async function claimUpdates(
+	registrations: Iterable<PackageRegistration>,
+): Promise<{ errors: string[]; markdown?: string }> {
+	const stableRegistrations = [...registrations]
+		.filter((registration) => isStableVersion(registration.version))
+		.sort((left, right) => left.name.localeCompare(right.name));
+	if (stableRegistrations.length === 0) return { errors: [] };
+	const path = statePath();
+	await mkdir(dirname(path), { mode: 0o700, recursive: true });
+	const release = await acquireLock(`${path}.lock`);
+	try {
+		const state = await readState(path);
+		const errors: string[] = [];
+		const sections: string[] = [];
+		let changed = false;
+		if (state[SUPPRESS_KEY] === true) {
+			for (const registration of stableRegistrations) {
+				const seenVersion = state[registration.name];
+				if (
+					typeof seenVersion !== "string" ||
+					compareVersions(registration.version, seenVersion) > 0
+				) {
+					state[registration.name] = registration.version;
+					changed = true;
+				}
+			}
+			if (changed) await writeState(path, state);
+			return { errors };
+		}
+		for (const registration of stableRegistrations) {
+			const seenVersion = state[registration.name];
+			if (
+				typeof seenVersion === "string" &&
+				compareVersions(registration.version, seenVersion) <= 0
+			)
+				continue;
+			try {
+				const entries = parseChangelog(
+					await readFile(registration.changelogPath, "utf8"),
+				).filter(
+					(entry) =>
+						compareVersions(entry.version, registration.version) <= 0 &&
+						(typeof seenVersion === "string"
+							? compareVersions(entry.version, seenVersion) > 0
+							: entry.version === registration.version),
+				);
+				if (entries.length === 0) {
+					errors.push(
+						`No ${registration.version} changelog entry found for ${registration.name}`,
+					);
+					continue;
+				}
+				sections.push(packageMarkdown(registration, entries));
+				state[registration.name] = registration.version;
+				changed = true;
+			} catch (error) {
+				errors.push(
+					`Could not read the ${registration.name} changelog: ${error instanceof Error ? error.message : String(error)}`,
+				);
+			}
+		}
+		if (changed) await writeState(path, state);
+		return {
+			errors,
+			...(sections.length > 0 ? { markdown: sections.join("\n\n") } : {}),
+		};
+	} finally {
+		await release();
+	}
+}
+
+function registerCoordinator(
+	pi: ExtensionAPI,
+	registration: PackageRegistration,
+): void {
+	let accepted = false;
+	pi.events.emit(REGISTRATION_CHANNEL, {
+		registration,
+		accept: () => {
+			accepted = true;
+		},
+	} satisfies RegistrationEvent);
+	if (accepted) return;
+
+	const registrations = new Map([[registration.name, registration]]);
+	pi.events.on(REGISTRATION_CHANNEL, (value) => {
+		if (!isRegistrationEvent(value)) return;
+		registrations.set(value.registration.name, value.registration);
+		value.accept();
+	});
+	pi.registerEntryRenderer<ChangelogEntryData>(
+		ENTRY_TYPE,
+		(entry, _options, theme) => {
+			if (!entry.data) return undefined;
+			const container = new Container();
+			container.addChild(new DynamicBorder());
+			container.addChild(
+				new Text(theme.bold(theme.fg("accent", "What's New")), 1, 0),
+			);
+			container.addChild(new Spacer(1));
+			container.addChild(
+				new Markdown(entry.data.markdown.trim(), 1, 0, getMarkdownTheme()),
+			);
+			container.addChild(new Spacer(1));
+			container.addChild(new DynamicBorder());
+			return container;
+		},
+	);
+	pi.on("session_start", async (event, ctx) => {
+		if (event.reason === "reload" || ctx.mode !== "tui") return;
+		if (
+			ctx.sessionManager
+				.getEntries()
+				.some((entry) =>
+					["branch_summary", "compaction", "message"].includes(entry.type),
+				)
+		)
+			return;
+		try {
+			const update = await claimUpdates(registrations.values());
+			if (update.markdown)
+				pi.appendEntry<ChangelogEntryData>(ENTRY_TYPE, {
+					markdown: update.markdown,
+				});
+			for (const error of update.errors) ctx.ui.notify(error, "warning");
+		} catch (error) {
+			ctx.ui.notify(
+				`Could not update Howaboua changelog state: ${error instanceof Error ? error.message : String(error)}`,
+				"warning",
+			);
+		}
+	});
+}
+
+export default function howabouaPackageChangelog(pi: ExtensionAPI): void {
+	registerCoordinator(pi, packageRegistration());
+}

package/index.ts

@@ -3,17 +3,33 @@ import { fileURLToPath } from "node:url";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { loadAskConfig } from "./ask/config.js";
 import { createAskTool } from "./ask/tool.js";
+import registerPackageChangelog from "./changelog.js";
 
 export { createAskTool } from "./ask/tool.js";
 
 const PROMPTS_DIR = join(dirname(fileURLToPath(import.meta.url)), "prompts");
+const REALTIME_VOICE_PROMPT_CHANNEL =
+	"@howaboua/pi-codex-conversion/realtime-voice-prompt/v1";
+const CODE_MODE_PACKAGE = "@howaboua/pi-codex-conversion";
+const CODE_MODE_MODULE = `${CODE_MODE_PACKAGE}/code-mode`;
 
-export default function humanInTheLoop(pi: ExtensionAPI): void {
-	pi.registerTool(
-		createAskTool({
-			onBlockedChange: (state) => pi.events.emit("herdr:blocked", state),
-		}),
-	);
+export default async function humanInTheLoop(pi: ExtensionAPI): Promise<void> {
+	registerPackageChangelog(pi);
+	const ask = createAskTool({
+		onBlockedChange: (state) => {
+			pi.events.emit(REALTIME_VOICE_PROMPT_CHANNEL, {
+				id: state.id,
+				active: state.active,
+				prompt: state.prompt,
+			});
+			pi.events.emit("herdr:blocked", {
+				active: state.active,
+				label: state.label,
+			});
+		},
+	});
+	pi.registerTool(ask);
+	await registerAskInCodeMode(pi, ask);
 	pi.on("resources_discover", () => {
 		const config = loadAskConfig();
 		return {
@@ -24,3 +40,67 @@ export default function humanInTheLoop(pi: ExtensionAPI): void {
 		};
 	});
 }
+
+async function registerAskInCodeMode(
+	pi: ExtensionAPI,
+	ask: ReturnType<typeof createAskTool>,
+): Promise<void> {
+	try {
+		const { adaptToolForCodeMode, registerCodeModeExtensionTools } =
+			await import("@howaboua/pi-codex-conversion/code-mode");
+		const registration = registerCodeModeExtensionTools(pi, () => [
+			adaptToolForCodeMode(ask, {
+				blocking: true,
+				usage:
+					"await tools.ask({ prompts: [{ title, body?, multiple?, choices?: [{ label, description? }] }], handoff? })",
+			}),
+		]);
+		pi.on("session_shutdown", () => registration.unregister());
+	} catch (error) {
+		if (isMissingCodeModeExtension(error)) return;
+		if (isOutdatedCodeModeExtension(error)) {
+			throw new Error(
+				"Update " +
+					CODE_MODE_PACKAGE +
+					" to 3.0.24 or newer to use Pi Ask with it",
+				{ cause: error },
+			);
+		}
+		throw error;
+	}
+}
+
+function isMissingCodeModeExtension(error: unknown): boolean {
+	if (
+		!error ||
+		typeof error !== "object" ||
+		!("code" in error) ||
+		(error.code !== "ERR_MODULE_NOT_FOUND" &&
+			error.code !== "MODULE_NOT_FOUND") ||
+		!("message" in error) ||
+		typeof error.message !== "string"
+	)
+		return false;
+	const missing = error.message.match(
+		/Cannot find (?:package|module) ['"]([^'"]+)['"]/,
+	)?.[1];
+	return missing === CODE_MODE_PACKAGE || missing === CODE_MODE_MODULE;
+}
+
+function isOutdatedCodeModeExtension(error: unknown): boolean {
+	if (
+		!error ||
+		typeof error !== "object" ||
+		!("code" in error) ||
+		!("message" in error) ||
+		typeof error.message !== "string"
+	)
+		return false;
+	return (
+		(error.code === "ERR_PACKAGE_PATH_NOT_EXPORTED" ||
+			error.code === "ERR_UNSUPPORTED_DIR_IMPORT") &&
+		(error.message.includes(CODE_MODE_MODULE) ||
+			(error.message.includes("Package subpath './code-mode'") &&
+				error.message.includes(CODE_MODE_PACKAGE)))
+	);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@howaboua/pi-ask",
-	"version": "0.0.4",
+	"version": "0.0.6",
 	"description": "Interactive decisions, review triage, and human handoffs for Pi.",
 	"type": "module",
 	"license": "MIT",
@@ -35,7 +35,9 @@
 		"README.md",
 		"LICENSE",
 		"tsconfig.json",
-		"biome.json"
+		"biome.json",
+		"changelog.ts",
+		"CHANGELOG.md"
 	],
 	"pi": {
 		"extensions": [
@@ -43,16 +45,23 @@
 		]
 	},
 	"peerDependencies": {
-		"@earendil-works/pi-coding-agent": ">=0.80.7",
-		"@earendil-works/pi-tui": ">=0.80.7",
+		"@howaboua/pi-codex-conversion": ">=3.0.24",
+		"@earendil-works/pi-coding-agent": ">=0.84.3",
+		"@earendil-works/pi-tui": ">=0.84.3",
 		"typebox": "*"
 	},
+	"peerDependenciesMeta": {
+		"@howaboua/pi-codex-conversion": {
+			"optional": true
+		}
+	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.4.16",
-		"@earendil-works/pi-coding-agent": "0.80.8",
-		"@earendil-works/pi-tui": "0.80.8",
-		"typebox": "1.1.38",
-		"typescript": "^6.0.3"
+		"@howaboua/pi-codex-conversion": "3.0.24",
+		"@biomejs/biome": "^2.5.10",
+		"@earendil-works/pi-coding-agent": "0.84.4",
+		"@earendil-works/pi-tui": "0.84.4",
+		"typebox": "1.3.18",
+		"typescript": "^7.0.2"
 	},
 	"scripts": {
 		"check": "bun run lint && bun run typecheck && bun run test",