@herbertgao/pi-extensions 2026.8.2 → 2026.8.4

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

@@ -0,0 +1,237 @@
+import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+import { Chalk } from "chalk";
+
+const chalk = {
+  level: 2,
+  c: new Chalk({ level: 2 }),
+};
+
+export const COLOR_LEVEL_VALUES = ["truecolor", "ansi256", "ansi16", "none"] as const;
+
+export type ColorLevel = (typeof COLOR_LEVEL_VALUES)[number];
+export type ColorName =
+  | "default"
+  | "black"
+  | "red"
+  | "green"
+  | "yellow"
+  | "blue"
+  | "magenta"
+  | "cyan"
+  | "white"
+  | "brightBlack"
+  | "brightRed"
+  | "brightGreen"
+  | "brightYellow"
+  | "brightBlue"
+  | "brightMagenta"
+  | "brightCyan"
+  | "brightWhite"
+  | `ansi256:${number}`
+  | `pi:${ThemeColor}`;
+
+interface ColorChoice {
+  label: string;
+  value: ColorName;
+}
+
+export const STANDARD_COLORS: ColorChoice[] = [
+  { label: "Default", value: "default" },
+  { label: "Black", value: "black" },
+  { label: "Red", value: "red" },
+  { label: "Green", value: "green" },
+  { label: "Yellow", value: "yellow" },
+  { label: "Blue", value: "blue" },
+  { label: "Magenta", value: "magenta" },
+  { label: "Cyan", value: "cyan" },
+  { label: "White", value: "white" },
+  { label: "Bright Black", value: "brightBlack" },
+  { label: "Bright Red", value: "brightRed" },
+  { label: "Bright Green", value: "brightGreen" },
+  { label: "Bright Yellow", value: "brightYellow" },
+  { label: "Bright Blue", value: "brightBlue" },
+  { label: "Bright Magenta", value: "brightMagenta" },
+  { label: "Bright Cyan", value: "brightCyan" },
+  { label: "Bright White", value: "brightWhite" },
+];
+
+const PI_THEME_COLORS: ThemeColor[] = [
+  "accent",
+  "border",
+  "borderAccent",
+  "borderMuted",
+  "success",
+  "error",
+  "warning",
+  "muted",
+  "dim",
+  "text",
+  "thinkingText",
+  "userMessageText",
+  "customMessageText",
+  "customMessageLabel",
+  "toolTitle",
+  "toolOutput",
+  "toolDiffAdded",
+  "toolDiffRemoved",
+  "toolDiffContext",
+  "syntaxType",
+  "thinkingOff",
+  "thinkingMinimal",
+  "thinkingLow",
+  "thinkingMedium",
+  "thinkingHigh",
+  "thinkingXhigh",
+  "bashMode",
+];
+
+const PI_FOREGROUND_COLORS: ColorChoice[] = PI_THEME_COLORS.map((color) => ({
+  label: `Pi ${themeColorDisplayName(color)}`,
+  value: `pi:${color}`,
+}));
+
+export const FOREGROUND_COLORS: ColorChoice[] = [...STANDARD_COLORS, ...PI_FOREGROUND_COLORS];
+
+const ANSI16_FG: Record<
+  Exclude<ColorName, `ansi256:${number}` | `pi:${ThemeColor}`>,
+  [number, number]
+> = {
+  default: [39, 49],
+  black: [30, 40],
+  red: [31, 41],
+  green: [32, 42],
+  yellow: [33, 43],
+  blue: [34, 44],
+  magenta: [35, 45],
+  cyan: [36, 46],
+  white: [37, 47],
+  brightBlack: [90, 100],
+  brightRed: [91, 101],
+  brightGreen: [92, 102],
+  brightYellow: [93, 103],
+  brightBlue: [94, 104],
+  brightMagenta: [95, 105],
+  brightCyan: [96, 106],
+  brightWhite: [97, 107],
+};
+
+export function normalizeColor(value: unknown): ColorName | undefined {
+  if (typeof value !== "string") return undefined;
+  if (STANDARD_COLORS.some((color) => color.value === value)) return value as ColorName;
+  if (PI_FOREGROUND_COLORS.some((color) => color.value === value)) return value as ColorName;
+  const match = /^ansi256:([0-9]{1,3})$/.exec(value);
+  if (!match) return undefined;
+  const code = Number(match[1]);
+  return Number.isInteger(code) && code >= 0 && code <= 255
+    ? (`ansi256:${code}` as ColorName)
+    : undefined;
+}
+
+export function colorDisplayName(color: ColorName | undefined): string {
+  if (!color || color === "default") return "Default";
+  if (color.startsWith("ansi256:")) return `ANSI256 ${color.slice("ansi256:".length)}`;
+  if (color.startsWith("pi:"))
+    return PI_FOREGROUND_COLORS.find((entry) => entry.value === color)?.label ?? color;
+  return STANDARD_COLORS.find((entry) => entry.value === color)?.label ?? color;
+}
+
+export function ansi256Digits(color: ColorName | undefined): string {
+  return color?.startsWith("ansi256:") ? String(Number(color.slice("ansi256:".length))) : "0";
+}
+
+export function appendAnsi256Digit(color: ColorName | undefined, digit: string): ColorName {
+  const digits = ansi256Digits(color);
+  const next = Number(`${digits}${digit}`);
+  return `ansi256:${Math.min(255, next)}`;
+}
+
+export function deleteAnsi256Digit(color: ColorName | undefined): ColorName {
+  const digits = ansi256Digits(color) || "0";
+  const next = digits.slice(0, -1);
+  return `ansi256:${next === "" ? 0 : Number(next)}`;
+}
+
+function useColorLevel(level: ColorLevel) {
+  const next = level === "truecolor" ? 3 : level === "ansi256" ? 2 : 1;
+  if (chalk.level === next) return;
+  chalk.level = next;
+  chalk.c = new Chalk({ level: next });
+}
+
+export function applyColors(
+  text: string,
+  foreground: ColorName | undefined,
+  background: ColorName | undefined,
+  bold: boolean | undefined,
+  level: ColorLevel,
+  theme?: Theme,
+): string {
+  if (level === "none") return text;
+  useColorLevel(level);
+
+  let output = text;
+  if (foreground && foreground !== "default")
+    output = applyOne(output, foreground, false, level, theme);
+  if (background && background !== "default") output = applyOne(output, background, true, level);
+  if (bold) output = chalk.c.bold(output);
+  return output;
+}
+
+// The styleable color bag shared by widget options and the context conditional-color helper.
+// fg/bg are validated ColorName (color picker); the warning/danger quartet is raw text input
+// (kind: "text" properties) normalized via normalizeColor() at read time.
+export interface ConditionalColorFields {
+  fg?: ColorName;
+  bg?: ColorName;
+  warningFg?: string;
+  warningBg?: string;
+  dangerFg?: string;
+  dangerBg?: string;
+}
+
+export function resetAnsi256Colors<T extends ConditionalColorFields>(options: T): T {
+  const next = { ...options };
+  if (next.fg?.startsWith("ansi256:")) next.fg = "default";
+  if (next.bg?.startsWith("ansi256:")) next.bg = "default";
+  if (next.warningFg?.startsWith("ansi256:")) next.warningFg = "default";
+  if (next.warningBg?.startsWith("ansi256:")) next.warningBg = "default";
+  if (next.dangerFg?.startsWith("ansi256:")) next.dangerFg = "default";
+  if (next.dangerBg?.startsWith("ansi256:")) next.dangerBg = "default";
+  return next;
+}
+
+function themeColorDisplayName(color: ThemeColor): string {
+  return color.replace(/([A-Z])/g, " $1").replace(/^./, (char) => char.toUpperCase());
+}
+
+function applyOne(
+  text: string,
+  color: ColorName,
+  background: boolean,
+  level: ColorLevel,
+  theme?: Theme,
+): string {
+  if (color.startsWith("pi:")) {
+    if (background || !theme) return text;
+    return theme.fg(color.slice("pi:".length) as ThemeColor, text);
+  }
+  if (color.startsWith("ansi256:")) {
+    const code = Number(color.slice("ansi256:".length));
+    if (level === "ansi256" || level === "truecolor") {
+      return background ? chalk.c.bgAnsi256(code)(text) : chalk.c.ansi256(code)(text);
+    }
+    return text;
+  }
+
+  const codes = ANSI16_FG[color as Exclude<ColorName, `ansi256:${number}` | `pi:${ThemeColor}`>];
+  if (!codes || color === "default") return text;
+  return `\x1b[${background ? codes[1] : codes[0]}m${text}\x1b[${background ? 49 : 39}m`;
+}
+
+// Keep the escape byte out of a regex literal so oxlint's no-control-regex rule does not
+// flag the intentional ANSI matcher. RegExp still receives the ESC sequence at runtime.
+const ANSI_ESCAPE_PATTERN = new RegExp(String.raw`\x1B\[[0-?]*[ -/]*[@-~]`, "g");
+
+export function stripAnsi(text: string): string {
+  return text.replace(ANSI_ESCAPE_PATTERN, "");
+}

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

