@robhowley/pi-openrouter 0.1.0 → 0.3.0

package/extensions/openrouter/format.ts

@@ -1,5 +1,13 @@
 import type { ActivityItem } from '@openrouter/sdk/models/index.js';
-import type { UsageSummary } from './types.js';
+import type { ModelStats, ProviderStats, TokenStats, UsageSummary } from './types.js';
+
+/** Convert a Date to YYYY-MM-DD string in local timezone (matching API format) */
+function localISODate(date: Date): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
 
 export function aggregateUsage(
   credits: { totalUsage: number; totalCredits?: number },
@@ -12,32 +20,24 @@ export function aggregateUsage(
   startOfWeek.setDate(startOfWeek.getDate() - 7);
 
   const weekData = analytics.filter((d) => {
-    const ts = new Date(d.date);
-    return ts >= startOfWeek;
+    // API dates are YYYY-MM-DD; compare by local date boundary
+    return d.date >= localISODate(startOfWeek);
   });
 
   const todayData = analytics.filter((d) => {
-    const ts = new Date(d.date);
-    return ts >= startOfDay;
+    // API dates are YYYY-MM-DD; compare by local date boundary
+    return d.date >= localISODate(startOfDay);
   });
 
   const week = sumSpend(weekData);
   const today = sumSpend(todayData);
   const month = credits.totalUsage;
 
-  // Top models by 7d spend
-  const modelSpend7d = aggregateByModel(weekData);
-  const topModels7d = Object.entries(modelSpend7d)
-    .map(([name, spend]) => ({ name, spend }))
-    .sort((a, b) => b.spend - a.spend)
-    .slice(0, 3);
-
-  // Top models by 30d spend
-  const modelSpend30d = aggregateByModel(analytics);
-  const topModels30d = Object.entries(modelSpend30d)
-    .map(([name, spend]) => ({ name, spend }))
-    .sort((a, b) => b.spend - a.spend)
-    .slice(0, 3);
+  // Build model stats for both 7d and 30d windows
+  const modelStatsMap = buildModelStats(weekData, analytics);
+  const topModels = Array.from(modelStatsMap.values())
+    .sort((a, b) => b.spend30d - a.spend30d)
+    .slice(0, 10);
 
   return {
     today,
@@ -45,12 +45,11 @@ export function aggregateUsage(
     month,
     cap: credits.totalCredits ?? 0,
     burnRate: (week / 7) * 30,
-    topModels7d,
-    topModels30d,
-    byModel: aggregateByModel(analytics),
-    byKey: aggregateByProvider(analytics),
+    topModels,
+    byProvider: buildProviderStats(analytics),
     byDay: aggregateByDay(analytics),
     timestamp,
+    hasActivityData: true, // aggregateUsage is only called when analytics data is available
   };
 }
 
@@ -58,24 +57,69 @@ function sumSpend(data: ActivityItem[]): number {
   return data.reduce((sum, d) => sum + d.usage, 0);
 }
 
-function aggregateByModel(data: ActivityItem[]): Record<string, number> {
+function aggregateTokens(data: ActivityItem[]): TokenStats {
   return data.reduce(
     (acc, d) => {
-      acc[d.model] = (acc[d.model] || 0) + d.usage;
+      acc.input += d.promptTokens || 0;
+      acc.output += d.completionTokens || 0;
+      acc.reasoning += d.reasoningTokens || 0;
+      acc.total += (d.promptTokens || 0) + (d.completionTokens || 0) + (d.reasoningTokens || 0);
       return acc;
     },
-    {} as Record<string, number>,
+    { input: 0, output: 0, reasoning: 0, total: 0 } as TokenStats,
   );
 }
 
-function aggregateByProvider(data: ActivityItem[]): Record<string, number> {
-  return data.reduce(
-    (acc, d) => {
-      acc[d.providerName] = (acc[d.providerName] || 0) + d.usage;
-      return acc;
-    },
-    {} as Record<string, number>,
-  );
+function aggregateRequests(data: ActivityItem[]): number {
+  return data.reduce((sum, d) => sum + (d.requests || 0), 0);
+}
+
+function buildModelStats(data7d: ActivityItem[], data30d: ActivityItem[]): Map<string, ModelStats> {
+  const all = new Map<string, ModelStats>();
+  const modelNames = new Set<string>();
+
+  // Collect all unique model names from both time windows
+  for (const d of data30d) modelNames.add(d.model);
+  for (const d of data7d) modelNames.add(d.model);
+
+  for (const name of modelNames) {
+    const data7dForModel = data7d.filter((d) => d.model === name);
+    const data30dForModel = data30d.filter((d) => d.model === name);
+
+    all.set(name, {
+      name,
+      spend7d: data7dForModel.reduce((s, d) => s + d.usage, 0),
+      spend30d: data30dForModel.reduce((s, d) => s + d.usage, 0),
+      tokens7d: aggregateTokens(data7dForModel),
+      tokens30d: aggregateTokens(data30dForModel),
+      requests7d: aggregateRequests(data7dForModel),
+      requests30d: aggregateRequests(data30dForModel),
+    });
+  }
+
+  return all;
+}
+
+function buildProviderStats(data: ActivityItem[]): ProviderStats[] {
+  const byName = new Map<string, ActivityItem[]>();
+
+  for (const d of data) {
+    const existing = byName.get(d.providerName) || [];
+    existing.push(d);
+    byName.set(d.providerName, existing);
+  }
+
+  const stats: ProviderStats[] = [];
+  for (const [name, items] of byName) {
+    stats.push({
+      name,
+      spend: items.reduce((s, d) => s + d.usage, 0),
+      tokens: aggregateTokens(items),
+      requests: aggregateRequests(items),
+    });
+  }
+
+  return stats.sort((a, b) => b.spend - a.spend);
 }
 
 function aggregateByDay(data: ActivityItem[]): Record<string, number> {

package/extensions/openrouter/index.ts

@@ -10,8 +10,6 @@ import { AuthError } from './client.js';
 import { UsageOverlayComponent } from './overlay.js';
 
 export default function (pi: ExtensionAPI) {
-  startBackgroundRefresh();
-
   pi.on('session_start', async (_event, ctx) => {
     ctx.ui.notify('OpenRouter extension loaded', 'info');
   });
@@ -24,6 +22,7 @@ export default function (pi: ExtensionAPI) {
     description: 'Show OpenRouter usage: caps, spend, burn rate, and model breakdowns',
     getArgumentCompletions: () => null,
     handler: async (args, ctx) => {
+      startBackgroundRefresh(); // Start cache refresh on first use
       const subcommand = args.trim() || undefined;
       await showUsageOverlay(ctx, subcommand);
     },
@@ -47,9 +46,14 @@ async function showUsageOverlay(ctx: ExtensionContext, _subcommand?: string) {
 
   try {
     summary = await fetchAndAggregate();
-    usageCache.set('usage', summary);
+    if (!summary) {
+      error =
+        'OpenRouter API key not found. Set OPENROUTER_MANAGEMENT_KEY (preferred) or OPENROUTER_API_KEY to use /usage.';
+    } else {
+      usageCache.set('usage', summary);
+    }
 
-    await showOverlay(ctx, summary, null, 0);
+    await showOverlay(ctx, summary, error, 0);
   } catch (error_) {
     const err = error_ as Error;
     error =
@@ -89,6 +93,11 @@ async function showOverlay(
         },
       };
     },
-    { overlay: true },
+    {
+      overlay: true,
+      overlayOptions: {
+        width: 100,
+      },
+    },
   );
 }