@0xkahi/pi-qol 0.0.1 → 0.0.3

package/src/extensions/model-select/model-select-dialog.ts

@@ -0,0 +1,340 @@
+import { modelsAreEqual } from '@earendil-works/pi-ai';
+import type { KeybindingsManager, Theme } from '@earendil-works/pi-coding-agent';
+import { type Component, type Focusable, fuzzyFilter, Input, type TUI, truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
+import { MAX_CONFIG_WARNING_LINES, MAX_VISIBLE_MODELS } from './constants';
+import { ModelFormatter } from './model-formatter';
+import type { DialogOptions, ModelItem, SelectionSection } from './types';
+
+function isPrintableInput(data: string): boolean {
+  if (data.length === 0) {
+    return false;
+  }
+  return [...data].every(char => {
+    const code = char.charCodeAt(0);
+    return code >= 32 && code !== 0x7f && (code < 0x80 || code > 0x9f);
+  });
+}
+
+export class ModelSelectDialog implements Component, Focusable {
+  private readonly searchInput = new Input();
+  private activeSection: SelectionSection;
+  private selectedFavouriteIndex = 0;
+  private selectedSearchIndex = 0;
+  private filteredSearchItems: ModelItem[];
+  private _focused = false;
+
+  constructor(
+    private readonly tui: TUI,
+    private readonly theme: Theme,
+    private readonly keybindings: KeybindingsManager,
+    private readonly options: DialogOptions,
+  ) {
+    this.activeSection = options.initialSearch || !options.hasFavouriteSection ? 'search' : 'favourites';
+    const currentFavouriteIndex = options.currentModel
+      ? options.favouriteItems.findIndex(item => modelsAreEqual(item.model, options.currentModel))
+      : -1;
+    this.selectedFavouriteIndex = currentFavouriteIndex >= 0 ? currentFavouriteIndex : 0;
+    this.searchInput.setValue(options.initialSearch);
+    this.searchInput.onSubmit = () => this.selectCurrentSearchItem();
+    this.searchInput.onEscape = () => this.options.onDone(null);
+    this.filteredSearchItems = this.filterSearchItems(options.initialSearch);
+    this.syncFocus();
+  }
+
+  get focused(): boolean {
+    return this._focused;
+  }
+
+  set focused(value: boolean) {
+    this._focused = value;
+    this.syncFocus();
+  }
+
+  invalidate(): void {
+    this.searchInput.invalidate();
+  }
+
+  handleInput(data: string): void {
+    if (this.keybindings.matches(data, 'tui.input.tab')) {
+      this.switchSection();
+      this.tui.requestRender();
+      return;
+    }
+
+    if (this.keybindings.matches(data, 'tui.select.cancel')) {
+      this.options.onDone(null);
+      return;
+    }
+
+    if (this.keybindings.matches(data, 'tui.select.up')) {
+      this.moveSelection(-1);
+      this.tui.requestRender();
+      return;
+    }
+
+    if (this.keybindings.matches(data, 'tui.select.down')) {
+      this.moveSelection(1);
+      this.tui.requestRender();
+      return;
+    }
+
+    if (this.keybindings.matches(data, 'tui.select.pageUp')) {
+      this.moveSelection(-MAX_VISIBLE_MODELS);
+      this.tui.requestRender();
+      return;
+    }
+
+    if (this.keybindings.matches(data, 'tui.select.pageDown')) {
+      this.moveSelection(MAX_VISIBLE_MODELS);
+      this.tui.requestRender();
+      return;
+    }
+
+    if (this.keybindings.matches(data, 'tui.select.confirm')) {
+      this.selectCurrentItem();
+      return;
+    }
+
+    if (this.activeSection !== 'search' && isPrintableInput(data)) {
+      this.activeSection = 'search';
+      this.syncFocus();
+    }
+
+    if (this.activeSection === 'search') {
+      this.searchInput.handleInput(data);
+      this.filteredSearchItems = this.filterSearchItems(this.searchInput.getValue());
+      this.selectedSearchIndex = Math.min(this.selectedSearchIndex, Math.max(0, this.filteredSearchItems.length - 1));
+      this.tui.requestRender();
+    }
+  }
+
+  render(width: number): string[] {
+    const safeWidth = Math.max(3, width);
+
+    if (this.options.layout === 'inline') {
+      const inner = safeWidth;
+      const lines = this.buildContentLines(inner);
+      const rule = this.theme.fg('border', '─'.repeat(inner));
+      const body = lines.map(line => this.padLine(line, inner));
+      return [rule, ...body, rule];
+    }
+
+    const inner = safeWidth - 2;
+    const lines = this.buildContentLines(inner);
+
+    const borderColor = (str: string) => this.theme.fg('border', str);
+    const horizontal = '─'.repeat(inner);
+    const top = borderColor(`╭${horizontal}╮`);
+    const bottom = borderColor(`╰${horizontal}╯`);
+    const side = borderColor('│');
+
+    const wrapped = lines.map(line => `${side}${this.padLine(line, inner)}${side}`);
+    return [top, ...wrapped, bottom];
+  }
+
+  private buildContentLines(inner: number): string[] {
+    const lines: string[] = [];
+
+    lines.push(this.line(this.renderTitle(), inner));
+    lines.push(this.line(this.renderTabs(), inner));
+
+    for (const warning of this.options.configWarnings.slice(0, MAX_CONFIG_WARNING_LINES)) {
+      lines.push(this.line(this.theme.fg('warning', `⚠ ${warning}`), inner));
+    }
+    if (this.options.configWarnings.length > MAX_CONFIG_WARNING_LINES) {
+      lines.push(
+        this.line(this.theme.fg('warning', `⚠ ${this.options.configWarnings.length - MAX_CONFIG_WARNING_LINES} more config warning(s)`), inner),
+      );
+    }
+
+    lines.push('');
+
+    if (this.activeSection === 'favourites') {
+      lines.push(...this.renderFavourites(inner));
+    } else {
+      lines.push(...this.renderSearch(inner));
+    }
+
+    lines.push('');
+    lines.push(this.line(this.renderHelp(), inner));
+
+    return lines;
+  }
+
+  private padLine(text: string, innerWidth: number): string {
+    const truncated = truncateToWidth(text.replace(/[\r\n]+/g, ' '), innerWidth, '');
+    const padding = Math.max(0, innerWidth - visibleWidth(truncated));
+    return truncated + ' '.repeat(padding);
+  }
+
+  private switchSection(): void {
+    if (!this.options.hasFavouriteSection) {
+      this.activeSection = 'search';
+      this.syncFocus();
+      return;
+    }
+
+    this.activeSection = this.activeSection === 'favourites' ? 'search' : 'favourites';
+    this.syncFocus();
+  }
+
+  private syncFocus(): void {
+    this.searchInput.focused = this._focused && this.activeSection === 'search';
+  }
+
+  private moveSelection(delta: number): void {
+    if (this.activeSection === 'favourites') {
+      this.selectedFavouriteIndex = this.wrapIndex(this.selectedFavouriteIndex + delta, this.options.favouriteItems.length);
+      return;
+    }
+
+    this.selectedSearchIndex = this.wrapIndex(this.selectedSearchIndex + delta, this.filteredSearchItems.length);
+  }
+
+  private wrapIndex(index: number, length: number): number {
+    if (length <= 0) {
+      return 0;
+    }
+    return ((index % length) + length) % length;
+  }
+
+  private selectCurrentItem(): void {
+    if (this.activeSection === 'favourites') {
+      const item = this.options.favouriteItems[this.selectedFavouriteIndex];
+      if (item) {
+        this.options.onDone(item.model);
+      }
+      return;
+    }
+
+    this.selectCurrentSearchItem();
+  }
+
+  private selectCurrentSearchItem(): void {
+    const item = this.filteredSearchItems[this.selectedSearchIndex];
+    if (item) {
+      this.options.onDone(item.model);
+    }
+  }
+
+  private filterSearchItems(query: string): ModelItem[] {
+    const trimmed = query.trim();
+    if (!trimmed) {
+      return this.options.searchItems;
+    }
+    return fuzzyFilter(this.options.searchItems, trimmed, item => item.searchText);
+  }
+
+  private renderTitle(): string {
+    const current = this.options.currentModel ? ModelFormatter.modelLabel(this.options.currentModel) : 'none';
+    return `${this.theme.fg('customMessageLabel', this.theme.bold('Select Model'))} ${this.theme.fg('muted', `current: ${current}`)}`;
+  }
+
+  private renderTabs(): string {
+    const tabs: string[] = [];
+    if (this.options.hasFavouriteSection) {
+      tabs.push(this.renderTab('favourites', `Favourites ${this.options.favouriteItems.length}`));
+    }
+    tabs.push(this.renderTab('search', `Search ${this.options.searchItems.length}`));
+    return tabs.join(this.theme.fg('muted', '  '));
+  }
+
+  private renderTab(section: SelectionSection, label: string): string {
+    const text = `[${label}]`;
+    if (this.activeSection === section) {
+      return this.theme.fg('accent', this.theme.bold(text));
+    }
+    return this.theme.fg('muted', text);
+  }
+
+  private renderFavourites(width: number): string[] {
+    const lines: string[] = [];
+
+    if (this.options.favouriteItems.length === 0) {
+      lines.push(this.line(this.theme.fg('muted', '  No configured favourites are available.'), width));
+    } else {
+      lines.push(...this.renderModelList(this.options.favouriteItems, this.selectedFavouriteIndex, width));
+      const selected = this.options.favouriteItems[this.selectedFavouriteIndex];
+      if (selected) {
+        lines.push('');
+        lines.push(this.line(this.theme.fg('muted', `  ${selected.description}`), width));
+      }
+    }
+
+    for (const warning of this.options.favouriteWarnings.slice(0, MAX_CONFIG_WARNING_LINES)) {
+      lines.push(this.line(this.theme.fg('warning', `  ⚠ ${warning}`), width));
+    }
+    if (this.options.favouriteWarnings.length > MAX_CONFIG_WARNING_LINES) {
+      lines.push(
+        this.line(
+          this.theme.fg('warning', `  ⚠ ${this.options.favouriteWarnings.length - MAX_CONFIG_WARNING_LINES} more favourite warning(s)`),
+          width,
+        ),
+      );
+    }
+
+    return lines;
+  }
+
+  private renderSearch(width: number): string[] {
+    const lines: string[] = [];
+    const providerText =
+      this.options.providerFilter.length === 0 ? 'all authorized providers' : `providers: ${this.options.providerFilter.join(', ')}`;
+
+    lines.push(this.line(this.theme.fg('muted', `Provider filter: ${providerText}`), width));
+    lines.push(this.line(this.theme.fg('muted', 'Search query:'), width));
+    lines.push(...this.searchInput.render(width));
+    lines.push('');
+
+    if (this.filteredSearchItems.length === 0) {
+      lines.push(this.line(this.theme.fg('muted', '  No matching models'), width));
+      return lines;
+    }
+
+    lines.push(...this.renderModelList(this.filteredSearchItems, this.selectedSearchIndex, width));
+    const selected = this.filteredSearchItems[this.selectedSearchIndex];
+    if (selected) {
+      lines.push('');
+      lines.push(this.line(this.theme.fg('muted', `  ${selected.description}`), width));
+    }
+
+    return lines;
+  }
+
+  private renderModelList(items: ModelItem[], selectedIndex: number, width: number): string[] {
+    const lines: string[] = [];
+    const startIndex = Math.max(0, Math.min(selectedIndex - Math.floor(MAX_VISIBLE_MODELS / 2), items.length - MAX_VISIBLE_MODELS));
+    const endIndex = Math.min(startIndex + MAX_VISIBLE_MODELS, items.length);
+
+    for (let index = startIndex; index < endIndex; index++) {
+      const item = items[index];
+      if (!item) {
+        continue;
+      }
+      lines.push(this.renderModelItem(item, index === selectedIndex, width));
+    }
+
+    if (startIndex > 0 || endIndex < items.length) {
+      lines.push(this.line(this.theme.fg('dim', `  (${selectedIndex + 1}/${items.length})`), width));
+    }
+
+    return lines;
+  }
+
+  private renderModelItem(item: ModelItem, isSelected: boolean, width: number): string {
+    const currentMark = modelsAreEqual(item.model, this.options.currentModel) ? this.theme.fg('success', ' ✓') : '';
+    const providerBadge = this.theme.fg('muted', `[${item.model.provider}]`);
+    const prefix = isSelected ? this.theme.fg('accent', '→ ') : '  ';
+    const modelText = isSelected ? this.theme.fg('accent', item.model.id) : item.model.id;
+    return this.line(`${prefix}${modelText} ${providerBadge}${currentMark}`, width);
+  }
+
+  private renderHelp(): string {
+    const tabHint = this.options.hasFavouriteSection ? 'tab switch sections • ' : '';
+    return this.theme.fg('dim', `${tabHint}↑↓ navigate • enter select • esc cancel`);
+  }
+
+  private line(text: string, width: number): string {
+    return truncateToWidth(text.replace(/[\r\n]+/g, ' '), Math.max(1, width), '');
+  }
+}

package/src/extensions/model-select/types.ts

@@ -0,0 +1,31 @@
+import type { Api, Model } from '@earendil-works/pi-ai';
+import type { ModelSelectLayout } from '../../schemas/model-select.config.schema';
+
+export type ModelItem = {
+  model: Model<Api>;
+  description: string;
+  searchText: string;
+};
+
+export type ModelLists = {
+  favouriteItems: ModelItem[];
+  favouriteWarnings: string[];
+  searchItems: ModelItem[];
+};
+
+export type SelectionSection = 'favourites' | 'search';
+
+export type DialogResult = Model<Api> | null;
+
+export type DialogOptions = {
+  currentModel: Model<Api> | undefined;
+  favouriteItems: ModelItem[];
+  favouriteWarnings: string[];
+  hasFavouriteSection: boolean;
+  searchItems: ModelItem[];
+  providerFilter: string[];
+  configWarnings: string[];
+  initialSearch: string;
+  layout: ModelSelectLayout;
+  onDone: (result: DialogResult) => void;
+};

package/src/index.ts

@@ -1,6 +1,8 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { ConfigLoader } from './config-loader';
 import { registerAutoSessionName } from './extensions/auto-session-name';
+import { registerCustomFooter } from './extensions/custom-footer';
+import { registerModelSelect } from './extensions/model-select';
 
 export default function (pi: ExtensionAPI) {
   const config = new ConfigLoader();
@@ -11,4 +13,6 @@ export default function (pi: ExtensionAPI) {
   });
 
   registerAutoSessionName(pi, { config });
+  registerModelSelect(pi, { config });
+  registerCustomFooter(pi, { config });
 }

