@herbertgao/pi-extensions 2026.8.2 → 2026.8.4

package/node_modules/pi-footer/src/ui/color-options.ts

@@ -0,0 +1,195 @@
+import {
+  appendAnsi256Digit,
+  deleteAnsi256Digit,
+  FOREGROUND_COLORS,
+  normalizeColor,
+  resetAnsi256Colors,
+  STANDARD_COLORS,
+} from "../colors.js";
+import type { WidgetOptions } from "../types.js";
+import type { Widget } from "../widgets/types.js";
+import { adjustAnsi, cycle } from "./helpers.js";
+import type { ColorOptionField } from "./model.js";
+
+export const EDIT_COLORS_HINT =
+  "↑/↓ field • ←/→ cycle/change • enter toggle • type digits for ANSI256 • backspace delete • esc back";
+
+export function hasCustomAnsiColors(lines: readonly (readonly Widget[])[]): boolean {
+  return lines.some((line) =>
+    line.some(
+      (widget) =>
+        colorOption(widget, "fg")?.startsWith("ansi256:") ||
+        colorOption(widget, "bg")?.startsWith("ansi256:") ||
+        colorOption(widget, "warningFg")?.startsWith("ansi256:") ||
+        colorOption(widget, "warningBg")?.startsWith("ansi256:") ||
+        colorOption(widget, "dangerFg")?.startsWith("ansi256:") ||
+        colorOption(widget, "dangerBg")?.startsWith("ansi256:"),
+    ),
+  );
+}
+
+export function resetCustomAnsiColors(lines: readonly (readonly Widget[])[]): void {
+  for (const line of lines) {
+    for (const widget of line) {
+      widget.update(resetAnsi256Colors(widget.options));
+    }
+  }
+}
+
+export function applyColorDigit(widget: Widget, field: ColorOptionField, digit: string): boolean {
+  if (!/^\d$/.test(digit)) return false;
+  if (field.id === "fgAnsi")
+    return updateColorOption(widget, "fg", appendAnsi256Digit(colorOption(widget, "fg"), digit));
+  if (field.id === "bgAnsi")
+    return updateColorOption(widget, "bg", appendAnsi256Digit(colorOption(widget, "bg"), digit));
+  if (field.id === "warningFgAnsi")
+    return updateColorOption(
+      widget,
+      "warningFg",
+      appendAnsi256Digit(colorOption(widget, "warningFg"), digit),
+    );
+  if (field.id === "warningBgAnsi")
+    return updateColorOption(
+      widget,
+      "warningBg",
+      appendAnsi256Digit(colorOption(widget, "warningBg"), digit),
+    );
+  if (field.id === "dangerFgAnsi")
+    return updateColorOption(
+      widget,
+      "dangerFg",
+      appendAnsi256Digit(colorOption(widget, "dangerFg"), digit),
+    );
+  if (field.id === "dangerBgAnsi")
+    return updateColorOption(
+      widget,
+      "dangerBg",
+      appendAnsi256Digit(colorOption(widget, "dangerBg"), digit),
+    );
+  return false;
+}
+
+export function deleteColorDigit(widget: Widget, field: ColorOptionField): boolean {
+  if (field.id === "fgAnsi")
+    return updateColorOption(widget, "fg", deleteAnsi256Digit(colorOption(widget, "fg")));
+  if (field.id === "bgAnsi")
+    return updateColorOption(widget, "bg", deleteAnsi256Digit(colorOption(widget, "bg")));
+  if (field.id === "warningFgAnsi")
+    return updateColorOption(
+      widget,
+      "warningFg",
+      deleteAnsi256Digit(colorOption(widget, "warningFg")),
+    );
+  if (field.id === "warningBgAnsi")
+    return updateColorOption(
+      widget,
+      "warningBg",
+      deleteAnsi256Digit(colorOption(widget, "warningBg")),
+    );
+  if (field.id === "dangerFgAnsi")
+    return updateColorOption(
+      widget,
+      "dangerFg",
+      deleteAnsi256Digit(colorOption(widget, "dangerFg")),
+    );
+  if (field.id === "dangerBgAnsi")
+    return updateColorOption(
+      widget,
+      "dangerBg",
+      deleteAnsi256Digit(colorOption(widget, "dangerBg")),
+    );
+  return false;
+}
+
+export function applyColorOptionField(
+  widget: Widget,
+  field: ColorOptionField,
+  delta: number,
+): void {
+  if (field.id === "bold") widget.update({ bold: !widget.options.bold });
+  else if (field.id === "fg")
+    updateColorOption(
+      widget,
+      "fg",
+      cycle(
+        FOREGROUND_COLORS.map((color) => color.value),
+        widget.options.fg ?? "default",
+        delta,
+      ),
+    );
+  else if (field.id === "bg")
+    updateColorOption(
+      widget,
+      "bg",
+      cycle(
+        STANDARD_COLORS.map((color) => color.value),
+        widget.options.bg ?? "default",
+        delta,
+      ),
+    );
+  else if (field.id === "warningFg")
+    updateColorOption(
+      widget,
+      "warningFg",
+      cycle(
+        FOREGROUND_COLORS.map((color) => color.value),
+        colorOption(widget, "warningFg") ?? "default",
+        delta,
+      ),
+    );
+  else if (field.id === "warningBg")
+    updateColorOption(
+      widget,
+      "warningBg",
+      cycle(
+        STANDARD_COLORS.map((color) => color.value),
+        colorOption(widget, "warningBg") ?? "default",
+        delta,
+      ),
+    );
+  else if (field.id === "dangerFg")
+    updateColorOption(
+      widget,
+      "dangerFg",
+      cycle(
+        FOREGROUND_COLORS.map((color) => color.value),
+        colorOption(widget, "dangerFg") ?? "default",
+        delta,
+      ),
+    );
+  else if (field.id === "dangerBg")
+    updateColorOption(
+      widget,
+      "dangerBg",
+      cycle(
+        STANDARD_COLORS.map((color) => color.value),
+        colorOption(widget, "dangerBg") ?? "default",
+        delta,
+      ),
+    );
+  else if (field.id === "fgAnsi")
+    updateColorOption(widget, "fg", adjustAnsi(colorOption(widget, "fg"), delta));
+  else if (field.id === "bgAnsi")
+    updateColorOption(widget, "bg", adjustAnsi(colorOption(widget, "bg"), delta));
+  else if (field.id === "warningFgAnsi")
+    updateColorOption(widget, "warningFg", adjustAnsi(colorOption(widget, "warningFg"), delta));
+  else if (field.id === "warningBgAnsi")
+    updateColorOption(widget, "warningBg", adjustAnsi(colorOption(widget, "warningBg"), delta));
+  else if (field.id === "dangerFgAnsi")
+    updateColorOption(widget, "dangerFg", adjustAnsi(colorOption(widget, "dangerFg"), delta));
+  else if (field.id === "dangerBgAnsi")
+    updateColorOption(widget, "dangerBg", adjustAnsi(colorOption(widget, "dangerBg"), delta));
+}
+
+function colorOption(widget: Widget, key: string) {
+  return normalizeColor(widget.options[key]);
+}
+
+function updateColorOption(
+  widget: Widget,
+  key: string,
+  value: WidgetOptions[keyof WidgetOptions],
+): true {
+  widget.update({ [key]: value });
+  return true;
+}

