@monotykamary/pi-better-openai 0.1.23

package/src/fast-controller.ts

@@ -0,0 +1,112 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ResolvedConfig, SupportedModel } from "./config.ts";
+import { isRecord } from "./config.ts";
+
+export function currentModelKey(ctx: ExtensionContext): string {
+  return ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "none";
+}
+
+export function supportsFast(ctx: ExtensionContext, supportedModels: SupportedModel[]): boolean {
+  const current = ctx.model;
+  if (!current) return false;
+  return supportedModels.some(
+    (model) => model.provider === current.provider && model.id === current.id,
+  );
+}
+
+export function modelList(supportedModels: SupportedModel[]): string {
+  return supportedModels.length > 0
+    ? supportedModels.map((model) => `${model.provider}/${model.id}`).join(", ")
+    : "none configured";
+}
+
+export function fastStateText(
+  ctx: ExtensionContext,
+  desiredActive: boolean,
+  active: boolean,
+  supportedModels: SupportedModel[],
+): string {
+  const model = currentModelKey(ctx);
+  if (active) return `Fast mode is on for ${model}.`;
+  if (desiredActive) {
+    return `Fast mode is requested, but inactive for unsupported model ${model}. Supported models: ${modelList(supportedModels)}.`;
+  }
+  return `Fast mode is off. Current model: ${model}.`;
+}
+
+export class FastController {
+  desiredActive = false;
+  active = false;
+  private lastInjectedAt: number | undefined;
+  private lastInjectedModel: string | undefined;
+  private lastInjectedTier: string | undefined;
+  private readonly serviceTier: string;
+
+  constructor(serviceTier: string) {
+    this.serviceTier = serviceTier;
+  }
+
+  applyDesiredState(ctx: ExtensionContext, cfg: ResolvedConfig): void {
+    this.active = this.desiredActive && supportsFast(ctx, cfg.supportedModels);
+  }
+
+  initializeForSession(ctx: ExtensionContext, cfg: ResolvedConfig, flagActive: boolean): void {
+    this.desiredActive = cfg.persistState ? cfg.desiredActive : false;
+    if (flagActive) this.desiredActive = true;
+    this.applyDesiredState(ctx, cfg);
+  }
+
+  setDesired(ctx: ExtensionContext, cfg: ResolvedConfig, next: boolean): void {
+    this.desiredActive = next;
+    this.applyDesiredState(ctx, cfg);
+  }
+
+  stateText(ctx: ExtensionContext, cfg: ResolvedConfig): string {
+    return fastStateText(ctx, this.desiredActive, this.active, cfg.supportedModels);
+  }
+
+  unsupportedRequestMessage(ctx: ExtensionContext, cfg: ResolvedConfig): string {
+    return `Fast mode requested, but ${currentModelKey(ctx)} is unsupported. It will activate automatically when you switch to a supported model: ${modelList(cfg.supportedModels)}.`;
+  }
+
+  inactiveForModelMessage(ctx: ExtensionContext): string {
+    return `Fast mode inactive for unsupported model ${currentModelKey(ctx)}.`;
+  }
+
+  settingsSummary(ctx: ExtensionContext, cfg: ResolvedConfig): string {
+    if (this.active) return "on";
+    if (this.desiredActive)
+      return supportsFast(ctx, cfg.supportedModels) ? "requested" : "requested inactive";
+    return "off";
+  }
+
+  statusSegment(ctx: ExtensionContext, cfg: ResolvedConfig): string | undefined {
+    return this.active && supportsFast(ctx, cfg.supportedModels)
+      ? `${ctx.model?.id ?? "model"} fast`
+      : undefined;
+  }
+
+  injectProviderPayload(
+    event: { payload?: unknown },
+    ctx: ExtensionContext,
+    cfg: ResolvedConfig,
+  ): unknown {
+    if (!this.active || !supportsFast(ctx, cfg.supportedModels) || !isRecord(event.payload))
+      return undefined;
+    this.lastInjectedAt = Date.now();
+    this.lastInjectedModel = currentModelKey(ctx);
+    this.lastInjectedTier = this.serviceTier;
+    return { ...event.payload, service_tier: this.serviceTier };
+  }
+
+  debugLines(ctx: ExtensionContext, cfg: ResolvedConfig): string[] {
+    return [
+      `Fast desired: ${this.desiredActive}`,
+      `Fast active: ${this.active}`,
+      `Current model: ${currentModelKey(ctx)}`,
+      `Supported model: ${supportsFast(ctx, cfg.supportedModels)}`,
+      `Configured service_tier: ${this.serviceTier}`,
+      `Last injected: ${this.lastInjectedAt ? `${new Date(this.lastInjectedAt).toLocaleTimeString()} (${this.lastInjectedModel}, ${this.lastInjectedTier})` : "never"}`,
+    ];
+  }
+}

