@herbertgao/pi-extensions 2026.8.2 → 2026.8.4

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

@@ -0,0 +1,383 @@
+import type { ColorName } from "./colors.js";
+import type { SeparatorStyle, WidgetSeparatorStyle } from "./separators.js";
+import type { IconMode, TerminalOptions, TerminalWidthMode, WidgetOptions } from "./types.js";
+import type { WidgetType } from "./widgets/registry.js";
+
+export interface PresetWidget {
+  type: WidgetType;
+  options?: WidgetOptions;
+}
+
+export interface PresetDefinition {
+  separator?: SeparatorStyle;
+  iconMode?: IconMode;
+  terminal?: Partial<TerminalOptions>;
+  lines: PresetWidget[][];
+}
+
+interface PowerlineSegment extends PresetWidget {
+  options: WidgetOptions & { fg: ColorName; bg: ColorName };
+}
+
+interface PowerlineTransitionContext {
+  left: PowerlineSegment;
+  right: PowerlineSegment;
+  index: number;
+}
+
+interface PowerlineCapOptions {
+  separator?: WidgetSeparatorStyle;
+  fg?: ColorName;
+  bg?: ColorName;
+}
+
+interface PowerlineLineOptions {
+  separator?: WidgetSeparatorStyle;
+  start?: boolean | PowerlineCapOptions;
+  end?: boolean | PowerlineCapOptions;
+  transition?: (
+    context: PowerlineTransitionContext,
+  ) => Partial<WidgetOptions> & { separator?: WidgetSeparatorStyle };
+}
+
+const FULL_WIDTH: Partial<TerminalOptions> = { widthMode: "full" satisfies TerminalWidthMode };
+
+function widget(type: WidgetType, options: WidgetOptions = {}): PresetWidget {
+  return { type, options };
+}
+
+function powerSegment(
+  type: WidgetType,
+  options: WidgetOptions & { fg: ColorName; bg: ColorName },
+): PowerlineSegment {
+  return { type, options };
+}
+
+function powerlineLine(
+  segments: readonly PowerlineSegment[],
+  options: PowerlineLineOptions = {},
+): PresetWidget[] {
+  if (segments.length === 0) return [];
+
+  const separator = options.separator ?? "powerline-right-spaced";
+  const line: PresetWidget[] = [];
+  const first = segments[0];
+  if (!first) return [];
+
+  if (options.start) line.push(capWidget(first.options.bg, options.start, "powerline-start"));
+
+  for (let index = 0; index < segments.length; index += 1) {
+    const current = segments[index];
+    if (!current) continue;
+    line.push(current);
+
+    const next = segments[index + 1];
+    if (!next) continue;
+    const transition = options.transition?.({ left: current, right: next, index }) ?? {};
+    line.push({
+      type: "separator",
+      options: {
+        separator: transition.separator ?? separator,
+        fg: current.options.bg,
+        bg: next.options.bg,
+        ...transition,
+      },
+    });
+  }
+
+  const last = segments.at(-1);
+  if (last && options.end) line.push(capWidget(last.options.bg, options.end, "powerline-end"));
+
+  return line;
+}
+
+function capWidget(
+  color: ColorName,
+  cap: true | PowerlineCapOptions,
+  defaultSeparator: WidgetSeparatorStyle,
+): PresetWidget {
+  const options = cap === true ? {} : cap;
+  return {
+    type: "separator",
+    options: {
+      separator: options.separator ?? defaultSeparator,
+      fg: options.fg ?? color,
+      bg: options.bg ?? "default",
+    },
+  };
+}
+
+function demoLabelLine(preset: keyof typeof BASE_PRESET_DEFINITIONS): PresetWidget[] {
+  return [widget("custom-text", { raw: true, fg: "pi:success", text: `Preset '${preset}':` })];
+}
+
+function demoEmptyLine(): PresetWidget[] {
+  return [widget("custom-text", { raw: true, fg: "pi:success", text: "" })];
+}
+
+const BASE_PRESET_DEFINITIONS = {
+  default: {
+    separator: "dot",
+    terminal: FULL_WIDTH,
+    lines: [
+      [
+        widget("model-provider"),
+        widget("thinking-level"),
+        widget("text-verbosity"),
+        widget("context-length"),
+        widget("git-branch"),
+        widget("git-diff", { gitDiffMode: "compact" }),
+        widget("cost"),
+        widget("total-time"),
+      ],
+    ],
+  },
+  powerline: {
+    separator: "none",
+    iconMode: "nerd",
+    terminal: FULL_WIDTH,
+    lines: [
+      powerlineLine([
+        powerSegment("model-provider", { fg: "brightWhite", bg: "ansi256:33", bold: true }),
+        powerSegment("git-branch", { fg: "brightWhite", bg: "ansi256:61", bold: true }),
+        powerSegment("tokens", { fg: "brightWhite", bg: "ansi256:64" }),
+        powerSegment("context-bar", {
+          fg: "ansi256:234",
+          bg: "ansi256:136",
+          contextBarMode: "medium",
+        }),
+        powerSegment("output-speed", { fg: "black", bg: "ansi256:37" }),
+        powerSegment("total-time", { fg: "brightWhite", bg: "ansi256:236" }),
+      ]),
+    ],
+  },
+  "powerline-bright": {
+    separator: "none",
+    iconMode: "nerd",
+    terminal: FULL_WIDTH,
+    lines: [
+      powerlineLine(
+        [
+          powerSegment("model", { fg: "brightWhite", bg: "ansi256:131", icon: "Model: " }),
+          powerSegment("context-length", { fg: "black", bg: "ansi256:220", icon: "Ctx: " }),
+          powerSegment("git-branch", { fg: "brightWhite", bg: "ansi256:68" }),
+          powerSegment("git-diff", {
+            fg: "black",
+            bg: "ansi256:108",
+            raw: true,
+            gitDiffMode: "compact",
+          }),
+          powerSegment("total-time", { fg: "black", bg: "ansi256:176", raw: true }),
+        ],
+        { start: true, end: true },
+      ),
+      powerlineLine(
+        [
+          powerSegment("cwd", { fg: "brightWhite", bg: "ansi256:131", segments: 3, icon: "cwd: " }),
+          powerSegment("cost", { fg: "black", bg: "ansi256:220", icon: "Cost: " }),
+        ],
+        { start: true, end: true },
+      ),
+    ],
+  },
+  "powerline-blocks": {
+    separator: "none",
+    iconMode: "nerd",
+    terminal: FULL_WIDTH,
+    lines: [
+      powerlineLine(
+        [
+          powerSegment("model", { fg: "brightWhite", bg: "ansi256:131", icon: "Model: " }),
+          powerSegment("context-length", { fg: "black", bg: "ansi256:222", icon: "Ctx: " }),
+          powerSegment("git-branch", { fg: "brightWhite", bg: "ansi256:67" }),
+          powerSegment("git-diff", {
+            fg: "black",
+            bg: "ansi256:151",
+            raw: true,
+            gitDiffMode: "compact",
+          }),
+        ],
+        { start: true, end: true },
+      ),
+      powerlineLine(
+        [
+          powerSegment("input-tokens", { fg: "brightWhite", bg: "ansi256:131", icon: "In: " }),
+          powerSegment("output-tokens", { fg: "black", bg: "ansi256:222", icon: "Out: " }),
+          powerSegment("cache-read", { fg: "brightWhite", bg: "ansi256:67", icon: "Cached: " }),
+          powerSegment("total-tokens", { fg: "black", bg: "ansi256:151", icon: "Total: " }),
+        ],
+        { start: true, end: true },
+      ),
+      powerlineLine(
+        [
+          powerSegment("context-bar", {
+            fg: "brightWhite",
+            bg: "ansi256:131",
+            icon: "Ctx ",
+            contextBarMode: "medium",
+          }),
+          powerSegment("total-time", { fg: "brightWhite", bg: "ansi256:131", raw: true }),
+        ],
+        {
+          start: true,
+          end: true,
+          transition: () => ({ separator: "powerline-soft-right" }),
+        },
+      ),
+    ],
+  },
+  "powerline-mono": {
+    separator: "none",
+    iconMode: "nerd",
+    terminal: FULL_WIDTH,
+    lines: [
+      powerlineLine(
+        [
+          powerSegment("model", { fg: "brightWhite", bg: "ansi256:240", icon: "Model: " }),
+          powerSegment("context-length", { fg: "black", bg: "ansi256:252", icon: "Ctx: " }),
+          powerSegment("git-branch", { fg: "brightWhite", bg: "ansi256:233" }),
+          powerSegment("git-diff", {
+            fg: "black",
+            bg: "ansi256:250",
+            raw: true,
+            gitDiffMode: "compact",
+          }),
+          powerSegment("cwd-basename", { fg: "brightWhite", bg: "ansi256:236" }),
+        ],
+        { start: true, end: true },
+      ),
+      powerlineLine(
+        [
+          powerSegment("output-tokens", { fg: "brightWhite", bg: "ansi256:240", icon: "👾 Out: " }),
+          powerSegment("cache-read", { fg: "black", bg: "ansi256:252", icon: "💰 Cached: " }),
+          powerSegment("total-tokens", { fg: "brightWhite", bg: "ansi256:233", icon: "Total: " }),
+          powerSegment("context-length", { fg: "black", bg: "ansi256:250", icon: "Ctx: " }),
+        ],
+        { start: true, end: true },
+      ),
+    ],
+  },
+  "git-heavy": {
+    separator: "dot",
+    iconMode: "nerd",
+    terminal: FULL_WIDTH,
+    lines: [
+      [
+        widget("model-provider"),
+        widget("cwd-basename"),
+        widget("git-branch"),
+        widget("git-sha"),
+        widget("git-status"),
+        widget("git-diff", { gitDiffMode: "compact" }),
+        widget("git-ahead-behind"),
+      ],
+    ],
+  },
+  compact: {
+    separator: "space",
+    terminal: { widthMode: "full-minus-40" },
+    lines: [
+      [
+        widget("model"),
+        widget("thinking-level"),
+        widget("text-verbosity"),
+        widget("git-branch"),
+        widget("context"),
+        widget("cost"),
+      ],
+    ],
+  },
+  "pi-footer": {
+    separator: "none",
+    iconMode: "text",
+    terminal: FULL_WIDTH,
+    lines: [
+      [
+        widget("cwd", { raw: true, fg: "pi:dim", cwdDisplayStyle: "full-home" }),
+        widget("git-branch", {
+          icon: " ",
+          fg: "pi:dim",
+          hideWhenEmpty: true,
+          gitBranchDisplayStyle: "round-brackets",
+        }),
+        widget("session-name", { icon: " • ", fg: "pi:dim", hideWhenEmpty: true }),
+      ],
+      [
+        widget("tokens", { raw: true, fg: "pi:dim", tokenFormatStyle: "compact" }),
+        widget("cache-read", {
+          icon: " R",
+          fg: "pi:dim",
+          tokenFormatStyle: "compact",
+          hideWhenZero: true,
+        }),
+        widget("cache-write", {
+          icon: " W",
+          fg: "pi:dim",
+          tokenFormatStyle: "compact",
+          hideWhenZero: true,
+        }),
+        widget("cache-hit-rate", {
+          icon: " CH",
+          fg: "pi:dim",
+          hideWhenZero: true,
+          cacheHitSource: "turn",
+        }),
+        widget("cost", {
+          icon: " ",
+          fg: "pi:dim",
+          costFormatStyle: "compact",
+          showSubscription: true,
+        }),
+        widget("context", {
+          icon: " ",
+          fg: "pi:dim",
+          contextConditionalColors: true,
+          warningFg: "pi:warning",
+          dangerFg: "pi:error",
+        }),
+        widget("context-window", {
+          icon: "/",
+          fg: "pi:dim",
+          contextConditionalColors: true,
+          warningFg: "pi:warning",
+          dangerFg: "pi:error",
+          tokenFormatStyle: "compact",
+        }),
+        widget("flex-separator"),
+        widget("model", { raw: true, fg: "pi:dim" }),
+        widget("thinking-level", { icon: " • ", fg: "pi:dim", hideWhenEmpty: true }),
+      ],
+    ],
+  },
+} satisfies Record<string, PresetDefinition>;
+
+function demoLines(...presets: Array<keyof typeof BASE_PRESET_DEFINITIONS>): PresetWidget[][] {
+  return presets.flatMap((preset, index) => [
+    demoLabelLine(preset),
+    ...BASE_PRESET_DEFINITIONS[preset].lines,
+    ...(index === presets.length - 1 ? [] : [demoEmptyLine()]),
+  ]);
+}
+
+export const PRESET_DEFINITIONS = {
+  ...BASE_PRESET_DEFINITIONS,
+  demo: {
+    separator: "none",
+    iconMode: "nerd",
+    terminal: FULL_WIDTH,
+    lines: demoLines(
+      "pi-footer",
+      "powerline",
+      "powerline-bright",
+      "powerline-blocks",
+      "powerline-mono",
+    ),
+  },
+  "demo-standard": {
+    separator: "dot",
+    terminal: FULL_WIDTH,
+    lines: demoLines("default", "compact", "git-heavy"),
+  },
+} satisfies Record<string, PresetDefinition>;
+
+export type Preset = keyof typeof PRESET_DEFINITIONS;

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

