pi-better-openai 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,51 @@
+# pi-better-openai
+
+A pi extension for OpenAI subscription workflows: fast mode, usage visibility, footer polish, and image generation through `openai-codex` auth.
+
+## Screenshots
+
+<!-- Add screenshots here. -->
+
+## Install
+
+Install from a local checkout:
+
+```bash
+pi install /path/to/pi-better-openai
+```
+
+For a project-local install instead of a global install, add `-l`:
+
+```bash
+pi install -l /path/to/pi-better-openai
+```
+
+Reload pi after installing:
+
+```text
+/reload
+```
+
+Sign in to OpenAI Codex subscription auth if you want usage stats or image generation:
+
+```text
+/login openai-codex
+```
+
+Start pi with fast mode enabled:
+
+```bash
+pi --fast
+```
+
+## Features
+
+- Fast mode for supported OpenAI models, toggled with `/fast` or in `/openai-settings`.
+- OpenAI subscription usage display via `/openai-usage` and the footer.
+- Interactive settings picker via `/openai-settings`.
+- Footer customization for model, thinking, fast mode, usage, and token/cost context.
+- OpenAI image generation/editing through the `openai_image` tool.
+- Commands:
+  - `/fast` toggles fast mode.
+  - `/openai-usage` shows current OpenAI subscription usage.
+  - `/openai-settings` opens settings, diagnostics, and config details.

package/extensions/config.ts

