@herbertgao/pi-extensions 2026.8.2 → 2026.8.4

package/node_modules/pi-footer/src/ui/title-bar.ts

@@ -0,0 +1,100 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+import packageJson from "../../package.json" with { type: "json" };
+
+const CONFIG_TITLE_TEXT = " pi-footer configuration ";
+const VERSION = packageJson.version;
+
+interface TitleBarParts {
+  title: string;
+  rightPad: number;
+}
+
+export function previewTitleParts(innerWidth: number): TitleBarParts {
+  const title = truncateToWidth(" Preview ", innerWidth, "…");
+  return {
+    title,
+    rightPad: Math.max(0, innerWidth - visibleWidth(title)),
+  };
+}
+
+export function configTitleBarParts(
+  innerWidth: number,
+  dim: (text: string) => string,
+  now = Date.now(),
+  status = "",
+  border: (text: string) => string = (text) => text,
+): TitleBarParts {
+  const titleWidth = Math.max(1, innerWidth - 1);
+  const decoratedStatus = status ? ` ${status} ` : "";
+  const statusWidth = visibleWidth(decoratedStatus);
+  const contentWidth = statusWidth > 0 ? Math.max(1, titleWidth - 1) : titleWidth;
+  const reserveForStatus = statusWidth > 0 ? statusWidth + 1 : 0;
+  const leftWidth = Math.max(1, contentWidth - reserveForStatus);
+  const suffixWidth = Math.max(0, leftWidth - visibleWidth(CONFIG_TITLE_TEXT));
+  const suffix = suffixWidth > 0 ? dim(truncateToWidth(`| v${VERSION} `, suffixWidth, "…")) : "";
+  const left = truncateToWidth(retroText(CONFIG_TITLE_TEXT, now) + suffix, leftWidth, "…");
+  if (statusWidth === 0) {
+    return {
+      title: left,
+      rightPad: Math.max(0, titleWidth - visibleWidth(left)),
+    };
+  }
+  const separator = border(
+    "─".repeat(Math.max(1, contentWidth - visibleWidth(left) - statusWidth)),
+  );
+  return {
+    title: `${left}${separator}${decoratedStatus}`,
+    rightPad: 1,
+  };
+}
+
+type Rgb = readonly [number, number, number];
+
+const RETRO_GRADIENT: readonly Rgb[] = [
+  [63, 81, 177],
+  [90, 85, 174],
+  [123, 95, 172],
+  [143, 106, 174],
+  [168, 106, 164],
+  [204, 107, 142],
+  [241, 130, 113],
+  [243, 164, 105],
+  [247, 201, 120],
+];
+
+export const RETRO_FRAME_INTERVAL_MS = 140;
+const RETRO_CYCLE_MS = 5000;
+
+export function retroText(text: string, now = Date.now()): string {
+  return gradientText(text, RETRO_GRADIENT, (now / RETRO_CYCLE_MS) % 1);
+}
+
+function gradientText(text: string, stops: readonly Rgb[], phase: number): string {
+  const chars = Array.from(text);
+  if (chars.length === 0) return "";
+  return chars
+    .map((char, index) => {
+      const position = chars.length === 1 ? phase : index / (chars.length - 1) + phase;
+      const [r, g, b] = sampleLoopingGradient(stops, position);
+      return `\x1b[1;38;2;${r};${g};${b}m${char}\x1b[0m`;
+    })
+    .join("");
+}
+
+function sampleLoopingGradient(stops: readonly Rgb[], t: number): Rgb {
+  if (stops.length === 0) return [255, 255, 255];
+  if (stops.length === 1) return stops[0] ?? [255, 255, 255];
+
+  const wrapped = ((t % 1) + 1) % 1;
+  const scaled = wrapped * stops.length;
+  const index = Math.floor(scaled) % stops.length;
+  const mix = scaled - Math.floor(scaled);
+  const left = stops[index] ?? stops[0] ?? [255, 255, 255];
+  const right = stops[(index + 1) % stops.length] ?? left;
+  return [
+    Math.round(left[0] + (right[0] - left[0]) * mix),
+    Math.round(left[1] + (right[1] - left[1]) * mix),
+    Math.round(left[2] + (right[2] - left[2]) * mix),
+  ];
+}

package/node_modules/pi-footer/src/ui/widget-actions.ts

