@wayner6/pi-usage 0.1.0

package/src/modules/provider/matching.ts

@@ -0,0 +1,228 @@
+import type { Metric, ProviderTarget, UsageAdapter } from "../../core/types.ts";
+import type { UsageConfig } from "../../core/config.ts";
+
+export function chooseAdapter(target: ProviderTarget, adapters: UsageAdapter[], config: UsageConfig): UsageAdapter | undefined {
+  const override = config.providerOverrides[target.providerId];
+  if (override === "disabled") return undefined;
+  if (override) return adapters.find((adapter) => adapter.id === override);
+  return adapters.find((adapter) => adapter.canHandle(target));
+}
+
+export function wildcardMatch(value: string, pattern: string): boolean {
+  const escaped = pattern.replace(/[.+?^${}()|[\\]\\\\]/g, "\\$&").replace(/\\*/g, ".*");
+  return new RegExp(`^${escaped}$`, "i").test(value);
+}
+
+export interface MatchedQuotaItem {
+  label: string;
+  remainingFraction: number;
+  resetAt?: string;
+}
+
+export interface MatchedGroupQuota {
+  label: string;
+  remainingFraction: number;
+  resetAt?: string;
+  matchedModelId?: string;
+  accountProvider?: string;
+  /**
+   * If the model specifically matches multiple distinct time windows (e.g. 5h and 7d windows for Codex),
+   * they are gathered here.
+   */
+  multiWindows?: MatchedQuotaItem[];
+}
+
+export function tokenizeModelId(id: string): string[] {
+  return id
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean);
+}
+
+export function friendlyGroupName(
+  group: { id?: string; label?: string },
+  modelId?: string,
+  accountProvider?: string,
+): string {
+  const mTokens = tokenizeModelId(modelId ?? "");
+  const gTokens = tokenizeModelId(`${group.id ?? ""} ${group.label ?? ""}`);
+  const prov = (accountProvider ?? "").toLowerCase();
+
+  const isGemini = mTokens.includes("gemini") || gTokens.includes("gemini") || prov.includes("google") || prov.includes("gemini");
+  const isClaude = mTokens.includes("claude") || gTokens.includes("claude") || prov.includes("anthropic");
+  const isCodex = mTokens.includes("codex") || gTokens.includes("codex") || prov.includes("codex") || gTokens.includes("5h") || gTokens.includes("7d");
+  const isGpt = mTokens.includes("gpt") || mTokens.includes("openai") || prov.includes("openai");
+
+  if (isGemini) {
+    if (gTokens.includes("flash") || mTokens.includes("flash")) return "Gemini Flash";
+    if (gTokens.includes("pro") || mTokens.includes("pro")) return "Gemini Pro";
+    return "Gemini";
+  }
+
+  if (isClaude) {
+    if (gTokens.includes("opus") || (gTokens.includes("thinking") && !gTokens.includes("flash"))) return "Claude Opus";
+    if (gTokens.includes("sonnet") || gTokens.includes("other")) return "Claude Sonnet";
+    if (gTokens.includes("haiku")) return "Claude Haiku";
+    return "Claude";
+  }
+
+  if (isCodex || (isGpt && (gTokens.includes("5h") || gTokens.includes("primary") || gTokens.includes("7d") || gTokens.includes("secondary")))) {
+    if (gTokens.includes("5h") || gTokens.includes("primary")) return "Codex 5h";
+    if (gTokens.includes("7d") || gTokens.includes("secondary") || gTokens.includes("1w")) return "Codex 7d";
+    return "Codex";
+  }
+
+  if (mTokens.includes("deepseek") || gTokens.includes("deepseek")) return "DeepSeek";
+  if (mTokens.includes("kimi") || mTokens.includes("moonshot") || gTokens.includes("kimi")) return "Kimi";
+  if (mTokens.includes("grok") || mTokens.includes("xai") || gTokens.includes("grok")) return "Grok";
+
+  return group.label || group.id || "Quota";
+}
+
+export type RawBridgeGroup = {
+  id?: string;
+  label?: string;
+  remainingFraction?: number;
+  resetTime?: string;
+  models?: Array<{ id?: string; displayName?: string; remainingFraction?: number; resetTime?: string }>;
+};
+
+export type RawBridgeAccount = {
+  provider?: string;
+  label?: string;
+  disabled?: boolean;
+  unavailable?: boolean;
+  rawGroups?: unknown;
+};
+
+export function matchModelAcrossAccounts(
+  accounts: RawBridgeAccount[],
+  activeModelId?: string,
+): { account: RawBridgeAccount; quota: MatchedGroupQuota } | undefined {
+  if (!accounts.length) return undefined;
+  const targetId = (activeModelId ?? "").trim().toLowerCase();
+  const targetTokens = tokenizeModelId(targetId);
+
+  interface Candidate {
+    account: RawBridgeAccount;
+    group: RawBridgeGroup;
+    score: number;
+    matchedModelId?: string | undefined;
+    isTimeWindow?: boolean;
+  }
+
+  const candidates: Candidate[] = [];
+
+  for (const account of accounts) {
+    if (account.disabled || account.unavailable) continue;
+    const groups = Array.isArray(account.rawGroups) ? (account.rawGroups as RawBridgeGroup[]) : [];
+    for (const group of groups) {
+      if (typeof group.remainingFraction !== "number") continue;
+
+      const groupModels = group.models ?? [];
+      let bestScore = 0;
+      let matchedModelId: string | undefined;
+
+      for (const m of groupModels) {
+        const mid = (m.id ?? "").trim().toLowerCase();
+        if (!mid) continue;
+
+        if (mid === targetId) {
+          bestScore = Math.max(bestScore, 100);
+          matchedModelId = mid;
+          break;
+        }
+
+        if (targetId.includes(mid) || mid.includes(targetId)) {
+          const score = 80 + Math.min(10, Math.floor((Math.min(mid.length, targetId.length) / Math.max(mid.length, targetId.length)) * 10));
+          if (score > bestScore) {
+            bestScore = score;
+            matchedModelId = mid;
+          }
+        }
+
+        const mTokens = tokenizeModelId(mid);
+        const overlap = mTokens.filter((t) => targetTokens.includes(t));
+        if (overlap.length >= 2) {
+          const score = 50 + overlap.length * 10;
+          if (score > bestScore) {
+            bestScore = score;
+            matchedModelId = mid;
+          }
+        }
+      }
+
+      const gTokens = tokenizeModelId(`${group.id ?? ""} ${group.label ?? ""}`);
+      const isTimeWindow = gTokens.includes("5h") || gTokens.includes("primary") || gTokens.includes("7d") || gTokens.includes("secondary");
+
+      if (bestScore < 60) {
+        const groupOverlap = gTokens.filter((t) => targetTokens.includes(t));
+        const provTokens = tokenizeModelId(account.provider ?? "");
+        const provOverlap = provTokens.filter((t) => targetTokens.includes(t));
+
+        if (groupOverlap.length > 0 || provOverlap.length > 0) {
+          const score = 25 + groupOverlap.length * 15 + provOverlap.length * 15;
+          if (score > bestScore) {
+            bestScore = score;
+          }
+        }
+      }
+
+      if (bestScore > 0) {
+        candidates.push({
+          account,
+          group,
+          score: bestScore,
+          isTimeWindow,
+          ...(matchedModelId ? { matchedModelId } : {}),
+        });
+      }
+    }
+  }
+
+  candidates.sort((a, b) => b.score - a.score);
+
+  const winner = candidates[0];
+  if (winner && winner.score >= 25) {
+    const matchedAccount = winner.account;
+
+    // Check if this matched account specifically has multiple time-window quotas (like 5h and 7d for Codex)
+    const groups = Array.isArray(matchedAccount.rawGroups) ? (matchedAccount.rawGroups as RawBridgeGroup[]) : [];
+    const timeWindowGroups = groups.filter((g) => {
+      if (typeof g.remainingFraction !== "number") return false;
+      const gTokens = tokenizeModelId(`${g.id ?? ""} ${g.label ?? ""}`);
+      return gTokens.includes("5h") || gTokens.includes("primary") || gTokens.includes("7d") || gTokens.includes("secondary");
+    });
+
+    let multiWindows: MatchedQuotaItem[] | undefined;
+    if (winner.isTimeWindow && timeWindowGroups.length > 1) {
+      multiWindows = timeWindowGroups.map((g) => ({
+        label: friendlyGroupName(g, activeModelId, matchedAccount.provider),
+        remainingFraction: g.remainingFraction!,
+        ...(g.resetTime ? { resetAt: g.resetTime } : {}),
+      }));
+    }
+
+    return {
+      account: matchedAccount,
+      quota: {
+        label: friendlyGroupName(winner.group, activeModelId, winner.account.provider),
+        remainingFraction: winner.group.remainingFraction!,
+        ...(winner.group.resetTime ? { resetAt: winner.group.resetTime } : {}),
+        ...(winner.matchedModelId ? { matchedModelId: winner.matchedModelId } : {}),
+        ...(winner.account.provider ? { accountProvider: winner.account.provider } : {}),
+        ...(multiWindows ? { multiWindows } : {}),
+      },
+    };
+  }
+
+  return undefined;
+}
+
+export function matchModelGroup(
+  groups: RawBridgeGroup[],
+  modelId?: string,
+): MatchedGroupQuota | undefined {
+  const res = matchModelAcrossAccounts([{ rawGroups: groups }], modelId);
+  return res?.quota;
+}

