@selesai/code 0.13.16 → 0.13.19

package/dist/extensions/pi-zentui/extensions/zentui/index.ts

@@ -36,6 +36,7 @@ import {
 	type SelectorBordersComponentConfig,
 	type SeparatorStyle,
 	saveAccentRailEditorStylePatch,
+	saveComponentPreset,
 	saveEditorComponentPatch,
 	saveExtensionStatusColorMode,
 	saveExtensionStatusDefaultPlacement,
@@ -74,6 +75,7 @@ import {
 } from "./interaction-summary";
 import { LiveContextController } from "./live-context";
 import { readPackageVersionResult } from "./package-version";
+import { getComponentPreset } from "./presets";
 import {
 	createProjectRefreshScheduler,
 	type ProjectRefreshRun,
@@ -97,6 +99,7 @@ import {
 	snapshotWorkingLineHighStyle,
 	WorkingLineController,
 } from "./working-line";
+import { WorkingLineExtensionSegments } from "./working-line-extension-segments";
 
 const ZENTUI_EDITOR_FACTORY = Symbol.for("pi-zentui.editor-factory");
 const ZENTUI_EDITOR_BASE_FACTORY = Symbol.for("pi-zentui.editor-base-factory");
@@ -293,6 +296,7 @@ export default function (pi: ExtensionAPI) {
 	const liveContext = new LiveContextController(sessionLifecycle, refresh);
 	const getActiveTheme = () => activeTheme;
 	const getCurrentConfig = () => currentConfig;
+	let invalidateWorkingLinePublisherState = () => {};
 	const workingLine = new WorkingLineController(
 		getCurrentConfig,
 		() => activeTheme as Theme,
@@ -300,7 +304,29 @@ export default function (pi: ExtensionAPI) {
 		Math.random,
 		Date.now,
 		() => interactionMetrics.currentThought(),
+		() => invalidateWorkingLinePublisherState(),
 	);
+	let workingLineSessionReady = false;
+	const workingLineExtensions = new WorkingLineExtensionSegments(
+		pi.events,
+		() =>
+			workingLineSessionReady &&
+			sessionLifecycle.isCurrent() &&
+			currentConfig.components.workingLine.enabled &&
+			activeTuiContext !== undefined &&
+			workingLine.isAvailable(),
+		(segments) => {
+			if (activeTuiContext && sessionLifecycle.isCurrent()) {
+				const applied = workingLine.updateExtensionSegments(segments, activeTuiContext);
+				if (!applied && !workingLine.isAvailable()) {
+					workingLine.invalidateExtensionSegments();
+				}
+				return applied;
+			}
+			return false;
+		},
+	);
+	invalidateWorkingLinePublisherState = () => workingLineExtensions.invalidate();
 	const getContextSnapshot = (ctx: ExtensionContext) => resolveContextUsage(ctx, liveContext.get());
 	const getContextWindow = (ctx: ExtensionContext): number | undefined =>
 		getContextSnapshot(ctx).contextWindow;
@@ -995,7 +1021,11 @@ export default function (pi: ExtensionAPI) {
 					!options.allowStaleZentui
 				) {
 					clearEditorOwnership();
-					return;
+					return {
+						ok: false,
+						reason:
+							"another Zentui instance is currently managing the editor; reload Pi to apply this change",
+					};
 				}
 				const editorMissingOrReplaced = !editorInstalled || !isOwnedEditorFactory(currentFactory);
 				if (editorMissingOrReplaced) return installEditor(ctx);
@@ -1147,6 +1177,12 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("session_start", async (_event, ctx) => {
 		const lifecycleGeneration = sessionLifecycle.start();
+		// A new generation must not expose or route extension segments through the previous
+		// session while asynchronous TUI startup is still pending.
+		workingLineSessionReady = false;
+		workingLineExtensions.invalidate();
+		if (activeTuiContext) workingLine.dispose(activeTuiContext);
+		else workingLine.invalidateExtensionSegments();
 		// Reload synchronously so private ownership uses this session's disk snapshot before
 		// any await or transcript restoration.
 		currentConfig = loadConfig();
@@ -1173,6 +1209,7 @@ export default function (pi: ExtensionAPI) {
 		if (!sessionLifecycle.isCurrent(lifecycleGeneration)) return;
 		liveContext.clear();
 		interactionMetrics.shutdown();
+		workingLineExtensions.invalidate();
 		state.sessionStartEpoch = Date.now();
 		invalidateUsageTotalsCache();
 		resetAgentTimer();
@@ -1181,16 +1218,50 @@ export default function (pi: ExtensionAPI) {
 		repositoryRoots.reset();
 		installUi(ctx);
 		workingLine.startSession(ctx);
+		workingLineSessionReady = true;
 		scheduleEditorReconciliation(ctx);
 	});
 
 	registerZentuiSettingsCommand(pi, {
 		sessionLifecycle,
 		getConfig: getCurrentConfig,
-		setEditorComponent(patch: Partial<EditorComponentConfig>, ctx: ExtensionContext) {
+		applyPreset(id, ctx, options) {
+			const preset = getComponentPreset(id);
+			if (!preset) throw new Error(`Unknown Zentui preset: ${id}`);
+			const previousFooterStyle = effectiveFooterStyle();
+			currentConfig = saveComponentPreset(preset);
+			if (!isTuiContext(ctx)) return { applied: true };
+			activeTheme = ctx.ui.theme;
+			const result = options?.deferEditor ? undefined : reconcileEditor(ctx);
+			if (currentConfig.components.editor.style !== "minimalist") {
+				setMinimalistDecorationActive(false);
+			}
+			reconcileUserMessages();
+			reconcileFooter(ctx);
+			reconcileProjectRefresh(ctx, effectiveFooterStyle() !== previousFooterStyle);
+			reconcileSessionTimer();
+			reconcileAgentTimer();
+			refresh();
+			return {
+				applied: !result || result.ok,
+				reason: result && !result.ok ? result.reason : undefined,
+			};
+		},
+		reconcilePresetEditor(ctx) {
+			if (!isTuiContext(ctx) || !sessionLifecycle.isCurrent()) return { applied: true };
+			const result = reconcileEditor(ctx);
+			reconcileProjectRefresh(ctx);
+			reconcileAgentTimer();
+			refresh();
+			return {
+				applied: !result || result.ok,
+				reason: result && !result.ok ? result.reason : undefined,
+			};
+		},
+		setEditorComponent(patch: Partial<EditorComponentConfig>, ctx: ExtensionContext, options) {
 			currentConfig = saveEditorComponentPatch(patch);
 			let result: EditorChangeResult | undefined;
-			if (patch.enabled !== undefined && isTuiContext(ctx)) {
+			if (patch.enabled !== undefined && isTuiContext(ctx) && !options?.deferEditor) {
 				result = reconcileEditor(ctx);
 			}
 			if (patch.style !== undefined && patch.style !== "minimalist") {
@@ -1241,6 +1312,7 @@ export default function (pi: ExtensionAPI) {
 		},
 		setWorkingLineComponent(patch: WorkingLineComponentPatch, ctx: ExtensionContext) {
 			currentConfig = saveWorkingLineComponentPatch(patch);
+			if (patch.enabled === false) workingLineExtensions.clear();
 			return workingLine.reconcile(ctx);
 		},
 		setSelectorBordersComponent(
@@ -1326,10 +1398,12 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.on("session_shutdown", async (_event, ctx) => {
+		workingLineSessionReady = false;
 		thinkingExperimental.shutdown();
 		liveContext.clear();
 		interactionMetrics.shutdown();
 		workingLine.dispose(ctx);
+		workingLineExtensions.invalidate();
 		cleanupUi(ctx);
 	});
 

package/dist/extensions/pi-zentui/extensions/zentui/presets.ts

@@ -0,0 +1,77 @@
+import {
+	type EditorComponentConfig,
+	type FooterComponentConfig,
+	hasUnsupportedComponentStyle,
+	type UserMessagesComponentConfig,
+	type ZentuiConfig,
+} from "./config";
+
+export type PresetId = "opencode" | "opencode-copy-friendly" | "rail" | "minimalist";
+export type ComponentPreset = Readonly<{
+	id: PresetId;
+	label: string;
+	components: Readonly<{
+		editor: Readonly<Pick<EditorComponentConfig, "enabled" | "style">>;
+		footer: Readonly<Pick<FooterComponentConfig, "style">>;
+		userMessages: Readonly<
+			Pick<UserMessagesComponentConfig, "enabled"> &
+				Partial<Pick<UserMessagesComponentConfig, "style">>
+		>;
+	}>;
+}>;
+
+export const componentPresets: readonly ComponentPreset[] = [
+	{
+		id: "opencode",
+		label: "Opencode",
+		components: {
+			editor: { enabled: true, style: "opencode" },
+			footer: { style: "starship" },
+			userMessages: { enabled: true, style: "framed" },
+		},
+	},
+	{
+		id: "opencode-copy-friendly",
+		label: "Opencode (copy-friendly)",
+		components: {
+			editor: { enabled: true, style: "opencode-copy-friendly" },
+			footer: { style: "starship" },
+			userMessages: { enabled: true, style: "framed-copy-friendly" },
+		},
+	},
+	{
+		id: "rail",
+		label: "Rail",
+		components: {
+			editor: { enabled: true, style: "accent-rail" },
+			footer: { style: "starship" },
+			userMessages: { enabled: true, style: "compact" },
+		},
+	},
+	{
+		id: "minimalist",
+		label: "Minimalist",
+		components: {
+			editor: { enabled: true, style: "minimalist" },
+			footer: { style: "hidden" },
+			userMessages: { enabled: false },
+		},
+	},
+];
+
+export function getComponentPreset(id: string): ComponentPreset | undefined {
+	return componentPresets.find((preset) => preset.id === id);
+}
+
+/** Match configured selections, not live ownership or dormant style options. */
+export function matchingComponentPreset(config: ZentuiConfig): ComponentPreset | undefined {
+	return componentPresets.find(({ components }) =>
+		(["editor", "footer", "userMessages"] as const).every((owner) => {
+			const selection = components[owner];
+			if ("style" in selection && hasUnsupportedComponentStyle(config, owner)) return false;
+			return Object.entries(selection).every(
+				([key, value]) => config.components[owner][key as keyof typeof selection] === value,
+			);
+		}),
+	);
+}

package/dist/extensions/pi-zentui/extensions/zentui/settings-command.ts

@@ -53,8 +53,15 @@ import {
 	type WorkingLineSpinner,
 	type WorkingLineTextAnimation,
 } from "./config";
+import { prepareEditorTextForCustomUi } from "./editor-transfer";
 import { sanitizeExtensionStatusText } from "./extension-status";
 import { isIconMode } from "./icons";
+import {
+	componentPresets,
+	getComponentPreset,
+	matchingComponentPreset,
+	type PresetId,
+} from "./presets";
 import type { SessionLifecycle } from "./session-lifecycle";
 import {
 	renderEditorSettingsPreview,
@@ -213,7 +220,17 @@ function experimentalThinkingCapability(
 type SettingsCommandDeps = {
 	sessionLifecycle: SessionLifecycle;
 	getConfig: () => PolishedTuiConfig;
-	setEditorComponent: (patch: EditorPatch, ctx: ExtensionContext) => ApplyResult;
+	applyPreset: (
+		id: PresetId,
+		ctx: ExtensionContext,
+		options?: { deferEditor?: boolean },
+	) => ApplyResult;
+	reconcilePresetEditor: (ctx: ExtensionContext) => ApplyResult;
+	setEditorComponent: (
+		patch: EditorPatch,
+		ctx: ExtensionContext,
+		options?: { deferEditor?: boolean },
+	) => ApplyResult;
 	setPolished: (patch: Partial<PolishedEditorStyleConfig>, ctx: ExtensionContext) => void;
 	setPolishedCopyFriendly: (
 		patch: Partial<PolishedCopyFriendlyEditorStyleConfig>,
@@ -310,6 +327,7 @@ const footerSegmentSettingDescriptions: Record<FooterSegmentSettingId, string> =
 };
 
 const directCommandSuggestions = [
+	...componentPresets.map(({ id }) => `preset ${id}`),
 	"editor enable",
 	"editor disable",
 	"editor toggle",
@@ -471,12 +489,20 @@ function argumentCompletions(prefix: string): AutocompleteItem[] | null {
 }
 
 function usageText(): string {
-	return "Usage: /zentui [editor|messages|statusline|viewport-indicators] [enable|disable|toggle], /zentui [messages|user-messages|working-line], or /zentui format <template>";
+	return "Usage: /zentui [editor|messages|statusline|viewport-indicators] [enable|disable|toggle], /zentui [messages|user-messages|working-line], /zentui preset <opencode|opencode-copy-friendly|rail|minimalist>, or /zentui format <template>";
 }
 
 function buildAppearanceItems(config: PolishedTuiConfig): SettingItem[] {
 	const component = config.components.selectorBorders;
 	return [
+		{
+			id: "preset",
+			label: "Preset",
+			description:
+				"Apply Editor, Footer, and User messages together once. Preserves colors and other settings; editor installation waits until this panel closes. Custom means no matching combination.",
+			currentValue: matchingComponentPreset(config)?.label ?? "Custom",
+			values: componentPresets.map(({ label }) => label),
+		},
 		{
 			id: "selectorBordersEnabled",
 			label: "Selector borders",
@@ -1133,11 +1159,38 @@ export function registerZentuiSettingsCommand(pi: ExtensionAPI, deps: SettingsCo
 		deps.setFooterComponent(patch, ctx);
 	};
 
+	const applyPreset = (id: PresetId, ctx: ExtensionContext) => {
+		try {
+			const result = deps.applyPreset(id, ctx);
+			deps.requestRender();
+			if (ctx.hasUI) {
+				const detail = result.reason?.trim();
+				ctx.ui.notify(
+					`Preset saved: ${getComponentPreset(id)?.label}${detail ? ` (${detail})` : !result.applied ? " (reload Pi to apply this change)" : ""}`,
+					!result.applied || detail ? "warning" : "info",
+				);
+			}
+		} catch (error) {
+			if (ctx.hasUI)
+				ctx.ui.notify(
+					`Could not update Zentui settings: ${error instanceof Error ? error.message : String(error)}`,
+					"error",
+				);
+		}
+	};
+
 	pi.registerCommand("zentui", {
 		description: "Configure Zentui",
 		getArgumentCompletions: argumentCompletions,
 		handler: async (_args, ctx) => {
 			const args = typeof _args === "string" ? _args : "";
+			const words = args.trim().split(/\s+/);
+			if (words[0]?.toLowerCase() === "preset") {
+				const preset = words.length === 2 ? getComponentPreset(words[1] ?? "") : undefined;
+				if (preset) applyPreset(preset.id, ctx);
+				else if (ctx.hasUI) ctx.ui.notify(usageText(), "warning");
+				return;
+			}
 			const format = parseFormatCommand(args);
 			if (format) {
 				try {
@@ -1210,8 +1263,19 @@ export function registerZentuiSettingsCommand(pi: ExtensionAPI, deps: SettingsCo
 			let requestedSection = initialSection ?? "appearance";
 			let requestedFocusId: string | undefined;
 			while (true) {
+				try {
+					prepareEditorTextForCustomUi(ctx.ui);
+				} catch (error) {
+					ctx.ui.notify(
+						`Could not open Zentui settings safely: ${error instanceof Error ? error.message : String(error)}`,
+						"error",
+					);
+					return;
+				}
 				const initialFocusId = requestedFocusId;
 				requestedFocusId = undefined;
+				const generation = deps.sessionLifecycle.currentGeneration();
+				let pendingPresetEditor = false;
 				const outcome = await ctx.ui.custom<SettingsOutcome>((tui, theme, _keybindings, done) => {
 					const listTheme = deps.settingsListTheme ?? getSettingsListTheme();
 					let activeSection = requestedSection;
@@ -1315,8 +1379,26 @@ export function registerZentuiSettingsCommand(pi: ExtensionAPI, deps: SettingsCo
 							listTheme,
 							(id, newValue) => {
 								try {
+									if (id === "preset") {
+										const preset = componentPresets.find(({ label }) => label === newValue);
+										if (!preset) return;
+										if (!deps.sessionLifecycle.isCurrent(generation)) return;
+										const result = deps.applyPreset(preset.id, ctx, { deferEditor: true });
+										pendingPresetEditor = true;
+										settingsList = makeSettingsList("preset");
+										notifyChange("Preset saved", preset.label, result);
+										return;
+									}
 									const enabled = isFeatureState(newValue) ? newValue === "enabled" : undefined;
 									if (id === "editorEnabled" && enabled !== undefined) {
+										if (pendingPresetEditor) {
+											const result = deps.setEditorComponent({ enabled }, ctx, {
+												deferEditor: true,
+											});
+											notifyChange("Editor", newValue, result);
+											finishSettings("close");
+											return;
+										}
 										finishSettings("close");
 										deps.sessionLifecycle.defer(() => {
 											try {
@@ -1838,6 +1920,25 @@ export function registerZentuiSettingsCommand(pi: ExtensionAPI, deps: SettingsCo
 						},
 					};
 				});
+				// Pi restores its saved editor text before custom() resolves. Reconcile only
+				// now, using the latest config and observed factory, never a captured factory.
+				if (pendingPresetEditor && !deps.sessionLifecycle.isCurrent(generation)) return;
+				if (pendingPresetEditor) {
+					try {
+						const result = deps.reconcilePresetEditor(ctx);
+						if (!result.applied || result.reason) {
+							ctx.ui.notify(
+								`Preset saved: editor (${result.reason ?? "reload Pi to apply this change"})`,
+								"warning",
+							);
+						}
+					} catch (error) {
+						ctx.ui.notify(
+							`Could not apply preset editor; reload Pi: ${error instanceof Error ? error.message : String(error)}`,
+							"error",
+						);
+					}
+				}
 				if (outcome === "close" || outcome === undefined) return;
 				if (
 					outcome === "edit-working-line-spinner-speed" ||

package/dist/extensions/pi-zentui/extensions/zentui/working-line-extension-segments.ts

@@ -0,0 +1,115 @@
+import type { EventBus } from "@earendil-works/pi-coding-agent";
+
+export const ZENTUI_WORKING_LINE_SEGMENT_CAPABILITY_EVENT =
+	"zentui:working-line-segment-capability";
+export const ZENTUI_WORKING_LINE_SEGMENT_EVENT = "zentui:working-line-segment";
+export const ZENTUI_WORKING_LINE_SEGMENT_PROTOCOL_VERSION = 1;
+
+export const MAX_WORKING_LINE_EXTENSION_SEGMENTS = 16;
+export const MAX_WORKING_LINE_EXTENSION_KEY_CODE_UNITS = 64;
+export const MAX_WORKING_LINE_EXTENSION_TEXT_CODE_UNITS = 256;
+
+export type WorkingLineSegmentCapability = {
+	supported: boolean;
+	active: boolean;
+	/** Present in protocol version 1 and later. */
+	version?: number;
+};
+
+export type WorkingLineSegmentUpdate = {
+	key: string;
+	text?: string;
+};
+
+type EventRecord = Record<string, unknown>;
+
+function eventRecord(value: unknown): EventRecord | undefined {
+	return value !== null && typeof value === "object" && !Array.isArray(value)
+		? (value as EventRecord)
+		: undefined;
+}
+
+function segmentUpdate(value: unknown): WorkingLineSegmentUpdate | undefined {
+	const record = eventRecord(value);
+	if (!record) return undefined;
+	if (
+		typeof record.key !== "string" ||
+		record.key.length === 0 ||
+		record.key.length > MAX_WORKING_LINE_EXTENSION_KEY_CODE_UNITS
+	) {
+		return undefined;
+	}
+	if (
+		record.text !== undefined &&
+		(typeof record.text !== "string" ||
+			record.text.length > MAX_WORKING_LINE_EXTENSION_TEXT_CODE_UNITS)
+	) {
+		return undefined;
+	}
+	return { key: record.key, text: record.text as string | undefined };
+}
+
+/** Collects keyed third-party segments and publishes deterministic snapshots to the Working line. */
+export class WorkingLineExtensionSegments {
+	private readonly segments = new Map<string, string>();
+	private publishDirty = false;
+
+	constructor(
+		events: EventBus | undefined,
+		private readonly isActive: () => boolean,
+		private readonly onChange: (segments: readonly string[]) => boolean | undefined,
+	) {
+		if (!events) return;
+		events.on(ZENTUI_WORKING_LINE_SEGMENT_CAPABILITY_EVENT, (value) => {
+			const capability = eventRecord(value);
+			if (!capability) return;
+			capability.supported = true;
+			capability.active = this.isActive();
+			capability.version = ZENTUI_WORKING_LINE_SEGMENT_PROTOCOL_VERSION;
+		});
+		events.on(ZENTUI_WORKING_LINE_SEGMENT_EVENT, (value) => {
+			const update = segmentUpdate(value);
+			if (!update) return;
+			if (update.text !== undefined && update.text.length > 0 && !this.isActive()) return;
+			if (update.text === undefined || update.text.length === 0) {
+				if (!this.segments.delete(update.key) && !this.publishDirty) return;
+			} else {
+				if (
+					!this.segments.has(update.key) &&
+					this.segments.size >= MAX_WORKING_LINE_EXTENSION_SEGMENTS
+				)
+					return;
+				if (this.segments.get(update.key) === update.text && !this.publishDirty) return;
+				this.segments.set(update.key, update.text);
+			}
+			this.publishDirty = true;
+			this.publish();
+		});
+	}
+
+	clear(): void {
+		if (this.segments.size === 0 && !this.publishDirty) return;
+		this.segments.clear();
+		this.publishDirty = true;
+		this.publish();
+	}
+
+	/** Drops session-scoped publisher state without attempting a Working-row write. */
+	invalidate(): void {
+		this.segments.clear();
+		this.publishDirty = false;
+	}
+
+	private publish(): void {
+		const applied = this.onChange(
+			[...this.segments.entries()]
+				.sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+				.map(([, text]) => text),
+		);
+		if (applied === false && !this.isActive()) {
+			this.invalidate();
+			return;
+		}
+		this.publishDirty = applied === false;
+	}
+}