@@ -0,0 +1,76 @@
+import { registry, type WidgetType } from "../widgets/registry.js";
+import type { Widget } from "../widgets/types.js";
+
+export function addLineAfter(lines: Widget[][], selectedLine: number): number {
+  lines.splice(selectedLine + 1, 0, []);
+  return selectedLine + 1;
+}
+
+export function cloneLineAfter(
+  lines: Widget[][],
+  selectedLine: number,
+  cloneWidget: (widget: Widget) => Widget = (widget) => registry.cloneWidget(widget),
+): number {
+  const line = lines[selectedLine] ?? [];
+  lines.splice(selectedLine + 1, 0, line.map(cloneWidget));
+  return selectedLine + 1;
+}
+
+export function deleteLine(lines: Widget[][], selectedLine: number): number {
+  if (lines.length <= 1) return selectedLine;
+  lines.splice(selectedLine, 1);
+  return Math.min(selectedLine, lines.length - 1);
+}
+
+export function moveLine(lines: Widget[][], selectedLine: number, delta: number): number {
+  const next = selectedLine + delta;
+  if (next < 0 || next >= lines.length) return selectedLine;
+  const [line] = lines.splice(selectedLine, 1);
+  if (!line) return selectedLine;
+  lines.splice(next, 0, line);
+  return next;
+}
+
+export function moveWidget(line: Widget[], selectedWidget: number, delta: number): number {
+  const next = selectedWidget + delta;
+  if (next < 0 || next >= line.length) return selectedWidget;
+  const [widget] = line.splice(selectedWidget, 1);
+  if (!widget) return selectedWidget;
+  line.splice(next, 0, widget);
+  return next;
+}
+
+export function cloneSelectedWidget(
+  line: Widget[],
+  selectedWidget: number,
+  cloneWidget: (widget: Widget) => Widget = (widget) => registry.cloneWidget(widget),
+): number {
+  const widget = line[selectedWidget];
+  if (!widget) return selectedWidget;
+  line.splice(selectedWidget + 1, 0, cloneWidget(widget));
+  return selectedWidget + 1;
+}
+
+export function deleteSelectedWidget(line: Widget[], selectedWidget: number): number {
+  if (line.length === 0) return selectedWidget;
+  line.splice(selectedWidget, 1);
+  return Math.max(0, Math.min(selectedWidget, line.length - 1));
+}
+
+export function toggleWidgetEnabled(widget: Widget | undefined): boolean {
+  if (!widget) return false;
+  widget.toggle();
+  return true;
+}
+
+export function toggleWidgetRaw(widget: Widget | undefined): boolean {
+  if (!widget || isLayoutWidgetType(widget.type)) return false;
+  widget.update({ raw: !(widget.options.raw ?? false) });
+  return true;
+}
+
+function isLayoutWidgetType(type: WidgetType): boolean {
+  return (
+    type === "custom-text" || type === "separator" || type === "spacer" || type === "flex-separator"
+  );
+}

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

@@ -0,0 +1,66 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+
+import { cloneConfig } from "./config.js";
+import type { GetExtensionStatuses } from "./extension-statuses.js";
+import type { StatuslineConfig, StatuslineData } from "./types.js";
+import { type ConfigChange, type ConfigSave, type ConfigUiResult } from "./ui/config-lifecycle.js";
+import { CONFIG_UI_HEIGHT_RATIO } from "./ui/model.js";
+import { StatuslineConfigScreen } from "./ui/screen.js";
+
+export { StatuslineConfigScreen } from "./ui/screen.js";
+
+export async function openStatuslineConfigUi(
+  ctx: ExtensionCommandContext,
+  initialConfig: StatuslineConfig,
+  previewData: StatuslineData,
+  onChange: ConfigChange,
+  onSave: ConfigSave,
+  getExtensionStatuses: GetExtensionStatuses,
+): Promise<ConfigUiResult> {
+  let finalConfig = cloneConfig(initialConfig);
+
+  return ctx.ui.custom<ConfigUiResult>(
+    (tui, theme, _keybindings, done) => {
+      const screen = new StatuslineConfigScreen(
+        finalConfig,
+        previewData,
+        getExtensionStatuses,
+        () => tui.requestRender(),
+        () => tui.terminal.rows,
+        {
+          onChange(config) {
+            finalConfig = cloneConfig(config);
+            onChange(finalConfig);
+            tui.requestRender();
+          },
+          async onSave(config) {
+            finalConfig = cloneConfig(config);
+            try {
+              await onSave(finalConfig);
+            } catch (error) {
+              ctx.ui.notify(
+                `Could not save pi-footer config: ${error instanceof Error ? error.message : String(error)}`,
+                "error",
+              );
+              throw error;
+            }
+          },
+          onClose(result) {
+            done(result);
+          },
+          getTheme: () => theme,
+        },
+      );
+      return screen;
+    },
+    {
+      overlay: true,
+      overlayOptions: {
+        anchor: "top-center",
+        width: "100%",
+        maxHeight: `${CONFIG_UI_HEIGHT_RATIO * 100}%`,
+        margin: 0,
+      },
+    },
+  );
+}

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

