pi-openai-usage 0.1.0

package/src/interactive-settings-menu.ts

@@ -0,0 +1,363 @@
+import { SettingsList, type SettingItem, type SettingsListTheme } from "@earendil-works/pi-tui";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+
+import {
+  APPROVED_BAR_WIDTHS,
+  APPROVED_REFRESH_INTERVAL_PRESETS,
+  BAR_STYLE_PRESETS,
+  COLOR_SCHEME_PRESETS,
+  type ApprovedBarWidth,
+  type ApprovedRefreshIntervalMs,
+  type BarStylePreset,
+  type ColorSchemePreset,
+  type ResetWidgetConfig,
+  type ResetWidgetConfigPatch,
+  type ResetWidgetMode,
+  type UsageConfig,
+  type UsageConfigPatch,
+  type WindowWidgetConfig,
+  type WindowWidgetConfigPatch,
+  type WindowWidgetMode,
+} from "./config";
+
+type InteractiveSettingsMenuContext = Pick<ExtensionCommandContext, "ui">;
+
+type PiTheme = {
+  fg?: (color: string, text: string) => string;
+};
+
+export type InteractiveSettingsMenuCallbacks = {
+  onCancel?: () => void;
+  onChange?: (id: string, newValue: string) => void;
+  onPatch?: (patch: UsageConfigPatch) => void;
+  theme?: SettingsListTheme;
+};
+
+type SettingPatchBuilder = (value: string) => UsageConfigPatch | undefined;
+
+const DISPLAY_VALUES = ["On", "Off", "Always"] as const;
+type DisplayValue = (typeof DISPLAY_VALUES)[number];
+const WINDOW_WIDGET_VALUES = ["hidden", "percent", "bar", "bar + percent"] as const;
+type WindowWidgetValue = (typeof WINDOW_WIDGET_VALUES)[number];
+const RESET_WIDGET_VALUES = ["hidden", "countdown", "clock", "both"] as const;
+type ResetWidgetValue = (typeof RESET_WIDGET_VALUES)[number];
+const HIDE_LABEL_VALUES = ["No", "Yes"] as const;
+type HideLabelValue = (typeof HIDE_LABEL_VALUES)[number];
+const WINDOW_WIDGET_MODE_BY_VALUE: Record<WindowWidgetValue, WindowWidgetMode> = {
+  hidden: "hidden",
+  percent: "percent",
+  bar: "bar",
+  "bar + percent": "bar-percent",
+};
+const RESET_WIDGET_MODE_BY_VALUE: Record<ResetWidgetValue, ResetWidgetMode> = {
+  hidden: "hidden",
+  countdown: "countdown",
+  clock: "clock",
+  both: "both",
+};
+const BAR_WIDTH_VALUES = APPROVED_BAR_WIDTHS.map(String);
+const BAR_WIDTH_BY_VALUE = new Map<string, ApprovedBarWidth>(
+  APPROVED_BAR_WIDTHS.map((width) => [String(width), width] as const),
+);
+const REFRESH_INTERVAL_VALUES = APPROVED_REFRESH_INTERVAL_PRESETS.map(({ label }) => label);
+const REFRESH_INTERVAL_BY_VALUE = new Map<string, ApprovedRefreshIntervalMs>(
+  APPROVED_REFRESH_INTERVAL_PRESETS.map(({ label, value }) => [label, value] as const),
+);
+
+type WindowWidgetKey = "fiveHour" | "sevenDay";
+type ResetWidgetKey = "fiveHourReset" | "sevenDayReset";
+
+const SETTING_PATCH_BUILDERS: Record<string, SettingPatchBuilder> = {
+  display: displayPatchForValue,
+  "color-scheme": colorSchemePatchForValue,
+  "bar-style": barStylePatchForValue,
+  "bar-width": barWidthPatchForValue,
+  "five-hour-display": windowWidgetPatchBuilder("fiveHour"),
+  "seven-day-display": windowWidgetPatchBuilder("sevenDay"),
+  "five-hour-reset-display": resetWidgetPatchBuilder("fiveHourReset"),
+  "seven-day-reset-display": resetWidgetPatchBuilder("sevenDayReset"),
+  "refresh-interval": refreshIntervalPatchForValue,
+  "hide-label": hideLabelPatchForValue,
+};
+
+export async function openInteractiveSettingsMenu(
+  ctx: InteractiveSettingsMenuContext,
+  config: UsageConfig,
+  callbacks: InteractiveSettingsMenuCallbacks = {},
+): Promise<void> {
+  await ctx.ui.custom<void>((_tui, theme, _keybindings, done) =>
+    createInteractiveSettingsMenu(config, {
+      ...callbacks,
+      onCancel: () => {
+        callbacks.onCancel?.();
+        done(undefined);
+      },
+      theme: createSettingsListTheme(theme as PiTheme),
+    }),
+  );
+}
+
+export function createInteractiveSettingsMenu(
+  config: UsageConfig,
+  callbacks: InteractiveSettingsMenuCallbacks = {},
+): SettingsList {
+  const rows = buildInteractiveSettingsRows(config);
+  return new SettingsList(
+    rows,
+    rows.length,
+    callbacks.theme ?? createSettingsListTheme(),
+    createChangeHandler(callbacks),
+    callbacks.onCancel ?? (() => undefined),
+  );
+}
+
+export function configPatchForInteractiveSetting(
+  id: string,
+  newValue: string,
+): UsageConfigPatch | undefined {
+  return SETTING_PATCH_BUILDERS[id]?.(newValue);
+}
+
+export function buildInteractiveSettingsRows(config: UsageConfig): SettingItem[] {
+  return [
+    {
+      id: "display",
+      label: "Display",
+      currentValue: formatDisplayValue(config),
+      values: [...DISPLAY_VALUES],
+    },
+    {
+      id: "color-scheme",
+      label: "Color scheme",
+      currentValue: formatJsonOnlyCustomValue(config.colors.scheme),
+      values: [...COLOR_SCHEME_PRESETS],
+    },
+    {
+      id: "bar-style",
+      label: "Bar style",
+      currentValue: formatJsonOnlyCustomValue(config.bar.style),
+      values: [...BAR_STYLE_PRESETS],
+    },
+    {
+      id: "bar-width",
+      label: "Bar width",
+      currentValue: String(config.bar.width),
+      values: [...BAR_WIDTH_VALUES],
+    },
+    buildWindowWidgetRow("five-hour-display", "5h display", config.widgets.fiveHour),
+    buildWindowWidgetRow("seven-day-display", "7d display", config.widgets.sevenDay),
+    buildResetWidgetRow(
+      "five-hour-reset-display",
+      "5h reset display",
+      config.widgets.fiveHourReset,
+    ),
+    buildResetWidgetRow(
+      "seven-day-reset-display",
+      "7d reset display",
+      config.widgets.sevenDayReset,
+    ),
+    {
+      id: "refresh-interval",
+      label: "Refresh interval",
+      currentValue: formatRefreshInterval(config.refreshIntervalMs),
+      values: [...REFRESH_INTERVAL_VALUES],
+    },
+    {
+      id: "hide-label",
+      label: "Hide label",
+      currentValue: config.display.showLabel ? "No" : "Yes",
+      values: [...HIDE_LABEL_VALUES],
+    },
+  ];
+}
+
+function buildWindowWidgetRow(
+  id: string,
+  label: string,
+  widget: WindowWidgetConfig,
+): SettingItem {
+  return {
+    id,
+    label,
+    currentValue: formatWindowWidgetValue(widget),
+    values: [...WINDOW_WIDGET_VALUES],
+  };
+}
+
+function buildResetWidgetRow(id: string, label: string, widget: ResetWidgetConfig): SettingItem {
+  return {
+    id,
+    label,
+    currentValue: formatResetWidgetValue(widget),
+    values: [...RESET_WIDGET_VALUES],
+  };
+}
+
+function createChangeHandler(
+  callbacks: InteractiveSettingsMenuCallbacks,
+): (id: string, newValue: string) => void {
+  return (id, newValue) => {
+    callbacks.onChange?.(id, newValue);
+
+    const patch = configPatchForInteractiveSetting(id, newValue);
+    if (patch !== undefined) callbacks.onPatch?.(patch);
+  };
+}
+
+function displayPatchForValue(value: string): UsageConfigPatch | undefined {
+  if (!isDisplayValue(value)) return undefined;
+
+  switch (value) {
+    case "On":
+      return { enabled: true, display: { showAlways: false } };
+    case "Off":
+      return { enabled: false, display: { showAlways: false } };
+    case "Always":
+      return { enabled: true, display: { showAlways: true } };
+  }
+}
+
+function colorSchemePatchForValue(value: string): UsageConfigPatch | undefined {
+  if (!isColorSchemePreset(value)) return undefined;
+  return { colors: { scheme: value } };
+}
+
+function barStylePatchForValue(value: string): UsageConfigPatch | undefined {
+  if (!isBarStylePreset(value)) return undefined;
+  return { bar: { style: value } };
+}
+
+function barWidthPatchForValue(value: string): UsageConfigPatch | undefined {
+  const width = BAR_WIDTH_BY_VALUE.get(value);
+  if (width === undefined) return undefined;
+  return { bar: { width } };
+}
+
+function windowWidgetPatchBuilder(widget: WindowWidgetKey): SettingPatchBuilder {
+  return (value) => {
+    const patch = windowWidgetPatchForValue(value);
+    if (patch === undefined) return undefined;
+    return usagePatchForWindowWidget(widget, patch);
+  };
+}
+
+function resetWidgetPatchBuilder(widget: ResetWidgetKey): SettingPatchBuilder {
+  return (value) => {
+    const patch = resetWidgetPatchForValue(value);
+    if (patch === undefined) return undefined;
+    return usagePatchForResetWidget(widget, patch);
+  };
+}
+
+function windowWidgetPatchForValue(value: string): WindowWidgetConfigPatch | undefined {
+  if (!isWindowWidgetValue(value)) return undefined;
+  const mode = WINDOW_WIDGET_MODE_BY_VALUE[value];
+  return { enabled: mode !== "hidden", mode };
+}
+
+function resetWidgetPatchForValue(value: string): ResetWidgetConfigPatch | undefined {
+  if (!isResetWidgetValue(value)) return undefined;
+  const mode = RESET_WIDGET_MODE_BY_VALUE[value];
+  return { enabled: mode !== "hidden", mode };
+}
+
+function refreshIntervalPatchForValue(value: string): UsageConfigPatch | undefined {
+  const refreshIntervalMs = REFRESH_INTERVAL_BY_VALUE.get(value);
+  if (refreshIntervalMs === undefined) return undefined;
+  return { refreshIntervalMs };
+}
+
+function hideLabelPatchForValue(value: string): UsageConfigPatch | undefined {
+  if (!isHideLabelValue(value)) return undefined;
+  return { display: { showLabel: value === "No" } };
+}
+
+function usagePatchForWindowWidget(
+  widget: WindowWidgetKey,
+  patch: WindowWidgetConfigPatch,
+): UsageConfigPatch {
+  const widgets: Partial<Record<WindowWidgetKey, WindowWidgetConfigPatch>> = {};
+  widgets[widget] = patch;
+  return { widgets };
+}
+
+function usagePatchForResetWidget(
+  widget: ResetWidgetKey,
+  patch: ResetWidgetConfigPatch,
+): UsageConfigPatch {
+  const widgets: Partial<Record<ResetWidgetKey, ResetWidgetConfigPatch>> = {};
+  widgets[widget] = patch;
+  return { widgets };
+}
+
+function isDisplayValue(value: string): value is DisplayValue {
+  return includesString(DISPLAY_VALUES, value);
+}
+
+function isWindowWidgetValue(value: string): value is WindowWidgetValue {
+  return includesString(WINDOW_WIDGET_VALUES, value);
+}
+
+function isResetWidgetValue(value: string): value is ResetWidgetValue {
+  return includesString(RESET_WIDGET_VALUES, value);
+}
+
+function isHideLabelValue(value: string): value is HideLabelValue {
+  return includesString(HIDE_LABEL_VALUES, value);
+}
+
+function isColorSchemePreset(value: string): value is ColorSchemePreset {
+  return includesString(COLOR_SCHEME_PRESETS, value);
+}
+
+function isBarStylePreset(value: string): value is BarStylePreset {
+  return includesString(BAR_STYLE_PRESETS, value);
+}
+
+function includesString<const T extends readonly string[]>(
+  values: T,
+  value: string,
+): value is T[number] {
+  return values.includes(value as T[number]);
+}
+
+function createSettingsListTheme(theme: PiTheme = {}): SettingsListTheme {
+  const fg = (color: string, text: string) =>
+    typeof theme.fg === "function" ? theme.fg(color, text) : text;
+
+  return {
+    label: (text, selected) => (selected ? fg("accent", text) : text),
+    value: (text, selected) => (selected ? fg("accent", text) : fg("muted", text)),
+    description: (text) => fg("dim", text),
+    cursor: fg("accent", "→ "),
+    hint: (text) => fg("dim", text),
+  };
+}
+
+function formatDisplayValue(config: UsageConfig): string {
+  if (!config.enabled) return "Off";
+  if (config.display.showAlways) return "Always";
+  return "On";
+}
+
+function formatWindowWidgetValue(widget: WindowWidgetConfig): string {
+  if (!widget.enabled || widget.mode === "hidden") return "hidden";
+  if (widget.mode === "bar-percent") return "bar + percent";
+  return widget.mode;
+}
+
+function formatResetWidgetValue(widget: ResetWidgetConfig): string {
+  if (!widget.enabled || widget.mode === "hidden") return "hidden";
+  return widget.mode;
+}
+
+function formatRefreshInterval(refreshIntervalMs: number): string {
+  return (
+    APPROVED_REFRESH_INTERVAL_PRESETS.find((preset) => preset.value === refreshIntervalMs)?.label ??
+    `${refreshIntervalMs}ms`
+  );
+}
+
+function formatJsonOnlyCustomValue(value: string): string {
+  return value === "custom" ? "custom (JSON)" : value;
+}

