@quandev104/pi-style 0.1.1

package/extension-src/pi-style/pi/compatibility-registry.ts

@@ -0,0 +1,329 @@
+export type CompatibilitySubtype =
+	| "native-user-message"
+	| "native-assistant-message"
+	| "native-compaction-message"
+	| "native-branch-message"
+	| "native-skill-message"
+	| "native-custom-message"
+	| "tool-call-renderer"
+	| "tool-result-renderer";
+
+type CompatibilityShape = "supported" | "unsupported" | "conflict" | "installed" | "skipped";
+
+export interface CompatibilityRecord {
+	feature: "messages" | "tools";
+	subtype: CompatibilitySubtype;
+	target: object;
+	owner: object;
+	method: PropertyKey;
+	originalIdentity: unknown;
+	originalDescriptor?: PropertyDescriptor;
+	installedIdentity?: unknown;
+	piVersion: string;
+	versionRange: string;
+	shape: CompatibilityShape;
+	diagnostic?: string | undefined;
+	generation: number;
+	disposed: boolean;
+	disposer: () => void;
+}
+
+export interface InstallResult {
+	status: "installed" | "already-installed" | "skipped";
+	record: CompatibilityRecord;
+	reason?: string | undefined;
+}
+
+const recordsByOwner = new WeakMap<object, Map<PropertyKey, CompatibilityRecord>>();
+let generation = 0;
+let registryTestHooks: {
+	afterWrite?: () => void;
+	defineProperty?: (target: object, key: PropertyKey, descriptor: PropertyDescriptor) => boolean;
+} = {};
+export function __setCompatibilityRegistryTestHooks(hooks: typeof registryTestHooks): () => void {
+	const previous = registryTestHooks;
+	registryTestHooks = hooks;
+	return () => {
+		registryTestHooks = previous;
+	};
+}
+
+function ownerRecords(owner: object): Map<PropertyKey, CompatibilityRecord> {
+	let records = recordsByOwner.get(owner);
+	if (!records) {
+		records = new Map();
+		recordsByOwner.set(owner, records);
+	}
+	return records;
+}
+
+export function currentGeneration(): number {
+	return generation;
+}
+export function nextGeneration(): number {
+	return ++generation;
+}
+export function getCompatibilityRecords(owner: object): readonly CompatibilityRecord[] {
+	return [...(recordsByOwner.get(owner)?.values() ?? [])];
+}
+
+function safeRead(target: object, method: PropertyKey): unknown {
+	try {
+		return Reflect.get(target, method);
+	} catch {
+		return undefined;
+	}
+}
+
+function skippedRecord(options: {
+	feature: CompatibilityRecord["feature"];
+	subtype: CompatibilitySubtype;
+	target: object;
+	method: PropertyKey;
+	piVersion: string;
+	versionRange: string;
+	shape: CompatibilityShape;
+	diagnostic: string;
+	generation: number;
+	originalIdentity?: unknown;
+}): CompatibilityRecord {
+	return {
+		...options,
+		owner: options.target,
+		originalIdentity: Object.hasOwn(options, "originalIdentity")
+			? options.originalIdentity
+			: safeRead(options.target, options.method),
+		disposed: true,
+		disposer: () => {},
+	};
+}
+
+function descriptorMatches(actual: PropertyDescriptor | undefined, expected: PropertyDescriptor | undefined): boolean {
+	if (!actual || !expected) return actual === expected;
+	return (
+		actual.value === expected.value &&
+		actual.get === expected.get &&
+		actual.set === expected.set &&
+		actual.writable === expected.writable &&
+		actual.enumerable === expected.enumerable &&
+		actual.configurable === expected.configurable
+	);
+}
+
+function restoreExact(record: CompatibilityRecord): { ok: boolean; diagnostic?: string } {
+	try {
+		const current = Object.getOwnPropertyDescriptor(record.target, record.method);
+		const installed = current?.value === record.installedIdentity;
+		if (!installed) return { ok: false, diagnostic: "current owner changed; native/later owner preserved" };
+		const defineProperty = registryTestHooks.defineProperty ?? Reflect.defineProperty;
+		const wrote = record.originalDescriptor
+			? defineProperty(record.target, record.method, record.originalDescriptor)
+			: Reflect.deleteProperty(record.target, record.method);
+		if (!wrote) return { ok: false, diagnostic: "exact descriptor restoration was rejected" };
+		if (!descriptorMatches(Object.getOwnPropertyDescriptor(record.target, record.method), record.originalDescriptor))
+			return { ok: false, diagnostic: "post-restore descriptor validation failed" };
+		return { ok: true };
+	} catch (error) {
+		return { ok: false, diagnostic: `restore failed: ${error instanceof Error ? error.message : String(error)}` };
+	}
+}
+
+function inspectCurrent(
+	target: object,
+	method: PropertyKey,
+): { current?: unknown; descriptor?: PropertyDescriptor; error?: string } {
+	try {
+		const descriptor = Object.getOwnPropertyDescriptor(target, method);
+		return {
+			current: descriptor && "value" in descriptor ? descriptor.value : undefined,
+			...(descriptor ? { descriptor } : {}),
+		};
+	} catch (error) {
+		return { error: `cannot inspect target: ${error instanceof Error ? error.message : String(error)}` };
+	}
+}
+
+function skippedResult(
+	options: Parameters<typeof installDelegatingPatch>[0],
+	shape: CompatibilityShape,
+	reason: string,
+	originalIdentity?: unknown,
+): InstallResult {
+	return {
+		status: "skipped",
+		reason,
+		record: skippedRecord({ ...options, shape, diagnostic: reason, originalIdentity }),
+	};
+}
+
+function expectedIdentityMatches(options: Parameters<typeof installDelegatingPatch>[0], current: unknown): boolean {
+	const expected =
+		options.hasExpectedIdentity === true ||
+		(options.hasExpectedIdentity === undefined && options.expectedIdentity !== undefined);
+	return !expected || current === options.expectedIdentity;
+}
+
+function validateInstall(
+	options: Parameters<typeof installDelegatingPatch>[0],
+	current: unknown,
+	existing: CompatibilityRecord | undefined,
+	ownDescriptor: PropertyDescriptor | undefined,
+): InstallResult | undefined {
+	if (!options.shape) return skippedResult(options, "unsupported", options.diagnostic ?? "unsupported shape", current);
+	const conflict = existing && activeConflict(existing, current, options.generation);
+	if (conflict) return conflict;
+	if (typeof current !== "function")
+		return skippedResult(
+			options,
+			ownDescriptor ? "unsupported" : "skipped",
+			"target property is not callable",
+			current,
+		);
+	if (!expectedIdentityMatches(options, current))
+		return skippedResult(options, "conflict", "current owner is not the captured pristine native identity", current);
+	return undefined;
+}
+
+function activeConflict(
+	existing: CompatibilityRecord,
+	current: unknown,
+	generation: number,
+): InstallResult | undefined {
+	if (existing.disposed) return undefined;
+	if (existing.installedIdentity === current && existing.generation === generation)
+		return { status: "already-installed", record: existing };
+	const reason =
+		existing.installedIdentity === current
+			? "active wrapper belongs to a different generation"
+			: "owner changed after pi-style installation";
+	return {
+		status: "skipped",
+		reason,
+		record: skippedRecord({
+			feature: existing.feature,
+			subtype: existing.subtype,
+			target: existing.target,
+			method: existing.method,
+			piVersion: existing.piVersion,
+			versionRange: existing.versionRange,
+			shape: "conflict",
+			diagnostic: reason,
+			generation,
+			originalIdentity: current,
+		}),
+	};
+}
+
+export function installDelegatingPatch(options: {
+	feature: CompatibilityRecord["feature"];
+	subtype: CompatibilitySubtype;
+	target: object;
+	method: PropertyKey;
+	piVersion: string;
+	versionRange: string;
+	shape: boolean;
+	generation: number;
+	expectedIdentity?: unknown;
+	hasExpectedIdentity?: boolean;
+	diagnostic?: string | undefined;
+	delegate: (original: unknown, thisArg: object, args: unknown[]) => unknown;
+}): InstallResult {
+	const { target, method } = options;
+	const inspection = inspectCurrent(target, method);
+	if (inspection.error) return skippedResult(options, "skipped", inspection.error);
+	const current = inspection.current;
+	const records = ownerRecords(target);
+	const validation = validateInstall(options, current, records.get(method), inspection.descriptor);
+	if (validation) return validation;
+	const originalDescriptor = Object.getOwnPropertyDescriptor(target, method);
+	const originalIdentity = current;
+	let active = true;
+	const installed = function (this: object, ...args: unknown[]): unknown {
+		if (!active) return Reflect.apply(originalIdentity as (...values: unknown[]) => unknown, this, args);
+		return options.delegate(originalIdentity, this, args);
+	};
+	const record: CompatibilityRecord = {
+		feature: options.feature,
+		subtype: options.subtype,
+		target,
+		owner: target,
+		method,
+		originalIdentity,
+		...(originalDescriptor ? { originalDescriptor } : {}),
+		installedIdentity: installed,
+		piVersion: options.piVersion,
+		versionRange: options.versionRange,
+		shape: "installed",
+		diagnostic: options.diagnostic,
+		generation: options.generation,
+		disposed: false,
+		disposer: () => {},
+	};
+	try {
+		Object.defineProperty(installed, "__piStyleCompatibilityRecord", { value: record, configurable: false });
+		const descriptor = { ...originalDescriptor, value: installed };
+		const wrote = Reflect.defineProperty(target, method, descriptor);
+		registryTestHooks.afterWrite?.();
+		const currentDescriptor = Object.getOwnPropertyDescriptor(target, method);
+		if (!wrote) return skippedResult(options, "skipped", "installation write was rejected");
+		if (!descriptorMatches(currentDescriptor, descriptor)) {
+			if (currentDescriptor?.value === installed) {
+				const rollback = restoreExact({ ...record, installedIdentity: installed });
+				if (!rollback.ok) {
+					record.diagnostic = rollback.diagnostic;
+					records.set(method, record);
+					return { status: "skipped", reason: rollback.diagnostic, record };
+				}
+			}
+			const reason =
+				currentDescriptor?.value === installed
+					? "wrapper-owned descriptor mismatch rolled back"
+					: "later owner preserved after post-write mismatch";
+			return {
+				status: "skipped",
+				reason,
+				record: skippedRecord({
+					...options,
+					shape: "conflict",
+					diagnostic: reason,
+					originalIdentity: currentDescriptor?.value,
+				}),
+			};
+		}
+		records.set(method, record);
+		record.disposer = () => {
+			if (record.disposed) return;
+			const restored = restoreExact(record);
+			if (!restored.ok) {
+				record.diagnostic = restored.diagnostic;
+				return;
+			}
+			active = false;
+			record.disposed = true;
+			records.delete(method);
+		};
+		return { status: "installed", record };
+	} catch (error) {
+		const currentDescriptor = Object.getOwnPropertyDescriptor(target, method);
+		const rollback =
+			currentDescriptor?.value === installed ? restoreExact({ ...record, installedIdentity: installed }) : { ok: true };
+		const reason = `installation rolled back (${rollback.diagnostic ?? "ok"}): ${error instanceof Error ? error.message : String(error)}`;
+		if (currentDescriptor?.value === installed && !rollback.ok) {
+			record.diagnostic = reason;
+			records.set(method, record);
+			record.disposer = () => {
+				if (record.disposed) return;
+				const retry = restoreExact(record);
+				if (!retry.ok) {
+					record.diagnostic = retry.diagnostic;
+					return;
+				}
+				active = false;
+				record.disposed = true;
+				records.delete(method);
+			};
+			return { status: "installed", reason, record };
+		}
+		return { status: "skipped", reason, record: skippedRecord({ ...options, shape: "skipped", diagnostic: reason }) };
+	}
+}