@@ -0,0 +1,28 @@
+import type { RenderStatuslineOptions } from "../render.js";
+import type { StatuslineData } from "../types.js";
+import type {
+  BaseWidgetContext,
+  WidgetContext,
+  WidgetDependency,
+  WidgetDependencyValues,
+} from "./types.js";
+
+export function contextForDependencies<const TDeps extends readonly WidgetDependency[]>(
+  baseCtx: BaseWidgetContext,
+  dependencies: TDeps,
+  data: StatuslineData,
+  options: RenderStatuslineOptions,
+): WidgetContext<TDeps> {
+  // getExtensionStatuses is read live from options, never snapshotted into data.
+  const source: WidgetDependencyValues = {
+    ...data,
+    getExtensionStatuses: options.getExtensionStatuses,
+  };
+  const output: BaseWidgetContext & Partial<WidgetDependencyValues> = { ...baseCtx };
+  const writableOutput = output as BaseWidgetContext & Partial<Record<WidgetDependency, unknown>>;
+  for (const dependency of dependencies) {
+    writableOutput[dependency] = source[dependency];
+  }
+  // TODO(widget-spec): remove this cast if TypeScript gains better support for dynamic object construction.
+  return output as WidgetContext<TDeps>;
+}

package/node_modules/pi-footer/src/widgets/core/active-tools.ts

@@ -0,0 +1,17 @@
+import { defineWidget } from "../types.js";
+
+export const ActiveToolsWidget = defineWidget({
+  type: "active-tools",
+  label: "Active Tools",
+  category: "Core",
+  description: "Active tool count",
+  dependencies: ["activeToolCount"],
+  baseOptions: ["raw", "hideWhenZero", "icon", "text"],
+  baseOptionDefaults: { hideWhenZero: true },
+  properties: [],
+  icons: { emoji: "🛠️", nerd: "󰒓", text: "tools" },
+  defaultStyle: { fg: "yellow", bg: "default", bold: false },
+  render({ ctx, renderWidget }) {
+    return renderWidget(String(ctx.activeToolCount));
+  },
+});

package/node_modules/pi-footer/src/widgets/core/context-window.ts

@@ -0,0 +1,24 @@
+import { defineWidget } from "../types.js";
+import { contextColorProperties, contextColors } from "../utils/context.js";
+import { formatTokenCount, tokenFormatStyleProperty } from "../utils/token-format.js";
+
+export const ContextWindowWidget = defineWidget({
+  type: "context-window",
+  label: "Context Window",
+  category: "Core",
+  description: "Model context window size",
+  dependencies: ["contextTokens", "contextMaxTokens"],
+  baseOptions: ["raw", "hideWhenZero", "icon"],
+  baseOptionDefaults: {},
+  properties: [tokenFormatStyleProperty(), ...contextColorProperties()],
+  icons: { emoji: "🪟", nerd: "󰍛", text: "window" },
+  defaultStyle: { fg: "brightBlack", bg: "default", bold: false },
+  render({ ctx, options, renderWidget }) {
+    return renderWidget(
+      ctx.contextMaxTokens ? formatTokenCount(ctx.contextMaxTokens, options.tokenFormatStyle) : "?",
+      {
+        ...contextColors(options, ctx.contextTokens, ctx.contextMaxTokens),
+      },
+    );
+  },
+});

package/node_modules/pi-footer/src/widgets/core/cwd-basename.ts

