opencode-quotas 0.0.1

package/src/ui/progress-bar.ts

@@ -0,0 +1,204 @@
+import { type AnsiColor, type ProgressBarConfig, type GradientLevel } from "../interfaces";
+import { isValidNumber, clamp } from "../utils/validation";
+
+const DEFAULT_BAR_WIDTH = 20;
+const DEFAULT_FILLED_CHAR = "█";
+const DEFAULT_EMPTY_CHAR = "░";
+
+const DEFAULT_GRADIENTS: GradientLevel[] = [
+    { threshold: 0.5, color: "green" },
+    { threshold: 0.8, color: "yellow" },
+    { threshold: 1.0, color: "red" },
+];
+
+const ANSI_CODES: Record<AnsiColor, string> = {
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  cyan: "\x1b[36m",
+  white: "\x1b[37m",
+  gray: "\x1b[90m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  reset: "\x1b[0m",
+};
+
+function shouldUseColor(config?: ProgressBarConfig): boolean {
+  // FORCE_COLOR should take precedence when explicitly set
+  if (process.env.FORCE_COLOR !== undefined) return true;
+
+  // Respect explicit no-color flags
+  if (process.env.NO_COLOR !== undefined) return false;
+  if (process.env.OPENCODE_QUOTAS_NO_COLOR !== undefined) return false;
+
+  // Respect explicit config request (useful for tests/environments)
+  if (config?.color === true) return true;
+
+  // If not a TTY, generally disable color
+  if (!process.stdout.isTTY) return false;
+
+  return false;
+}
+
+export function colorize(text: string, color: AnsiColor | undefined, useColor: boolean): string {
+  if (!useColor) return text;
+  if (!color || color === "reset") return text;
+  return `${ANSI_CODES[color]}${text}${ANSI_CODES.reset}`;
+}
+
+function formatNumber(value: number): string {
+  if (!Number.isFinite(value)) return "0";
+  if (Number.isInteger(value)) {
+    return `${value}`;
+  }
+  if (Math.abs(value) >= 100) {
+    return value.toFixed(1);
+  }
+  return value.toFixed(1);
+}
+
+export type RenderQuotaBarParts = {
+  labelPart: string;
+  bar: string;
+  percent: string;
+  valuePart: string;
+  detailsPart: string;
+  statusEmoji: string;
+  statusText: string;
+};
+
+export function getQuotaStatusEmoji(
+  ratio: number,
+  config: ProgressBarConfig = {}
+): string {
+  // Default thresholds if not provided
+  const gradients = config.gradients || DEFAULT_GRADIENTS;
+
+  const sorted = [...gradients].sort((a, b) => a.threshold - b.threshold);
+  
+  // Find the matching level
+  const match = sorted.find((g) => ratio <= g.threshold);
+  const color = match ? match.color : sorted[sorted.length - 1]?.color || "red";
+
+  switch (color) {
+    case "green": return "🟢";
+    case "yellow": return "🟡";
+    case "red": return "🔴";
+    default: return "⚪"; // Grey/Unknown
+  }
+}
+
+export function getQuotaStatusText(
+  ratio: number,
+  config: ProgressBarConfig = {}
+): string {
+  // Default thresholds if not provided
+  const gradients = config.gradients || DEFAULT_GRADIENTS;
+
+  const sorted = [...gradients].sort((a, b) => a.threshold - b.threshold);
+  
+  // Find the matching level
+  const match = sorted.find((g) => ratio <= g.threshold);
+  const color = match ? match.color : sorted[sorted.length - 1]?.color || "red";
+
+  switch (color) {
+    case "green": return "OK "; // Space for alignment
+    case "yellow": return "WRN";
+    case "red": return "ERR";
+    default: return "UNK";
+  }
+}
+
+export function renderQuotaBarParts(
+  used: number,
+  limit: number,
+  options: {
+    label: string;
+    unit: string;
+    details?: string;
+    config?: ProgressBarConfig;
+  },
+): RenderQuotaBarParts {
+  const config = options.config || {};
+  const width = config.width ?? DEFAULT_BAR_WIDTH;
+  const filledChar = config.filledChar ?? DEFAULT_FILLED_CHAR;
+  const emptyChar = config.emptyChar ?? DEFAULT_EMPTY_CHAR;
+  const showMode = config.show ?? "used";
+  const useColor = shouldUseColor(config);
+
+  // Defensive guards: normalize inputs
+  const usedVal = isValidNumber(used) ? Math.max(0, used) : 0;
+  const limitVal = isValidNumber(limit) && limit > 0 ? limit : 0;
+
+  // Calculate value and ratio based on mode
+  let displayValue = usedVal;
+  let ratio = 0;
+
+  if (limitVal > 0) {
+    if (showMode === "available") {
+      displayValue = Math.max(0, limitVal - usedVal);
+    }
+    ratio = displayValue / limitVal;
+  }
+
+  // Cap visual ratio at 1.0 for the bar filling, but keep actual ratio for color calculation if needed
+  const visualRatio = Math.min(Math.max(ratio, 0), 1);
+
+  const filledLen = Math.round(width * visualRatio);
+  const emptyLen = Math.max(0, width - filledLen);
+
+  // Determine Color
+  let barColor: AnsiColor = "reset";
+  let statusColor: AnsiColor = "reset";
+  
+  if (config.gradients && config.gradients.length > 0) {
+    // Sort gradients by threshold to ensure correct evaluation
+    const sorted = [...config.gradients].sort(
+      (a, b) => a.threshold - b.threshold,
+    );
+
+    // Find the matching level
+    const match = sorted.find((g) => ratio <= g.threshold);
+
+    if (match) {
+      barColor = match.color;
+      statusColor = match.color;
+    } else {
+      // If ratio exceeds all thresholds (e.g. > 100%), use the last defined color (highest severity)
+      barColor = sorted[sorted.length - 1].color;
+      statusColor = sorted[sorted.length - 1].color;
+    }
+  }
+
+  const filledStr = filledChar.repeat(filledLen);
+  const emptyStr = emptyChar.repeat(emptyLen);
+
+  const bar = `${colorize(filledStr, barColor, useColor)}${emptyStr}`; // Only color filled part? Or empty too? usually just filled.
+
+  const percentRaw = limitVal > 0 ? `${Math.round(ratio * 100)}%` : "n/a";
+  const percentText = percentRaw === "n/a" ? percentRaw : percentRaw.padStart(4);
+  const percent = colorize(percentText, barColor, useColor);
+  
+  const valueText = `${formatNumber(displayValue)}/${formatNumber(limitVal)} ${options.unit}`;
+
+  // Only append colon if label is present and not empty
+  const labelPart = options.label ? `${options.label}: ` : "";
+
+  // Determine Emoji
+  const statusEmoji = getQuotaStatusEmoji(ratio, config);
+  const statusTextRaw = getQuotaStatusText(ratio, config);
+  const statusText = colorize(statusTextRaw, statusColor, useColor);
+
+  return {
+    labelPart,
+    bar,
+    percent,
+    valuePart: `(${valueText})`,
+    detailsPart: options.details ? ` | ${options.details}` : "",
+    statusEmoji,
+    statusText,
+  };
+}
+

package/src/ui/quota-table.ts

@@ -0,0 +1,173 @@
+import { renderQuotaBarParts, type RenderQuotaBarParts, colorize } from "./progress-bar";
+import { type ProgressBarConfig, type QuotaData, type QuotaColumn } from "../interfaces";
+import { validateQuotaData } from "../utils/validation";
+
+type RenderedQuotaLine = {
+    id: string;
+    providerName: string;
+    line: string;
+};
+
+const DEFAULT_COLUMNS: QuotaColumn[] = ["status", "name", "percent", "bar", "reset", "ettl"];
+const HEADERS: Record<QuotaColumn, string> = {
+    name: "QUOTA NAME",
+    bar: "UTILIZATION",
+    percent: "USED",
+    value: "VALUE",
+    reset: "RESET",
+    ettl: "ETTL",
+    window: "WINDOW",
+    info: "INFO",
+    status: "ST"
+};
+
+export function renderQuotaTable(
+    quotas: QuotaData[],
+    options: {
+        progressBarConfig?: ProgressBarConfig;
+        tableConfig?: { columns?: QuotaColumn[], header?: boolean };
+    },
+): RenderedQuotaLine[] {
+    if (quotas.length === 0) return [];
+
+    const columns = options.tableConfig?.columns || DEFAULT_COLUMNS;
+    const useColor = options.progressBarConfig?.color ?? false;
+
+    // 1. Pre-calculate cell data for every row
+    const rows = quotas.map((quota) => {
+        const validated = validateQuotaData(quota) || quota;
+        const isUnlimited = validated.limit === null || validated.limit <= 0;
+        
+        // Render bar parts if limited
+        let barParts: RenderQuotaBarParts | null = null;
+        if (!isUnlimited) {
+            barParts = renderQuotaBarParts(validated.used, validated.limit!, {
+                label: "",
+                unit: validated.unit,
+                config: options.progressBarConfig,
+            });
+        }
+
+        const name = colorize(validated.providerName, "cyan", useColor);
+        const status = barParts 
+            ? barParts.statusText 
+            : (validated.info === "unlimited" ? colorize("OK ", "green", useColor) : colorize("UNK", "gray", useColor));
+        
+        // Strip "resets in " or "resets at " prefix for cleaner table display
+        const resetRaw = validated.reset?.replace(/^resets (in|at) /, "") || "";
+        const reset = colorize(resetRaw, "gray", useColor);
+        
+        // Remove leading 'in ' if present and strip '(predicted)'
+        const ettlRaw = validated.predictedReset?.replace(/^in\s+/i, "").replace(/\(predicted\)/, "").trim() || "-";
+        const ettl = colorize(ettlRaw, "gray", useColor);
+
+        return {
+            quota: validated,
+            barParts,
+            cells: {
+                name,
+                bar: barParts ? barParts.bar : (isUnlimited ? colorize("Unlimited", "green", useColor) : ""),
+                percent: barParts ? barParts.percent : "",
+                value: barParts ? barParts.valuePart : `${validated.used} ${validated.unit}`,
+                reset,
+                ettl,
+                window: validated.window || "",
+                info: validated.info || "",
+                status,
+            } as Record<QuotaColumn, string>
+        };
+    });
+
+    // 2. Measure widths
+    const widths: Record<QuotaColumn, number> = {
+        name: 0, bar: 0, percent: 0, value: 0, reset: 0, window: 0, info: 0, status: 0, ettl: 0
+    };
+
+    // Calculate max widths including headers
+    for (const col of columns) {
+        widths[col] = Math.max(widths[col], HEADERS[col].length);
+    }
+
+    for (const row of rows) {
+        for (const col of columns) {
+            const content = row.cells[col];
+            const visibleLength = content.replace(/\x1b\[[0-9;]*m/g, "").length;
+            if (visibleLength > widths[col]) {
+                widths[col] = visibleLength;
+            }
+        }
+    }
+
+    const outputRows: RenderedQuotaLine[] = [];
+
+    // 3. Render Header (optional)
+    if (options.tableConfig?.header !== false) {
+        const headerSegments: string[] = [];
+        const separatorSegments: string[] = [];
+
+        for (const col of columns) {
+            const width = widths[col];
+            const headerTitle = HEADERS[col];
+            // Alignments: same as content
+            // percent: right
+            // others: left
+            
+            const coloredHeader = colorize(headerTitle, "bold", useColor);
+            let segment = "";
+            let sep = "";
+            
+            // When padding, we need to consider visible length of the colored string vs stripped
+            // But here `headerTitle` is uncolored when calculating padding, so standard pad works
+            // provided we apply color AFTER padding, OR pad properly.
+            // Actually, padStart/padEnd on the uncolored string, THEN colorize.
+            
+            let paddedTitle = "";
+            if (col === "percent") {
+                paddedTitle = headerTitle.padStart(width);
+            } else {
+                paddedTitle = headerTitle.padEnd(width);
+            }
+            segment = colorize(paddedTitle, "bold", useColor);
+            
+            // Create separator line using hyphens
+            sep = colorize("-".repeat(width), "dim", useColor);
+
+            headerSegments.push(segment);
+            separatorSegments.push(sep);
+        }
+
+        outputRows.push({ id: "header", providerName: "header", line: headerSegments.join("   ") });
+        outputRows.push({ id: "sep", providerName: "sep", line: separatorSegments.join("   ") });
+    }
+
+    // 4. Render lines
+    rows.forEach((row) => {
+        const segments: string[] = [];
+        
+        for (let i = 0; i < columns.length; i++) {
+            const col = columns[i];
+            const content = row.cells[col];
+            const width = widths[col];
+            
+            let segment = "";
+            const visibleLength = content.replace(/\x1b\[[0-9;]*m/g, "").length;
+            const padding = Math.max(0, width - visibleLength);
+
+            if (col === "percent") {
+                segment = " ".repeat(padding) + content;
+            } else {
+                segment = content + " ".repeat(padding);
+            }
+            
+            segments.push(segment);
+        }
+
+        outputRows.push({
+            id: row.quota.id,
+            providerName: row.quota.providerName,
+            line: segments.join("   "), // Use 3 spaces separator as in example
+        });
+    });
+
+    return outputRows;
+}

package/src/utils/debug.ts

@@ -0,0 +1 @@
+// Legacy helper removed. Use logger.debug directly.

package/src/utils/paths.ts

@@ -0,0 +1,41 @@
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+
+export function getDataDirectory(): string {
+    const home = homedir();
+
+    switch (platform()) {
+        case "win32":
+            return process.env.APPDATA
+                ? join(process.env.APPDATA, "opencode")
+                : join(home, "AppData", "Roaming", "opencode");
+        case "darwin":
+            return join(home, "Library", "Application Support", "opencode");
+        default:
+            return process.env.XDG_DATA_HOME
+                ? join(process.env.XDG_DATA_HOME, "opencode")
+                : join(home, ".local", "share", "opencode");
+    }
+}
+
+export function getConfigDirectory(): string {
+    const home = homedir();
+
+    switch (platform()) {
+        case "win32":
+            return process.env.APPDATA
+                ? join(process.env.APPDATA, "opencode")
+                : join(home, "AppData", "Roaming", "opencode");
+        case "darwin":
+            return join(home, "Library", "Application Support", "opencode");
+        default:
+            return process.env.XDG_CONFIG_HOME
+                ? join(process.env.XDG_CONFIG_HOME, "opencode")
+                : join(home, ".config", "opencode");
+    }
+}
+
+export const AUTH_FILE = (): string => join(getDataDirectory(), "auth.json");
+export const HISTORY_FILE = (): string => join(getDataDirectory(), "quota-history.json");
+export const DEBUG_LOG_FILE = (): string => join(getDataDirectory(), "quotas-debug.log");
+export const ANTIGRAVITY_ACCOUNTS_FILE = (): string => join(getConfigDirectory(), "antigravity-accounts.json");

package/src/utils/time.ts

@@ -0,0 +1,40 @@
+export function formatRelativeTime(targetDate: Date): string {
+  const now = new Date();
+  const diffMs = targetDate.getTime() - now.getTime();
+  if (diffMs <= 0) return "now";
+
+  const diffMins = Math.floor(diffMs / (1000 * 60));
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  const remainingHours = diffHours % 24;
+  const remainingMins = diffMins % 60;
+
+  if (diffDays > 0) {
+    return `${diffDays}d ${remainingHours}h`;
+  }
+  if (diffHours > 0) {
+    return `${diffHours}h ${remainingMins}m`;
+  }
+  return `${diffMins}m`;
+}
+
+export function formatDurationMs(ms: number): string {
+    if (ms <= 0) return "now";
+    
+    const diffMins = Math.floor(ms / (1000 * 60));
+    const diffHours = Math.floor(diffMins / 60);
+    const diffDays = Math.floor(diffHours / 24);
+    const remainingHours = diffHours % 24;
+    const remainingMins = diffMins % 60;
+
+    if (diffDays > 0) {
+        return `${diffDays}d ${remainingHours}h`;
+    }
+    if (diffHours > 0) {
+        return `${diffHours}h ${remainingMins}m`;
+    }
+    if (diffMins > 0) {
+        return `${diffMins}m`;
+    }
+    return "less than 1m";
+}

package/src/utils/validation.ts

@@ -0,0 +1,63 @@
+import { type QuotaData } from "../interfaces";
+
+export function isValidNumber(v: unknown): v is number {
+    return typeof v === "number" && Number.isFinite(v);
+}
+
+export function clamp(value: number, min: number, max?: number): number {
+    if (!Number.isFinite(value)) return min;
+    if (value < min) return min;
+    if (max !== undefined && value > max) return max;
+    return value;
+}
+
+export function validatePollingInterval(v: unknown): number | null {
+    if (v === null || v === undefined) return null;
+    const n = typeof v === "string" ? Number(v.trim()) : Number(v);
+    if (!Number.isFinite(n) || n <= 0) return null;
+    return n;
+}
+
+export function validateQuotaData(input: unknown): QuotaData | null {
+    if (typeof input !== "object" || input === null) return null;
+    const q = input as Partial<QuotaData>;
+
+    if (!q.id || typeof q.id !== "string") return null;
+    if (!q.providerName || typeof q.providerName !== "string") return null;
+
+    let used = Number(q.used ?? 0);
+    if (!Number.isFinite(used)) used = 0;
+    if (used < 0) used = 0;
+
+    let limit: number | null = null;
+    if (q.limit === null) {
+        limit = null;
+    } else if (q.limit !== undefined) {
+        const n = Number(q.limit);
+        if (Number.isFinite(n) && n > 0) {
+            limit = n;
+        } else {
+            limit = null;
+        }
+    }
+
+    const unit = typeof q.unit === "string" ? q.unit : "";
+    const reset = typeof q.reset === "string" ? q.reset : undefined;
+    const predictedReset = typeof q.predictedReset === "string" ? q.predictedReset : undefined;
+    const window = typeof q.window === "string" ? q.window : undefined;
+    const info = typeof q.info === "string" ? q.info : undefined;
+    const details = typeof q.details === "string" ? q.details : undefined;
+
+    return {
+        id: q.id,
+        providerName: q.providerName,
+        used,
+        limit,
+        unit,
+        reset,
+        predictedReset,
+        window,
+        info,
+        details,
+    };
+}