package/src/libs/subscription-usage/strategy/anthropic-oauth-usage.strategy.ts

@@ -0,0 +1,41 @@
+import { RawDataParser } from '../../../utils/raw-data-parser.util';
+import type { ProviderAuth, RateWindow, SubscriptionUsageStrategy } from '../subscription-usage-api.util';
+
+export class AnthropicOauthUsageStrategy implements SubscriptionUsageStrategy {
+  readonly provider = 'anthropic';
+  readonly label = 'Claude';
+
+  async fetchUsage(auth: ProviderAuth) {
+    const response = await fetch(this.request(auth));
+    const data = RawDataParser.asRecord(await response.json());
+    if (!data) return;
+
+    const windows: RateWindow[] = [];
+    for (const [key, label] of [
+      ['five_hour', '5h'],
+      ['seven_day', 'Week'],
+    ] as const) {
+      const source = RawDataParser.asRecord(data[key]);
+      const usedPercent = RawDataParser.numberValue(source?.utilization);
+      if (usedPercent === undefined) continue;
+      const resetAt = RawDataParser.stringValue(source?.resets_at);
+      const resetDate = resetAt ? new Date(resetAt) : undefined;
+      windows.push({
+        label,
+        usedPercent,
+        resetAt: resetDate && Number.isFinite(resetDate.getTime()) ? resetDate : undefined,
+      });
+    }
+    return windows;
+  }
+
+  private request(opts: ProviderAuth) {
+    return new Request('https://api.anthropic.com/api/oauth/usage', {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${opts.token}`,
+        'anthropic-beta': 'oauth-2025-04-20',
+      },
+    });
+  }
+}

package/src/libs/subscription-usage/strategy/openai-codex-usage.strategy.ts

@@ -0,0 +1,75 @@
+import { RawDataParser } from '../../../utils/raw-data-parser.util';
+import type { ProviderAuth, RateWindow, SubscriptionUsageStrategy } from '../subscription-usage-api.util';
+
+const PRIMARY_WINDOW_FALLBACK_SECONDS = 10800;
+const SECONDARY_WINDOW_FALLBACK_SECONDS = 86400;
+
+export class OpenAiCodexUsageStrategy implements SubscriptionUsageStrategy {
+  readonly provider = 'openai-codex';
+  readonly label = 'Codex';
+
+  async fetchUsage(auth: ProviderAuth) {
+    const response = await fetch(this.request(auth));
+    if (!response.ok) return;
+
+    const data = RawDataParser.asRecord(await response.json());
+    if (!data) return;
+
+    const windows: RateWindow[] = [];
+    this.pushRateLimitWindows(windows, RawDataParser.asRecord(data.rate_limit));
+
+    const additionalRateLimits = Array.isArray(data.additional_rate_limits) ? data.additional_rate_limits : [];
+    for (const item of additionalRateLimits) {
+      const entry = RawDataParser.asRecord(item);
+      if (!entry) continue;
+
+      const prefix = RawDataParser.stringValue(entry.limit_name) ?? RawDataParser.stringValue(entry.metered_feature) ?? 'Additional';
+      this.pushRateLimitWindows(windows, RawDataParser.asRecord(entry.rate_limit), prefix);
+    }
+
+    return windows.length > 0 ? windows : undefined;
+  }
+
+  private pushRateLimitWindows(windows: RateWindow[], rateLimit: Record<string, unknown> | undefined, prefix?: string): void {
+    this.pushRateWindow(windows, RawDataParser.asRecord(rateLimit?.primary_window), PRIMARY_WINDOW_FALLBACK_SECONDS, prefix);
+    this.pushRateWindow(windows, RawDataParser.asRecord(rateLimit?.secondary_window), SECONDARY_WINDOW_FALLBACK_SECONDS, prefix);
+  }
+
+  private pushRateWindow(windows: RateWindow[], window: Record<string, unknown> | undefined, fallbackWindowSeconds: number, prefix?: string): void {
+    if (!window) return;
+
+    const resetDate = this.getResetDate(window);
+    windows.push({
+      label: this.getWindowLabel(RawDataParser.numberValue(window.limit_window_seconds), fallbackWindowSeconds, prefix),
+      usedPercent: RawDataParser.numberValue(window.used_percent) ?? 0,
+      resetAt: resetDate,
+    });
+  }
+
+  private getResetDate(window: Record<string, unknown>): Date | undefined {
+    const resetSeconds = RawDataParser.numberValue(window.reset_at);
+    if (!resetSeconds) return;
+
+    const resetDate = new Date(resetSeconds * 1000);
+    return Number.isFinite(resetDate.getTime()) ? resetDate : undefined;
+  }
+
+  private getWindowLabel(windowSeconds: number | undefined, fallbackWindowSeconds: number, prefix?: string): string {
+    const seconds = windowSeconds && windowSeconds > 0 ? windowSeconds : fallbackWindowSeconds;
+    const hours = Math.round(seconds / 3600);
+
+    const label = hours >= 144 ? 'Week' : hours >= 24 ? 'Day' : `${hours}h`;
+    return prefix ? `${prefix} ${label}` : label;
+  }
+
+  private request(opts: ProviderAuth) {
+    return new Request('https://chatgpt.com/backend-api/wham/usage', {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${opts.token}`,
+        ...(opts?.accountId ? { 'ChatGPT-Account-Id': opts.accountId } : {}),
+        Accept: 'application/json',
+      },
+    });
+  }
+}