@@ -0,0 +1,19 @@
+import { basename } from "node:path";
+
+import { defineWidget } from "../types.js";
+
+export const CwdBasenameWidget = defineWidget({
+  type: "cwd-basename",
+  label: "Working Dir Name",
+  category: "Core",
+  description: "Current directory name",
+  dependencies: ["cwd"],
+  baseOptions: ["raw", "hideWhenEmpty", "icon", "text"],
+  baseOptionDefaults: { text: "" },
+  properties: [],
+  icons: { emoji: "📂", nerd: "", text: "dir" },
+  defaultStyle: { fg: "blue", bg: "default", bold: false },
+  render({ ctx, renderWidget }) {
+    return renderWidget(basename(ctx.cwd));
+  },
+});

package/node_modules/pi-footer/src/widgets/core/cwd.ts

@@ -0,0 +1,108 @@
+import { basename, sep } from "node:path";
+
+import { defineWidget } from "../types.js";
+
+const CWD_DISPLAY_STYLES = {
+  default: {
+    label: "Default (last path segments)",
+    list: "default",
+  },
+  "full-home": {
+    label: "Full path (~ home)",
+    list: "full-path",
+  },
+  fish: {
+    label: "Fish-style abbreviations",
+    list: "fish-style",
+  },
+} as const;
+
+type CwdDisplayStyle = keyof typeof CWD_DISPLAY_STYLES;
+
+const CWD_DISPLAY_STYLE_VALUES = Object.keys(CWD_DISPLAY_STYLES) as CwdDisplayStyle[];
+
+export const CwdWidget = defineWidget({
+  type: "cwd",
+  label: "Working Dir",
+  category: "Core",
+  description: "Current working directory",
+  dependencies: ["cwd"],
+  baseOptions: ["raw", "icon"],
+  baseOptionDefaults: {},
+  properties: [
+    {
+      id: "cwdDisplayStyle",
+      label: "Display style",
+      kind: "choice",
+      description: "Working directory display style",
+      default: "default",
+      options: {
+        choices: CWD_DISPLAY_STYLE_VALUES.map((style) => ({
+          id: style,
+          label: CWD_DISPLAY_STYLES[style].label,
+          list: CWD_DISPLAY_STYLES[style].list,
+        })),
+        showInWidgets: true,
+        showInColors: false,
+        listProperty: "display",
+      },
+    },
+    {
+      id: "segments",
+      label: "Segments",
+      kind: "number",
+      description: "Number of trailing path segments or fish abbreviation width",
+      default: 2,
+      options: { min: 1, max: 8, showInWidgets: true, showInColors: false },
+    },
+  ],
+  icons: { emoji: "📁", nerd: "", text: "cwd" },
+  defaultStyle: { fg: "blue", bg: "default", bold: false },
+  render({ ctx, options, renderWidget }) {
+    return renderWidget(
+      formatCwdPath(ctx.cwd, options.cwdDisplayStyle, options.segments) || basename(ctx.cwd),
+    );
+  },
+});
+
+function formatCwdPath(path: string, style: CwdDisplayStyle, segments: number) {
+  if (style === "full-home") return fullHomePath(path);
+  if (style === "fish") return fishStylePath(path, segments);
+  return shortenPath(path, segments);
+}
+
+function shortenPath(path: string, maxSegments: number) {
+  const normalized = fullHomePath(path);
+  const parts = normalized.split(/[\\/]+/).filter(Boolean);
+  if (parts.length <= maxSegments) return normalized || sep;
+  const prefix = normalized.startsWith("~") ? "~/…" : "…";
+  return `${prefix}/${parts.slice(-maxSegments).join("/")}`;
+}
+
+function fullHomePath(path: string) {
+  const home = process.env.HOME;
+  if (!home || !isPathInsideHome(path, home)) return path;
+  return `~${path.slice(home.length)}`;
+}
+
+function fishStylePath(path: string, segmentLength: number) {
+  const normalized = fullHomePath(path);
+  const hasHomePrefix = normalized.startsWith("~");
+  const parts = normalized.split(/[\\/]+/).filter(Boolean);
+  const pathParts = hasHomePrefix ? parts.slice(1) : parts;
+  if (pathParts.length <= 1) return normalized || sep;
+
+  const prefix = hasHomePrefix ? "~/" : normalized.startsWith(sep) ? sep : "";
+  const abbreviated = pathParts.map((part, index) =>
+    index === pathParts.length - 1
+      ? part
+      : Array.from(part).slice(0, segmentLength).join("") || part,
+  );
+  return `${prefix}${abbreviated.join("/")}`;
+}
+
+function isPathInsideHome(path: string, home: string) {
+  if (path === home) return true;
+  const next = path[home.length];
+  return path.startsWith(home) && (next === "/" || next === "\\");
+}

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