package/src/settings.ts

@@ -0,0 +1,23 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { UsageConfig } from "./core/config.ts";
+import { configPath, saveConfig } from "./core/config.ts";
+
+export async function handleSettings(args: string, ctx: ExtensionCommandContext, config: UsageConfig): Promise<UsageConfig> {
+  const [key, value] = args.trim().split(/\s+/);
+  const next = structuredClone(config);
+  if (!key) {
+    ctx.ui.notify(`Config: ${configPath()}\nstatus=${next.display.status} widget=${next.display.widget} interval=${next.refresh.intervalSeconds}s timeout=${next.refresh.timeoutSeconds}s`, "info");
+    return next;
+  }
+  if (key === "widget" && /^(on|off)$/.test(value ?? "")) next.display.widget = value === "on";
+  else if (key === "status" && /^(on|off)$/.test(value ?? "")) next.display.status = value === "on";
+  else if (key === "interval" && Number.isFinite(Number(value))) next.refresh.intervalSeconds = Math.min(3600, Math.max(30, Number(value)));
+  else if (key === "timeout" && Number.isFinite(Number(value))) next.refresh.timeoutSeconds = Math.min(60, Math.max(2, Number(value)));
+  else {
+    ctx.ui.notify("Usage: /usage settings [widget|status] [on|off], or interval/timeout <seconds>", "warning");
+    return config;
+  }
+  await saveConfig(next);
+  ctx.ui.notify(`Pi Usage settings saved to ${configPath()}`, "info");
+  return next;
+}