package/src/footer-layout.ts

@@ -0,0 +1,97 @@
+import { sep } from "node:path";
+import type { PetPlacement } from "./config.ts";
+import { truncateToWidth, visibleWidth } from "./format.ts";
+
+export function abbreviateHomePath(
+  path: string,
+  home = process.env.HOME || process.env.USERPROFILE,
+): string {
+  if (!home) return path;
+  if (path === home) return "~";
+  const homePrefix = home.endsWith(sep) ? home : `${home}${sep}`;
+  return path.startsWith(homePrefix) ? `~/${path.slice(homePrefix.length)}` : path;
+}
+
+export function isInlinePetPlacement(placement: PetPlacement): boolean {
+  return placement === "inline-left" || placement === "inline-right" || placement === "badge";
+}
+
+export function petSizeCellsForPlacement(placement: PetPlacement, sizeCells: number): number {
+  return placement === "badge" ? Math.min(6, sizeCells) : sizeCells;
+}
+
+function spaces(width: number): string {
+  return " ".repeat(Math.max(0, width));
+}
+
+function padTextToWidth(value: string, width: number): string {
+  return value + spaces(width - visibleWidth(value));
+}
+
+export function isTerminalImageLine(line: string): boolean {
+  return line.includes("\x1b_G") || line.includes("\x1b]1337;File=");
+}
+
+function petLineCell(line: string, width: number): string {
+  if (!line) return spaces(width);
+  if (isTerminalImageLine(line)) return `\x1b[0m${line}`;
+  const clipped = truncateToWidth(line, width, "");
+  return clipped + spaces(width - visibleWidth(clipped));
+}
+
+function stripLeadingCursorUp(line: string): string {
+  if (!line.startsWith("\x1b[")) return line;
+  const end = line.indexOf("A", 2);
+  if (end === -1) return line;
+  return /^\d+$/.test(line.slice(2, end)) ? line.slice(end + 1) : line;
+}
+
+function stripTrailingCursorDown(line: string): string {
+  if (!line.endsWith("B")) return line;
+  const start = line.lastIndexOf("\x1b[");
+  if (start === -1) return line;
+  return /^\d+$/.test(line.slice(start + 2, -1)) ? line.slice(0, start) : line;
+}
+
+function terminalImageInlineLeftSequence(line: string, totalRows: number): string {
+  const moveUp = totalRows > 1 ? `\x1b[${totalRows - 1}A` : "";
+  const moveDown = totalRows > 1 ? `\x1b[${totalRows - 1}B` : "";
+  const balancedLine = stripTrailingCursorDown(stripLeadingCursorUp(line));
+  return `\x1b[0m\r${moveUp}${balancedLine}${moveDown}`;
+}
+
+export function combineInlinePetFooter(
+  petLines: string[],
+  textLines: string[],
+  width: number,
+  placement: PetPlacement,
+  petWidth: number,
+): string[] {
+  const gap = 2;
+  const textWidth = Math.max(1, width - petWidth - gap);
+  const totalRows = Math.max(petLines.length, textLines.length);
+  const hasTerminalImageLine = petLines.some(isTerminalImageLine);
+  const leftImageLine =
+    placement === "inline-left" ? petLines.find(isTerminalImageLine) : undefined;
+  const renderPetOnRight =
+    placement === "inline-right" || (placement !== "inline-left" && hasTerminalImageLine);
+  const lines: string[] = [];
+
+  for (let row = 0; row < totalRows; row++) {
+    const petLine = petLines[row] ?? "";
+    const textLine = textLines[row] ?? "";
+    const textPart = truncateToWidth(textLine, textWidth, "...");
+    const petPart = leftImageLine ? spaces(petWidth) : petLineCell(petLine, petWidth);
+    if (renderPetOnRight) {
+      lines.push(`${padTextToWidth(textPart, textWidth)}${spaces(gap)}${petPart}`);
+    } else {
+      lines.push(`${petPart}${spaces(gap)}${textPart}`);
+    }
+  }
+
+  if (leftImageLine && lines.length > 0) {
+    lines[lines.length - 1] += terminalImageInlineLeftSequence(leftImageLine, totalRows);
+  }
+
+  return lines;
+}