package/extension-src/pi-style/pi/config-host.ts

@@ -0,0 +1,52 @@
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { ConfigFilePort, ConfigStoragePaths } from "../app/config-storage.js";
+
+const locks = new Map<string, Promise<void>>();
+
+function serialize(path: string, operation: () => Promise<void>): Promise<void> {
+	const previous = locks.get(path) ?? Promise.resolve();
+	const current = previous.catch(() => undefined).then(operation);
+	locks.set(path, current);
+	return current.finally(() => {
+		if (locks.get(path) === current) locks.delete(path);
+	});
+}
+
+export interface ConfigHostFs {
+	readonly mkdir?: typeof mkdir;
+	readonly readFile?: typeof readFile;
+	readonly rename?: typeof rename;
+	readonly unlink?: typeof unlink;
+	readonly writeFile?: typeof writeFile;
+}
+
+export function createPiConfigFilePort(fs: ConfigHostFs = {}): ConfigFilePort {
+	const fsMkdir = fs.mkdir ?? mkdir;
+	const fsReadFile = fs.readFile ?? readFile;
+	const fsRename = fs.rename ?? rename;
+	const fsUnlink = fs.unlink ?? unlink;
+	const fsWriteFile = fs.writeFile ?? writeFile;
+	return {
+		read: (path) => fsReadFile(path, "utf8"),
+		writeAtomic: async (path, content) =>
+			serialize(path, async () => {
+				await fsMkdir(dirname(path), { recursive: true });
+				const temporary = `${path}.pi-style-${process.pid}-${Date.now()}.tmp`;
+				try {
+					await fsWriteFile(temporary, content, { mode: 0o600 });
+					await fsRename(temporary, path);
+				} finally {
+					await fsUnlink(temporary).catch(() => undefined);
+				}
+			}),
+	};
+}
+
+export function defaultStoragePaths(cwd: string, overrides: Partial<ConfigStoragePaths> = {}): ConfigStoragePaths {
+	return {
+		globalPath: overrides.globalPath ?? join(getAgentDir(), "settings.json"),
+		projectPath: overrides.projectPath ?? join(cwd, CONFIG_DIR_NAME, "settings.json"),
+	};
+}