package/src/ui/details.ts

@@ -0,0 +1,26 @@
+import { DynamicBorder } from "@earendil-works/pi-coding-agent";
+import { Container, Key, Text, matchesKey } from "@earendil-works/pi-tui";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { UsageSnapshot } from "../core/types.ts";
+import { snapshotLines } from "./format.ts";
+
+export async function showDetails(ctx: ExtensionCommandContext, snapshots: UsageSnapshot[]): Promise<void> {
+  const lines = snapshots.length ? snapshots.flatMap((snapshot, index) => [...(index ? [""] : []), ...snapshotLines(snapshot)]) : ["No usage data available."];
+  if (ctx.mode !== "tui") {
+    ctx.ui.notify(lines.join("\n"), snapshots.some((item) => item.state === "ok" || item.state === "stale") ? "info" : "warning");
+    return;
+  }
+  await ctx.ui.custom<void>((_tui, theme, _keybindings, done) => {
+    const container = new Container();
+    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+    container.addChild(new Text(theme.fg("accent", theme.bold("Pi Usage · Provider Usage")), 1, 0));
+    container.addChild(new Text(lines.map((line) => line.startsWith("    ") ? theme.fg("dim", line) : line).join("\n"), 1, 1));
+    container.addChild(new Text(theme.fg("dim", "Enter/Esc close"), 1, 0));
+    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+    return {
+      render: (width: number) => container.render(width),
+      invalidate: () => container.invalidate(),
+      handleInput: (data: string) => { if (matchesKey(data, Key.enter) || matchesKey(data, Key.escape)) done(); },
+    };
+  });
+}

