@quandev104/pi-style 0.1.1

package/extension-src/pi-style/app/runtime.ts

@@ -0,0 +1,404 @@
+import type { ExtensionContext, ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import { diffConfig } from "../domain/config-diff.js";
+import type { NormalizedPiStyleConfig } from "../domain/config-types.js";
+import type { GitCommandRunner } from "../domain/providers.js";
+import type { StatusSnapshot } from "../domain/status.js";
+import { normalizeThinkingLevel } from "../domain/status.js";
+import { installEditor } from "../features/editor/index.js";
+import {
+	installStartup,
+	type StartupHost,
+	type StartupReason,
+	type StartupResources,
+	type StartupSnapshot,
+} from "../features/startup/index.js";
+import { installStatusLine } from "../features/status-line/index.js";
+import { DisposableStore } from "../shared/disposable-store.js";
+import { CachedGitProvider, InMemoryContextProvider, InMemoryUsageProvider } from "./providers.js";
+import { RenderScheduler } from "./render-scheduler.js";
+import { createSnapshot, replaceSnapshot, type UiSnapshot } from "./snapshot.js";
+
+export interface RuntimeInstallationState {
+	readonly status: "installed" | "disabled" | "failed";
+	readonly editor: "installed" | "preserved" | "disabled" | "failed";
+	readonly startup: "installed" | "disabled" | "failed";
+}
+
+export interface PiStyleRuntime {
+	generation: number;
+	readonly providerIdentity: { git: object; context: object; usage: object };
+	readonly installationState: RuntimeInstallationState;
+	mode: ExtensionContext["mode"];
+	hasUI: boolean;
+	disposed: boolean;
+	snapshot: UiSnapshot;
+	disposables: DisposableStore;
+	scheduler: RenderScheduler;
+	update(values: StatusSnapshot): void;
+	updateStartupResources(resources: StartupResources): void;
+	dismissStartup(): void;
+	invalidateGit(): void;
+	configure(config: NormalizedPiStyleConfig): void;
+	dispose(): void;
+}
+
+export interface RuntimeHost {
+	readonly mode: ExtensionContext["mode"];
+	readonly hasUI: boolean;
+	readonly ui?: ExtensionUIContext;
+	readonly cwd?: string;
+	readonly model?: { id?: string; name?: string; provider?: string; reasoning?: boolean } | undefined;
+	readonly thinkingLevel?: string | undefined;
+	readonly config: NormalizedPiStyleConfig;
+	readonly startupReason?: StartupReason;
+	readonly provider?: string;
+	readonly requestRender?: () => void;
+	readonly resources?: StartupResources;
+	readonly extensionStatusProvider?: () => readonly import("../domain/status.js").ExtensionStatus[] | undefined;
+	readonly gitRunner?: GitCommandRunner;
+	getContextUsage?:
+		| (() => { tokens: number | null; contextWindow: number; percent: number | null } | undefined)
+		| undefined;
+}
+
+export function createPiStyleRuntime(
+	host: RuntimeHost,
+	generation: number,
+	requestRender: () => void = () => {},
+): PiStyleRuntime {
+	let disposed = false;
+	const extensionStatuses = (): readonly import("../domain/status.js").ExtensionStatus[] | undefined => {
+		if (!host.extensionStatusProvider) return undefined;
+		try {
+			return host.extensionStatusProvider();
+		} catch {
+			host.ui?.notify?.("pi-style extension statuses unavailable; provider recovery required", "warning");
+			return [];
+		}
+	};
+	let currentConfig = host.config;
+	const disposables = new DisposableStore();
+	const scheduler = new RenderScheduler({ requestRender }, generation, () => !disposed);
+	const git = new CachedGitProvider(host.gitRunner);
+	const contextProvider = new InMemoryContextProvider();
+	const usageProvider = new InMemoryUsageProvider();
+	const usage = host.getContextUsage?.();
+	const initialStatuses = extensionStatuses();
+	const initialValues = {
+		...(initialStatuses ? { extensionStatuses: initialStatuses } : {}),
+		...(host.model?.name || host.model?.id ? { model: host.model.name ?? host.model.id } : {}),
+		...(host.model?.provider ? { provider: host.model.provider } : {}),
+		...(host.model?.reasoning !== undefined ? { reasoning: host.model.reasoning } : {}),
+		...(host.thinkingLevel ? { thinkingLevel: normalizeThinkingLevel(host.thinkingLevel) } : {}),
+		...(host.cwd ? { cwd: host.cwd } : {}),
+		...(usage
+			? {
+					context: {
+						...(usage.tokens !== null ? { currentTokens: usage.tokens } : {}),
+						windowTokens: usage.contextWindow,
+						...(usage.percent !== null ? { percent: usage.percent } : {}),
+					},
+				}
+			: {}),
+	};
+	let currentSnapshot = createSnapshot(generation, 0, initialValues);
+	let statusLine: ReturnType<typeof installStatusLine> | undefined;
+	let editor: ReturnType<typeof installEditor> | undefined;
+	let startup: ReturnType<typeof installStartup> | undefined;
+	let installationState: RuntimeInstallationState = {
+		status: "disabled",
+		editor: "disabled",
+		startup: "disabled",
+	};
+	const startupSnapshot = (config: NormalizedPiStyleConfig): StartupSnapshot => ({
+		...currentSnapshot,
+		reason: host.startupReason ?? "startup",
+		...(host.provider ? { startupProvider: host.provider } : {}),
+		...(host.cwd ? { project: host.cwd.split(/[\\/]/).filter(Boolean).at(-1) } : {}),
+		preset: config.preset,
+		...(host.resources ? { resources: host.resources } : {}),
+	});
+	const installStatus = () => {
+		if (!host.hasUI || host.mode !== "tui" || !host.ui || !currentConfig.enabled || !currentConfig.statusLine.enabled) {
+			installationState = { ...installationState, status: "disabled" };
+			return;
+		}
+		try {
+			statusLine = installStatusLine({
+				host: host.ui,
+				config: currentConfig,
+				generation,
+				initialSnapshot: currentSnapshot,
+				isCurrent: () => !disposed,
+				clearOnStartup: host.startupReason === "startup",
+			});
+			if (statusLine) {
+				disposables.add(statusLine);
+				installationState = { ...installationState, status: "installed" };
+			} else installationState = { ...installationState, status: "failed" };
+		} catch (error) {
+			host.ui.notify?.(
+				`pi-style status unavailable: ${error instanceof Error ? error.message : "installation failed"}`,
+				"warning",
+			);
+			statusLine = undefined;
+			installationState = { ...installationState, status: "failed" };
+		}
+	};
+	const installEditorFeature = () => {
+		if (!host.hasUI || host.mode !== "tui" || !host.ui || !currentConfig.enabled || !currentConfig.editor.enabled) {
+			installationState = { ...installationState, editor: "disabled" };
+			return;
+		}
+		try {
+			editor = installEditor({
+				host: host.ui,
+				config: currentConfig,
+				generation,
+				initialSnapshot: currentSnapshot,
+				isCurrent: () => !disposed,
+			});
+			if (editor) {
+				disposables.add(editor);
+				installationState = { ...installationState, editor: editor.preservedPrevious ? "preserved" : "installed" };
+			} else installationState = { ...installationState, editor: "failed" };
+		} catch (error) {
+			host.ui.notify?.(
+				`pi-style editor unavailable: ${error instanceof Error ? error.message : "installation failed"}`,
+				"warning",
+			);
+			editor = undefined;
+			installationState = { ...installationState, editor: "failed" };
+		}
+	};
+	const installStartupFeature = () => {
+		if (
+			!host.hasUI ||
+			host.mode !== "tui" ||
+			!host.ui ||
+			!currentConfig.enabled ||
+			currentConfig.startup.mode === "off"
+		) {
+			installationState = { ...installationState, startup: "disabled" };
+			return;
+		}
+		try {
+			startup = installStartup({
+				host: { ...(host.ui as unknown as StartupHost), mode: host.mode, hasUI: host.hasUI },
+				config: currentConfig,
+				snapshot: startupSnapshot(currentConfig),
+				generation,
+				requestRender,
+				timeoutMs: 3000,
+				isCurrent: () => !disposed,
+			});
+			if (startup) {
+				disposables.add(startup);
+				installationState = { ...installationState, startup: "installed" };
+			} else installationState = { ...installationState, startup: "failed" };
+		} catch (error) {
+			host.ui.notify?.(
+				`pi-style startup unavailable: ${error instanceof Error ? error.message : "installation failed"}`,
+				"warning",
+			);
+			startup = undefined;
+			installationState = { ...installationState, startup: "failed" };
+		}
+	};
+	const disposeFeature = (label: string, dispose: (() => void) | undefined): void => {
+		if (!dispose) return;
+		try {
+			dispose();
+		} catch (error) {
+			host.ui?.notify?.(`pi-style ${label} cleanup failed; preserving the current owner`, "warning");
+			void error;
+		}
+	};
+	const disposeStatus = () => {
+		disposeFeature("status", statusLine?.dispose);
+		statusLine = undefined;
+		installationState = { ...installationState, status: "disabled" };
+	};
+	const disposeEditor = () => {
+		disposeFeature("editor", editor?.dispose);
+		editor = undefined;
+		installationState = { ...installationState, editor: "disabled" };
+	};
+	const disposeStartup = () => {
+		disposeFeature("startup", startup?.dispose);
+		startup = undefined;
+		installationState = { ...installationState, startup: "disabled" };
+	};
+	installStatus();
+	installEditorFeature();
+	installStartupFeature();
+	if (host.cwd && currentConfig.enabled && currentConfig.statusLine.enabled) {
+		void git.get(host.cwd).then((value) => {
+			if (disposed) return;
+			currentSnapshot = replaceSnapshot(currentSnapshot, generation, { ...currentSnapshot, git: value });
+			statusLine?.update(currentSnapshot);
+			editor?.update(currentSnapshot);
+			startup?.update({
+				...currentSnapshot,
+				reason: host.startupReason ?? "startup",
+				...(host.provider ? { startupProvider: host.provider } : {}),
+				...(host.cwd ? { project: host.cwd.split(/[\\/]/).filter(Boolean).at(-1) } : {}),
+				preset: currentConfig.preset,
+				...(host.resources ? { resources: host.resources } : {}),
+			});
+			requestRender();
+		});
+	}
+	if (usage) {
+		contextProvider.set("active", {
+			...(usage.tokens !== null ? { currentTokens: usage.tokens } : {}),
+			windowTokens: usage.contextWindow,
+			...(usage.percent !== null ? { percent: usage.percent } : {}),
+		});
+	}
+	return {
+		generation,
+		providerIdentity: { git, context: contextProvider, usage: usageProvider },
+		get installationState() {
+			return installationState;
+		},
+		mode: host.mode,
+		hasUI: host.hasUI,
+		snapshot: currentSnapshot,
+		disposables,
+		scheduler,
+		updateStartupResources(resources) {
+			if (disposed) return;
+			startup?.update({
+				...currentSnapshot,
+				reason: host.startupReason ?? "startup",
+				...(host.provider ? { startupProvider: host.provider } : {}),
+				...(host.cwd ? { project: host.cwd.split(/[\\/]/).filter(Boolean).at(-1) } : {}),
+				preset: currentConfig.preset,
+				resources,
+			});
+			requestRender();
+		},
+		dismissStartup() {
+			startup?.dismiss();
+		},
+		update(values) {
+			if (disposed) return;
+			const liveUsage = host.getContextUsage?.();
+			const context = liveUsage
+				? {
+						...(liveUsage.tokens !== null ? { currentTokens: liveUsage.tokens } : {}),
+						windowTokens: liveUsage.contextWindow,
+						...(liveUsage.percent !== null ? { percent: liveUsage.percent } : {}),
+					}
+				: undefined;
+			const statuses = extensionStatuses();
+			currentSnapshot = replaceSnapshot(currentSnapshot, generation, {
+				...currentSnapshot,
+				...values,
+				...(context ? { context } : {}),
+				...(statuses ? { extensionStatuses: statuses } : {}),
+			});
+			statusLine?.update(currentSnapshot);
+			editor?.update(currentSnapshot);
+			startup?.update({
+				...currentSnapshot,
+				reason: host.startupReason ?? "startup",
+				...(host.provider ? { startupProvider: host.provider } : {}),
+				...(host.cwd ? { project: host.cwd.split(/[\\/]/).filter(Boolean).at(-1) } : {}),
+				preset: currentConfig.preset,
+				...(host.resources ? { resources: host.resources } : {}),
+			});
+		},
+		configure(nextConfig) {
+			if (disposed) return;
+			const previous = currentConfig;
+			const impactPlan = diffConfig(previous, nextConfig);
+			if (impactPlan.impacts.length === 0) return;
+			currentConfig = nextConfig;
+			const statusChanged =
+				JSON.stringify(previous.statusLine) !== JSON.stringify(nextConfig.statusLine) ||
+				previous.placement !== nextConfig.placement ||
+				previous.enabled !== nextConfig.enabled;
+			const editorChanged =
+				JSON.stringify(previous.editor) !== JSON.stringify(nextConfig.editor) ||
+				previous.enabled !== nextConfig.enabled;
+			const startupChanged =
+				JSON.stringify(previous.startup) !== JSON.stringify(nextConfig.startup) ||
+				previous.enabled !== nextConfig.enabled;
+			if (statusChanged) {
+				disposeStatus();
+				currentConfig = nextConfig;
+				installStatus();
+			}
+			if (editorChanged) {
+				disposeEditor();
+				currentConfig = nextConfig;
+				installEditorFeature();
+			}
+			if (startupChanged) {
+				disposeStartup();
+				currentConfig = nextConfig;
+				installStartupFeature();
+			}
+			statusLine?.configure(nextConfig);
+			editor?.configure(nextConfig);
+			startup?.configure(nextConfig);
+		},
+		invalidateGit() {
+			if (disposed || !host.cwd || !currentConfig.enabled || !currentConfig.statusLine.enabled) return;
+			git.invalidate(host.cwd);
+			void git.get(host.cwd).then((value) => {
+				if (disposed) return;
+				currentSnapshot = replaceSnapshot(currentSnapshot, generation, { ...currentSnapshot, git: value });
+				statusLine?.update(currentSnapshot);
+				editor?.update(currentSnapshot);
+				startup?.update({
+					...currentSnapshot,
+					reason: host.startupReason ?? "startup",
+					...(host.provider ? { startupProvider: host.provider } : {}),
+					...(host.cwd ? { project: host.cwd.split(/[\\/]/).filter(Boolean).at(-1) } : {}),
+					preset: currentConfig.preset,
+				});
+				requestRender();
+			});
+		},
+		get disposed() {
+			return disposed;
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			scheduler.cancel();
+			// UI surfaces are restored synchronously so teardown is deterministic;
+			// the store then disposes the (already disposed) feature instances idempotently.
+			disposeStatus();
+			disposeEditor();
+			disposeStartup();
+			git.dispose();
+			contextProvider.clear();
+			usageProvider.reset();
+			void disposables.dispose();
+		},
+	};
+}
+
+export class PiStyleRuntimeController {
+	private activeRuntime: PiStyleRuntime | undefined;
+	private nextGeneration = 0;
+
+	start(ctx: RuntimeHost): PiStyleRuntime {
+		this.stop();
+		this.activeRuntime = createPiStyleRuntime(ctx, ++this.nextGeneration);
+		return this.activeRuntime;
+	}
+
+	stop(): void {
+		this.activeRuntime?.dispose();
+		this.activeRuntime = undefined;
+	}
+
+	get current(): PiStyleRuntime | undefined {
+		return this.activeRuntime;
+	}
+}

package/extension-src/pi-style/app/snapshot.ts

@@ -0,0 +1,15 @@
+import type { StatusSnapshot } from "../domain/status.js";
+
+export interface UiSnapshot extends StatusSnapshot {
+	readonly revision: number;
+	readonly generation: number;
+}
+
+export function createSnapshot(generation: number, revision = 0, values: StatusSnapshot = {}): UiSnapshot {
+	return Object.freeze({ generation, revision, ...values });
+}
+
+export function replaceSnapshot(current: UiSnapshot, generation: number, values: StatusSnapshot): UiSnapshot {
+	if (current.generation !== generation) return current;
+	return createSnapshot(generation, current.revision + 1, values);
+}

package/extension-src/pi-style/domain/capabilities.ts

@@ -0,0 +1,34 @@
+export type DiagnosticClass = "capability" | "configuration" | "conflict" | "fallback" | "error";
+export interface CapabilityRecord {
+	readonly name: string;
+	readonly available: boolean;
+	readonly tier: "A" | "B" | "C";
+	readonly detail?: string;
+}
+export interface DiagnosticRecord {
+	readonly classification: DiagnosticClass;
+	readonly code: string;
+	readonly message: string;
+	readonly secretFree: true;
+}
+export interface CapabilityHost {
+	ui?: Record<string, unknown>;
+	mode?: string;
+	hasUI?: boolean;
+}
+export function detectCapabilities(host: CapabilityHost): readonly CapabilityRecord[] {
+	const ui = host.ui ?? {};
+	return Object.freeze(
+		["setWidget", "setHeader", "setEditorComponent", "setFooter", "setWorkingIndicator"].map((name) =>
+			Object.freeze({ name, available: typeof ui[name] === "function", tier: "A" as const }),
+		),
+	);
+}
+export function diagnostic(classification: DiagnosticClass, code: string, message: string): DiagnosticRecord {
+	return Object.freeze({
+		classification,
+		code,
+		message: message.replace(/(api[_-]?key|token|secret|password)\s*[:=]\s*\S+/gi, "$1=[redacted]"),
+		secretFree: true,
+	});
+}

package/extension-src/pi-style/domain/config-authorization.ts

@@ -0,0 +1,20 @@
+import type { NormalizedPiStyleConfig } from "./config-types.js";
+
+export interface TierCAuthorizationInput {
+	readonly certifiedHost: boolean;
+	readonly coreFlag: boolean;
+	readonly surfaceFlag: boolean;
+	readonly surface: "messages" | "tools" | "userMessage" | "assistantMessage" | "specialBlocks";
+	readonly config: NormalizedPiStyleConfig;
+}
+
+/** Persisted and ordinary command state is intentionally not an input: authorization is session-bound. */
+export function isTierCAuthorized(input: TierCAuthorizationInput): boolean {
+	if (!input.certifiedHost || !input.coreFlag || !input.surfaceFlag || !input.config.enabled) return false;
+	if (input.surface === "tools") return input.config.tools.enabled;
+	if (input.surface === "userMessage") return input.config.messages.enabled && input.config.messages.userPrefix;
+	if (input.surface === "assistantMessage")
+		return input.config.messages.enabled && input.config.messages.assistantPrefix;
+	if (input.surface === "specialBlocks") return input.config.messages.enabled && input.config.messages.specialBlocks;
+	return input.config.messages.enabled;
+}

package/extension-src/pi-style/domain/config-diagnostics.ts

@@ -0,0 +1,20 @@
+export type ConfigDiagnosticLevel = "warning" | "error";
+export interface ConfigDiagnostic {
+	readonly code: string;
+	readonly level: ConfigDiagnosticLevel;
+	readonly path: string;
+	readonly message: string;
+}
+
+export function boundedDiagnostics(items: readonly ConfigDiagnostic[], limit = 32): readonly ConfigDiagnostic[] {
+	const seen = new Set<string>();
+	const result: ConfigDiagnostic[] = [];
+	for (const item of items) {
+		const key = `${item.level}:${item.code}:${item.path}:${item.message}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		result.push(Object.freeze(item));
+		if (result.length >= limit) break;
+	}
+	return Object.freeze(result);
+}

package/extension-src/pi-style/domain/config-diff.ts

@@ -0,0 +1,30 @@
+import type { NormalizedPiStyleConfig } from "./config-types.js";
+
+export type ConfigImpact = "none" | "status" | "editor" | "startup" | "compatibility" | "all";
+
+export interface ConfigDiff {
+	readonly changed: readonly string[];
+	readonly impacts: readonly ConfigImpact[];
+}
+
+export function diffConfig(previous: NormalizedPiStyleConfig, next: NormalizedPiStyleConfig): ConfigDiff {
+	const changed: string[] = [];
+	const impacts = new Set<ConfigImpact>();
+	const compare = (key: string, before: unknown, after: unknown, impact: ConfigImpact) => {
+		if (JSON.stringify(before) === JSON.stringify(after)) return;
+		changed.push(key);
+		impacts.add(impact);
+	};
+	compare("enabled", previous.enabled, next.enabled, "all");
+	compare("statusLine", previous.statusLine, next.statusLine, "status");
+	compare("placement", previous.placement, next.placement, "status");
+	compare("editor", previous.editor, next.editor, "editor");
+	compare("startup", previous.startup, next.startup, "startup");
+	compare("messages", previous.messages, next.messages, "compatibility");
+	compare("tools", previous.tools, next.tools, "compatibility");
+	compare("theme", previous.theme, next.theme, "all");
+	compare("compatibility", previous.compatibility, next.compatibility, "compatibility");
+	if (impacts.has("all"))
+		return Object.freeze({ changed: Object.freeze(changed), impacts: Object.freeze(["all"] as const) });
+	return Object.freeze({ changed: Object.freeze(changed), impacts: Object.freeze([...impacts]) });
+}

package/extension-src/pi-style/domain/config-migrations.ts

@@ -0,0 +1,52 @@
+import { boundedDiagnostics, type ConfigDiagnostic } from "./config-diagnostics.js";
+import { PI_STYLE_SCHEMA_VERSION } from "./config-types.js";
+
+function record(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export interface MigrationResult {
+	readonly config: Record<string, unknown> | undefined;
+	readonly diagnostics: readonly ConfigDiagnostic[];
+	readonly readOnly: boolean;
+}
+
+/** Purely validates the durable envelope; v1 is identity and future data is read-only. */
+export function migrateConfig(input: unknown, source = "config"): MigrationResult {
+	if (!record(input))
+		return {
+			config: undefined,
+			readOnly: false,
+			diagnostics: boundedDiagnostics([
+				{ code: "CFG-001", level: "warning", path: source, message: "configuration must be an object; defaults used" },
+			]),
+		};
+	const version = input.schemaVersion;
+	if (version === undefined)
+		return {
+			config: { ...input, schemaVersion: PI_STYLE_SCHEMA_VERSION },
+			readOnly: false,
+			diagnostics: boundedDiagnostics([
+				{
+					code: "CFG-002",
+					level: "warning",
+					path: `${source}.schemaVersion`,
+					message: "missing schemaVersion accepted as v1-shaped input",
+				},
+			]),
+		};
+	if (version !== PI_STYLE_SCHEMA_VERSION)
+		return {
+			config: undefined,
+			readOnly: true,
+			diagnostics: boundedDiagnostics([
+				{
+					code: "CFG-003",
+					level: "error",
+					path: `${source}.schemaVersion`,
+					message: `unsupported schemaVersion ${String(version)}; ignored without rewrite`,
+				},
+			]),
+		};
+	return { config: { ...input }, readOnly: false, diagnostics: [] };
+}