package/src/libs/subscription-usage/subscription-usage-api.util.ts

@@ -0,0 +1,78 @@
+import { readFileSync } from 'node:fs';
+import { PathUtil } from '../../utils/path.util';
+import { RawDataParser } from '../../utils/raw-data-parser.util';
+
+export type ProviderAuth = {
+  token: string;
+  accountId?: string;
+};
+
+export type SubscriptionProvider = 'anthropic' | 'openai-codex';
+type SubscriptionAuthconfig = Partial<Record<SubscriptionProvider, Record<string, unknown>>>;
+
+export type RateWindow = {
+  label: string;
+  usedPercent: number;
+  resetAt?: Date;
+};
+
+export type FetchUsageResponse = {
+  label: string;
+  rateWindow: RateWindow[];
+};
+
+export interface SubscriptionUsageStrategy {
+  readonly provider: SubscriptionProvider;
+  readonly label: string;
+  fetchUsage(auth: ProviderAuth): Promise<RateWindow[] | undefined>;
+}
+
+export class SubscriptionUsageApi {
+  async fetchUsage(strategy: SubscriptionUsageStrategy): Promise<FetchUsageResponse | undefined> {
+    const auth = this.getOauthProviderAuth(strategy.provider);
+    if (!auth) return;
+    const rateWindow = await strategy.fetchUsage(auth);
+    if (!rateWindow) return;
+    return {
+      label: strategy.label,
+      rateWindow,
+    };
+  }
+
+  formatResetDescription(date: Date): string {
+    const diffMs = date.getTime() - Date.now();
+    if (diffMs <= 0) return 'now';
+
+    const minutes = Math.floor(diffMs / 60000);
+    if (minutes < 60) return `${minutes}m`;
+
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    if (hours < 24) return remainingMinutes > 0 ? `${hours}h${remainingMinutes}m` : `${hours}h`;
+
+    const days = Math.floor(hours / 24);
+    const remainingHours = hours % 24;
+    return remainingHours > 0 ? `${days}d${remainingHours}h` : `${days}d`;
+  }
+
+  private getOauthProviderAuth(provider: SubscriptionProvider): ProviderAuth | undefined {
+    const auth = this.loadAuthConfig();
+    if (!auth) return;
+
+    const providerAuth = auth[provider];
+    const access = RawDataParser.stringValue(providerAuth?.access);
+    if (!access) return;
+
+    return {
+      token: access,
+      accountId: RawDataParser.stringValue(providerAuth?.accountId),
+    };
+  }
+
+  private loadAuthConfig(): SubscriptionAuthconfig | undefined {
+    const authJson = PathUtil.findPiAuthConfig();
+    if (!authJson.exists) return undefined;
+
+    return RawDataParser.asRecord(JSON.parse(readFileSync(authJson.path, 'utf-8'))) as SubscriptionAuthconfig | undefined;
+  }
+}