package/node_modules/pi-footer/src/ui/config-lifecycle.ts

@@ -0,0 +1,61 @@
+import { cloneConfig } from "../config.js";
+import type { StatuslineConfig } from "../types.js";
+
+export type ConfigChange = (config: StatuslineConfig) => void;
+export type ConfigSave = (config: StatuslineConfig) => Promise<void>;
+
+export interface ConfigUiResult {
+  config: StatuslineConfig;
+  saved: boolean;
+}
+
+export type ConfigState = "clean" | "dirty" | "saving" | "saved" | "error";
+
+export class ConfigLifecycle {
+  private savedConfig: StatuslineConfig;
+  private configState: ConfigState = "clean";
+
+  constructor(config: StatuslineConfig) {
+    this.savedConfig = cloneConfig(config);
+  }
+
+  get dirty(): boolean {
+    return this.configState === "dirty" || this.configState === "error";
+  }
+
+  get state(): ConfigState {
+    return this.configState;
+  }
+
+  get label(): string | undefined {
+    if (this.configState === "dirty") return "Unsaved";
+    if (this.configState === "saving") return "Saving…";
+    if (this.configState === "saved") return "Saved";
+    if (this.configState === "error") return "Save failed";
+    return undefined;
+  }
+
+  markChanged(): void {
+    this.configState = "dirty";
+  }
+
+  beginSave(): void {
+    this.configState = "saving";
+  }
+
+  markSaved(config: StatuslineConfig): void {
+    this.savedConfig = cloneConfig(config);
+    this.configState = "saved";
+  }
+
+  markSaveFailed(): void {
+    this.configState = "error";
+  }
+
+  closeResult(saved: boolean): ConfigUiResult {
+    return {
+      config: cloneConfig(this.savedConfig),
+      saved,
+    };
+  }
+}

