@selesai/code 0.13.15 → 0.13.18

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;
+	}
+}

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

@@ -494,6 +494,7 @@ export type WorkingLineRuntimeSegments = {
 	elapsedMs?: number;
 	thought?: { durationMs: number; active: boolean };
 	tokens?: { input: number; output: number; outputApproximate?: boolean };
+	extensions?: readonly string[];
 };
 
 export type WorkingLineFrameState = {
@@ -573,6 +574,26 @@ function truncateWithEllipsis(value: string, capacity: number): string {
 	return prefix ? `${prefix}…` : "";
 }
 
+function fitWorkingLineExtensionSegments(
+	values: readonly string[],
+	budget: number,
+	delimiter: string,
+): string[] {
+	const fitted: string[] = [];
+	let used = 0;
+	for (const value of values) {
+		const normalized = normalizeWorkingLineMessage(value);
+		const remaining = budget - used - visibleWidth(delimiter);
+		if (!normalized || remaining <= 0) continue;
+		const text = truncateWithEllipsis(normalized, remaining);
+		if (!text) continue;
+		fitted.push(text);
+		used += visibleWidth(delimiter) + visibleWidth(text);
+		if (text !== normalized) break;
+	}
+	return fitted;
+}
+
 export type ComposedWorkingLine = { message: string; row: string };
 
 /** Validate and measure the fixed visible width shared by every frame in a preset. */
@@ -596,7 +617,17 @@ export function composeWorkingLineRow(
 		MAX_WORKING_LINE_FRAME_CELLS - workingLineSpinnerWidth(config.spinner) - visibleWidth(" ");
 	const delimiter = " · ";
 	const tokens = config.segments.tokens ? formatWorkingLineTokens(runtime.tokens) : undefined;
-	const mandatoryWidth = tokens ? visibleWidth(delimiter) + visibleWidth(tokens) : 0;
+	const tokenWidth = tokens ? visibleWidth(delimiter) + visibleWidth(tokens) : 0;
+	const extensions = fitWorkingLineExtensionSegments(
+		runtime.extensions ?? [],
+		Math.max(0, maximumRowCells - tokenWidth - 1),
+		delimiter,
+	);
+	const extensionWidth = extensions.reduce(
+		(width, value) => width + visibleWidth(delimiter) + visibleWidth(value),
+		0,
+	);
+	const mandatoryWidth = tokenWidth + extensionWidth;
 	const messageCapacity = maximumRowCells - mandatoryWidth;
 	const fittedMessage = truncateWithEllipsis(normalized, messageCapacity);
 	const segments: string[] = [fittedMessage];
@@ -630,6 +661,7 @@ export function composeWorkingLineRow(
 	if (accepted.has("elapsed") && elapsed) segments.push(elapsed);
 	if (accepted.has("thought") && thought) segments.push(thought);
 	if (tokens) segments.push(tokens);
+	segments.push(...extensions);
 	return { message: normalized, row: segments.filter(Boolean).join(delimiter) };
 }
 
@@ -1027,6 +1059,8 @@ export class WorkingLineController {
 	private installedIndicatorOptions: WorkingIndicatorOptions | undefined;
 	private tokens: WorkingLineRuntimeSegments["tokens"];
 	private thought: WorkingLineRuntimeSegments["thought"];
+	private extensionSegments: readonly string[] = [];
+	private extensionSegmentsDirty = false;
 	private readonly activeTools = new Map<string, string>();
 	private elapsedUpdatesActive = false;
 	private elapsedUpdatesContext: WorkingLineContext | undefined;
@@ -1040,6 +1074,7 @@ export class WorkingLineController {
 		private readonly random: () => number = Math.random,
 		private readonly now: () => number = Date.now,
 		private readonly getThought: () => WorkingLineRuntimeSegments["thought"] = () => this.thought,
+		private readonly onUnavailable: () => void = () => {},
 	) {}
 
 	startSession(ctx: WorkingLineContext): WorkingLineReconcileResult {
@@ -1087,6 +1122,24 @@ export class WorkingLineController {
 		this.updateMetrics(tokens, this.getThought(), ctx);
 	}
 
+	updateExtensionSegments(segments: readonly string[], ctx: WorkingLineContext): boolean {
+		const unchanged =
+			this.extensionSegments.length === segments.length &&
+			this.extensionSegments.every((value, index) => value === segments[index]);
+		if (unchanged && !this.extensionSegmentsDirty) return true;
+		if (!unchanged) {
+			this.extensionSegments = [...segments];
+			this.extensionSegmentsDirty = true;
+		}
+		return this.updateIndicator(ctx);
+	}
+
+	/** Drops extension state that is no longer valid for the current owned Working row. */
+	invalidateExtensionSegments(): void {
+		this.extensionSegments = [];
+		this.extensionSegmentsDirty = false;
+	}
+
 	startTool(toolCallId: string, toolName: string, ctx: WorkingLineContext): void {
 		this.activeTools.delete(toolCallId);
 		this.activeTools.set(toolCallId, normalizeWorkingLineToolLabel(toolName));
@@ -1141,6 +1194,16 @@ export class WorkingLineController {
 		return this.selectedMessage;
 	}
 
+	/** Whether this controller currently claims both required public Working-row surfaces. */
+	isAvailable(): boolean {
+		return (
+			this.getConfig().components.workingLine.enabled &&
+			this.installed &&
+			this.ownsIndicator &&
+			this.ownsMessage
+		);
+	}
+
 	private install(
 		ctx: WorkingLineContext,
 		forceIndicator = false,
@@ -1151,6 +1214,7 @@ export class WorkingLineController {
 		if (!ui) {
 			this.installed = false;
 			this.deactivateElapsedUpdates();
+			this.invalidateUnavailableExtensionSegments();
 			return { applied: false, reason: "Working line requires a newer Pi TUI" };
 		}
 		const rootConfig = this.getConfig();
@@ -1206,6 +1270,7 @@ export class WorkingLineController {
 			elapsedMs: this.agentActive ? this.durationClock.elapsedMs() : undefined,
 			thought,
 			tokens: this.tokens,
+			extensions: this.extensionSegments,
 		};
 	}
 
@@ -1217,7 +1282,10 @@ export class WorkingLineController {
 		rebase = false,
 	): void {
 		const key = this.makeFrameKey(rootConfig, selectedMessage);
-		if (!force && this.installed && this.frameKey === key) return;
+		if (!force && this.installed && this.frameKey === key) {
+			this.extensionSegmentsDirty = false;
+			return;
+		}
 		const config = rootConfig.components.workingLine;
 		const sampledAtMs = this.now();
 		let spinnerTick = 0;
@@ -1289,19 +1357,22 @@ export class WorkingLineController {
 		this.installed = true;
 		this.frameKey = key;
 		this.installedIndicatorOptions = indicatorOptions;
+		this.extensionSegmentsDirty = false;
 	}
 
-	private updateIndicator(ctx: WorkingLineContext): void {
+	private updateIndicator(ctx: WorkingLineContext): boolean {
 		const rootConfig = this.getConfig();
-		if (!rootConfig.components.workingLine.enabled || !this.installed) return;
+		if (!rootConfig.components.workingLine.enabled || !this.installed) return false;
 		const ui = workingLineUi(ctx);
-		if (!ui) return;
+		if (!ui) return false;
 		const snapshot = this.installationSnapshot();
 		try {
 			this.applyIndicator(ui, rootConfig);
+			return !this.extensionSegmentsDirty;
 		} catch {
 			// A transient last-writer/public-API failure must not break the agent turn.
 			this.recoverOrReleaseAfterFailure(ui, snapshot);
+			return false;
 		}
 	}
 
@@ -1378,6 +1449,15 @@ export class WorkingLineController {
 		}
 	}
 
+	private invalidateUnavailableExtensionSegments(): void {
+		this.invalidateExtensionSegments();
+		try {
+			this.onUnavailable();
+		} catch {
+			// Availability cleanup is fail-open like the public Working-row release.
+		}
+	}
+
 	private releaseAfterFailure(ui: WorkingLineUi): void {
 		this.deactivateElapsedUpdates();
 		if (this.ownsIndicator) {
@@ -1400,6 +1480,7 @@ export class WorkingLineController {
 		this.frameKey = undefined;
 		this.installedPhase = undefined;
 		this.installedIndicatorOptions = undefined;
+		this.invalidateUnavailableExtensionSegments();
 	}
 
 	private reset(ctx: WorkingLineContext): void {
@@ -1434,5 +1515,6 @@ export class WorkingLineController {
 		this.activeTools.clear();
 		this.tokens = undefined;
 		this.thought = undefined;
+		this.invalidateExtensionSegments();
 	}
 }