package/src/schemas/auto-session-name.config.schema.ts

@@ -1,9 +1,9 @@
 import z from 'zod';
-import { ModelConfigschema } from './shared-config.schema';
+import { ModelConfigSchema } from './shared-config.schema';
 
 export const AutoSessionNameConfigSchema = z.object({
   enabled: z.boolean().default(false),
-  model: ModelConfigschema.optional(),
+  model: ModelConfigSchema.optional(),
 });
 export type AutoSessionNameConfig = z.infer<typeof AutoSessionNameConfigSchema>;
 

package/src/schemas/config.schema.ts

@@ -1,16 +1,27 @@
 import z from 'zod';
 import { AutoSessionNameConfigSchema, PartialAutoSessionNameConfigSchema } from './auto-session-name.config.schema';
+import { CustomFooterConfigSchema, DEFAULT_CUSTOM_FOOTER_CONFIG, PartialCustomFooterConfigSchema } from './custom-footer-config.schema';
+import { ModelSelectConfigSchema, PartialModelSelectConfigSchema } from './model-select.config.schema';
 
 export const ConfigSchema = z.object({
   $schema: z.string().optional(),
   auto_session_name: AutoSessionNameConfigSchema.default({
     enabled: false,
   }),
+  model_select: ModelSelectConfigSchema.default({
+    enabled: false,
+    favourite: [],
+    provider_filter: [],
+    layout: 'inline',
+  }),
+  custom_footer: CustomFooterConfigSchema.default(DEFAULT_CUSTOM_FOOTER_CONFIG),
 });
 export type Config = z.infer<typeof ConfigSchema>;
 
 export const PartialConfigSchema = z.object({
   $schema: z.string().optional(),
   auto_session_name: PartialAutoSessionNameConfigSchema.optional(),
+  model_select: PartialModelSelectConfigSchema.optional(),
+  custom_footer: PartialCustomFooterConfigSchema.optional(),
 });
 export type PartialConfig = z.infer<typeof PartialConfigSchema>;