package/extension-src/pi-style/pi/config-session.ts

@@ -0,0 +1,105 @@
+import type { ConfigFilePort } from "../app/config-storage.js";
+import { readScopedConfig } from "../app/config-storage.js";
+import type { ConfigDiagnostic } from "../domain/config-diagnostics.js";
+import { resolveConfigDetailed } from "../domain/config-normalization.js";
+
+export interface SessionFlagReader {
+	getFlag(name: string): unknown;
+}
+export interface SessionAuthorization {
+	core: boolean;
+	user: boolean;
+	assistant: boolean;
+	specialBlocks: boolean;
+	tools: boolean;
+	ascii: boolean;
+}
+export interface ProductPolicy {
+	readonly corePatchGate: "omitted" | "allow" | "deny";
+}
+export interface ConfigSourceAdapter {
+	setSession(cwd: string, trusted: boolean): void;
+	load(): Promise<{
+		config: unknown;
+		diagnostics: readonly ConfigDiagnostic[];
+		sources: Readonly<Record<string, string>>;
+		rawSources?: {
+			defaults?: unknown;
+			global?: unknown;
+			project?: unknown;
+			environment?: Record<string, string | undefined>;
+		};
+		productPolicy?: ProductPolicy;
+	}>;
+}
+
+function sessionOverrides(_pi: SessionFlagReader): Record<string, unknown> {
+	return {};
+}
+
+/** Product policy is deny-only: any explicit false wins; true never grants Tier C. */
+export function resolveProductGate(
+	global: unknown,
+	project: unknown,
+	session: unknown,
+	projectTrusted: boolean,
+): ProductPolicy {
+	const values = [global, projectTrusted ? project : undefined, session];
+	for (const value of values) {
+		if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+		const compatibility = (value as Record<string, unknown>).compatibility;
+		if (!compatibility || typeof compatibility !== "object" || Array.isArray(compatibility)) continue;
+		if (!Object.hasOwn(compatibility, "allowCorePatches")) continue;
+		const leaf = (compatibility as Record<string, unknown>).allowCorePatches;
+		if (leaf === false) return { corePatchGate: "deny" };
+	}
+	return { corePatchGate: "omitted" };
+}
+
+export function readSessionAuthorization(pi: SessionFlagReader): SessionAuthorization {
+	return {
+		core: pi.getFlag("pi-style-core-patches") === true,
+		user: pi.getFlag("pi-style-message-user") === true,
+		assistant: pi.getFlag("pi-style-message-assistant") === true,
+		specialBlocks: pi.getFlag("pi-style-message-special-blocks") === true,
+		tools: pi.getFlag("pi-style-tools") === true,
+		ascii: pi.getFlag("pi-style-ascii") === true,
+	};
+}
+
+export function createConfigSourceAdapter(
+	pi: SessionFlagReader,
+	port: ConfigFilePort,
+	paths: (cwd: string) => { globalPath: string; projectPath: string },
+): ConfigSourceAdapter {
+	let trusted = true;
+	let currentCwd = process.cwd();
+	return {
+		setSession(nextCwd, nextTrusted) {
+			currentCwd = nextCwd;
+			trusted = nextTrusted;
+		},
+		async load() {
+			const storage = paths(currentCwd);
+			const global = await readScopedConfig(port, storage.globalPath);
+			const project = trusted ? await readScopedConfig(port, storage.projectPath) : undefined;
+			const resolved = resolveConfigDetailed({
+				global: global.value,
+				project: project?.value,
+				projectTrusted: trusted,
+				environment: process.env,
+				session: sessionOverrides(pi),
+			});
+			const productPolicy = resolveProductGate(global.value, project?.value, sessionOverrides(pi), trusted);
+			return {
+				config: resolved.config,
+				diagnostics: [...global.diagnostics, ...(project?.diagnostics ?? []), ...resolved.diagnostics],
+				sources: resolved.sources,
+				rawSources: { global: global.value, project: project?.value, environment: process.env },
+				productPolicy,
+			};
+		},
+	};
+}
+
+export { sessionOverrides };

