@robhowley/pi-openrouter 0.1.0 → 0.3.1

package/extensions/openrouter/__tests__/format.test.ts

@@ -1,8 +1,44 @@
 import { describe, it, expect } from 'vitest';
 import { aggregateUsage } from '../format.js';
+import { renderSpendSparkline } from '../chart.js';
 import type { ActivityItem } from '@openrouter/sdk/models/index.js';
 
 describe('aggregateUsage', () => {
+  it('should correctly aggregate today spend regardless of timezone', () => {
+    const credits = {
+      totalUsage: 10,
+      totalCredits: 100,
+    };
+
+    // Get today's date in YYYY-MM-DD format using LOCAL date
+    // This matches how the API returns dates (YYYY-MM-DD without timezone)
+    const now = new Date();
+    const todayStr = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
+
+    const analytics: ActivityItem[] = [
+      {
+        date: todayStr,
+        model: 'gpt-4',
+        modelPermaslug: 'gpt-4-perma',
+        endpointId: 'ep-1',
+        usage: 6.55,
+        byokUsageInference: 0,
+        requests: 10,
+        promptTokens: 1000,
+        completionTokens: 100,
+        reasoningTokens: 0,
+        providerName: 'openai',
+      },
+    ];
+
+    const result = aggregateUsage(credits, analytics);
+
+    // Today should include data from todayStr (date strings compared directly)
+    // This was previously a bug where dates were parsed as UTC timestamps
+    // causing timezone-related filtering errors
+    expect(result.today).toBe(6.55);
+  });
+
   it('should calculate from analytics', () => {
     const credits = {
       totalUsage: 38.42,
@@ -73,9 +109,8 @@ describe('aggregateUsage', () => {
     expect(result.month).toBe(18.21);
     expect(result.week).toBe(0);
     expect(result.today).toBe(0);
-    expect(result.topModels7d).toEqual([]);
-    expect(result.byModel).toEqual({});
-    expect(result.byKey).toEqual({});
+    expect(result.topModels).toEqual([]);
+    expect(result.byProvider).toEqual([]);
     expect(result.byDay).toEqual({});
   });
 
@@ -85,7 +120,7 @@ describe('aggregateUsage', () => {
       totalCredits: 100,
     };
     // Use a fixed date that's definitely in the past
-    const date = '2026-05-03';
+    const date = '2026-05-04';
     const analytics: ActivityItem[] = [
       {
         date: date,
@@ -117,102 +152,175 @@ describe('aggregateUsage', () => {
 
     const result = aggregateUsage(credits, analytics);
 
-    expect(result.byModel).toEqual({
-      'gpt-4': 5.0,
-      'claude-3': 3.0,
-    });
-    expect(result.topModels7d).toHaveLength(2);
-    const first = result.topModels7d[0]!;
-    expect(first.name).toBe('gpt-4');
-    expect(first.spend).toBe(5.0);
+    // topModels should be populated with model stats
+    expect(result.topModels).toHaveLength(2);
+    expect(result.topModels[0]?.name).toBe('gpt-4');
+    expect(result.topModels[0]?.spend30d).toBe(5.0);
+    expect(result.topModels[0]?.tokens7d.total).toBe(150); // 100 + 50
+    expect(result.topModels[0]?.tokens30d.total).toBe(150);
+    expect(result.topModels[0]?.requests7d).toBe(5);
+    expect(result.topModels[0]?.requests30d).toBe(5);
+    expect(result.topModels[1]?.name).toBe('claude-3');
+    expect(result.topModels[1]?.spend30d).toBe(3.0);
+    expect(result.topModels[1]?.tokens7d.total).toBe(90); // 60 + 30
+    expect(result.topModels[1]?.tokens30d.total).toBe(90);
   });
 
-  it('should aggregate by provider name (not endpoint ID)', () => {
+  it('should include 30d model data', () => {
     const credits = {
-      totalUsage: 10,
-      totalCredits: 100,
+      totalUsage: 100,
+      totalCredits: 200,
     };
-    const date = '2026-05-01';
+    // Data from recent dates for 30d
     const analytics: ActivityItem[] = [
       {
-        date: date,
+        date: '2026-04-15',
         model: 'gpt-4',
         modelPermaslug: 'gpt-4-perma',
         endpointId: 'ep-1',
-        usage: 5.0,
+        usage: 50.0,
         byokUsageInference: 0,
-        requests: 5,
-        promptTokens: 100,
-        completionTokens: 50,
+        requests: 10,
+        promptTokens: 1000,
+        completionTokens: 100,
         reasoningTokens: 0,
         providerName: 'openai',
       },
       {
-        date: date,
+        date: '2026-04-20',
         model: 'claude-3',
         modelPermaslug: 'claude-3-perma',
         endpointId: 'ep-2',
-        usage: 3.0,
+        usage: 30.0,
         byokUsageInference: 0,
-        requests: 3,
-        promptTokens: 60,
-        completionTokens: 30,
+        requests: 5,
+        promptTokens: 500,
+        completionTokens: 50,
         reasoningTokens: 0,
-        providerName: 'openai', // Same provider, different endpoint
+        providerName: 'anthropic',
       },
     ];
 
     const result = aggregateUsage(credits, analytics);
 
-    // byKey should use providerName, not endpointId
-    expect(result.byKey).toEqual({
-      openai: 8.0, // Total from both endpoints
-    });
-    // Should NOT contain endpoint IDs
-    expect(result.byKey).not.toHaveProperty('ep-1');
-    expect(result.byKey).not.toHaveProperty('ep-2');
+    // topModels should be populated with 30d data
+    expect(result.topModels).toHaveLength(2);
+    expect(result.topModels[0]?.name).toBe('gpt-4');
+    expect(result.topModels[0]?.spend30d).toBe(50.0);
+    expect(result.topModels[1]?.name).toBe('claude-3');
+    expect(result.topModels[1]?.spend30d).toBe(30.0);
   });
 
-  it('should include 30d model data', () => {
+  it('should aggregate provider stats with tokens', () => {
     const credits = {
-      totalUsage: 100,
-      totalCredits: 200,
+      totalUsage: 10,
+      totalCredits: 100,
     };
-    // Data from recent dates for 30d
+    const date = '2026-05-01';
     const analytics: ActivityItem[] = [
       {
-        date: '2026-04-15',
+        date: date,
         model: 'gpt-4',
         modelPermaslug: 'gpt-4-perma',
         endpointId: 'ep-1',
-        usage: 50.0,
+        usage: 5.0,
         byokUsageInference: 0,
-        requests: 10,
-        promptTokens: 1000,
-        completionTokens: 100,
+        requests: 5,
+        promptTokens: 100,
+        completionTokens: 50,
         reasoningTokens: 0,
         providerName: 'openai',
       },
       {
-        date: '2026-04-20',
+        date: date,
         model: 'claude-3',
         modelPermaslug: 'claude-3-perma',
         endpointId: 'ep-2',
-        usage: 30.0,
+        usage: 3.0,
         byokUsageInference: 0,
-        requests: 5,
-        promptTokens: 500,
-        completionTokens: 50,
+        requests: 3,
+        promptTokens: 60,
+        completionTokens: 30,
         reasoningTokens: 0,
-        providerName: 'anthropic',
+        providerName: 'openai', // Same provider, different endpoint
       },
     ];
 
     const result = aggregateUsage(credits, analytics);
 
-    // topModels30d should be populated
-    expect(result.topModels30d).toHaveLength(2);
-    expect(result.topModels30d[0]).toEqual({ name: 'gpt-4', spend: 50.0 });
-    expect(result.topModels30d[1]).toEqual({ name: 'claude-3', spend: 30.0 });
+    // byProvider should use providerName, aggregated correctly
+    expect(result.byProvider).toHaveLength(1);
+    expect(result.byProvider[0]?.name).toBe('openai');
+    expect(result.byProvider[0]?.spend).toBe(8.0);
+    // Token counts should be aggregated
+    expect(result.byProvider[0]?.tokens.total).toBe(240); // 100 + 50 + 60 + 30
+    expect(result.byProvider[0]?.tokens.input).toBe(160); // 100 + 60
+    expect(result.byProvider[0]?.tokens.output).toBe(80); // 50 + 30
+    expect(result.byProvider[0]?.requests).toBe(8); // 5 + 3
+  });
+});
+
+describe('renderSpendSparkline', () => {
+  it('should generate chart with < 30 days (should pad with zeros)', () => {
+    const byDay = {
+      '2026-05-01': 10.5,
+      '2026-05-02': 15.25,
+      '2026-05-03': 8.0,
+    };
+    const chartLines = renderSpendSparkline(byDay, 60);
+
+    // 9 bar + 1 separator + 2 label lines = 12
+    expect(chartLines).toHaveLength(12);
+    // First line should have bars (Unicode block characters)
+    expect(chartLines[0]).toMatch(/[█]/);
+  });
+
+  it('should generate chart with exactly 30 days', () => {
+    const byDay: Record<string, number> = {};
+    for (let i = 1; i <= 30; i++) {
+      const day = i < 10 ? `0${i}` : `${i}`;
+      byDay[`2026-05-${day}`] = i * 2.5;
+    }
+
+    const chartLines = renderSpendSparkline(byDay, 60);
+    // 9 bar + 1 separator + 2 label lines = 12
+    expect(chartLines).toHaveLength(12);
+    // First line should have bars
+    expect(chartLines[0]).toMatch(/[█]/);
+  });
+
+  it('should respect width constraints', () => {
+    const byDay = { '2026-05-01': 10 };
+    const narrowChart = renderSpendSparkline(byDay, 30);
+    const wideChart = renderSpendSparkline(byDay, 80);
+
+    // 9 bar + 1 separator + 2 label lines = 12
+    expect(narrowChart).toHaveLength(12);
+    expect(wideChart).toHaveLength(12);
+    // Bar width should be constrained
+    expect(narrowChart[0]!.length).toBeLessThanOrEqual(67);
+    expect(wideChart[0]!.length).toBeGreaterThanOrEqual(narrowChart[0]!.length);
+  });
+
+  it('should produce valid x-axis labels', () => {
+    const byDay: Record<string, number> = {};
+    for (let i = 1; i <= 30; i++) {
+      const day = i < 10 ? `0${i}` : `${i}`;
+      byDay[`2026-05-${day}`] = i * 2.5;
+    }
+
+    const chartLines = renderSpendSparkline(byDay, 80);
+    const dayNumbersLine = chartLines[11]; // day numbers are at line 11
+
+    expect(dayNumbersLine).toBeDefined();
+    // Should contain day numbers for positions 0, 5, 10, 15, 20, 25, 29 (30 bars total)
+    // Each day number is 2 chars, so day 1=col4, day 6=col12, day 11=col20, etc
+    expect(dayNumbersLine).toContain('01'); // Day 0 (29 days ago from 05-30)
+    expect(dayNumbersLine).toContain('06'); // Day 5
+    expect(dayNumbersLine).toContain('11'); // Day 10
+    expect(dayNumbersLine).toContain('16'); // Day 15
+    expect(dayNumbersLine).toContain('21'); // Day 20
+    expect(dayNumbersLine).toContain('26'); // Day 25
+    expect(dayNumbersLine).toContain('30'); // Day 29 (today)
   });
 });

package/extensions/openrouter/cache.ts

@@ -57,16 +57,25 @@ function getBackoffInterval(): number {
   return BACKGROUND_REFRESH_INTERVAL_MS * Math.pow(2, backoffMultiplier);
 }
 
-export async function fetchAndAggregate(): Promise<UsageSummary> {
+export async function fetchAndAggregate(): Promise<UsageSummary | null> {
   const credits = await getCredits();
+  if (!credits) return null;
   let analytics: ActivityItem[] | null = null;
+  let hasActivityData = true;
   try {
     analytics = await getActivity();
+    if (!analytics) hasActivityData = false;
   } catch (err) {
-    console.log('Activity fetch failed (management key required):', err);
+    // getActivity() requires a management key; suppress this expected error
+    if (!(err instanceof Error) || !err.message.includes('management key')) {
+      console.log('Activity fetch failed:', err);
+    }
+    hasActivityData = false;
   }
   const timestamp = Date.now();
-  return aggregateUsage(credits, analytics ?? [], timestamp);
+  const summary = aggregateUsage(credits, analytics ?? [], timestamp);
+  summary.hasActivityData = hasActivityData;
+  return summary;
 }
 
 function scheduleRefresh(): void {
@@ -75,13 +84,15 @@ function scheduleRefresh(): void {
   refreshInterval = setInterval(async () => {
     try {
       const summary = await fetchAndAggregate();
-      usageCache.set('usage', summary);
-
-      // Reset failure count on success and restart with normal interval
-      if (consecutiveFailures > 0) {
-        consecutiveFailures = 0;
-        stopBackgroundRefresh();
-        scheduleRefresh();
+      if (summary) {
+        usageCache.set('usage', summary);
+
+        // Reset failure count on success and restart with normal interval
+        if (consecutiveFailures > 0) {
+          consecutiveFailures = 0;
+          stopBackgroundRefresh();
+          scheduleRefresh();
+        }
       }
     } catch (err) {
       consecutiveFailures++;

package/extensions/openrouter/chart.ts

@@ -0,0 +1,158 @@
+/**
+ * Bar chart rendering for daily spend data
+ * @param byDay - Record mapping date strings (YYYY-MM-DD) to spend amounts
+ * @param _width - Maximum width for the chart (including padding)
+ * @returns Formatted ASCII bar chart string (for text-table row)
+ */
+export function renderSpendBarChart(byDay: Record<string, number>, _width: number): string {
+  if (Object.keys(byDay).length === 0) {
+    return 'No spend data';
+  }
+
+  // Find the date range from the data (use most recent 30 days worth of dates)
+  const sortedKeys = Object.keys(byDay).sort();
+  const latestDateStr = sortedKeys[sortedKeys.length - 1]!;
+
+  // Parse date components (handle both YYYY-MM-DD and YYYY-MM-DDTHH:mm:ssZ)
+  const dateMatch = latestDateStr.match(/^(\d{4})-(\d{2})-(\d{2})/);
+  if (!dateMatch) {
+    return 'Invalid date format';
+  }
+
+  // Build 30-day window ending on the latest date in the data
+  const [, yearStr, monthStr, dayStr] = dateMatch;
+  if (!yearStr || !monthStr || !dayStr) {
+    return 'Invalid date format';
+  }
+  const year = parseInt(yearStr, 10);
+  const month = parseInt(monthStr, 10);
+  const day = parseInt(dayStr, 10);
+
+  const values: number[] = [];
+  const dates: string[] = [];
+
+  // Generate 30 days of dates ending on latestDate
+  for (let i = 29; i >= 0; i--) {
+    const d = new Date(year, month - 1, day);
+    d.setDate(d.getDate() - i);
+
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, '0');
+    const dayStr = String(d.getDate()).padStart(2, '0');
+    const dateKey = `${y}-${m}-${dayStr}`;
+
+    dates.push(dateKey);
+    // Look up value in byDay (try exact match and time-suffixed variants)
+    let value = byDay[dateKey];
+    if (value === undefined) {
+      // Try with time suffixes
+      value = byDay[dateKey + 'T00:00:00Z'] ?? byDay[dateKey + ' 00:00:00'];
+    }
+    values.push(value ?? 0);
+  }
+
+  const max = Math.max(...values);
+
+  if (max === 0) {
+    return 'No spend';
+  }
+
+  // Build 9-row horizontal bar chart (top to bottom)
+  // Each bar is 2 chars: "█ " (bar + breathing space)
+  const chartHeight = 9;
+  const valueStep = Math.ceil(max / chartHeight);
+  const lines: string[] = [];
+  const chartWidth = 30 * 2; // 30 bars with space between
+
+  // Draw rows from top (highest value) to bottom (lowest - the x-axis)
+  for (let row = chartHeight - 1; row >= 0; row--) {
+    const rowValue = row * valueStep;
+    const label = String(rowValue).padStart(3);
+
+    let line = `  ${label} |`;
+
+    // For each bar: fill if the bar's height reaches above current row
+    // Add space after each bar for breathing room
+    for (const v of values) {
+      const barHeight = Math.ceil((v / max) * chartHeight);
+      line += barHeight > row ? '█' : ' ';
+      line += ' '; // Breathing space between bars
+    }
+
+    lines.push(line);
+  }
+
+  // Separator line - spans full width including spaces between bars
+  lines.push('      +' + '─'.repeat(chartWidth));
+
+  // Month label line - mark month changes
+  const firstMonth = dates[0]!.slice(5, 7);
+  const lastMonth = dates[dates.length - 1]!.slice(5, 7);
+
+  let monthLine = '      ';
+  // Find where month changes
+  const monthChangeIndex = dates.findIndex((d, i) => i > 0 && d.slice(5, 7) !== firstMonth);
+
+  if (firstMonth === lastMonth) {
+    // All in one month - centered label
+    const label = getMonthName(firstMonth);
+    const padding = Math.floor((chartWidth - label.length) / 2);
+    monthLine += ' '.repeat(padding) + label + ' '.repeat(chartWidth - padding - label.length);
+  } else if (monthChangeIndex > 0) {
+    // Month transition - show first month near start, second near end
+    const firstLabel = getMonthName(firstMonth);
+    const secondLabel = getMonthName(lastMonth);
+    // Position labels: first at ~8 chars, second at ~52 chars
+    const firstPos = 4;
+    const secondPos = chartWidth - 8;
+    monthLine +=
+      ' '.repeat(firstPos) +
+      firstLabel +
+      ' '.repeat(secondPos - firstPos - firstLabel.length) +
+      secondLabel +
+      ' '.repeat(chartWidth - secondPos - secondLabel.length);
+  }
+
+  lines.push(monthLine.slice(0, 6 + chartWidth));
+
+  // Day numbers line - show every 2-3 days, aligning with bar positions
+  // Each day is at position i*2, so day 0=col0, day 5=col10, day 10=col20, etc
+  let daysLine = '      ';
+  for (let i = 0; i < 30; i++) {
+    // Show day number at every bar position
+    const dayNum = dates[i]!.slice(8, 10);
+    if (i === 0 || i === 29 || i % 5 === 0) {
+      // Place the 2-digit day number, it will take 2 chars which aligns perfectly
+      daysLine += dayNum;
+    } else {
+      daysLine += '  ';
+    }
+  }
+  lines.push(daysLine.slice(0, 6 + chartWidth));
+
+  return lines.join('\n');
+}
+
+function getMonthName(mm: string): string {
+  const months: Record<string, string> = {
+    '01': 'Jan',
+    '02': 'Feb',
+    '03': 'Mar',
+    '04': 'Apr',
+    '05': 'May',
+    '06': 'Jun',
+    '07': 'Jul',
+    '08': 'Aug',
+    '09': 'Sep',
+    '10': 'Oct',
+    '11': 'Nov',
+    '12': 'Dec',
+  };
+  return months[mm] ?? mm;
+}
+
+// Legacy export for backward compatibility
+export function renderSpendSparkline(...args: Parameters<typeof renderSpendBarChart>): string[] {
+  const chartOutput = renderSpendBarChart(...args);
+  return chartOutput.split('\n').filter((line) => line.length > 0);
+}

package/extensions/openrouter/client.ts

@@ -4,26 +4,30 @@ import { OpenRouter } from '@openrouter/sdk/sdk/sdk.js';
 
 let client: OpenRouter | null = null;
 
-function getClient(): OpenRouter {
+function getClient(): OpenRouter | null {
   if (client) return client;
   const apiKey = process.env['OPENROUTER_MANAGEMENT_KEY'] || process.env['OPENROUTER_API_KEY'];
-  if (!apiKey) throw new AuthError('OPENROUTER_API_KEY or OPENROUTER_MANAGEMENT_KEY not set');
+  if (!apiKey) return null;
   client = new OpenRouter({ apiKey });
   return client;
 }
 
-export async function getCredits(): Promise<GetCreditsResponse['data']> {
+export async function getCredits(): Promise<GetCreditsResponse['data'] | null> {
+  const client = getClient();
+  if (!client) return null;
   try {
-    const response = await getClient().credits.getCredits();
+    const response = await client.credits.getCredits();
     return response.data;
   } catch (err) {
     throw mapSdkError(err);
   }
 }
 
-export async function getActivity(): Promise<ActivityResponse['data']> {
+export async function getActivity(): Promise<ActivityResponse['data'] | null> {
+  const client = getClient();
+  if (!client) return null;
   try {
-    const response = await getClient().analytics.getUserActivity();
+    const response = await client.analytics.getUserActivity();
     return response.data;
   } catch (err) {
     throw mapSdkError(err);