opencode-gemini-auth 1.4.0 → 1.4.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-gemini-auth",
   "module": "index.ts",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "author": "jenslys",
   "repository": "https://github.com/jenslys/opencode-gemini-auth",
   "files": [

package/src/plugin/quota.test.ts

@@ -34,10 +34,10 @@ describe("formatGeminiQuotaOutput", () => {
     Date.now = REAL_DATE_NOW;
   });
 
-  it("renders sorted, model-specific usage lines", () => {
+  it("renders grouped progress bars, groups by version, and hides token type when all are REQUESTS", () => {
     const buckets: RetrieveUserQuotaBucket[] = [
       {
-        modelId: "gemini-2.5-pro",
+        modelId: "gemini-2.5-pro_vertex",
         tokenType: "requests",
         remainingFraction: 0.5,
         remainingAmount: "100",
@@ -47,16 +47,75 @@ describe("formatGeminiQuotaOutput", () => {
         modelId: "gemini-2.5-flash",
         remainingAmount: "20",
       },
+      {
+        modelId: "gemini-2.5-pro",
+        tokenType: "requests",
+        remainingFraction: 0.7,
+        remainingAmount: "140",
+        resetTime: new Date(FIXED_NOW + 2 * 60 * 60 * 1000).toISOString(),
+      },
+      {
+        modelId: "gemini-3-pro-preview",
+        tokenType: "requests",
+        remainingFraction: 0.95,
+      },
+      {
+        modelId: "gemini-2.0-flash",
+        tokenType: "requests",
+        remainingFraction: 0.8,
+      },
     ];
 
     const output = formatGeminiQuotaOutput("test-project", buckets);
     expect(output).toContain("Gemini quota usage for project `test-project`");
-    expect(output).toContain("- gemini-2.5-flash: 20 remaining");
+    expect(output).toContain("Variant");
+    expect(output).toContain("Remaining");
+    expect(output).toContain("Reset");
+    expect(output).not.toContain("Type");
+    expect(output).toContain("gemini-2.5-flash\n  ↳ default");
+    expect(output).toContain("gemini-2.5-pro\n  ↳ default");
+    expect(output).toContain("  ↳ vertex");
+    expect(output).toContain("Gemini 3 (1 model, 1 bucket)");
+    expect(output).toContain("Gemini 2.5 (2 models, 3 buckets)");
+    expect(output).toContain("Gemini 2.0 (1 model, 1 bucket)");
+    expect(output).toContain("▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░ 70.0% (140 left)");
     expect(output).toContain(
-      "- gemini-2.5-pro (requests): 50.0% remaining (100 left), resets in 1h",
+      "▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░ 50.0% (100 left)",
+    );
+    expect(output.indexOf("Gemini 3 (1 model, 1 bucket)")).toBeLessThan(
+      output.indexOf("Gemini 2.5 (2 models, 3 buckets)"),
+    );
+    expect(output.indexOf("Gemini 2.5 (2 models, 3 buckets)")).toBeLessThan(
+      output.indexOf("Gemini 2.0 (1 model, 1 bucket)"),
+    );
+    expect(output).toContain("\n\nGemini 2.5 (2 models, 3 buckets)");
+    expect(output.indexOf("gemini-2.0-flash")).toBeGreaterThan(
+      output.indexOf("gemini-2.5-pro"),
     );
     expect(output.indexOf("gemini-2.5-flash")).toBeLessThan(
       output.indexOf("gemini-2.5-pro"),
     );
   });
+
+  it("shows token type column when multiple token types are present", () => {
+    const buckets: RetrieveUserQuotaBucket[] = [
+      {
+        modelId: "gemini-2.5-pro_vertex",
+        tokenType: "REQUESTS",
+        remainingFraction: 0.9,
+      },
+      {
+        modelId: "gemini-2.5-pro",
+        tokenType: "TOKENS",
+        remainingFraction: 0.8,
+      },
+    ];
+
+    const output = formatGeminiQuotaOutput("test-project", buckets);
+    expect(output).toContain("Type");
+    expect(output).toContain("Gemini 2.5 (1 model, 2 buckets)");
+    expect(output).toContain("REQUESTS");
+    expect(output).toContain("TOKENS");
+    expect(output).toContain("  ↳ vertex");
+  });
 });

package/src/plugin/quota.ts

@@ -82,10 +82,45 @@ export function formatGeminiQuotaOutput(
   buckets: RetrieveUserQuotaBucket[],
 ): string {
   const sortedBuckets = [...buckets].sort(compareQuotaBuckets);
-  const lines = [`Gemini quota usage for project \`${projectId}\``, ""];
+  const groupedRows = groupQuotaRows(sortedBuckets);
+  const versionGroups = groupByVersion(groupedRows);
+  const variantWidth = Math.max(
+    "Variant".length,
+    ...versionGroups.flatMap((group) =>
+      group.models.flatMap((model) => model.rows.map((row) => row.variant.length))
+    ),
+  );
+  const tokenTypeValues = [...new Set(versionGroups.flatMap((group) =>
+    group.models.flatMap((model) => model.rows.map((row) => row.tokenType))
+  ))];
+  const showTokenType = tokenTypeValues.length > 1 || tokenTypeValues[0] !== "REQUESTS";
+  const lines = [
+    `Gemini quota usage for project \`${projectId}\``,
+    "",
+    showTokenType
+      ? `  ↳ ${pad("Variant", variantWidth)}  Remaining                   Reset      Type`
+      : `  ↳ ${pad("Variant", variantWidth)}  Remaining                   Reset`,
+  ];
 
-  for (const bucket of sortedBuckets) {
-    lines.push(formatQuotaBucketLine(bucket));
+  for (let index = 0; index < versionGroups.length; index += 1) {
+    const versionGroup = versionGroups[index];
+    if (!versionGroup) {
+      continue;
+    }
+    if (index > 0) {
+      lines.push("");
+    }
+    lines.push(formatVersionGroupTitle(versionGroup));
+    for (const model of versionGroup.models) {
+      lines.push(model.baseModel);
+      for (const row of model.rows) {
+        lines.push(
+          showTokenType
+            ? `  ↳ ${pad(row.variant, variantWidth)}  ${pad(row.usageRemaining, 27)} ${pad(row.resetValue, 8)} ${row.tokenType}`
+            : `  ↳ ${pad(row.variant, variantWidth)}  ${pad(row.usageRemaining, 27)} ${row.resetValue}`,
+        );
+      }
+    }
   }
 
   return lines.join("\n");
@@ -110,18 +145,6 @@ function compareQuotaBuckets(
   return (left.resetTime ?? "").localeCompare(right.resetTime ?? "");
 }
 
-function formatQuotaBucketLine(bucket: RetrieveUserQuotaBucket): string {
-  const modelId = bucket.modelId?.trim() || "unknown-model";
-  const tokenType = bucket.tokenType?.trim();
-  const usageRemaining = formatUsageRemaining(bucket);
-  const resetLabel = formatRelativeResetTime(bucket.resetTime);
-  const subject = tokenType ? `${modelId} (${tokenType})` : modelId;
-
-  return resetLabel
-    ? `- ${subject}: ${usageRemaining}, ${resetLabel}`
-    : `- ${subject}: ${usageRemaining}`;
-}
-
 function formatUsageRemaining(bucket: RetrieveUserQuotaBucket): string {
   const remainingAmount = formatRemainingAmount(bucket.remainingAmount);
   const remainingFraction = bucket.remainingFraction;
@@ -129,17 +152,19 @@ function formatUsageRemaining(bucket: RetrieveUserQuotaBucket): string {
     typeof remainingFraction === "number" && Number.isFinite(remainingFraction);
 
   if (hasFraction) {
-    const percent = Math.max(0, remainingFraction * 100).toFixed(1);
+    const clamped = clamp(remainingFraction, 0, 1);
+    const percent = (clamped * 100).toFixed(1);
+    const bar = buildProgressBar(clamped);
     return remainingAmount
-      ? `${percent}% remaining (${remainingAmount} left)`
-      : `${percent}% remaining`;
+      ? `${bar} ${percent}% (${remainingAmount} left)`
+      : `${bar} ${percent}%`;
   }
 
   if (remainingAmount) {
-    return `${remainingAmount} remaining`;
+    return remainingAmount;
   }
 
-  return "remaining unknown";
+  return "unknown";
 }
 
 function formatRemainingAmount(value: string | undefined): string | undefined {
@@ -180,3 +205,178 @@ export function formatRelativeResetTime(resetTime: string | undefined): string |
   }
   return `resets in ${minutes}m`;
 }
+
+function buildProgressBar(fraction: number, width = 20): string {
+  const clamped = clamp(fraction, 0, 1);
+  const filled = clamped >= 1
+    ? width
+    : Math.max(0, Math.min(width, Math.max(clamped > 0 ? 1 : 0, Math.floor(clamped * width))));
+  const empty = width - filled;
+  return `${"▓".repeat(filled)}${"░".repeat(empty)}`;
+}
+
+function pad(value: string, width: number): string {
+  if (value.length >= width) {
+    return value;
+  }
+  return value.padEnd(width, " ");
+}
+
+function clamp(value: number, min: number, max: number): number {
+  if (value < min) {
+    return min;
+  }
+  if (value > max) {
+    return max;
+  }
+  return value;
+}
+
+function normalizeTokenType(bucket: RetrieveUserQuotaBucket): string {
+  const value = bucket.tokenType?.trim();
+  return value ? value.toUpperCase() : "REQUESTS";
+}
+
+interface GroupedQuotaRow {
+  variant: string;
+  usageRemaining: string;
+  resetValue: string;
+  tokenType: string;
+}
+
+interface GroupedQuotaModel {
+  baseModel: string;
+  version: string | undefined;
+  rows: GroupedQuotaRow[];
+}
+
+function groupQuotaRows(sortedBuckets: RetrieveUserQuotaBucket[]): GroupedQuotaModel[] {
+  const groups = new Map<string, GroupedQuotaModel>();
+
+  for (const bucket of sortedBuckets) {
+    const modelId = bucket.modelId?.trim() || "unknown-model";
+    const { baseModel, variant } = splitModelVariant(modelId);
+    const usageRemaining = formatUsageRemaining(bucket);
+    const resetLabel = formatRelativeResetTime(bucket.resetTime);
+    const resetValue = resetLabel?.replace("resets in ", "") ?? "-";
+    const tokenType = normalizeTokenType(bucket);
+
+    const existing = groups.get(baseModel);
+    if (existing) {
+      existing.rows.push({
+        variant,
+        usageRemaining,
+        resetValue,
+        tokenType,
+      });
+      continue;
+    }
+
+    groups.set(baseModel, {
+      baseModel,
+      version: extractModelVersion(baseModel),
+      rows: [{
+        variant,
+        usageRemaining,
+        resetValue,
+        tokenType,
+      }],
+    });
+  }
+
+  return [...groups.values()];
+}
+
+interface VersionQuotaGroup {
+  title: string;
+  version: string | undefined;
+  models: GroupedQuotaModel[];
+}
+
+function groupByVersion(models: GroupedQuotaModel[]): VersionQuotaGroup[] {
+  const groups = new Map<string, VersionQuotaGroup>();
+
+  for (const model of models) {
+    const key = model.version ?? "__unknown__";
+    const existing = groups.get(key);
+    if (existing) {
+      existing.models.push(model);
+      continue;
+    }
+
+    groups.set(key, {
+      title: model.version ? `Gemini ${model.version}` : "Other",
+      version: model.version,
+      models: [model],
+    });
+  }
+
+  const ordered = [...groups.values()].sort((left, right) =>
+    compareVersionDesc(left.version, right.version),
+  );
+
+  for (const group of ordered) {
+    group.models.sort((left, right) => left.baseModel.localeCompare(right.baseModel));
+  }
+
+  return ordered;
+}
+
+function extractModelVersion(modelId: string): string | undefined {
+  const match = modelId.match(/^gemini-([0-9]+(?:\.[0-9]+)*)-/i);
+  return match?.[1];
+}
+
+function compareVersionDesc(left: string | undefined, right: string | undefined): number {
+  if (!left && !right) {
+    return 0;
+  }
+  if (!left) {
+    return 1;
+  }
+  if (!right) {
+    return -1;
+  }
+
+  const leftSegments = left.split(".").map((part) => Number.parseInt(part, 10));
+  const rightSegments = right.split(".").map((part) => Number.parseInt(part, 10));
+  const max = Math.max(leftSegments.length, rightSegments.length);
+
+  for (let index = 0; index < max; index += 1) {
+    const l = leftSegments[index] ?? 0;
+    const r = rightSegments[index] ?? 0;
+    if (Number.isNaN(l) || Number.isNaN(r)) {
+      break;
+    }
+    if (l > r) {
+      return -1;
+    }
+    if (l < r) {
+      return 1;
+    }
+  }
+
+  return right.localeCompare(left);
+}
+
+function formatVersionGroupTitle(group: VersionQuotaGroup): string {
+  const modelCount = group.models.length;
+  const bucketCount = group.models.reduce((count, model) => count + model.rows.length, 0);
+  const modelLabel = modelCount === 1 ? "model" : "models";
+  const bucketLabel = bucketCount === 1 ? "bucket" : "buckets";
+  return `${group.title} (${modelCount} ${modelLabel}, ${bucketCount} ${bucketLabel})`;
+}
+
+function splitModelVariant(modelId: string): { baseModel: string; variant: string } {
+  const vertexSuffix = "_vertex";
+  if (modelId.endsWith(vertexSuffix)) {
+    return {
+      baseModel: modelId.slice(0, -vertexSuffix.length),
+      variant: "vertex",
+    };
+  }
+  return {
+    baseModel: modelId,
+    variant: "default",
+  };
+}