package/extension-src/pi-style/pi/index.ts

@@ -0,0 +1,77 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { StatusSnapshot } from "../domain/status.js";
+import { registerPiStyleCommand } from "./commands.js";
+import { type CompatibilityTestHooks, createPiStyleSessionCoordinator } from "./session-coordinator.js";
+import { usageFromSession } from "./session-usage.js";
+
+/** Usage patch that omits the key when no session usage exists (exact optional types). */
+function usagePatch(ctx: ExtensionContext): StatusSnapshot {
+	const usage = usageFromSession(ctx.sessionManager);
+	return usage ? { usage } : {};
+}
+
+let compatibilityTestHooks: CompatibilityTestHooks = {};
+export function __setCompatibilityTestHooks(hooks: CompatibilityTestHooks): () => void {
+	const previous = compatibilityTestHooks;
+	compatibilityTestHooks = hooks;
+	return () => {
+		compatibilityTestHooks = previous;
+	};
+}
+
+/** Thin Pi adapter: register flags, commands, and forward lifecycle events. */
+export default function piStyleExtension(pi: ExtensionAPI): void {
+	// The core/message/tool surfaces are default-on (safe: fingerprint-certified against
+	// exact Pi 0.83.0, fail-closed elsewhere, conflict-preserving). The OFF switch is the
+	// product gate `compatibility.allowCorePatches: false` (or `enabled: false`) in config.
+	for (const [name, description] of [
+		["pi-style-core-patches", "Enable pi-style message/tool core patches"],
+		["pi-style-message-user", "Enable pi-style user message prefix"],
+		["pi-style-message-assistant", "Enable pi-style assistant message prefix"],
+		["pi-style-message-special-blocks", "Enable pi-style boxed compaction/skill/branch/custom message blocks"],
+		["pi-style-tools", "Enable pi-style tool renderer decoration"],
+	] as const)
+		pi.registerFlag(name, { type: "boolean", description, default: true });
+	// ASCII markers stay opt-in; unicode markers are the default.
+	pi.registerFlag("pi-style-ascii", { type: "boolean", description: "Use ASCII pi-style markers" });
+	const coordinator = createPiStyleSessionCoordinator(pi, compatibilityTestHooks);
+	registerPiStyleCommand(pi, coordinator.app);
+	pi.on("session_start", async (event, ctx) => {
+		await coordinator.start(event, ctx);
+	});
+	pi.on("agent_start", () => coordinator.app.runtime.current?.dismissStartup());
+	pi.on("input", () => coordinator.app.runtime.current?.dismissStartup());
+	pi.on("tool_execution_start", () => coordinator.app.runtime.current?.dismissStartup());
+	pi.on("model_select", (event) =>
+		coordinator.app.update(
+			{
+				model: event.model.name || event.model.id,
+				...(event.model.provider ? { provider: event.model.provider } : {}),
+				...(event.model.reasoning !== undefined ? { reasoning: event.model.reasoning } : {}),
+			},
+			"immediate",
+		),
+	);
+	pi.on("thinking_level_select", (event) => coordinator.app.update({ thinkingLevel: event.level }, "immediate"));
+	pi.on("session_info_changed", (event) => coordinator.app.update({ sessionName: event.name }, "coalesced"));
+	pi.on("message_update", () => coordinator.app.update({}, "coalesced"));
+	// Usage (tokens + cost) is aggregated from finalized session entries at
+	// message/turn boundaries, mirroring Pi's native footer; per-chunk updates
+	// stay usage-free to keep streaming cheap.
+	pi.on("message_end", (_event, ctx) => coordinator.app.update({ ...usagePatch(ctx) }, "coalesced"));
+	pi.on("turn_end", (_event, ctx) => coordinator.app.update({ ...usagePatch(ctx) }, "deferred"));
+	pi.on("agent_settled", (_event, ctx) => coordinator.app.update({ ...usagePatch(ctx) }, "coalesced"));
+	pi.on("session_tree", (_event, ctx) => coordinator.app.update({ ...usagePatch(ctx) }, "deferred"));
+	pi.on("session_compact", (_event, ctx) => coordinator.app.update({ ...usagePatch(ctx) }, "deferred"));
+	pi.on("tool_result", (event, ctx) => {
+		if (["write", "edit", "bash"].includes(event.toolName)) {
+			coordinator.app.runtime.current?.invalidateGit();
+			coordinator.app.update({ ...usagePatch(ctx) }, "delayed-retry");
+		}
+	});
+	pi.on("user_bash", (_event, ctx) => {
+		coordinator.app.runtime.current?.invalidateGit();
+		coordinator.app.update({ ...usagePatch(ctx) }, "delayed-retry");
+	});
+	pi.on("session_shutdown", () => coordinator.shutdown());
+}