package/src/schemas/custom-footer-config.schema.ts

@@ -0,0 +1,64 @@
+import z from 'zod';
+import { ColorHexSchema } from './shared-config.schema';
+
+const CustomFooterColorsSchema = z.object({
+  directory: ColorHexSchema.optional(),
+  modelName: ColorHexSchema.optional(),
+  anthropicUsage: ColorHexSchema.optional().default('#D97706'),
+  codexUsage: ColorHexSchema.optional().default('#10B981'),
+});
+
+const CustomFooterIconsSchema = z.object({
+  directory: z.string().optional().default(' '),
+  refresh: z.string().optional().default(''),
+  cache: z.string().optional().default(' '),
+  cacheRead: z.string().optional().default(' '),
+  cacheWrite: z.string().optional().default(' '),
+});
+
+const CustomFooterDisplaySchema = z.object({
+  tokens: z.boolean().optional().default(true),
+  cache: z.boolean().optional().default(true),
+});
+
+const DEFAULT_CUSTOM_FOOTER_COLORS = CustomFooterColorsSchema.parse({});
+const DEFAULT_CUSTOM_FOOTER_ICONS = CustomFooterIconsSchema.parse({});
+const DEFAULT_CUSTOM_FOOTER_DISPLAY = CustomFooterDisplaySchema.parse({});
+
+export const CustomFooterConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  colors: CustomFooterColorsSchema.default(DEFAULT_CUSTOM_FOOTER_COLORS),
+  icons: CustomFooterIconsSchema.default(DEFAULT_CUSTOM_FOOTER_ICONS),
+  display: CustomFooterDisplaySchema.default(DEFAULT_CUSTOM_FOOTER_DISPLAY),
+});
+export type CustomFooterConfig = z.infer<typeof CustomFooterConfigSchema>;
+
+export const DEFAULT_CUSTOM_FOOTER_CONFIG = CustomFooterConfigSchema.parse({ enabled: false });
+
+export const PartialCustomFooterConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  colors: z
+    .object({
+      directory: ColorHexSchema.optional(),
+      modelName: ColorHexSchema.optional(),
+      anthropicUsage: ColorHexSchema.optional(),
+      codexUsage: ColorHexSchema.optional(),
+    })
+    .optional(),
+  icons: z
+    .object({
+      directory: z.string().optional(),
+      refresh: z.string().optional(),
+      cache: z.string().optional(),
+      cacheRead: z.string().optional(),
+      cacheWrite: z.string().optional(),
+    })
+    .optional(),
+  display: z
+    .object({
+      tokens: z.boolean().optional(),
+      cache: z.boolean().optional(),
+    })
+    .optional(),
+});
+export type PartialCustomFooterConfig = z.infer<typeof PartialCustomFooterConfigSchema>;