@@ -0,0 +1,232 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { CONFIG_BASENAME, logPrefix } from "./identity.ts";
+
+export const FOOTER_MODES = ["replace", "status", "off"] as const;
+export const IMAGE_SAVE_MODES = ["none", "project", "global", "custom"] as const;
+export const IMAGE_OUTPUT_FORMATS = ["png", "jpeg", "webp"] as const;
+
+export const DEFAULT_SUPPORTED_MODELS = [
+  "openai/gpt-5.4",
+  "openai/gpt-5.5",
+  "openai-codex/gpt-5.4",
+  "openai-codex/gpt-5.5"
+] as const;
+
+export type FooterMode = typeof FOOTER_MODES[number];
+export type ImageSaveMode = typeof IMAGE_SAVE_MODES[number];
+export type ImageOutputFormat = typeof IMAGE_OUTPUT_FORMATS[number];
+
+export type UsageConfig = {
+  enabled?: boolean;
+  refreshIntervalMs?: number;
+  showOnlyOnSubscriptionModels?: boolean;
+  showResetTimes?: boolean;
+};
+
+export type FooterConfig = {
+  mode?: FooterMode;
+};
+
+export type ImageConfig = {
+  enabled?: boolean;
+  defaultModel?: string;
+  defaultSave?: ImageSaveMode;
+  outputFormat?: ImageOutputFormat;
+  timeoutMs?: number;
+};
+
+export interface ConfigFile {
+  persistState?: boolean;
+  active?: boolean;
+  desiredActive?: boolean;
+  supportedModels?: string[];
+  usage?: UsageConfig;
+  footer?: FooterConfig;
+  image?: ImageConfig;
+}
+
+export interface SupportedModel {
+  provider: string;
+  id: string;
+}
+
+export interface ResolvedConfig {
+  configPath: string;
+  projectConfigPath: string;
+  globalConfigPath: string;
+  projectConfigExists: boolean;
+  globalConfigExists: boolean;
+  persistState: boolean;
+  active: boolean;
+  desiredActive: boolean;
+  supportedModels: SupportedModel[];
+  usage: Required<UsageConfig>;
+  footer: Required<FooterConfig>;
+  image: Required<ImageConfig>;
+}
+
+export const DEFAULT_USAGE_CONFIG: Required<UsageConfig> = {
+  enabled: true,
+  refreshIntervalMs: 60_000,
+  showOnlyOnSubscriptionModels: true,
+  showResetTimes: true
+};
+
+export const DEFAULT_FOOTER_CONFIG: Required<FooterConfig> = {
+  mode: "replace"
+};
+
+export const DEFAULT_IMAGE_CONFIG: Required<ImageConfig> = {
+  enabled: true,
+  defaultModel: "gpt-5.5",
+  defaultSave: "project",
+  outputFormat: "png",
+  timeoutMs: 180_000
+};
+
+export const DEFAULT_CONFIG: ConfigFile = {
+  persistState: true,
+  active: false,
+  desiredActive: false,
+  supportedModels: [...DEFAULT_SUPPORTED_MODELS],
+  usage: DEFAULT_USAGE_CONFIG,
+  footer: DEFAULT_FOOTER_CONFIG,
+  image: DEFAULT_IMAGE_CONFIG
+};
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function configPaths(cwd: string, home = homedir()) {
+  return {
+    project: join(cwd, ".pi", "extensions", CONFIG_BASENAME),
+    global: join(home, ".pi", "agent", "extensions", CONFIG_BASENAME)
+  };
+}
+
+export function parseModelKey(value: string): SupportedModel | undefined {
+  const key = value.trim();
+  const slash = key.indexOf("/");
+  if (slash <= 0 || slash === key.length - 1) return undefined;
+  const provider = key.slice(0, slash).trim();
+  const id = key.slice(slash + 1).trim();
+  return provider && id ? { provider, id } : undefined;
+}
+
+export function normalizeModelKeys(value: unknown): string[] | undefined {
+  if (value === undefined) return undefined;
+  if (!Array.isArray(value)) return undefined;
+  return value
+    .filter((entry): entry is string => typeof entry === "string")
+    .map((entry) => parseModelKey(entry))
+    .filter((entry): entry is SupportedModel => entry !== undefined)
+    .map((entry) => `${entry.provider}/${entry.id}`);
+}
+
+export function parseModels(value: unknown): SupportedModel[] | undefined {
+  const keys = normalizeModelKeys(value);
+  if (keys === undefined) return undefined;
+  return keys.map((key) => parseModelKey(key)).filter((entry): entry is SupportedModel => entry !== undefined);
+}
+
+export function readRawConfig(path: string): Record<string, unknown> {
+  if (!existsSync(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as unknown;
+    return isRecord(parsed) ? parsed : {};
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`${logPrefix()} Failed to read ${path}: ${message}`);
+    return {};
+  }
+}
+
+export function readConfig(path: string): ConfigFile | undefined {
+  if (!existsSync(path)) return undefined;
+  const parsed = readRawConfig(path);
+  const config: ConfigFile = {};
+  if (typeof parsed.persistState === "boolean") config.persistState = parsed.persistState;
+  if (typeof parsed.active === "boolean") config.active = parsed.active;
+  if (typeof parsed.desiredActive === "boolean") config.desiredActive = parsed.desiredActive;
+  const supportedModels = normalizeModelKeys(parsed.supportedModels);
+  if (supportedModels !== undefined) config.supportedModels = supportedModels;
+  if (isRecord(parsed.usage)) {
+    config.usage = {};
+    if (typeof parsed.usage.enabled === "boolean") config.usage.enabled = parsed.usage.enabled;
+    if (typeof parsed.usage.refreshIntervalMs === "number") config.usage.refreshIntervalMs = parsed.usage.refreshIntervalMs;
+    if (typeof parsed.usage.showOnlyOnSubscriptionModels === "boolean") config.usage.showOnlyOnSubscriptionModels = parsed.usage.showOnlyOnSubscriptionModels;
+    if (typeof parsed.usage.showResetTimes === "boolean") config.usage.showResetTimes = parsed.usage.showResetTimes;
+  }
+  if (isRecord(parsed.footer) && typeof parsed.footer.mode === "string" && (FOOTER_MODES as readonly string[]).includes(parsed.footer.mode)) {
+    config.footer = { mode: parsed.footer.mode as FooterMode };
+  }
+  if (isRecord(parsed.image)) {
+    config.image = {};
+    if (typeof parsed.image.enabled === "boolean") config.image.enabled = parsed.image.enabled;
+    if (typeof parsed.image.defaultModel === "string" && parsed.image.defaultModel.trim()) config.image.defaultModel = parsed.image.defaultModel.trim();
+    if (typeof parsed.image.defaultSave === "string" && (IMAGE_SAVE_MODES as readonly string[]).includes(parsed.image.defaultSave)) config.image.defaultSave = parsed.image.defaultSave as ImageSaveMode;
+    if (typeof parsed.image.outputFormat === "string" && (IMAGE_OUTPUT_FORMATS as readonly string[]).includes(parsed.image.outputFormat)) config.image.outputFormat = parsed.image.outputFormat as ImageOutputFormat;
+    if (typeof parsed.image.timeoutMs === "number") config.image.timeoutMs = parsed.image.timeoutMs;
+  }
+  return config;
+}
+
+export function writeConfig(path: string, config: ConfigFile | Record<string, unknown>): void {
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`${logPrefix()} Failed to write ${path}: ${message}`);
+  }
+}
+
+function ensureConfigFile(projectConfigPath: string, globalConfigPath: string): void {
+  if (existsSync(projectConfigPath) || existsSync(globalConfigPath)) return;
+  writeConfig(globalConfigPath, DEFAULT_CONFIG);
+}
+
+export function resolveConfig(cwd: string): ResolvedConfig {
+  const paths = configPaths(cwd);
+  ensureConfigFile(paths.project, paths.global);
+
+  const projectConfigExists = existsSync(paths.project);
+  const globalConfigExists = existsSync(paths.global);
+  const globalConfig = readConfig(paths.global) ?? {};
+  const projectConfig = readConfig(paths.project) ?? {};
+  const merged = { ...DEFAULT_CONFIG, ...globalConfig, ...projectConfig };
+  const selectedPath = projectConfigExists ? paths.project : paths.global;
+  const desiredActive = merged.desiredActive ?? merged.active ?? false;
+
+  return {
+    configPath: selectedPath,
+    projectConfigPath: paths.project,
+    globalConfigPath: paths.global,
+    projectConfigExists,
+    globalConfigExists,
+    persistState: merged.persistState ?? true,
+    active: merged.active ?? desiredActive,
+    desiredActive,
+    supportedModels: parseModels(merged.supportedModels) ?? parseModels(DEFAULT_SUPPORTED_MODELS) ?? [],
+    usage: {
+      ...DEFAULT_USAGE_CONFIG,
+      ...(globalConfig.usage ?? {}),
+      ...(projectConfig.usage ?? {}),
+      refreshIntervalMs: Math.max(15_000, Math.min(10 * 60_000, projectConfig.usage?.refreshIntervalMs ?? globalConfig.usage?.refreshIntervalMs ?? DEFAULT_USAGE_CONFIG.refreshIntervalMs))
+    },
+    footer: {
+      ...DEFAULT_FOOTER_CONFIG,
+      ...(globalConfig.footer ?? {}),
+      ...(projectConfig.footer ?? {})
+    },
+    image: {
+      ...DEFAULT_IMAGE_CONFIG,
+      ...(globalConfig.image ?? {}),
+      ...(projectConfig.image ?? {}),
+      timeoutMs: Math.max(30_000, Math.min(5 * 60_000, projectConfig.image?.timeoutMs ?? globalConfig.image?.timeoutMs ?? DEFAULT_IMAGE_CONFIG.timeoutMs))
+    }
+  };
+}