@@ -0,0 +1,114 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+import { applyColors } from "./colors.js";
+import type { GetExtensionStatuses } from "./extension-statuses.js";
+import { separatorText } from "./separators.js";
+import type { StatuslineData, StatuslineSettings } from "./types.js";
+import { contextForDependencies } from "./widgets/context.js";
+import { registry } from "./widgets/registry.js";
+import type { WidgetStore } from "./widgets/store.js";
+import type { BaseWidgetContext, Widget } from "./widgets/types.js";
+
+export interface RenderStatuslineOptions {
+  getExtensionStatuses?: GetExtensionStatuses;
+  theme?: Theme;
+  requestRender?: () => void;
+}
+
+export function renderStatuslines(
+  store: WidgetStore,
+  data: StatuslineData,
+  width: number,
+  options: RenderStatuslineOptions = {},
+): string[] {
+  const settings = store.settings;
+  if (!settings.enabled || width <= 0) return [];
+
+  const baseCtx: BaseWidgetContext = {
+    iconMode: settings.iconMode,
+    minimalist: settings.minimalist,
+    colorLevel: settings.terminal.colorLevel,
+    ...(options.theme ? { theme: options.theme } : {}),
+    ...(options.requestRender ? { requestRender: options.requestRender } : {}),
+  };
+  const lineWidth = effectiveWidth(settings, width);
+  return store.lines
+    .map((line) => renderLine(line, settings, lineWidth, { baseCtx, data, options }))
+    .filter((line) => line.trim().length > 0);
+}
+
+function padRight(left: string, right: string, width: number): string {
+  const spaces = Math.max(1, width - visibleWidth(left) - visibleWidth(right));
+  return truncateToWidth(`${left}${" ".repeat(spaces)}${right}`, width, "…");
+}
+
+interface RenderedSegment {
+  widget: Widget;
+  segment: string;
+}
+
+interface RenderLineContext {
+  baseCtx: BaseWidgetContext;
+  data: StatuslineData;
+  options: RenderStatuslineOptions;
+}
+
+function renderLine(
+  line: readonly Widget[],
+  settings: StatuslineSettings,
+  width: number,
+  ctx: RenderLineContext,
+): string {
+  const rendered = line
+    .filter((widget) => widget.enabled)
+    .map((widget) => ({
+      widget,
+      segment:
+        widget.render(
+          contextForDependencies(
+            ctx.baseCtx,
+            registry.spec(widget.type).dependencies,
+            ctx.data,
+            ctx.options,
+          ),
+        ) ?? "",
+    }));
+
+  const flexIndex = rendered.findIndex((entry) => entry.widget.type === "flex-separator");
+  if (flexIndex === -1) {
+    return truncateToWidth(joinSegments(rendered, settings), width, "…");
+  }
+
+  const left = joinSegments(rendered.slice(0, flexIndex), settings);
+  const right = joinSegments(rendered.slice(flexIndex + 1), settings);
+  return right ? padRight(left, right, width) : truncateToWidth(left, width, "…");
+}
+
+function effectiveWidth(settings: StatuslineSettings, width: number): number {
+  if (settings.terminal.widthMode === "full-minus-40") return Math.max(1, width - 40);
+  return width;
+}
+
+function joinSegments(entries: readonly RenderedSegment[], settings: StatuslineSettings): string {
+  const segments = entries.filter((entry) => entry.segment.length > 0);
+  if (segments.length === 0) return "";
+
+  let output = segments[0]?.segment ?? "";
+  for (let index = 1; index < segments.length; index += 1) {
+    const previous = segments[index - 1];
+    const current = segments[index];
+    if (!previous || !current) continue;
+    if (previous.widget.type !== "separator" && current.widget.type !== "separator") {
+      output += applyColors(
+        separatorText(settings.separator),
+        settings.separatorFg,
+        settings.separatorBg,
+        false,
+        settings.terminal.colorLevel,
+      );
+    }
+    output += current.segment;
+  }
+  return output;
+}

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