package/src/ui/format.ts

@@ -0,0 +1,62 @@
+import type { Metric, UsageSnapshot } from "../core/types.ts";
+
+export function percentBar(value: number, width = 10): string {
+  const count = Math.round(Math.min(1, Math.max(0, value)) * width);
+  return `${"━".repeat(count)}${"─".repeat(width - count)}`;
+}
+
+export function relativeTime(value?: string): string | undefined {
+  if (!value) return undefined;
+  const delta = new Date(value).getTime() - Date.now();
+  if (!Number.isFinite(delta)) return undefined;
+  if (delta <= 0) return "reset due";
+  const minutes = Math.ceil(delta / 60000);
+  if (minutes < 60) return `resets in ${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const mins = minutes % 60;
+  if (hours < 48) return `resets in ${hours}h${mins ? ` ${mins}m` : ""}`;
+  return `resets in ${Math.floor(hours / 24)}d ${hours % 24}h`;
+}
+
+export function metricText(metric: Metric): string {
+  switch (metric.kind) {
+    case "balance": {
+      const symbol = metric.currency === "CNY" || metric.currency === "RMB" ? "¥" : metric.currency === "USD" ? "$" : `${metric.currency} `;
+      return `${metric.label}: ${symbol}${metric.amount.toFixed(2)}${metric.detail ? ` · ${metric.detail}` : ""}`;
+    }
+    case "quota-window": return `${metric.label} ${percentBar(metric.remainingFraction)} ${Math.round(metric.remainingFraction * 100)}% left${relativeTime(metric.resetAt) ? ` · ${relativeTime(metric.resetAt)}` : ""}`;
+    case "credits": return `${metric.label}: ${metric.remaining} ${metric.unit}`;
+    case "usage-limit": return `${metric.label}: ${metric.used}/${metric.limit} ${metric.unit}`;
+    case "rate-limit": return `${metric.label}: ${metric.value} ${metric.unit}`;
+    case "status": return `${metric.label}: ${metric.value}`;
+    case "custom": return `${metric.label}: ${metric.value}`;
+  }
+}
+
+export function compactSnapshot(snapshot?: UsageSnapshot): string {
+  if (!snapshot) return "Loading...";
+  if (snapshot.state !== "ok" && snapshot.state !== "stale") {
+    switch (snapshot.state) {
+      case "unauthorized": return `${snapshot.displayName} · Unauthorized`;
+      case "not-installed": return `${snapshot.displayName} · Bridge Not Found`;
+      case "unsupported": return `${snapshot.displayName} · Unsupported`;
+      case "empty": return snapshot.summary ? `${snapshot.displayName} · ${snapshot.summary}` : `${snapshot.displayName} · No Quota`;
+      default: return `${snapshot.displayName} · ${snapshot.state}`;
+    }
+  }
+  return `${snapshot.summary ?? snapshot.displayName}${snapshot.stale ? " · stale" : ""}`;
+}
+
+export function snapshotLines(snapshot: UsageSnapshot): string[] {
+  const lines = [`${snapshot.displayName} [${snapshot.state}]${snapshot.stale ? " · stale" : ""}`];
+  if (snapshot.error) lines.push(`  Error: ${snapshot.error}`);
+  if (snapshot.diagnostic) lines.push(`  ${snapshot.diagnostic}`);
+  for (const account of snapshot.accounts) {
+    const flags = [account.status, account.disabled ? "disabled" : undefined, account.unavailable ? "unavailable" : undefined].filter(Boolean).join(", ");
+    lines.push(`  ${account.provider} · ${account.label}${flags ? ` (${flags})` : ""}`);
+    if (account.error) lines.push(`    Error: ${account.error}`);
+    if (!account.metrics.length) lines.push("    No quota reported");
+    for (const metric of account.metrics) lines.push(`    ${metricText(metric)}`);
+  }
+  return lines;
+}