@@ -0,0 +1,202 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+import type { ColorLevel } from "./colors.js";
+import { COLOR_LEVEL_VALUES, normalizeColor } from "./colors.js";
+import {
+  cloneExtensionStatusRow,
+  DEFAULT_EXTENSION_STATUS_ROW,
+  normalizeExtensionStatusRow,
+} from "./extension-statuses.js";
+import {
+  PRESET_DEFINITIONS,
+  type Preset,
+  type PresetDefinition,
+  type PresetWidget,
+} from "./presets.js";
+import { SEPARATOR_VALUES, type SeparatorStyle } from "./separators.js";
+import type {
+  IconMode,
+  StatuslineConfig,
+  StatuslineSettings,
+  TerminalOptions,
+  TerminalWidthMode,
+  WidgetEntry,
+} from "./types.js";
+import { ICON_MODE_VALUES, isRecord, TERMINAL_WIDTH_MODE_VALUES } from "./types.js";
+import { registry, type WidgetType } from "./widgets/registry.js";
+
+export const STATUS_KEY = "pi-footer";
+
+const CONFIG_ENV = "PI_FOOTER_CONFIG";
+const DEFAULT_CONFIG_PATH = join(getAgentDir(), "extensions", "pi-footer.json");
+const SEPARATORS = new Set<SeparatorStyle>(SEPARATOR_VALUES);
+
+const DEFAULT_TERMINAL_OPTIONS: TerminalOptions = {
+  widthMode: "full",
+  colorLevel: "ansi256",
+};
+
+export const DEFAULT_CONFIG: StatuslineConfig = {
+  version: 1,
+  enabled: true,
+  preset: "default",
+  lines: linesForPreset("default"),
+  separator: "dot",
+  separatorFg: "default",
+  separatorBg: "default",
+  iconMode: "emoji",
+  minimalist: false,
+  terminal: DEFAULT_TERMINAL_OPTIONS,
+  extensionStatusRow: DEFAULT_EXTENSION_STATUS_ROW,
+};
+
+export function getConfigPath(): string {
+  return process.env[CONFIG_ENV] ?? DEFAULT_CONFIG_PATH;
+}
+
+function linesForPreset(preset: Preset): WidgetEntry[][] {
+  return PRESET_DEFINITIONS[preset].lines.map((line) => widgetsFromPresetLine(line));
+}
+
+export function configWithPreset(config: StatuslineConfig, preset: Preset): StatuslineConfig {
+  const definition: PresetDefinition = PRESET_DEFINITIONS[preset];
+  return {
+    ...config,
+    preset,
+    lines: linesForPreset(preset),
+    separator: definition.separator ?? config.separator,
+    iconMode: definition.iconMode ?? config.iconMode,
+    terminal: { ...config.terminal, ...definition.terminal },
+  };
+}
+
+function widgetsFromPresetLine(line: readonly PresetWidget[]): WidgetEntry[] {
+  return line.map((widget) => registry.createEntry(widget.type, widget.options));
+}
+
+export function normalizeConfig(input: unknown): StatuslineConfig {
+  if (!isRecord(input)) return cloneConfig(DEFAULT_CONFIG);
+
+  const preset = isPreset(input.preset) ? input.preset : DEFAULT_CONFIG.preset;
+  const lines = normalizeLines(input.lines, preset);
+
+  return {
+    version: 1,
+    enabled: typeof input.enabled === "boolean" ? input.enabled : DEFAULT_CONFIG.enabled,
+    preset,
+    lines,
+    separator: isSeparatorStyle(input.separator)
+      ? input.separator
+      : (PRESET_DEFINITIONS[preset].separator ?? DEFAULT_CONFIG.separator),
+    separatorFg: normalizeColor(input.separatorFg) ?? DEFAULT_CONFIG.separatorFg,
+    separatorBg: normalizeColor(input.separatorBg) ?? DEFAULT_CONFIG.separatorBg,
+    iconMode: isIconMode(input.iconMode) ? input.iconMode : DEFAULT_CONFIG.iconMode,
+    minimalist:
+      typeof input.minimalist === "boolean" ? input.minimalist : DEFAULT_CONFIG.minimalist,
+    terminal: normalizeTerminalOptions(input.terminal, PRESET_DEFINITIONS[preset].terminal),
+    extensionStatusRow: normalizeExtensionStatusRow(input.extensionStatusRow),
+  };
+}
+
+export function cloneSettings(settings: StatuslineSettings): StatuslineSettings {
+  return {
+    ...settings,
+    terminal: { ...settings.terminal },
+    extensionStatusRow: cloneExtensionStatusRow(settings.extensionStatusRow),
+  };
+}
+
+export function cloneConfig(config: StatuslineConfig): StatuslineConfig {
+  return {
+    ...cloneSettings(config),
+    lines: config.lines.map((line) =>
+      line.map((widget) => ({ ...widget, options: { ...widget.options } })),
+    ),
+  };
+}
+
+export async function loadConfig(path = getConfigPath()): Promise<StatuslineConfig> {
+  try {
+    const raw = await readFile(path, "utf8");
+    return normalizeConfig(JSON.parse(raw));
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return cloneConfig(DEFAULT_CONFIG);
+    }
+    throw error;
+  }
+}
+
+export async function saveConfig(config: StatuslineConfig, path = getConfigPath()): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(normalizeConfig(config), null, 2)}\n`, "utf8");
+}
+
+function normalizeLines(linesValue: unknown, preset: Preset): WidgetEntry[][] {
+  if (!Array.isArray(linesValue)) return linesForPreset(preset);
+  return linesValue.map((line) => normalizeWidgets(line));
+}
+
+function normalizeWidgets(value: unknown): WidgetEntry[] {
+  if (!Array.isArray(value)) return [];
+
+  const widgets: WidgetEntry[] = [];
+  for (const item of value) {
+    if (!isRecord(item) || typeof item.type !== "string") continue;
+    const spec = registry.maybeSpec(item.type);
+    if (!spec) continue;
+    widgets.push({
+      id:
+        typeof item.id === "string" && item.id.length > 0
+          ? item.id
+          : registry.createEntry(spec.type as WidgetType).id,
+      type: spec.type as WidgetType,
+      enabled: typeof item.enabled === "boolean" ? item.enabled : true,
+      options: registry.normalizeOptions(
+        spec.type as WidgetType,
+        isRecord(item.options) ? item.options : {},
+      ),
+    });
+  }
+
+  return widgets;
+}
+
+function normalizeTerminalOptions(
+  value: unknown,
+  defaults: Partial<TerminalOptions> = {},
+): TerminalOptions {
+  const base = { ...DEFAULT_TERMINAL_OPTIONS, ...defaults };
+  if (!isRecord(value)) return base;
+  return {
+    widthMode:
+      typeof value.widthMode === "string" &&
+      TERMINAL_WIDTH_MODE_VALUES.includes(value.widthMode as TerminalWidthMode)
+        ? (value.widthMode as TerminalWidthMode)
+        : base.widthMode,
+    colorLevel:
+      typeof value.colorLevel === "string" &&
+      COLOR_LEVEL_VALUES.includes(value.colorLevel as ColorLevel)
+        ? (value.colorLevel as ColorLevel)
+        : base.colorLevel,
+  };
+}
+
+export function isPreset(value: unknown): value is Preset {
+  return typeof value === "string" && Object.hasOwn(PRESET_DEFINITIONS, value);
+}
+
+function isSeparatorStyle(value: unknown): value is SeparatorStyle {
+  return typeof value === "string" && SEPARATORS.has(value as SeparatorStyle);
+}
+
+function isIconMode(value: unknown): value is IconMode {
+  return typeof value === "string" && ICON_MODE_VALUES.includes(value as IconMode);
+}
+
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+  return error instanceof Error && "code" in error;
+}

package/node_modules/pi-footer/src/event-widgets.ts

@@ -0,0 +1,41 @@
+import { isRecord } from "./types.js";
+
+export const UPDATE_EVENT_WIDGET_EVENT = "pi-footer:update-widget";
+
+interface UpdateEventWidgetPayload {
+  widgetId: string;
+  value: string | null;
+}
+
+const EVENT_WIDGET_ID_PREFIX = "event_";
+
+export function createEventWidgetId(): string {
+  return `${EVENT_WIDGET_ID_PREFIX}${Math.random().toString(36).slice(2, 10)}`;
+}
+
+export class EventWidgetValues {
+  private readonly valuesById = new Map<string, string>();
+
+  get values(): ReadonlyMap<string, string> {
+    return this.valuesById;
+  }
+
+  update(payload: unknown): boolean {
+    if (!isUpdatePayload(payload)) return false;
+    if (payload.value === null) {
+      return this.valuesById.delete(payload.widgetId);
+    }
+    const previous = this.valuesById.get(payload.widgetId);
+    this.valuesById.set(payload.widgetId, payload.value);
+    return previous !== payload.value;
+  }
+}
+
+function isUpdatePayload(value: unknown): value is UpdateEventWidgetPayload {
+  if (!isRecord(value)) return false;
+  return (
+    typeof value.widgetId === "string" &&
+    value.widgetId.length > 0 &&
+    (typeof value.value === "string" || value.value === null)
+  );
+}

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

@@ -0,0 +1,102 @@
+import { isRecord } from "./types.js";
+
+export const EMPTY_STATUS_LABEL = "[Empty status]";
+
+export interface ExtensionStatusRowConfig {
+  hiddenKeys: string[];
+  knownKeys: string[];
+}
+
+interface ExtensionStatusEntry {
+  key: string;
+  value: string;
+  published: boolean;
+}
+
+export type GetExtensionStatuses = () => ReadonlyMap<string, string>;
+
+export const DEFAULT_EXTENSION_STATUS_ROW: ExtensionStatusRowConfig = {
+  hiddenKeys: [],
+  knownKeys: [],
+};
+
+export const EMPTY_EXTENSION_STATUSES: ReadonlyMap<string, string> = new Map<string, string>();
+
+export function extensionStatusEntries(
+  statuses: ReadonlyMap<string, string>,
+  ownStatusKey: string,
+): ExtensionStatusEntry[] {
+  return [...statuses.entries()]
+    .filter(([key, value]) => key !== ownStatusKey && value.length > 0)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([key, value]) => ({ key, value, published: true }));
+}
+
+export function allExtensionStatusEntries(
+  statuses: ReadonlyMap<string, string>,
+  rowConfig: ExtensionStatusRowConfig,
+  ownStatusKey: string,
+): ExtensionStatusEntry[] {
+  const keys = new Set([...statuses.keys(), ...rowConfig.hiddenKeys, ...rowConfig.knownKeys]);
+  return [...keys]
+    .filter((key) => key.length > 0 && key !== ownStatusKey)
+    .sort((left, right) => left.localeCompare(right))
+    .map((key) => {
+      const value = statuses.get(key) ?? "";
+      return {
+        key,
+        value: value.length > 0 ? value : EMPTY_STATUS_LABEL,
+        published: value.length > 0,
+      };
+    });
+}
+
+export function visibleExtensionStatusRowEntries(
+  statuses: ReadonlyMap<string, string>,
+  hiddenKeys: readonly string[],
+  ownStatusKey: string,
+): ExtensionStatusEntry[] {
+  const hidden = new Set(hiddenKeys);
+  return extensionStatusEntries(statuses, ownStatusKey).filter((entry) => !hidden.has(entry.key));
+}
+
+export function toggleExtensionStatusRowKey(
+  rowConfig: ExtensionStatusRowConfig,
+  key: string,
+): ExtensionStatusRowConfig {
+  const hidden = new Set(rowConfig.hiddenKeys);
+  const known = new Set(rowConfig.knownKeys);
+  known.add(key);
+  if (hidden.has(key)) hidden.delete(key);
+  else hidden.add(key);
+  return {
+    hiddenKeys: sortedKeys(hidden),
+    knownKeys: sortedKeys(known),
+  };
+}
+
+export function normalizeExtensionStatusRow(value: unknown): ExtensionStatusRowConfig {
+  if (!isRecord(value)) return cloneExtensionStatusRow(DEFAULT_EXTENSION_STATUS_ROW);
+  return {
+    hiddenKeys: normalizeKeyList(value.hiddenKeys),
+    knownKeys: normalizeKeyList(value.knownKeys),
+  };
+}
+
+export function cloneExtensionStatusRow(value: ExtensionStatusRowConfig): ExtensionStatusRowConfig {
+  return {
+    hiddenKeys: [...value.hiddenKeys],
+    knownKeys: [...value.knownKeys],
+  };
+}
+
+function normalizeKeyList(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return sortedKeys(
+    new Set(value.filter((key): key is string => typeof key === "string" && key.length > 0)),
+  );
+}
+
+function sortedKeys(keys: Iterable<string>): string[] {
+  return [...keys].sort((left, right) => left.localeCompare(right));
+}