package/node_modules/pi-footer/src/ui/edit-colors.ts

@@ -0,0 +1,13 @@
+import { registry } from "../widgets/registry.js";
+import type { Widget } from "../widgets/types.js";
+import { colorFields, colorFieldValue } from "./fields.js";
+
+const EDIT_COLORS_TITLE_PREFIX = "Colors /";
+
+export function editColorsTitle(widget: Widget): string {
+  return `${EDIT_COLORS_TITLE_PREFIX} ${registry.spec(widget.type).label}`;
+}
+
+export function editColorsFieldRows(widget: Widget): string[] {
+  return colorFields(widget).map((field) => `${field.label}: ${colorFieldValue(widget, field)}`);
+}

package/node_modules/pi-footer/src/ui/events.ts

@@ -0,0 +1,35 @@
+import { highlightCode } from "@earendil-works/pi-coding-agent";
+
+import { UPDATE_EVENT_WIDGET_EVENT } from "../event-widgets.js";
+import type { Widget } from "../widgets/types.js";
+
+export function eventWidgetUsageLines(
+  widget: Widget,
+  width: number,
+  line: (content: string, width: number) => string,
+  dim: (text: string) => string,
+): string[] {
+  return [
+    line("", width),
+    line(dim("Send events with a value:"), width),
+    line(eventWidgetUsageCode(widgetId(widget), "Value"), width),
+    line("", width),
+    line(dim("Send events to remove status:"), width),
+    line(eventWidgetUsageCode(widgetId(widget), "NULL"), width),
+  ];
+}
+
+function widgetId(widget: Widget) {
+  const value = widget.options.widgetId;
+  return typeof value === "string" ? value : "";
+}
+
+function eventWidgetUsageCode(widgetId: string, value: string): string {
+  const v = value === "NULL" ? "null" : `"${value}"`;
+  return (
+    highlightCode(
+      `pi.events.emit(${JSON.stringify(UPDATE_EVENT_WIDGET_EVENT)}, { "widgetId": ${JSON.stringify(widgetId)}, "value": ${v} });`,
+      "typescript",
+    )[0] ?? ""
+  );
+}

package/node_modules/pi-footer/src/ui/extension-status-picker.ts