@@ -0,0 +1,52 @@
+export const SEPARATOR_VALUES = [
+  "none",
+  "dot",
+  "pipe",
+  "space",
+  "powerline",
+  "dash",
+  "comma",
+] as const;
+
+export type SeparatorStyle = (typeof SEPARATOR_VALUES)[number];
+
+export const WIDGET_SEPARATOR_VALUES = [
+  ...SEPARATOR_VALUES,
+  "powerline-right",
+  "powerline-right-spaced",
+  "powerline-left",
+  "powerline-left-spaced",
+  "powerline-soft-right",
+  "powerline-soft-left",
+  "powerline-start",
+  "powerline-end",
+  "custom",
+] as const;
+
+export type WidgetSeparatorStyle = (typeof WIDGET_SEPARATOR_VALUES)[number];
+
+export function separatorText(separator: SeparatorStyle): string {
+  if (separator === "none") return "";
+  if (separator === "space") return " ";
+  if (separator === "pipe") return " | ";
+  if (separator === "powerline") return "  ";
+  if (separator === "dash") return " - ";
+  if (separator === "comma") return ", ";
+  return " • ";
+}
+
+export function widgetSeparatorText(
+  separator: WidgetSeparatorStyle | undefined,
+  customText: string,
+): string {
+  if (separator === "custom") return customText;
+  if (separator === "powerline" || separator === "powerline-right-spaced") return " ";
+  if (separator === "powerline-right") return "";
+  if (separator === "powerline-left-spaced") return " ";
+  if (separator === "powerline-left") return "";
+  if (separator === "powerline-soft-right") return "";
+  if (separator === "powerline-soft-left") return "";
+  if (separator === "powerline-start") return "";
+  if (separator === "powerline-end") return "";
+  return separatorText(separator ?? "pipe");
+}

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