@@ -0,0 +1,34 @@
+import { createEventWidgetId } from "../../event-widgets.js";
+import { defineWidget } from "../types.js";
+
+export const EventValueWidget = defineWidget({
+  type: "event",
+  label: "Event Value",
+  category: "Core",
+  description: "Value updated by other extensions through pi.events",
+  dependencies: ["eventWidgets"],
+  baseOptions: ["raw", "hideWhenEmpty", "icon", "text"],
+  baseOptionDefaults: { hideWhenEmpty: true },
+  properties: [
+    {
+      id: "widgetId",
+      label: "Widget ID",
+      kind: "text",
+      description: "ID used by pi.events publishers to update this widget",
+      default: "",
+      options: {
+        showInWidgets: true,
+        showInColors: false,
+        listProperty: "id",
+      },
+    },
+  ],
+  icons: { emoji: "", nerd: "", text: "" },
+  defaultStyle: { fg: "default", bg: "default", bold: false },
+  createOptionDefaults() {
+    return { widgetId: createEventWidgetId() };
+  },
+  render({ ctx, options, renderWidget }) {
+    return renderWidget(ctx.eventWidgets?.get(options.widgetId ?? ""));
+  },
+});

package/node_modules/pi-footer/src/widgets/core/external-status.ts

@@ -0,0 +1,102 @@
+import type { WidgetOptions } from "../../types.js";
+import { defineWidget } from "../types.js";
+
+export const ExtensionStatusWidget = defineWidget({
+  type: "external-status",
+  label: "Extension Status",
+  category: "Core",
+  description: "Status value published by another pi extension through ctx.ui.setStatus",
+  dependencies: ["getExtensionStatuses"],
+  baseOptions: ["raw", "hideWhenEmpty", "icon", "text"],
+  baseOptionDefaults: { hideWhenEmpty: true },
+  properties: [
+    {
+      id: "externalStatusKey",
+      label: "Status key",
+      kind: "text",
+      description: "Extension status key to render",
+      default: "",
+      options: {
+        showInWidgets: true,
+        showInColors: true,
+        listProperty: "status",
+        editAction: "external-status-key",
+      },
+    },
+    {
+      id: "trimValue",
+      label: "Trim value",
+      kind: "number",
+      description: "Leading visible characters to trim from the status value",
+      default: 0,
+      options: {
+        min: 0,
+        max: 10,
+        showInWidgets: true,
+        showInColors: false,
+        listProperty: "trim",
+      },
+    },
+    {
+      id: "preserveTrimStyles",
+      label: "Preserve trim styles",
+      kind: "boolean",
+      description: "Replay ANSI styles from the trimmed prefix after labels or custom icons",
+      default: true,
+      options: {
+        showInWidgets: false,
+        showInColors: false,
+      },
+    },
+  ],
+  icons: { emoji: "", nerd: "", text: "" },
+  defaultStyle: { fg: "default", bg: "default", bold: false },
+  render({ ctx, options, renderWidget }) {
+    const key = options.externalStatusKey.trim();
+    const value = key ? ctx.getExtensionStatuses?.()?.get(key) : undefined;
+    const rendered = value
+      ? trimLeadingVisibleChars(value, options.trimValue, options.preserveTrimStyles)
+      : { value: "" };
+    return renderWidget(rendered.value, {
+      ...(rendered.preservedTrimStyles
+        ? { preservedTrimStyles: rendered.preservedTrimStyles }
+        : {}),
+      ...(shouldStripIncomingStyles(options) ? { stripIncomingStyles: true } : {}),
+    });
+  },
+});
+
+function shouldStripIncomingStyles(options: WidgetOptions) {
+  return (
+    (options.fg !== undefined && options.fg !== "default") ||
+    (options.bg !== undefined && options.bg !== "default") ||
+    options.bold === true
+  );
+}
+
+function trimLeadingVisibleChars(text: string, count: number, preserveStyles: boolean) {
+  if (count <= 0) return { value: text };
+
+  let trimmed = 0;
+  let index = 0;
+  let preservedStyles = "";
+  while (index < text.length && trimmed < count) {
+    // ANSI sequences have zero visible width. Keep walking without counting them as trimmed chars.
+    // oxlint-disable-next-line no-control-regex
+    const ansiMatch = /^\x1b\[[0-?]*[ -/]*[@-~]/.exec(text.slice(index));
+    if (ansiMatch) {
+      if (preserveStyles) preservedStyles += ansiMatch[0];
+      index += ansiMatch[0].length;
+      continue;
+    }
+
+    // Advance by Unicode code point so surrogate-pair symbols count as one visible character.
+    const codePoint = text.codePointAt(index);
+    if (codePoint === undefined) break;
+    index += codePoint > 0xffff ? 2 : 1;
+    trimmed += 1;
+  }
+
+  const value = text.slice(index);
+  return preservedStyles ? { value, preservedTrimStyles: preservedStyles } : { value };
+}

package/node_modules/pi-footer/src/widgets/core/model-provider.ts

@@ -0,0 +1,20 @@
+import { defineWidget } from "../types.js";
+
+export const ModelProviderWidget = defineWidget({
+  type: "model-provider",
+  label: "Provider/Model",
+  category: "Core",
+  description: "Provider and model together",
+  dependencies: ["model", "provider"],
+  baseOptions: ["raw", "icon"],
+  baseOptionDefaults: {},
+  properties: [],
+  icons: { emoji: "🤖", nerd: "󰚩", text: "model" },
+  defaultStyle: { fg: "cyan", bg: "default", bold: false },
+  render({ ctx, renderWidget }) {
+    const value = ctx.provider
+      ? `${ctx.provider}/${ctx.model ?? "no-model"}`
+      : (ctx.model ?? "no-model");
+    return renderWidget(value);
+  },
+});

package/node_modules/pi-footer/src/widgets/core/model.ts

@@ -0,0 +1,35 @@
+import { defineWidget } from "../types.js";
+
+export const ModelWidget = defineWidget({
+  type: "model",
+  label: "Model",
+  category: "Core",
+  description: "Active model id",
+  dependencies: ["model", "provider"],
+  baseOptions: ["raw", "icon"],
+  baseOptionDefaults: {},
+  properties: [
+    {
+      id: "showProvider",
+      label: "Show provider",
+      kind: "boolean",
+      description: "Show provider name before the model id",
+      default: false,
+      options: {
+        label: "with-provider",
+        showInWidgets: true,
+        showInColors: true,
+        listProperty: "",
+      },
+    },
+  ],
+  icons: { emoji: "🤖", nerd: "󰚩", text: "model" },
+  defaultStyle: { fg: "cyan", bg: "default", bold: false },
+  render({ ctx, options, renderWidget }) {
+    const value =
+      options.showProvider && ctx.provider
+        ? `${ctx.provider}/${ctx.model ?? "no-model"}`
+        : (ctx.model ?? "no-model");
+    return renderWidget(value);
+  },
+});

package/node_modules/pi-footer/src/widgets/core/provider.ts

@@ -0,0 +1,17 @@
+import { defineWidget } from "../types.js";
+
+export const ProviderWidget = defineWidget({
+  type: "provider",
+  label: "Provider",
+  category: "Core",
+  description: "Active model provider",
+  dependencies: ["provider"],
+  baseOptions: ["raw", "hideWhenEmpty", "icon", "text"],
+  baseOptionDefaults: {},
+  properties: [],
+  icons: { emoji: "☁️", nerd: "󰒋", text: "provider" },
+  defaultStyle: { fg: "cyan", bg: "default", bold: false },
+  render({ ctx, renderWidget }) {
+    return renderWidget(ctx.provider);
+  },
+});

package/node_modules/pi-footer/src/widgets/core/session-name.ts

@@ -0,0 +1,17 @@
+import { defineWidget } from "../types.js";
+
+export const SessionNameWidget = defineWidget({
+  type: "session-name",
+  label: "Session Name",
+  category: "Core",
+  description: "Pi session name",
+  dependencies: ["sessionName"],
+  baseOptions: ["raw", "hideWhenEmpty", "icon", "text"],
+  baseOptionDefaults: { hideWhenEmpty: true },
+  properties: [],
+  icons: { emoji: "🏷️", nerd: "󰍹", text: "session" },
+  defaultStyle: { fg: "cyan", bg: "default", bold: false },
+  render({ ctx, renderWidget }) {
+    return renderWidget(ctx.sessionName);
+  },
+});