@@ -0,0 +1,60 @@
+import { truncateToWidth } from "@earendil-works/pi-tui";
+
+import { STATUS_KEY } from "../config.js";
+import {
+  allExtensionStatusEntries,
+  type ExtensionStatusRowConfig,
+  type GetExtensionStatuses,
+} from "../extension-statuses.js";
+import type { Widget } from "../widgets/types.js";
+
+export function statusKeyPickerLines(
+  getExtensionStatuses: GetExtensionStatuses,
+  rowConfig: ExtensionStatusRowConfig,
+  width: number,
+  line: (content: string, width: number) => string,
+  dim: (text: string) => string,
+): string[] {
+  const entries = allExtensionStatusEntries(getExtensionStatuses(), rowConfig, STATUS_KEY);
+  const lines = [line("", width), line(dim("Available extension statuses:"), width)];
+
+  if (entries.length === 0) {
+    lines.push(
+      line(dim("No extension statuses are currently available. Type a key manually."), width),
+    );
+    return lines;
+  }
+
+  for (const entry of entries) {
+    lines.push(
+      line(
+        `${dim(entry.key)} ${truncateToWidth(entry.value, Math.max(1, width - entry.key.length - 4), "…")}`,
+        width,
+      ),
+    );
+  }
+  return lines;
+}
+
+export function cycleExternalStatusKey(
+  widget: Widget,
+  getExtensionStatuses: GetExtensionStatuses,
+  rowConfig: ExtensionStatusRowConfig,
+  delta: number,
+): boolean {
+  const keys = allExtensionStatusEntries(getExtensionStatuses(), rowConfig, STATUS_KEY).map(
+    (entry) => entry.key,
+  );
+  if (keys.length === 0) return false;
+  const currentValue = widget.options.externalStatusKey;
+  const current = typeof currentValue === "string" ? currentValue : "";
+  const currentIndex = keys.indexOf(current);
+  const nextIndex =
+    currentIndex === -1
+      ? delta > 0
+        ? 0
+        : keys.length - 1
+      : (currentIndex + delta + keys.length) % keys.length;
+  widget.update({ externalStatusKey: keys[nextIndex] ?? current });
+  return true;
+}

package/node_modules/pi-footer/src/ui/extension-statuses.ts

@@ -0,0 +1,73 @@
+import { truncateToWidth } from "@earendil-works/pi-tui";
+
+import { STATUS_KEY } from "../config.js";
+import {
+  allExtensionStatusEntries,
+  toggleExtensionStatusRowKey,
+  type GetExtensionStatuses,
+} from "../extension-statuses.js";
+import type { StatuslineSettings } from "../types.js";
+
+export function extensionStatusRowLines(
+  config: StatuslineSettings,
+  getExtensionStatuses: GetExtensionStatuses,
+  selected: number,
+  width: number,
+  menuTitle: (title: string, subtitle: string) => string,
+  line: (content: string, width: number) => string,
+  menuLine: (selected: boolean, content: string, width: number) => string,
+  dim: (text: string) => string,
+  success: (text: string) => string,
+  warning: (text: string) => string,
+): string[] {
+  const entries = allExtensionStatusEntries(
+    getExtensionStatuses(),
+    config.extensionStatusRow,
+    STATUS_KEY,
+  );
+  const hidden = new Set(config.extensionStatusRow.hiddenKeys);
+  const lines = [
+    line(
+      menuTitle("Pi extensions", "Published statuses and extension status row visibility"),
+      width,
+    ),
+    line(dim("↑/↓ select • pgup/pgdn jump • ←/→ or enter toggle • esc back"), width),
+  ];
+
+  if (entries.length === 0) {
+    lines.push(line(warning("No extension statuses are currently available."), width));
+    return lines;
+  }
+
+  entries.forEach((entry, index) => {
+    const state = hidden.has(entry.key) ? dim("off") : success("on ");
+    const key = dim(entry.key);
+    const maxValueWidth = Math.max(1, width - entry.key.length - 8);
+    const value = truncateToWidth(entry.value, maxValueWidth, "…");
+    lines.push(menuLine(index === selected, `${state} ${key} ${value}`, width));
+  });
+  return lines;
+}
+
+export function toggleExtensionStatusRowSelection(
+  config: StatuslineSettings,
+  getExtensionStatuses: GetExtensionStatuses,
+  selected: number,
+): boolean {
+  const entry = allExtensionStatusEntries(
+    getExtensionStatuses(),
+    config.extensionStatusRow,
+    STATUS_KEY,
+  )[selected];
+  if (!entry) return false;
+  config.extensionStatusRow = toggleExtensionStatusRowKey(config.extensionStatusRow, entry.key);
+  return true;
+}
+
+export function extensionStatusRowCount(
+  config: StatuslineSettings,
+  getExtensionStatuses: GetExtensionStatuses,
+): number {
+  return allExtensionStatusEntries(getExtensionStatuses(), config.extensionStatusRow, STATUS_KEY)
+    .length;
+}