package/src/format.ts

@@ -0,0 +1,104 @@
+import {
+  truncateToWidth as truncateTerminalText,
+  visibleWidth as terminalVisibleWidth,
+} from "@earendil-works/pi-tui";
+
+const ANSI_ESCAPE_PATTERN = String.raw`\u001B\[[0-?]*[ -/]*[@-~]`;
+const ANSI_ESCAPE_REGEXP = new RegExp(ANSI_ESCAPE_PATTERN, "g");
+const DIAGNOSTIC_MAX_LENGTH = 500;
+const REDACTED = "[REDACTED]";
+const SENSITIVE_DIAGNOSTIC_KEY_SUFFIXES = [
+  "token",
+  "apikey",
+  "accesskey",
+  "authorization",
+  "password",
+  "passwd",
+  "secret",
+  "privatekey",
+  "credential",
+  "credentials",
+  "accountid",
+] as const;
+
+function replaceControlCharacters(value: string): string {
+  let result = "";
+  for (const char of value) {
+    const code = char.charCodeAt(0);
+    result += code <= 31 || (code >= 127 && code <= 159) ? " " : char;
+  }
+  return result;
+}
+
+export function stripAnsi(value: string): string {
+  return value.replace(ANSI_ESCAPE_REGEXP, "");
+}
+
+export function visibleWidth(value: string): number {
+  return terminalVisibleWidth(value);
+}
+
+export function truncateToWidth(value: string, width: number, ellipsis = "..."): string {
+  return truncateTerminalText(value, width, ellipsis);
+}
+
+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, " ").trim();
+}
+
+export function maskIdentifier(value: string | undefined): string | undefined {
+  const trimmed = value?.trim();
+  if (!trimmed) return undefined;
+  if (trimmed.length <= 8) return "found";
+  return `${trimmed.slice(0, 4)}...${trimmed.slice(-4)}`;
+}
+
+export function sanitizeDiagnosticError(
+  message: string,
+  maxLength = DIAGNOSTIC_MAX_LENGTH,
+): string {
+  const redactedSecrets = stripAnsi(message)
+    .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [REDACTED]")
+    .replace(/\bsk-[A-Za-z0-9_-]{8,}\b/g, "sk-[REDACTED]")
+    .replace(/\bacct_[A-Za-z0-9_-]{6,}\b/g, "acct_[REDACTED]")
+    .replace(
+      /(["']?(?:access|access_token|token|api[_-]?key|authorization|accountId|account_id)["']?\s*[:=]\s*["']?)([^"',\s}\]]+)/gi,
+      "$1[REDACTED]",
+    )
+    .replace(/\[REDACTED\](?:\])+/g, "[REDACTED]");
+  const redacted = replaceControlCharacters(redactedSecrets).replace(/ +/g, " ").trim();
+  const sanitized = redacted || "Unknown error.";
+  if (sanitized.length <= maxLength) return sanitized;
+  return `${sanitized.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}
+
+function isSensitiveDiagnosticKey(key: string): boolean {
+  const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
+  return (
+    normalized === "access" ||
+    normalized === "auth" ||
+    normalized === "refresh" ||
+    SENSITIVE_DIAGNOSTIC_KEY_SUFFIXES.some((suffix) => normalized.endsWith(suffix))
+  );
+}
+
+export function redactDiagnosticValue(value: unknown): unknown {
+  if (typeof value === "string") return sanitizeDiagnosticError(value);
+  if (Array.isArray(value)) return value.map(redactDiagnosticValue);
+  if (typeof value !== "object" || value === null) return value;
+
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [
+      key,
+      isSensitiveDiagnosticKey(key) ? REDACTED : redactDiagnosticValue(entry),
+    ]),
+  );
+}

package/src/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}]`;
+}