@@ -0,0 +1,122 @@
+import type { ColorLevel, ColorName } from "./colors.js";
+import type { ExtensionStatusRowConfig } from "./extension-statuses.js";
+import type { Preset } from "./presets.js";
+import type { SeparatorStyle } from "./separators.js";
+import type { WidgetType } from "./widgets/registry.js";
+
+export interface WidgetEntry {
+  id: string;
+  type: WidgetType;
+  enabled: boolean;
+  options: WidgetOptions;
+}
+
+type WidgetOptionValue = string | number | boolean | undefined;
+
+// Shared style options. These are renderer-level options, not widget-specific metadata.
+export interface WidgetStyle {
+  fg?: ColorName;
+  bg?: ColorName;
+  bold?: boolean;
+}
+
+export interface WidgetOptions extends WidgetStyle {
+  [key: string]: WidgetOptionValue;
+
+  // Shared/base options. New widget-specific fields must be declared through widget metadata.
+  icon?: string;
+  raw?: boolean;
+  hideWhenEmpty?: boolean;
+  hideWhenZero?: boolean;
+  text?: string;
+}
+
+export const TERMINAL_WIDTH_MODE_VALUES = ["full", "full-minus-40"] as const;
+export type TerminalWidthMode = (typeof TERMINAL_WIDTH_MODE_VALUES)[number];
+
+export interface TerminalOptions {
+  widthMode: TerminalWidthMode;
+  colorLevel: ColorLevel;
+}
+
+export interface StatuslineSettings {
+  version: 1;
+  enabled: boolean;
+  preset: Preset;
+  separator: SeparatorStyle;
+  separatorFg: ColorName;
+  separatorBg: ColorName;
+  iconMode: IconMode;
+  minimalist: boolean;
+  terminal: TerminalOptions;
+  extensionStatusRow: ExtensionStatusRowConfig;
+}
+
+export interface StatuslineConfig extends StatuslineSettings {
+  lines: WidgetEntry[][];
+}
+
+export const ICON_MODE_VALUES = ["emoji", "nerd", "text"] as const;
+
+export type IconMode = (typeof ICON_MODE_VALUES)[number];
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+export interface SessionMetrics {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  totalTokens: number;
+  costUsd: number;
+  userMessages: number;
+  assistantMessages: number;
+  toolResults: number;
+  firstTimestampMs: number | undefined;
+  lastTimestampMs: number | undefined;
+  compactions: number;
+}
+
+export interface TurnMetrics {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  totalTokens: number;
+  costUsd: number;
+}
+
+export interface GitInfo {
+  branch: string | null;
+  sha: string | null;
+  root: string | null;
+  staged: number;
+  unstaged: number;
+  untracked: number;
+  insertions: number;
+  deletions: number;
+  ahead: number;
+  behind: number;
+  remote: string | null;
+  isRepo: boolean;
+}
+
+export interface StatuslineData {
+  model: string | undefined;
+  provider: string | undefined;
+  sessionName: string | undefined;
+  sessionId: string | undefined;
+  thinkingLevel: string | undefined;
+  textVerbosity: string | undefined;
+  git: GitInfo;
+  cwd: string;
+  activeToolCount: number;
+  usingSubscription: boolean;
+  contextTokens: number | undefined;
+  contextMaxTokens: number | undefined;
+  metrics: SessionMetrics;
+  turnMetrics: TurnMetrics;
+  eventWidgets: ReadonlyMap<string, string>;
+}

package/node_modules/pi-footer/src/ui/color-level-confirm.ts

@@ -0,0 +1,22 @@
+import type { ColorLevel } from "../colors.js";
+import { COLOR_LEVEL_LABELS } from "./model.js";
+
+type ColorLevelConfirmAction = "confirm" | "cancel";
+
+export const COLOR_LEVEL_CONFIRM_HINT = "Press enter/y to proceed, esc/n to go back.";
+export const COLOR_LEVEL_CONFIRM_WARNING =
+  "Changing color level will reset all custom ANSI256 widget colors.";
+
+export function colorLevelConfirmValueLabel(colorLevel: ColorLevel | undefined): string {
+  return `New color level: ${colorLevel ? COLOR_LEVEL_LABELS[colorLevel] : "unknown"}`;
+}
+
+export function colorLevelConfirmAction(
+  data: string,
+  isEscape: boolean,
+  isEnter: boolean,
+): ColorLevelConfirmAction | undefined {
+  if (isEscape || data === "n") return "cancel";
+  if (isEnter || data === "y") return "confirm";
+  return undefined;
+}