package/node_modules/pi-footer/src/ui/fields.ts

@@ -0,0 +1,252 @@
+import { colorDisplayName, normalizeColor } from "../colors.js";
+import type { WidgetOptions } from "../types.js";
+import { registry } from "../widgets/registry.js";
+import type { Widget, WidgetProperty } from "../widgets/types.js";
+import type { ColorOptionField, OptionField } from "./model.js";
+
+export function fieldsForWidget(widget: Widget): OptionField[] {
+  const spec = registry.spec(widget.type);
+  const properties: readonly WidgetProperty[] = spec.properties;
+  const fields: OptionField[] = [{ id: "enabled", label: "Enabled", kind: "boolean" }];
+
+  for (const option of spec.baseOptions) {
+    if (option === "raw") fields.push({ id: "raw", label: "Raw value only", kind: "boolean" });
+    if (option === "hideWhenEmpty")
+      fields.push({ id: "hideWhenEmpty", label: "Hide when empty", kind: "boolean" });
+    if (option === "hideWhenZero")
+      fields.push({ id: "hideWhenZero", label: "Hide when zero", kind: "boolean" });
+    if (option === "icon") fields.push({ id: "icon", label: "Custom icon", kind: "text" });
+    if (option === "text" && !widget.options.hideWhenEmpty)
+      fields.push({ id: "text", label: "Text when empty", kind: "text" });
+  }
+
+  for (const property of properties) {
+    if (property.options?.showInFields === false) continue;
+    if (!isMetadataPropertyVisible(property, widget.options)) continue;
+    fields.push(metadataField(property));
+  }
+
+  return fields;
+}
+
+export function colorFields(widget?: Widget): ColorOptionField[] {
+  const fields: ColorOptionField[] = [
+    { id: "fg", label: "Foreground", kind: "color" },
+    { id: "bg", label: "Background", kind: "color" },
+    { id: "bold", label: "Bold", kind: "boolean" },
+    { id: "fgAnsi", label: "Custom ANSI256 foreground", kind: "ansi" },
+    { id: "bgAnsi", label: "Custom ANSI256 background", kind: "ansi" },
+  ];
+  if (
+    widget &&
+    registry
+      .spec(widget.type)
+      .properties.find((property) => property.id === "contextConditionalColors") &&
+    widget.options.contextConditionalColors
+  ) {
+    fields.push(
+      { id: "warningFg", label: "Warning foreground", kind: "color" },
+      { id: "warningBg", label: "Warning background", kind: "color" },
+      { id: "warningFgAnsi", label: "Custom ANSI256 warning foreground", kind: "ansi" },
+      { id: "warningBgAnsi", label: "Custom ANSI256 warning background", kind: "ansi" },
+      { id: "dangerFg", label: "Danger foreground", kind: "color" },
+      { id: "dangerBg", label: "Danger background", kind: "color" },
+      { id: "dangerFgAnsi", label: "Custom ANSI256 danger foreground", kind: "ansi" },
+      { id: "dangerBgAnsi", label: "Custom ANSI256 danger background", kind: "ansi" },
+    );
+  }
+  return fields;
+}
+
+export function fieldValue(widget: Widget, field: OptionField): string {
+  if (field.id === "enabled") return widget.enabled ? "on" : "off";
+  if (field.kind === "boolean") return getBooleanField(widget, field.id) ? "on" : "off";
+  if (field.kind === "number") return String(getNumberField(widget, field.id) ?? "");
+  if (field.kind === "choice") {
+    const value = getTextField(widget, field.id);
+    return field.choices?.find((choice) => choice.id === value)?.label ?? value;
+  }
+  return getTextField(widget, field.id) || "(empty)";
+}
+
+export function colorFieldValue(widget: Widget, field: ColorOptionField): string {
+  if (field.id === "bold") return widget.options.bold ? "on" : "off";
+  if (field.id === "fg") return colorDisplayName(widget.options.fg);
+  if (field.id === "bg") return colorDisplayName(widget.options.bg);
+  if (field.id === "warningFg") return colorDisplayName(colorOption(widget, "warningFg"));
+  if (field.id === "warningBg") return colorDisplayName(colorOption(widget, "warningBg"));
+  if (field.id === "dangerFg") return colorDisplayName(colorOption(widget, "dangerFg"));
+  if (field.id === "dangerBg") return colorDisplayName(colorOption(widget, "dangerBg"));
+  if (field.id === "fgAnsi")
+    return widget.options.fg?.startsWith("ansi256:") ? widget.options.fg.slice(8) : "0";
+  if (field.id === "bgAnsi")
+    return widget.options.bg?.startsWith("ansi256:") ? widget.options.bg.slice(8) : "0";
+  if (field.id === "warningFgAnsi") {
+    const color = colorOption(widget, "warningFg");
+    return color?.startsWith("ansi256:") ? color.slice(8) : "0";
+  }
+  if (field.id === "warningBgAnsi") {
+    const color = colorOption(widget, "warningBg");
+    return color?.startsWith("ansi256:") ? color.slice(8) : "0";
+  }
+  if (field.id === "dangerFgAnsi") {
+    const color = colorOption(widget, "dangerFg");
+    return color?.startsWith("ansi256:") ? color.slice(8) : "0";
+  }
+  if (field.id === "dangerBgAnsi") {
+    const color = colorOption(widget, "dangerBg");
+    return color?.startsWith("ansi256:") ? color.slice(8) : "0";
+  }
+  return "";
+}
+
+export function getBooleanField(widget: Widget, id: string): boolean {
+  const spec = registry.spec(widget.type);
+  const property = spec.properties.find((item) => item.id === id);
+  if (property?.kind === "boolean") return Boolean(widget.options[id] ?? property.default);
+  if (spec.baseOptions.some((option) => option === id)) {
+    if (id === "raw") return widget.options.raw ?? false;
+    if (id === "hideWhenEmpty") return widget.options.hideWhenEmpty ?? false;
+    if (id === "hideWhenZero") return widget.options.hideWhenZero ?? false;
+  }
+  return false;
+}
+
+export function getNumberField(widget: Widget, id: string): number | undefined {
+  const property = registry.spec(widget.type).properties.find((item) => item.id === id);
+  if (property?.kind === "number") {
+    const value = widget.options[id];
+    return typeof value === "number" ? value : Number(property.default);
+  }
+  return undefined;
+}
+
+export function getTextField(widget: Widget, id: string): string {
+  const spec = registry.spec(widget.type);
+  const property = spec.properties.find((item) => item.id === id);
+  if (property && (property.kind === "text" || property.kind === "choice")) {
+    const value = widget.options[id];
+    return typeof value === "string" ? value : String(property.default);
+  }
+  if (spec.baseOptions.some((option) => option === id)) {
+    if (id === "icon") return widget.options.icon ?? "";
+    if (id === "text") return widget.options.text ?? "";
+  }
+  return "";
+}
+
+export function formatWidgetOptions(widget: Widget): string {
+  const spec = registry.spec(widget.type);
+  const properties: readonly WidgetProperty[] = spec.properties;
+  const parts = baseSummaryParts(widget);
+  if (spec.baseOptions.some((option) => option === "hideWhenZero") && widget.options.hideWhenZero)
+    parts.push("hide-zero");
+  if (
+    spec.baseOptions.some((option) => option === "text") &&
+    !widget.options.hideWhenEmpty &&
+    widget.options.text
+  )
+    parts.push(`text='${widget.options.text}'`);
+  for (const property of properties) {
+    if (!isMetadataPropertyVisible(property, widget.options)) continue;
+    if (property.options?.showInWidgets === false) continue;
+    addMetadataSummaryPart(parts, widget, property);
+  }
+  return parts.join(" • ");
+}
+
+export function formatWidgetColorOptions(widget: Widget): string {
+  const summary = formatMetadataWidgetColorOptions(widget);
+  const colorSummary = formatColorStyleSummary(widget);
+  if (!summary) return colorSummary;
+  if (!colorSummary) return summary;
+  return `${summary} • ${colorSummary}`;
+}
+
+export function isMetadataPropertyVisible(
+  property: WidgetProperty,
+  options: WidgetOptions,
+): boolean {
+  const condition = property.showWhen;
+  if (!condition) return true;
+  return options[condition.property] === condition.equals;
+}
+
+function colorOption(widget: Widget, key: string) {
+  return normalizeColor(widget.options[key]);
+}
+
+function formatMetadataWidgetColorOptions(widget: Widget): string {
+  const spec = registry.spec(widget.type);
+  const properties: readonly WidgetProperty[] = spec.properties;
+  const parts = baseSummaryParts(widget);
+  if (
+    spec.baseOptions.some((option) => option === "text") &&
+    !widget.options.hideWhenEmpty &&
+    widget.options.text
+  )
+    parts.push(`text='${widget.options.text}'`);
+  for (const property of properties) {
+    if (!isMetadataPropertyVisible(property, widget.options)) continue;
+    if (!property.options?.showInColors) continue;
+    addMetadataSummaryPart(parts, widget, property);
+  }
+  return parts.join(" • ");
+}
+
+function metadataField(property: WidgetProperty): OptionField {
+  const field: OptionField = {
+    id: property.id,
+    label: property.label,
+    kind: property.kind,
+  };
+  if (property.options?.min !== undefined) field.min = property.options.min;
+  if (property.options?.max !== undefined) field.max = property.options.max;
+  if (property.options?.choices !== undefined) field.choices = property.options.choices;
+  if (property.options?.editAction !== undefined) field.editAction = property.options.editAction;
+  return field;
+}
+
+function addMetadataSummaryPart(parts: string[], widget: Widget, property: WidgetProperty): void {
+  const value = widget.options[property.id] ?? property.default;
+  if (property.kind === "boolean") {
+    if (value === true) parts.push(property.options?.label ?? property.id);
+    return;
+  }
+  if (property.kind === "choice") {
+    if (value === property.default) return;
+    const choice = property.options?.choices?.find((item) => item.id === value);
+    const label = choice?.list ?? String(value);
+    const prefix = property.options?.listProperty || property.id;
+    if (prefix) parts.push(`${prefix}=${label}`);
+    else parts.push(label);
+    return;
+  }
+  if (property.kind === "number" || property.kind === "text") {
+    const prefix = property.options?.listProperty || property.id;
+    const renderedValue = property.options?.quoteValue ? `'${String(value)}'` : String(value);
+    if (value !== undefined && value !== "") parts.push(`${prefix}=${renderedValue}`);
+  }
+}
+
+function baseSummaryParts(widget: Widget): string[] {
+  const { options } = widget;
+  const spec = registry.spec(widget.type);
+  const parts: string[] = [];
+  if (spec.baseOptions.some((option) => option === "raw") && options.raw) parts.push("raw");
+  if (spec.baseOptions.some((option) => option === "hideWhenEmpty") && options.hideWhenEmpty)
+    parts.push("hide-empty");
+  if (spec.baseOptions.some((option) => option === "icon") && options.icon)
+    parts.push(`icon='${options.icon}'`);
+  return parts;
+}
+
+function formatColorStyleSummary(widget: Widget): string {
+  const { options } = widget;
+  const defaultFg = registry.spec(widget.type).defaultStyle.fg ?? "default";
+  const parts: string[] = [];
+  if (options.fg && options.fg !== defaultFg) parts.push(`fg=${colorDisplayName(options.fg)}`);
+  if (options.bg && options.bg !== "default") parts.push(`bg=${colorDisplayName(options.bg)}`);
+  if (options.bold) parts.push("bold");
+  return parts.join(" • ");
+}