package/extensions/format.ts

@@ -0,0 +1,35 @@
+export function stripAnsi(value: string): string {
+  return value.replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, "");
+}
+
+export function visibleWidth(value: string): number {
+  return stripAnsi(value).length;
+}
+
+function leadingAnsi(value: string): string {
+  return value.match(/^(?:\u001b\[[0-?]*[ -/]*[@-~])+/)?.[0] ?? "";
+}
+
+function trailingAnsi(value: string): string {
+  return value.match(/(?:\u001b\[[0-?]*[ -/]*[@-~])+$/)?.[0] ?? "";
+}
+
+export function truncateToWidth(value: string, width: number, ellipsis = "..."): string {
+  if (visibleWidth(value) <= width) return value;
+  if (width <= 0) return "";
+  const plain = stripAnsi(value);
+  if (width <= ellipsis.length) return ellipsis.slice(0, width);
+  return `${leadingAnsi(value)}${plain.slice(0, Math.max(0, width - ellipsis.length))}${ellipsis}${trailingAnsi(value)}`;
+}
+
+export function formatTokens(count: number): string {
+  if (count < 1000) return count.toString();
+  if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
+  if (count < 1000000) return `${Math.round(count / 1000)}k`;
+  if (count < 10000000) return `${(count / 1000000).toFixed(1)}M`;
+  return `${Math.round(count / 1000000)}M`;
+}
+
+export function sanitizeStatusText(text: string): string {
+  return text.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim();
+}

package/extensions/identity.ts

@@ -0,0 +1,7 @@
+export const EXTENSION_NAME = "pi-better-openai";
+export const CONFIG_BASENAME = "pi-better-openai.json";
+export const STATUS_KEY = "better-openai";
+
+export function logPrefix(): string {
+  return `[${EXTENSION_NAME}]`;
+}