package/src/progress-bar.ts

@@ -0,0 +1,163 @@
+import {
+  MAX_BAR_WIDTH,
+  MIN_BAR_WIDTH,
+  type BarConfig,
+  type BarStyleName,
+  type CustomBarStyleConfig,
+} from "./config";
+import { isSingleCellGlyph } from "./display-width";
+
+export type ProgressBarStyle = {
+  filled: string;
+  empty: string;
+  partials: string[];
+};
+
+export type ProgressBarSegmentKind = "filled" | "partial" | "empty";
+
+export type ProgressBarSegment = {
+  text: string;
+  kind: ProgressBarSegmentKind;
+};
+
+type BuiltInBarStyleName = Exclude<BarStyleName, "custom">;
+
+export const BUILT_IN_BAR_STYLES: Record<BuiltInBarStyleName, ProgressBarStyle> = {
+  blocks: {
+    filled: "█",
+    empty: "░",
+    partials: ["▏", "▎", "▍", "▌", "▋", "▊", "▉"],
+  },
+  thin: { filled: "━", empty: "─", partials: [] },
+  ascii: { filled: "#", empty: "-", partials: [] },
+  dots: { filled: "●", empty: "○", partials: [] },
+  squares: { filled: "■", empty: "□", partials: [] },
+  braille: {
+    filled: "⣿",
+    empty: "⠀",
+    partials: ["⣀", "⣤", "⣶"],
+  },
+};
+
+/**
+ * Renders a fixed-width text progress bar.
+ *
+ * The renderer is pure display text logic: it has no theme, color, or Pi UI knowledge.
+ * A null or unavailable percent renders an empty bar while preserving configured width.
+ */
+export function renderProgressBar(percent: number | null | undefined, config: BarConfig): string {
+  return renderProgressBarSegments(percent, config)
+    .map((segment) => segment.text)
+    .join("");
+}
+
+/**
+ * Exposes fixed-width bar cells for callers that layer colors over selected cells.
+ *
+ * Segmenting remains pure progress-bar ownership: callers decide whether and how to
+ * color filled, partial, or empty cells.
+ */
+export function renderProgressBarSegments(
+  percent: number | null | undefined,
+  config: BarConfig,
+): ProgressBarSegment[] {
+  const width = clampInteger(config.width, MIN_BAR_WIDTH, MAX_BAR_WIDTH);
+  const style = resolveBarStyle(config);
+
+  if (!isFiniteNumber(percent)) return emptySegments(width, style);
+
+  const filledCells = (clampNumber(percent, 0, 100) / 100) * width;
+  if (config.partials && style.partials.length > 0) {
+    return renderPartialBarSegments(filledCells, width, style);
+  }
+
+  return renderFullCellBarSegments(Math.round(filledCells), width, style);
+}
+
+function renderPartialBarSegments(
+  filledCells: number,
+  width: number,
+  style: ProgressBarStyle,
+): ProgressBarSegment[] {
+  const fullCells = Math.min(width, Math.floor(filledCells));
+  const fractionalCell = filledCells - fullCells;
+
+  if (fullCells >= width || fractionalCell <= Number.EPSILON) {
+    return renderFullCellBarSegments(fullCells, width, style);
+  }
+
+  const partialCell = partialCellForFraction(fractionalCell, style.partials);
+  const emptyCells = width - fullCells - 1;
+  return [
+    ...repeatSegments(style.filled, fullCells, "filled"),
+    { text: partialCell, kind: "partial" },
+    ...repeatSegments(style.empty, emptyCells, "empty"),
+  ];
+}
+
+function renderFullCellBarSegments(
+  filledCells: number,
+  width: number,
+  style: ProgressBarStyle,
+): ProgressBarSegment[] {
+  const clampedFilledCells = clampInteger(filledCells, 0, width);
+  return [
+    ...repeatSegments(style.filled, clampedFilledCells, "filled"),
+    ...repeatSegments(style.empty, width - clampedFilledCells, "empty"),
+  ];
+}
+
+function emptySegments(width: number, style: ProgressBarStyle): ProgressBarSegment[] {
+  return repeatSegments(style.empty, width, "empty");
+}
+
+function repeatSegments(
+  text: string,
+  count: number,
+  kind: ProgressBarSegmentKind,
+): ProgressBarSegment[] {
+  return Array.from({ length: Math.max(0, count) }, () => ({ text, kind }));
+}
+
+function partialCellForFraction(fraction: number, partials: readonly string[]): string {
+  const index = clampInteger(Math.ceil(fraction * (partials.length + 1)) - 1, 0, partials.length - 1);
+  return partials[index] ?? partials[partials.length - 1] ?? "";
+}
+
+function resolveBarStyle(config: BarConfig): ProgressBarStyle {
+  if (config.style === "custom") return customBarStyle(config.custom);
+  return BUILT_IN_BAR_STYLES[config.style] ?? BUILT_IN_BAR_STYLES.blocks;
+}
+
+function customBarStyle(custom: CustomBarStyleConfig): ProgressBarStyle {
+  return {
+    filled: singleCellGlyph(custom.filled, DEFAULT_CUSTOM_BAR_STYLE.filled),
+    empty: singleCellGlyph(custom.empty, DEFAULT_CUSTOM_BAR_STYLE.empty),
+    partials: custom.partials
+      .map((partial) => singleCellGlyph(partial, ""))
+      .filter((partial) => partial.length > 0),
+  };
+}
+
+function singleCellGlyph(value: string, fallback: string): string {
+  const [firstGlyph] = Array.from(value);
+  if (firstGlyph !== undefined && isSingleCellGlyph(firstGlyph)) return firstGlyph;
+  return fallback;
+}
+
+function isFiniteNumber(value: number | null | undefined): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function clampInteger(value: number, min: number, max: number): number {
+  return clampNumber(Math.round(value), min, max);
+}
+
+function clampNumber(value: number, min: number, max: number): number {
+  return Math.max(min, Math.min(max, value));
+}
+
+const DEFAULT_CUSTOM_BAR_STYLE: Pick<ProgressBarStyle, "filled" | "empty"> = {
+  filled: "▰",
+  empty: "▱",
+};