package/extension-src/pi-style/pi/operational-state.ts

@@ -0,0 +1,29 @@
+import type { RuntimeInstallationState } from "../app/runtime.js";
+import type { NormalizedPiStyleConfig } from "../domain/config-types.js";
+import type { CompatibilityCoordinator } from "./compatibility-coordinator.js";
+
+export function buildOperationalState(
+	config: NormalizedPiStyleConfig,
+	authorization: { core: boolean; productCorePatchGate?: string },
+	compatibility: CompatibilityCoordinator,
+	installationState?: RuntimeInstallationState,
+	productCorePatchGate?: string,
+): Readonly<Record<string, unknown>> {
+	return {
+		compatibility: {
+			...compatibility.state(config),
+			configuredByProduct: config.messages.enabled || config.tools.enabled,
+		},
+		installations: installationState ?? {
+			status: config.enabled && config.statusLine.enabled ? "active" : "disabled",
+			editor: config.enabled && config.editor.enabled ? "active" : "disabled",
+			startup: config.enabled && config.startup.mode !== "off" ? "active" : "disabled",
+		},
+		provider: { status: "unavailable", recovery: "inject a capability-safe provider" },
+		authorization: {
+			core: authorization.core,
+			...(authorization.productCorePatchGate ? { productCorePatchGate: authorization.productCorePatchGate } : {}),
+			...(productCorePatchGate ? { productCorePatchGate } : {}),
+		},
+	};
+}