agent-leaderboard 0.1.0

package/dist/cli.js

@@ -0,0 +1,2065 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.20.6_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.20.6_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/parsers/ccusage.js
+import { execSync as execSync2 } from "child_process";
+function isCcusageAvailable() {
+  return CcusageParser.isInstalled();
+}
+var CcusageParser;
+var init_ccusage = __esm({
+  "../shared/dist/parsers/ccusage.js"() {
+    "use strict";
+    init_esm_shims();
+    CcusageParser = class {
+      /**
+       * Check if ccusage is installed
+       */
+      static isInstalled() {
+        try {
+          execSync2("which ccusage", { stdio: "pipe" });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Run ccusage and get JSON output
+       */
+      static async fetchData(options = {}) {
+        const raw = await this.fetchRawData(options);
+        return this.normalize(raw);
+      }
+      /**
+       * Run ccusage and get raw JSON output (includes totals)
+       */
+      static async fetchRawData(options = {}) {
+        if (!this.isInstalled()) {
+          throw new Error("ccusage is not installed. Install it from: https://github.com/ryoppippi/ccusage");
+        }
+        try {
+          const daysArg = options.days ? `--days ${options.days}` : "";
+          const command = `ccusage --json ${daysArg}`;
+          const output = execSync2(command, { encoding: "utf8", maxBuffer: 10 * 1024 * 1024 });
+          return JSON.parse(output);
+        } catch (error) {
+          throw new Error(`Failed to fetch ccusage data: ${error.message}`);
+        }
+      }
+      /**
+       * Parse ccusage JSON output
+       */
+      static parse(jsonOutput) {
+        try {
+          const data = JSON.parse(jsonOutput);
+          return this.normalize(data);
+        } catch (error) {
+          throw new Error(`Failed to parse ccusage output: ${error.message}`);
+        }
+      }
+      /**
+       * Normalize ccusage data to DailyUsage format
+       */
+      static normalize(data) {
+        const dailyUsage = [];
+        for (const day of data.daily) {
+          dailyUsage.push(this.normalizeDayEntry(day));
+        }
+        dailyUsage.sort((a, b) => a.date.localeCompare(b.date));
+        return dailyUsage;
+      }
+      static normalizeDayEntry(day) {
+        const tokensInput = day.inputTokens + day.cacheCreationTokens;
+        const tokensOutput = day.outputTokens;
+        const tokensCached = day.cacheReadTokens;
+        const model = day.modelsUsed.length > 0 ? day.modelsUsed[0] : "unknown";
+        return {
+          date: day.date,
+          provider: "claude",
+          model,
+          tokensInput,
+          tokensOutput,
+          tokensCached,
+          cost: day.totalCost,
+          calls: 1
+          // ccusage doesn't track individual API calls, use 1 as placeholder
+        };
+      }
+      /**
+       * Aggregate multiple days into a single entry
+       */
+      static aggregate(usageData) {
+        const aggregated = /* @__PURE__ */ new Map();
+        for (const entry of usageData) {
+          const existing = aggregated.get(entry.date);
+          if (existing) {
+            existing.tokensInput += entry.tokensInput;
+            existing.tokensOutput += entry.tokensOutput;
+            existing.tokensCached = (existing.tokensCached || 0) + (entry.tokensCached || 0);
+            existing.cost += entry.cost;
+            existing.calls += entry.calls;
+          } else {
+            aggregated.set(entry.date, { ...entry });
+          }
+        }
+        return aggregated;
+      }
+      /**
+       * Get usage data for a date range
+       */
+      static async getDateRange(startDate, endDate) {
+        const daysDiff = Math.ceil((endDate.getTime() - startDate.getTime()) / (1e3 * 60 * 60 * 24));
+        const allData = await this.fetchData({ days: daysDiff + 10 });
+        const startStr = startDate.toISOString().split("T")[0];
+        const endStr = endDate.toISOString().split("T")[0];
+        return allData.filter((d) => d.date >= startStr && d.date <= endStr);
+      }
+    };
+  }
+});
+
+// ../shared/dist/utils/validation.js
+import { z } from "zod";
+function escapeXML(unsafe) {
+  return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+var tokenSchema, deviceIdSchema, dateSchema, providerSchema, modelSchema, userIdSchema, dailyUsageSchema, syncPayloadSchema, graphQuerySchema, statsQuerySchema;
+var init_validation = __esm({
+  "../shared/dist/utils/validation.js"() {
+    "use strict";
+    init_esm_shims();
+    tokenSchema = z.string().regex(/^[a-f0-9]{64}$/, "Invalid token format");
+    deviceIdSchema = z.string().regex(/^[a-f0-9]{64}$/, "Invalid device ID format");
+    dateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Invalid date format (expected YYYY-MM-DD)");
+    providerSchema = z.string().regex(/^[a-z0-9-]+$/i, "Invalid provider name").max(50);
+    modelSchema = z.string().regex(/^[a-z0-9._-]+$/i, "Invalid model name").max(100);
+    userIdSchema = z.string().uuid("Invalid user ID format");
+    dailyUsageSchema = z.object({
+      date: dateSchema,
+      provider: providerSchema,
+      model: modelSchema.nullable().optional(),
+      tokensInput: z.number().int().min(0).max(1e9),
+      tokensOutput: z.number().int().min(0).max(1e9),
+      tokensCached: z.number().int().min(0).max(1e9).optional().default(0),
+      cost: z.number().min(0).max(1e6),
+      calls: z.number().int().min(0).max(1e6)
+    });
+    syncPayloadSchema = z.object({
+      token: tokenSchema,
+      deviceId: deviceIdSchema,
+      timestamp: z.number().int().positive(),
+      data: z.array(dailyUsageSchema).min(0).max(1e3),
+      generateGraphs: z.boolean().optional().default(false)
+    });
+    graphQuerySchema = z.object({
+      token: tokenSchema,
+      days: z.string().regex(/^\d+$/).optional(),
+      theme: z.enum(["github-dark", "github-light"]).optional(),
+      view: z.enum(["yearly", "monthly"]).optional()
+    });
+    statsQuerySchema = z.object({
+      token: tokenSchema
+    });
+  }
+});
+
+// ../shared/dist/svg-generator.js
+function generateSVG(dailyUsage, config2) {
+  const generator = new SVGGenerator(config2);
+  return generator.generate(dailyUsage);
+}
+var DEFAULT_CONFIG, THEMES, SVGGenerator;
+var init_svg_generator = __esm({
+  "../shared/dist/svg-generator.js"() {
+    "use strict";
+    init_esm_shims();
+    init_validation();
+    DEFAULT_CONFIG = {
+      theme: "dark",
+      days: 365,
+      width: 800,
+      height: 150,
+      showStats: true,
+      provider: "",
+      view: "yearly",
+      customColors: {
+        empty: "#161b22",
+        level1: "#0e4429",
+        level2: "#006d32",
+        level3: "#26a641",
+        level4: "#39d353"
+      }
+    };
+    THEMES = {
+      "dark": {
+        empty: "#161b22",
+        level1: "#0e4429",
+        level2: "#006d32",
+        level3: "#26a641",
+        level4: "#39d353",
+        text: "#8b949e",
+        background: "#0d1117"
+      },
+      "light": {
+        empty: "#ebedf0",
+        level1: "#9be9a8",
+        level2: "#40c463",
+        level3: "#30a14e",
+        level4: "#216e39",
+        text: "#57606a",
+        background: "#ffffff"
+      }
+    };
+    SVGGenerator = class {
+      config;
+      colors;
+      cellSize = 10;
+      cellGap = 3;
+      monthLabelHeight = 20;
+      weekLabelWidth = 30;
+      constructor(config2 = {}) {
+        this.config = {
+          ...DEFAULT_CONFIG,
+          ...config2,
+          customColors: config2.customColors || DEFAULT_CONFIG.customColors
+        };
+        const theme = this.config.theme;
+        this.colors = config2.customColors && config2.theme === "custom" ? { ...THEMES["dark"], ...config2.customColors } : theme === "light" ? THEMES["light"] : THEMES["dark"];
+      }
+      /**
+       * Generate SVG from daily usage data
+       */
+      generate(dailyUsageMap) {
+        if (this.config.view === "monthly") {
+          return this.generateMonthlyView(dailyUsageMap);
+        }
+        if (this.config.view === "biweekly") {
+          return this.generateBiweeklyView(dailyUsageMap);
+        }
+        if (this.config.view === "biweekly-compact") {
+          return this.generateBiweeklyCompactView(dailyUsageMap);
+        }
+        const gridData = this.generateGridData(dailyUsageMap);
+        const monthLabels = this.computeMonthLabels(gridData.grid);
+        const totalWeeks = gridData.grid.length;
+        const width = this.weekLabelWidth + totalWeeks * (this.cellSize + this.cellGap);
+        const height = this.monthLabelHeight + 7 * (this.cellSize + this.cellGap) + 40;
+        let svg = this.generateHeader(width, height);
+        svg += this.renderMonthLabels(monthLabels);
+        svg += this.generateDayLabels();
+        svg += this.generateCells(gridData.grid);
+        if (this.config.showStats) {
+          svg += this.generateStats(gridData.stats, width, height);
+        }
+        svg += this.generateLegend(width, height);
+        svg += "</svg>";
+        return svg;
+      }
+      generateHeader(width, height) {
+        return `<?xml version="1.0" encoding="UTF-8"?>
+<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
+  <style>
+    .cell {
+      rx: 2;
+      transition: all 0.1s ease;
+      cursor: pointer;
+    }
+    .cell:hover {
+      stroke: ${this.colors.text};
+      stroke-width: 2;
+      opacity: 0.8;
+    }
+    text {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Helvetica', 'Arial', sans-serif;
+      font-size: 11px;
+      fill: ${this.colors.text};
+    }
+    .month-label { font-size: 10px; }
+  </style>
+  <rect width="${width}" height="${height}" fill="${this.colors.background}"/>
+
+`;
+      }
+      renderMonthLabels(labels) {
+        let svg = `  <!-- Month labels -->
+  <g transform="translate(${this.weekLabelWidth}, 0)">
+`;
+        labels.forEach((label) => {
+          const x = label.weekIndex * (this.cellSize + this.cellGap);
+          svg += `    <text x="${x}" y="10" class="month-label">${label.month}</text>
+`;
+        });
+        svg += `  </g>
+
+`;
+        return svg;
+      }
+      generateDayLabels() {
+        return `  <!-- Day labels -->
+  <g transform="translate(0, ${this.monthLabelHeight})">
+    <text x="0" y="${this.cellSize + this.cellGap * 1.5}" text-anchor="start">Mon</text>
+    <text x="0" y="${(this.cellSize + this.cellGap) * 3 + this.cellGap * 1.5}" text-anchor="start">Wed</text>
+    <text x="0" y="${(this.cellSize + this.cellGap) * 5 + this.cellGap * 1.5}" text-anchor="start">Fri</text>
+  </g>
+
+`;
+      }
+      generateCells(grid) {
+        let svg = `  <!-- Contribution cells -->
+  <g transform="translate(${this.weekLabelWidth}, ${this.monthLabelHeight})">
+`;
+        grid.forEach((week, weekIndex) => {
+          week.forEach((day, dayIndex) => {
+            if (!day.date)
+              return;
+            const x = weekIndex * (this.cellSize + this.cellGap);
+            const y = dayIndex * (this.cellSize + this.cellGap);
+            const color = this.getColorForLevel(day.level);
+            const tooltip = this.generateTooltip(day);
+            svg += `    <rect class="cell" x="${x}" y="${y}" width="${this.cellSize}" height="${this.cellSize}" fill="${color}">
+`;
+            svg += `      <title>${tooltip}</title>
+`;
+            svg += `    </rect>
+`;
+          });
+        });
+        svg += `  </g>
+
+`;
+        return svg;
+      }
+      generateTooltip(day) {
+        if (day.tokens === 0) {
+          return escapeXML(`${day.date}: No activity`);
+        }
+        const parts = [
+          escapeXML(day.date),
+          escapeXML(`${day.tokens.toLocaleString()} tokens`),
+          escapeXML(`$${day.cost.toFixed(3)}`),
+          escapeXML(`${day.calls} ${day.calls === 1 ? "call" : "calls"}`)
+        ];
+        if (day.providers.length > 0) {
+          const escapedProviders = day.providers.map((p) => escapeXML(p)).join(", ");
+          parts.push(`(${escapedProviders})`);
+        }
+        return parts.join(" \u2022 ");
+      }
+      generateStats(stats, width, height) {
+        return `  <!-- Stats footer -->
+  <g transform="translate(0, ${height - 30})">
+    <text x="5" y="10" style="font-size: 10px;">
+      ${stats.activeDays} active ${stats.activeDays === 1 ? "day" : "days"} \u2022 ${stats.totalTokens.toLocaleString()} tokens \u2022 $${stats.totalCost.toFixed(2)} \u2022 Max: ${stats.maxTokens.toLocaleString()}/day
+    </text>
+  </g>
+
+`;
+      }
+      generateLegend(width, height) {
+        const legendY = height - 15;
+        const startX = width - 130;
+        let svg = `  <!-- Legend -->
+  <g transform="translate(${startX}, ${legendY})">
+`;
+        svg += `    <text x="0" y="10" style="font-size: 9px;">Less</text>
+`;
+        for (let level = 0; level <= 4; level++) {
+          const color = this.getColorForLevel(level);
+          const x = 25 + level * 13;
+          svg += `    <rect x="${x}" y="2" width="${this.cellSize}" height="${this.cellSize}" fill="${color}" rx="2"/>
+`;
+        }
+        svg += `    <text x="${25 + 5 * 13 + 5}" y="10" style="font-size: 9px;">More</text>
+`;
+        svg += `  </g>
+`;
+        return svg;
+      }
+      getColorForLevel(level) {
+        const colorMap = {
+          0: "empty",
+          1: "level1",
+          2: "level2",
+          3: "level3",
+          4: "level4"
+        };
+        const key = colorMap[level];
+        return key ? this.colors[key] : this.colors.empty;
+      }
+      calculateLevel(tokens, maxTokens) {
+        if (tokens === 0 || maxTokens === 0)
+          return 0;
+        const ratio = tokens / maxTokens;
+        if (ratio < 0.25)
+          return 1;
+        if (ratio < 0.5)
+          return 2;
+        if (ratio < 0.75)
+          return 3;
+        return 4;
+      }
+      /**
+       * Get the date range for one month back from today
+       */
+      getOneMonthDateRange() {
+        const now = /* @__PURE__ */ new Date();
+        const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        const startDate = new Date(today);
+        startDate.setMonth(today.getMonth() - 1);
+        const tomorrow = new Date(today);
+        tomorrow.setDate(tomorrow.getDate() + 1);
+        const daysToShow = Math.round((tomorrow.getTime() - startDate.getTime()) / (1e3 * 60 * 60 * 24));
+        return { today, startDate, daysToShow };
+      }
+      /**
+       * Aggregate daily usage data into periods
+       */
+      aggregateIntoPeriods(dailyUsageMap, startDate, daysToShow, numPeriods) {
+        const periods = [];
+        let currentDate = new Date(startDate);
+        const daysPerPeriod = Math.ceil(daysToShow / numPeriods);
+        for (let periodNum = 0; periodNum < numPeriods; periodNum++) {
+          const periodStart = new Date(currentDate);
+          let periodCost = 0;
+          let periodTokens = 0;
+          let periodCalls = 0;
+          let periodActiveDays = 0;
+          const daysInThisPeriod = Math.min(daysPerPeriod, daysToShow - periodNum * daysPerPeriod);
+          let periodEnd = new Date(periodStart);
+          for (let dayInPeriod = 0; dayInPeriod < daysInThisPeriod; dayInPeriod++) {
+            const year = currentDate.getFullYear();
+            const month = String(currentDate.getMonth() + 1).padStart(2, "0");
+            const day = String(currentDate.getDate()).padStart(2, "0");
+            const dateStr = `${year}-${month}-${day}`;
+            const data = dailyUsageMap.get(dateStr);
+            if (data) {
+              periodCost += data.totalCost;
+              periodTokens += data.totalTokens;
+              periodCalls += data.totalCalls;
+              periodActiveDays++;
+            }
+            periodEnd = new Date(currentDate);
+            currentDate.setDate(currentDate.getDate() + 1);
+          }
+          const startMonth = periodStart.toLocaleDateString("en-US", { month: "short" });
+          const startDay = periodStart.getDate();
+          const endMonth = periodEnd.toLocaleDateString("en-US", { month: "short" });
+          const endDay = periodEnd.getDate();
+          const periodLabel = startMonth === endMonth ? `${startMonth} ${startDay} - ${endDay}` : `${startMonth} ${startDay} - ${endMonth} ${endDay}`;
+          periods.push({
+            periodLabel,
+            startDate: periodStart,
+            endDate: periodEnd,
+            cost: periodCost,
+            tokens: periodTokens,
+            calls: periodCalls,
+            activeDays: periodActiveDays
+          });
+        }
+        let totalCost = 0;
+        let totalTokens = 0;
+        let totalActiveDays = 0;
+        let maxPeriodCost = 0;
+        periods.forEach((period) => {
+          totalCost += period.cost;
+          totalTokens += period.tokens;
+          totalActiveDays += period.activeDays;
+          if (period.cost > maxPeriodCost)
+            maxPeriodCost = period.cost;
+        });
+        return { periods, totalCost, totalTokens, totalActiveDays, maxPeriodCost };
+      }
+      /**
+       * Format token count with units (K, M, B, T)
+       */
+      formatTokens(tokens) {
+        if (tokens >= 1e12)
+          return `${(tokens / 1e12).toFixed(1)}T`;
+        if (tokens >= 1e9)
+          return `${(tokens / 1e9).toFixed(1)}B`;
+        if (tokens >= 1e6)
+          return `${(tokens / 1e6).toFixed(1)}M`;
+        if (tokens >= 1e3)
+          return `${(tokens / 1e3).toFixed(1)}K`;
+        return tokens.toString();
+      }
+      generateGridData(dailyUsageMap) {
+        const grid = [];
+        const today = /* @__PURE__ */ new Date();
+        const startDate = new Date(today);
+        startDate.setDate(today.getDate() - this.config.days + 1);
+        const dayOfWeek = startDate.getDay();
+        startDate.setDate(startDate.getDate() - dayOfWeek);
+        let maxTokens = 0;
+        let totalTokens = 0;
+        let totalCost = 0;
+        let activeDays = 0;
+        for (const data of dailyUsageMap.values()) {
+          if (data.totalTokens > maxTokens)
+            maxTokens = data.totalTokens;
+          if (data.totalTokens > 0)
+            activeDays++;
+          totalTokens += data.totalTokens;
+          totalCost += data.totalCost;
+        }
+        let currentDate = new Date(startDate);
+        const endDate = new Date(today);
+        let week = [];
+        while (currentDate <= endDate) {
+          const dateStr = currentDate.toISOString().split("T")[0];
+          const data = dailyUsageMap.get(dateStr);
+          const tokens = data?.totalTokens || 0;
+          const cost = data?.totalCost || 0;
+          const calls = data?.totalCalls || 0;
+          const providers = data ? Object.keys(data.byProvider) : [];
+          const level = this.calculateLevel(tokens, maxTokens);
+          week.push({
+            date: dateStr,
+            level,
+            tokens,
+            cost,
+            calls,
+            providers,
+            dayOfWeek: currentDate.getDay()
+          });
+          if (currentDate.getDay() === 6) {
+            grid.push(week);
+            week = [];
+          }
+          currentDate.setDate(currentDate.getDate() + 1);
+        }
+        if (week.length > 0) {
+          while (week.length < 7) {
+            week.push({
+              date: "",
+              level: 0,
+              tokens: 0,
+              cost: 0,
+              calls: 0,
+              providers: [],
+              dayOfWeek: week.length
+            });
+          }
+          grid.push(week);
+        }
+        return {
+          grid,
+          stats: {
+            maxTokens,
+            totalTokens,
+            totalCost,
+            activeDays
+          }
+        };
+      }
+      computeMonthLabels(grid) {
+        const labels = [];
+        const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+        let lastMonth = -1;
+        grid.forEach((week, weekIndex) => {
+          const firstDay = week.find((d) => d.date);
+          if (firstDay && firstDay.date) {
+            const month = new Date(firstDay.date).getMonth();
+            if (month !== lastMonth && weekIndex > 0) {
+              labels.push({
+                month: months[month],
+                weekIndex
+              });
+              lastMonth = month;
+            }
+          }
+        });
+        return labels;
+      }
+      /**
+       * Generate monthly view aggregated by weeks
+       * Shows 4 weeks of data, each week in one cell
+       */
+      generateMonthlyView(dailyUsageMap) {
+        const { today, startDate, daysToShow } = this.getOneMonthDateRange();
+        const { periods, totalCost, totalTokens, totalActiveDays, maxPeriodCost } = this.aggregateIntoPeriods(dailyUsageMap, startDate, daysToShow, 4);
+        const cellSize = 180;
+        const cellGap = 20;
+        const titleHeight = 35;
+        const footerHeight = 45;
+        const sidePadding = 30;
+        const cols = 4;
+        const width = cols * (cellSize + cellGap) - cellGap + sidePadding * 2;
+        const height = titleHeight + cellSize + footerHeight;
+        let svg = this.generateHeader(width, height);
+        const lastUpdated = today.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
+        svg += `  <!-- Header -->
+`;
+        svg += `  <g transform="translate(0, 0)">
+`;
+        svg += `    <text x="${width / 2}" y="22" text-anchor="middle" style="font-size: 16px; font-weight: 600; fill: ${this.colors.text};">LLM Activity</text>
+`;
+        svg += `  </g>
+
+`;
+        svg += `  <!-- Week Cells -->
+  <g transform="translate(${sidePadding}, ${titleHeight})">
+`;
+        for (let i = 0; i < periods.length; i++) {
+          const period = periods[i];
+          const x = i * (cellSize + cellGap);
+          const y = 0;
+          const level = this.calculateLevel(period.cost * 1e3, maxPeriodCost * 1e3);
+          const costColor = this.getColorForLevel(level);
+          const periodStartStr = period.startDate.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+          const periodEndStr = period.endDate.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+          const tooltipText = `${periodStartStr} - ${periodEndStr}\\n$${period.cost.toFixed(2)} \u2022 ${period.tokens.toLocaleString()} tokens\\n${period.activeDays} active ${period.activeDays === 1 ? "day" : "days"}`;
+          const escapedTooltip = escapeXML(tooltipText);
+          svg += `    <g>
+`;
+          svg += `      <rect class="cell" x="${x}" y="${y}" width="${cellSize}" height="${cellSize}" fill="${this.colors.empty}" rx="8">
+`;
+          svg += `        <title>${escapedTooltip}</title>
+`;
+          svg += `      </rect>
+`;
+          const escapedDateRange = escapeXML(`${periodStartStr} - ${periodEndStr}`);
+          svg += `      <text x="${x + cellSize / 2}" y="${y + 24}" text-anchor="middle" style="font-size: 12px; fill: ${this.colors.text}; opacity: 0.7;">${escapedDateRange}</text>
+`;
+          if (period.cost > 0) {
+            const costStr = period.cost >= 1 ? `$${period.cost.toFixed(2)}` : `$${period.cost.toFixed(3)}`;
+            const escapedCostStr = escapeXML(costStr);
+            svg += `      <text x="${x + cellSize / 2}" y="${y + cellSize / 2 + 6}" text-anchor="middle" style="font-size: 32px; font-weight: 700; fill: ${costColor};">${escapedCostStr}</text>
+`;
+            const tokenStr = period.tokens >= 1e6 ? `${(period.tokens / 1e6).toFixed(1)}M` : period.tokens >= 1e3 ? `${(period.tokens / 1e3).toFixed(1)}k` : period.tokens.toString();
+            const escapedTokenStr = escapeXML(`${tokenStr} tokens`);
+            svg += `      <text x="${x + cellSize / 2}" y="${y + cellSize - 42}" text-anchor="middle" style="font-size: 13px; fill: ${this.colors.text}; opacity: 0.7;">${escapedTokenStr}</text>
+`;
+            const activeDaysStr = `${period.activeDays} active ${period.activeDays === 1 ? "day" : "days"}`;
+            const escapedActiveDays = escapeXML(activeDaysStr);
+            svg += `      <text x="${x + cellSize / 2}" y="${y + cellSize - 22}" text-anchor="middle" style="font-size: 12px; fill: ${this.colors.text}; opacity: 0.6;">${escapedActiveDays}</text>
+`;
+          } else {
+            svg += `      <text x="${x + cellSize / 2}" y="${y + cellSize / 2 + 5}" text-anchor="middle" style="font-size: 16px; fill: ${this.colors.text}; opacity: 0.5;">No activity</text>
+`;
+          }
+          svg += `    </g>
+`;
+        }
+        svg += `  </g>
+
+`;
+        const footerText = `${totalActiveDays} active ${totalActiveDays === 1 ? "day" : "days"} \u2022 ${this.formatTokens(totalTokens)} tokens \u2022 $${totalCost.toFixed(2)} total \u2022 Updated ${lastUpdated}`;
+        const escapedFooter = escapeXML(footerText);
+        svg += `  <!-- Stats Footer -->
+`;
+        svg += `  <g transform="translate(0, ${height - 20})">
+`;
+        svg += `    <text x="${width / 2}" y="10" text-anchor="middle" style="font-size: 11px; fill: ${this.colors.text}; opacity: 0.7;">
+`;
+        svg += `      ${escapedFooter}
+`;
+        svg += `    </text>
+`;
+        svg += `  </g>
+
+`;
+        svg += "</svg>";
+        return svg;
+      }
+      /**
+       * Generate biweekly view - 2 cards, each showing 2 weeks of data
+       * Designed for 750x392 aspect ratio (roughly 1.9:1)
+       */
+      generateBiweeklyView(dailyUsageMap) {
+        const { today, startDate, daysToShow } = this.getOneMonthDateRange();
+        const { periods, totalCost, totalTokens, totalActiveDays } = this.aggregateIntoPeriods(dailyUsageMap, startDate, daysToShow, 2);
+        const cardWidth = 350;
+        const cardHeight = 300;
+        const cardGap = 30;
+        const titleHeight = 40;
+        const footerHeight = 52;
+        const sidePadding = 25;
+        const cols = 2;
+        const width = cols * cardWidth + (cols - 1) * cardGap + sidePadding * 2;
+        const height = titleHeight + cardHeight + footerHeight;
+        let svg = this.generateHeader(width, height);
+        const lastUpdated = today.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
+        svg += `  <!-- Header -->
+`;
+        svg += `  <g transform="translate(0, 0)">
+`;
+        svg += `    <text x="${width / 2}" y="25" text-anchor="middle" style="font-size: 18px; font-weight: 600; fill: ${this.colors.text};">LLM Activity</text>
+`;
+        svg += `  </g>
+
+`;
+        svg += `  <!-- Period Cards -->
+  <g transform="translate(${sidePadding}, ${titleHeight})">
+`;
+        for (let i = 0; i < periods.length; i++) {
+          const period = periods[i];
+          const x = i * (cardWidth + cardGap);
+          const y = 0;
+          const costColor = this.getColorForLevel(4);
+          const tooltipText = `${period.periodLabel}\\n$${period.cost.toFixed(2)} \u2022 ${period.tokens.toLocaleString()} tokens\\n${period.activeDays} active ${period.activeDays === 1 ? "day" : "days"}`;
+          const escapedTooltip = escapeXML(tooltipText);
+          svg += `    <g>
+`;
+          svg += `      <rect class="cell" x="${x}" y="${y}" width="${cardWidth}" height="${cardHeight}" fill="${this.colors.empty}" rx="8">
+`;
+          svg += `        <title>${escapedTooltip}</title>
+`;
+          svg += `      </rect>
+`;
+          const escapedDateRange = escapeXML(period.periodLabel);
+          svg += `      <text x="${x + cardWidth / 2}" y="${y + 30}" text-anchor="middle" style="font-size: 16px; fill: ${this.colors.text}; opacity: 0.7;">${escapedDateRange}</text>
+`;
+          if (period.cost > 0) {
+            const costStr = period.cost >= 1 ? `$${period.cost.toFixed(2)}` : `$${period.cost.toFixed(3)}`;
+            const escapedCostStr = escapeXML(costStr);
+            svg += `      <text x="${x + cardWidth / 2}" y="${y + cardHeight / 2 + 10}" text-anchor="middle" style="font-size: 42px; font-weight: 700; fill: ${costColor};">${escapedCostStr}</text>
+`;
+            const escapedTokenStr = escapeXML(`${this.formatTokens(period.tokens)} tokens`);
+            svg += `      <text x="${x + cardWidth / 2}" y="${y + cardHeight - 60}" text-anchor="middle" style="font-size: 18px; fill: ${this.colors.text}; opacity: 0.7;">${escapedTokenStr}</text>
+`;
+            const activeDaysStr = `${period.activeDays} active ${period.activeDays === 1 ? "day" : "days"}`;
+            const escapedActiveDays = escapeXML(activeDaysStr);
+            svg += `      <text x="${x + cardWidth / 2}" y="${y + cardHeight - 35}" text-anchor="middle" style="font-size: 16px; fill: ${this.colors.text}; opacity: 0.6;">${escapedActiveDays}</text>
+`;
+          } else {
+            svg += `      <text x="${x + cardWidth / 2}" y="${y + cardHeight / 2 + 5}" text-anchor="middle" style="font-size: 18px; fill: ${this.colors.text}; opacity: 0.5;">No activity</text>
+`;
+          }
+          svg += `    </g>
+`;
+        }
+        svg += `  </g>
+
+`;
+        const footerText = `${totalActiveDays} active ${totalActiveDays === 1 ? "day" : "days"} \u2022 ${this.formatTokens(totalTokens)} tokens \u2022 $${totalCost.toFixed(2)} total \u2022 Updated ${lastUpdated}`;
+        const escapedFooter = escapeXML(footerText);
+        svg += `  <!-- Stats Footer -->
+`;
+        svg += `  <g transform="translate(0, ${height - 25})">
+`;
+        svg += `    <text x="${width / 2}" y="10" text-anchor="middle" style="font-size: 12px; fill: ${this.colors.text}; opacity: 0.7;">
+`;
+        svg += `      ${escapedFooter}
+`;
+        svg += `    </text>
+`;
+        svg += `  </g>
+
+`;
+        svg += "</svg>";
+        return svg;
+      }
+      /**
+       * Generate compact biweekly view - 2 cards with minimal vertical padding
+       * Same as biweekly but with reduced spacing around cost display
+       */
+      generateBiweeklyCompactView(dailyUsageMap) {
+        const { today, startDate, daysToShow } = this.getOneMonthDateRange();
+        const { periods, totalCost, totalTokens, totalActiveDays } = this.aggregateIntoPeriods(dailyUsageMap, startDate, daysToShow, 2);
+        const cardWidth = 350;
+        const cardHeight = 180;
+        const cardGap = 30;
+        const titleHeight = 40;
+        const footerHeight = 52;
+        const sidePadding = 25;
+        const outerPadding = 10;
+        const cols = 2;
+        const width = cols * cardWidth + (cols - 1) * cardGap + sidePadding * 2 + outerPadding * 2;
+        const height = titleHeight + cardHeight + footerHeight + outerPadding * 2;
+        let svg = this.generateHeader(width, height);
+        const lastUpdated = today.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
+        svg += `  <!-- Header -->
+`;
+        svg += `  <g transform="translate(0, 0)">
+`;
+        svg += `    <text x="${width / 2 - outerPadding}" y="25" text-anchor="middle" style="font-size: 18px; font-weight: 600; fill: ${this.colors.text};">LLM Activity</text>
+`;
+        svg += `  </g>
+
+`;
+        svg += `  <!-- Period Cards -->
+  <g transform="translate(${sidePadding + outerPadding}, ${titleHeight + outerPadding})">
+`;
+        for (let i = 0; i < periods.length; i++) {
+          const period = periods[i];
+          const x = i * (cardWidth + cardGap);
+          const y = 0;
+          const costColor = this.getColorForLevel(4);
+          const tooltipText = `${period.periodLabel}\\n$${period.cost.toFixed(2)} \u2022 ${period.tokens.toLocaleString()} tokens\\n${period.activeDays} active ${period.activeDays === 1 ? "day" : "days"}`;
+          const escapedTooltip = escapeXML(tooltipText);
+          svg += `    <g>
+`;
+          svg += `      <rect class="cell" x="${x}" y="${y}" width="${cardWidth}" height="${cardHeight}" fill="${this.colors.empty}" rx="8">
+`;
+          svg += `        <title>${escapedTooltip}</title>
+`;
+          svg += `      </rect>
+`;
+          const escapedDateRange = escapeXML(period.periodLabel);
+          svg += `      <text x="${x + cardWidth / 2}" y="${y + 35}" text-anchor="middle" style="font-size: 16px; fill: ${this.colors.text}; opacity: 0.7;">${escapedDateRange}</text>
+`;
+          if (period.cost > 0) {
+            const costStr = period.cost >= 1 ? `$${period.cost.toFixed(2)}` : `$${period.cost.toFixed(3)}`;
+            const escapedCostStr = escapeXML(costStr);
+            svg += `      <text x="${x + cardWidth / 2}" y="${y + cardHeight / 2 + 5}" text-anchor="middle" style="font-size: 42px; font-weight: 700; fill: ${costColor};">${escapedCostStr}</text>
+`;
+            const escapedTokenStr = escapeXML(`${this.formatTokens(period.tokens)} tokens`);
+            svg += `      <text x="${x + cardWidth / 2}" y="${y + cardHeight - 50}" text-anchor="middle" style="font-size: 18px; fill: ${this.colors.text}; opacity: 0.7;">${escapedTokenStr}</text>
+`;
+            const activeDaysStr = `${period.activeDays} active ${period.activeDays === 1 ? "day" : "days"}`;
+            const escapedActiveDays = escapeXML(activeDaysStr);
+            svg += `      <text x="${x + cardWidth / 2}" y="${y + cardHeight - 25}" text-anchor="middle" style="font-size: 16px; fill: ${this.colors.text}; opacity: 0.6;">${escapedActiveDays}</text>
+`;
+          } else {
+            svg += `      <text x="${x + cardWidth / 2}" y="${y + cardHeight / 2 + 5}" text-anchor="middle" style="font-size: 18px; fill: ${this.colors.text}; opacity: 0.5;">No activity</text>
+`;
+          }
+          svg += `    </g>
+`;
+        }
+        svg += `  </g>
+
+`;
+        const footerText = `${totalActiveDays} active ${totalActiveDays === 1 ? "day" : "days"} \u2022 ${this.formatTokens(totalTokens)} tokens \u2022 $${totalCost.toFixed(2)} total \u2022 Updated ${lastUpdated}`;
+        const escapedFooter = escapeXML(footerText);
+        svg += `  <!-- Stats Footer -->
+`;
+        svg += `  <g transform="translate(${outerPadding}, ${height - 25 - outerPadding})">
+`;
+        svg += `    <text x="${width / 2 - outerPadding}" y="10" text-anchor="middle" style="font-size: 12px; fill: ${this.colors.text}; opacity: 0.7;">
+`;
+        svg += `      ${escapedFooter}
+`;
+        svg += `    </text>
+`;
+        svg += `  </g>
+
+`;
+        svg += "</svg>";
+        return svg;
+      }
+    };
+  }
+});
+
+// src/commands/graph.ts
+var graph_exports = {};
+__export(graph_exports, {
+  generateLocalGraph: () => generateLocalGraph
+});
+import chalk8 from "chalk";
+import ora5 from "ora";
+import { writeFile } from "fs/promises";
+async function generateLocalGraph(options) {
+  const outputFile = options.output || "llm-activity.svg";
+  const days = parseInt(options.days || "365", 10);
+  console.log(chalk8.bold.cyan(`
+\u{1F3A8} Generating activity graph...
+`));
+  const spinner = ora5("Fetching usage data...").start();
+  let usageData = [];
+  try {
+    usageData = await CcusageParser.fetchData({ days });
+    spinner.succeed(`Fetched ${usageData.length} days of data`);
+  } catch (error) {
+    spinner.fail("Failed to fetch data");
+    console.log(chalk8.red(`
+\u274C Error: ${error.message}
+`));
+    process.exit(1);
+  }
+  const aggregated = /* @__PURE__ */ new Map();
+  for (const entry of usageData) {
+    if (!aggregated.has(entry.date)) {
+      aggregated.set(entry.date, {
+        date: entry.date,
+        totalTokens: 0,
+        totalCost: 0,
+        totalCalls: 0,
+        byProvider: {}
+      });
+    }
+    const day = aggregated.get(entry.date);
+    const tokens = entry.tokensInput + entry.tokensOutput;
+    day.totalTokens += tokens;
+    day.totalCost += entry.cost;
+    day.totalCalls += entry.calls;
+    if (!day.byProvider[entry.provider]) {
+      day.byProvider[entry.provider] = { tokens: 0, cost: 0, calls: 0 };
+    }
+    day.byProvider[entry.provider].tokens += tokens;
+    day.byProvider[entry.provider].cost += entry.cost;
+    day.byProvider[entry.provider].calls += entry.calls;
+  }
+  const svgSpinner = ora5("Generating SVG...").start();
+  try {
+    const svg = generateSVG(aggregated, { days });
+    await writeFile(outputFile, svg);
+    svgSpinner.succeed(`SVG generated: ${outputFile}`);
+  } catch (error) {
+    svgSpinner.fail("Failed to generate SVG");
+    console.log(chalk8.red(`
+\u274C Error: ${error.message}
+`));
+    process.exit(1);
+  }
+  let totalTokens = 0;
+  let totalCost = 0;
+  let activeDays = 0;
+  for (const day of aggregated.values()) {
+    if (day.totalTokens > 0) activeDays++;
+    totalTokens += day.totalTokens;
+    totalCost += day.totalCost;
+  }
+  console.log(chalk8.gray(`
+\u{1F4C8} Statistics:`));
+  console.log(chalk8.gray(`   Active days: ${activeDays}`));
+  console.log(chalk8.gray(`   Total tokens: ${totalTokens.toLocaleString()}`));
+  console.log(chalk8.gray(`   Total cost: $${totalCost.toFixed(2)}`));
+  console.log(chalk8.green(`
+\u2705 Done!
+`));
+}
+var init_graph = __esm({
+  "src/commands/graph.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_ccusage();
+    init_svg_generator();
+  }
+});
+
+// src/cli.ts
+init_esm_shims();
+import { Command } from "commander";
+
+// src/commands/login.ts
+init_esm_shims();
+import chalk from "chalk";
+import ora from "ora";
+import open from "open";
+import http from "http";
+import { URL } from "url";
+import { randomBytes } from "crypto";
+
+// src/utils/config.ts
+init_esm_shims();
+import Conf from "conf";
+var PRODUCTION_API_URL = "https://llm-activity.timoreichert.com";
+var config = new Conf({
+  projectName: "llm-activity",
+  defaults: {
+    token: "",
+    userId: "",
+    githubLogin: "",
+    apiUrl: "",
+    providers: {
+      claude: { enabled: false },
+      cursor: { enabled: false },
+      openai: { enabled: false }
+    }
+  }
+});
+function getApiUrl() {
+  const raw = process.env.LEADERBOARD_URL || config.get("apiUrl") || PRODUCTION_API_URL;
+  return raw.replace(/\/api\/?$/, "");
+}
+function getConfig() {
+  return config.store;
+}
+function saveConfig(data) {
+  config.set(data);
+}
+function resetConfig() {
+  config.clear();
+}
+function getConfigPath() {
+  return config.path;
+}
+
+// src/commands/login.ts
+import fetch from "node-fetch";
+async function loginCommand() {
+  const config2 = getConfig();
+  if (!config2.token) {
+    const spinner2 = ora("Creating account...").start();
+    try {
+      const token = randomBytes(32).toString("hex");
+      const apiUrl = getApiUrl();
+      const res = await fetch(`${apiUrl}/api/sync`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          token,
+          deviceId: randomBytes(32).toString("hex"),
+          data: [],
+          timestamp: Date.now()
+        })
+      });
+      if (!res.ok) {
+        throw new Error("Failed to create account");
+      }
+      saveConfig({ ...config2, token, createdAt: Date.now() });
+      spinner2.succeed("Account created");
+    } catch (error) {
+      spinner2.fail("Failed to create account");
+      console.log(chalk.red(error.message));
+      if (error.message.includes("ECONNREFUSED")) {
+        console.log(chalk.dim("Make sure the API server is running."));
+      }
+      process.exit(1);
+    }
+  }
+  const updatedConfig = getConfig();
+  const port = await findAvailablePort(9876);
+  const { promise: callbackPromise, server } = createCallbackServer(port);
+  const spinner = ora("Starting Slack login...").start();
+  try {
+    const params = new URLSearchParams({
+      redirect_port: String(port),
+      link_token: updatedConfig.token
+    });
+    const apiUrl = getApiUrl();
+    const authUrl = `${apiUrl}/api/auth/slack?${params}`;
+    spinner.succeed("Opening browser");
+    console.log(chalk.dim(`If browser doesn't open, visit: ${authUrl}`));
+    await open(authUrl);
+    const waitSpinner = ora("Waiting for Slack authorization...").start();
+    const result = await Promise.race([
+      callbackPromise,
+      timeout(12e4, "Authentication timed out after 2 minutes")
+    ]);
+    waitSpinner.stop();
+    server.close();
+    if ("error" in result) {
+      throw new Error(result.error);
+    }
+    console.log(chalk.green(`
+Logged in as ${chalk.bold(result.slackName)}`));
+    console.log(chalk.dim('Run "leaderboard sync" to sync your data.'));
+  } catch (error) {
+    spinner.stop();
+    server.close();
+    console.log(chalk.red(`
+Login failed: ${error.message}`));
+    if (error.message.includes("ECONNREFUSED")) {
+      console.log(chalk.dim("Make sure the API server is running."));
+    } else if (error.message.includes("not configured")) {
+      console.log(chalk.dim("Slack OAuth is not configured on the server."));
+    }
+    process.exit(1);
+  }
+}
+function findAvailablePort(startPort) {
+  return new Promise((resolve) => {
+    const server = http.createServer();
+    server.listen(startPort, () => {
+      server.close(() => resolve(startPort));
+    });
+    server.on("error", () => {
+      resolve(findAvailablePort(startPort + 1));
+    });
+  });
+}
+function createCallbackServer(port) {
+  let resolveCallback;
+  const promise = new Promise((resolve) => {
+    resolveCallback = resolve;
+  });
+  const server = http.createServer((req, res) => {
+    const url = new URL(req.url || "/", `http://localhost:${port}`);
+    if (url.pathname === "/callback") {
+      const slackName = url.searchParams.get("slack_name");
+      const error = url.searchParams.get("error");
+      if (error) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+            <body style="font-family: system-ui; text-align: center; padding: 50px;">
+              <h1>Login Failed</h1>
+              <p>Error: ${error}</p>
+              <p>You can close this window.</p>
+            </body>
+          </html>
+        `);
+        resolveCallback({ error });
+      } else if (slackName) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+            <body style="font-family: system-ui; text-align: center; padding: 50px;">
+              <h1>Login Successful!</h1>
+              <p>Logged in as <strong>${slackName}</strong></p>
+              <p>You can close this window and return to the terminal.</p>
+            </body>
+          </html>
+        `);
+        resolveCallback({ slackName });
+      } else {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+            <body style="font-family: system-ui; text-align: center; padding: 50px;">
+              <h1>Invalid Callback</h1>
+              <p>Something went wrong. Please try again.</p>
+            </body>
+          </html>
+        `);
+        resolveCallback({ error: "Invalid callback" });
+      }
+    } else {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  });
+  server.listen(port);
+  return { promise, server };
+}
+function timeout(ms, message) {
+  return new Promise((_, reject) => {
+    setTimeout(() => reject(new Error(message)), ms);
+  });
+}
+
+// src/commands/login-github.ts
+init_esm_shims();
+import chalk2 from "chalk";
+import ora2 from "ora";
+import open2 from "open";
+import http2 from "http";
+import { URL as URL2 } from "url";
+import fetch2 from "node-fetch";
+async function loginCommand2(_options) {
+  const config2 = getConfig();
+  if (config2.token && config2.githubLogin) {
+    console.log(chalk2.yellow(`Already logged in as ${chalk2.bold(config2.githubLogin)}.`));
+    console.log(chalk2.dim('Run "leaderboard config --reset" to logout first.'));
+    return;
+  }
+  const existingToken = config2.token || null;
+  if (existingToken) {
+    console.log(chalk2.dim("Existing account found. Linking to GitHub..."));
+  }
+  const port = await findAvailablePort2(9876);
+  const { promise: callbackPromise, server } = createCallbackServer2(port);
+  const spinner = ora2("Getting authorization URL...").start();
+  try {
+    const params = new URLSearchParams({ redirect_port: String(port) });
+    if (existingToken) {
+      params.set("link_token", existingToken);
+    }
+    const response = await fetch2(`${getApiUrl()}/api/auth/github?${params}`);
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error || "Failed to get authorization URL");
+    }
+    const { url } = await response.json();
+    spinner.succeed("Opening browser");
+    console.log(chalk2.dim(`If browser doesn't open, visit: ${url}`));
+    await open2(url);
+    const timeoutSpinner = ora2("Waiting for authentication...").start();
+    const result = await Promise.race([
+      callbackPromise,
+      timeout2(12e4, "Authentication timed out after 2 minutes")
+    ]);
+    timeoutSpinner.stop();
+    server.close();
+    if ("error" in result) {
+      throw new Error(result.error);
+    }
+    saveConfig({
+      ...config2,
+      token: result.token,
+      githubLogin: result.username
+    });
+    if (existingToken) {
+      console.log(chalk2.green(`Linked to GitHub as ${chalk2.bold(result.username)}`));
+    } else {
+      console.log(chalk2.green(`Logged in as ${chalk2.bold(result.username)}`));
+    }
+    console.log(chalk2.dim('Run "leaderboard sync" to sync your data.'));
+  } catch (error) {
+    spinner.stop();
+    server.close();
+    console.log(chalk2.red(`Login failed: ${error.message}`));
+    if (error.message.includes("ECONNREFUSED")) {
+      console.log(chalk2.dim("Make sure the API server is running."));
+    }
+    process.exit(1);
+  }
+}
+function findAvailablePort2(startPort) {
+  return new Promise((resolve) => {
+    const server = http2.createServer();
+    server.listen(startPort, () => {
+      server.close(() => resolve(startPort));
+    });
+    server.on("error", () => {
+      resolve(findAvailablePort2(startPort + 1));
+    });
+  });
+}
+function createCallbackServer2(port) {
+  let resolveCallback;
+  const promise = new Promise((resolve) => {
+    resolveCallback = resolve;
+  });
+  const server = http2.createServer((req, res) => {
+    const url = new URL2(req.url || "/", `http://localhost:${port}`);
+    if (url.pathname === "/callback") {
+      const token = url.searchParams.get("token");
+      const username = url.searchParams.get("username");
+      const error = url.searchParams.get("error");
+      if (error) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+            <body style="font-family: system-ui; text-align: center; padding: 50px;">
+              <h1>Authentication Failed</h1>
+              <p>Error: ${error}</p>
+              <p>You can close this window.</p>
+            </body>
+          </html>
+        `);
+        resolveCallback({ error });
+      } else if (token && username) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+            <body style="font-family: system-ui; text-align: center; padding: 50px;">
+              <h1>Authentication Successful!</h1>
+              <p>Logged in as <strong>${username}</strong></p>
+              <p>You can close this window and return to the terminal.</p>
+            </body>
+          </html>
+        `);
+        resolveCallback({ token, username });
+      } else {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+            <body style="font-family: system-ui; text-align: center; padding: 50px;">
+              <h1>Invalid Callback</h1>
+              <p>Missing token or username.</p>
+            </body>
+          </html>
+        `);
+        resolveCallback({ error: "Invalid callback - missing token or username" });
+      }
+    } else {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  });
+  server.listen(port);
+  return { promise, server };
+}
+function timeout2(ms, message) {
+  return new Promise((_, reject) => {
+    setTimeout(() => reject(new Error(message)), ms);
+  });
+}
+
+// src/commands/init.ts
+init_esm_shims();
+import chalk4 from "chalk";
+import prompts from "prompts";
+import ora3 from "ora";
+import { execSync as execSync3 } from "child_process";
+import { readFileSync, writeFileSync, existsSync, mkdirSync as mkdirSync2 } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/utils/cron.ts
+init_esm_shims();
+import { spawnSync } from "child_process";
+import { platform } from "os";
+import { mkdirSync } from "fs";
+import chalk3 from "chalk";
+var CRON_SCHEDULES = {
+  "every-30-min": "*/30 * * * *",
+  // Every 30 minutes
+  hourly: "0 * * * *",
+  // Every hour
+  "four-times-daily": "0 0,6,12,18 * * *",
+  // Every 6 hours
+  daily: "0 0 * * *"
+  // Midnight every day
+};
+async function setupCronJob(frequency) {
+  const os = platform();
+  const cronSchedule = CRON_SCHEDULES[frequency];
+  if (os === "darwin") {
+    await setupLaunchd(frequency);
+  } else if (os === "linux") {
+    await setupCrontab(cronSchedule);
+  } else if (os === "win32") {
+    await setupWindowsTask(frequency);
+  } else {
+    throw new Error(`Unsupported platform: ${os}`);
+  }
+}
+async function setupLaunchd(frequency) {
+  const intervals = {
+    "every-30-min": 1800,
+    // 30 minutes
+    hourly: 3600,
+    // 1 hour
+    "four-times-daily": 21600,
+    // 6 hours
+    daily: 86400
+    // 24 hours
+  };
+  const interval = intervals[frequency] || 1800;
+  const label = "com.llm-activity.sync";
+  const plistPath = `${process.env.HOME}/Library/LaunchAgents/${label}.plist`;
+  let binaryPath;
+  try {
+    const result = spawnSync("which", ["llm-activity"], { encoding: "utf8" });
+    binaryPath = result.stdout.trim();
+    if (!binaryPath || result.status !== 0) {
+      throw new Error("llm-activity not found in PATH");
+    }
+  } catch {
+    throw new Error("llm-activity command not found. Please build and install the CLI first:\n  npm run build\n  npm install -g .");
+  }
+  const homeDir = process.env.HOME;
+  if (!homeDir) {
+    throw new Error("HOME environment variable not set");
+  }
+  const logDir = `${homeDir}/.llm-activity`;
+  const launchAgentsDir = `${homeDir}/Library/LaunchAgents`;
+  const escapedBinaryPath = binaryPath.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  const escapedLogDir = logDir.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${label}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${escapedBinaryPath}</string>
+        <string>sync</string>
+    </array>
+    <key>StartInterval</key>
+    <integer>${interval}</integer>
+    <key>RunAtLoad</key>
+    <false/>
+    <key>StandardErrorPath</key>
+    <string>${escapedLogDir}/sync-error.log</string>
+    <key>StandardOutPath</key>
+    <string>${escapedLogDir}/sync-out.log</string>
+</dict>
+</plist>`;
+  try {
+    mkdirSync(launchAgentsDir, { recursive: true });
+  } catch (error) {
+    throw new Error(`Failed to create LaunchAgents directory: ${error.message}`);
+  }
+  const fs = await import("fs/promises");
+  await fs.writeFile(plistPath, plist);
+  try {
+    spawnSync("launchctl", ["load", plistPath], { stdio: "ignore" });
+  } catch (error) {
+  }
+  console.log(chalk3.gray(`
+   Configured launchd at: ${plistPath}`));
+}
+async function setupCrontab(schedule) {
+  let currentCrontab = "";
+  try {
+    const result2 = spawnSync("crontab", ["-l"], { encoding: "utf8" });
+    if (result2.status === 0) {
+      currentCrontab = result2.stdout;
+    }
+  } catch {
+  }
+  if (currentCrontab.includes("llm-activity sync")) {
+    currentCrontab = currentCrontab.split("\n").filter((line) => !line.includes("llm-activity sync")).join("\n");
+  }
+  let binaryPath;
+  try {
+    const result2 = spawnSync("which", ["llm-activity"], { encoding: "utf8" });
+    binaryPath = result2.stdout.trim();
+    if (!binaryPath || result2.status !== 0) {
+      throw new Error("llm-activity not found in PATH");
+    }
+  } catch {
+    throw new Error("llm-activity command not found. Please build and install the CLI first:\n  npm run build\n  npm install -g .");
+  }
+  const homeDir = process.env.HOME;
+  if (!homeDir) {
+    throw new Error("HOME environment variable not set");
+  }
+  const logFile = `${homeDir}/.llm-activity/sync.log`;
+  const cronEntry = `${schedule} ${binaryPath} sync >> ${logFile} 2>&1`;
+  const newCrontab = currentCrontab ? `${currentCrontab}
+${cronEntry}
+` : `${cronEntry}
+`;
+  const fs = await import("fs/promises");
+  const tmpFile = `/tmp/llm-activity-crontab-${Date.now()}`;
+  await fs.writeFile(tmpFile, newCrontab);
+  const result = spawnSync("crontab", [tmpFile], { encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(`Failed to install crontab: ${result.stderr}`);
+  }
+  await fs.unlink(tmpFile);
+  console.log(chalk3.gray(`
+   Configured crontab: ${schedule}`));
+}
+async function setupWindowsTask(frequency) {
+  const taskName = "LLM-Activity-Sync";
+  let binaryPath;
+  try {
+    const result = spawnSync("where", ["llm-activity"], { encoding: "utf8", shell: false });
+    binaryPath = result.stdout.trim().split("\n")[0];
+    if (!binaryPath || result.status !== 0) {
+      throw new Error("llm-activity not found in PATH");
+    }
+  } catch {
+    throw new Error("llm-activity command not found. Please build and install the CLI first:\n  npm run build\n  npm install -g .");
+  }
+  const tasksToDelete = [taskName, `${taskName}-2`, `${taskName}-6`, `${taskName}-12`, `${taskName}-18`];
+  for (const task of tasksToDelete) {
+    try {
+      spawnSync("schtasks", ["/Delete", "/TN", task, "/F"], { stdio: "ignore" });
+    } catch {
+    }
+  }
+  const tasksToCreate = [];
+  if (frequency === "daily") {
+    tasksToCreate.push({ name: taskName, time: "00:00" });
+  } else if (frequency === "twice-daily") {
+    tasksToCreate.push({ name: taskName, time: "00:00" });
+    tasksToCreate.push({ name: `${taskName}-2`, time: "12:00" });
+  } else if (frequency === "four-times-daily") {
+    tasksToCreate.push({ name: taskName, time: "00:00" });
+    tasksToCreate.push({ name: `${taskName}-6`, time: "06:00" });
+    tasksToCreate.push({ name: `${taskName}-12`, time: "12:00" });
+    tasksToCreate.push({ name: `${taskName}-18`, time: "18:00" });
+  }
+  for (const task of tasksToCreate) {
+    const args = [
+      "/Create",
+      "/TN",
+      task.name,
+      "/TR",
+      `"${binaryPath}" sync`,
+      "/SC",
+      "DAILY",
+      "/ST",
+      task.time,
+      "/F"
+      // Force create (overwrite if exists)
+    ];
+    const result = spawnSync("schtasks", args, { encoding: "utf8", shell: false });
+    if (result.status !== 0) {
+      throw new Error(`Failed to create task ${task.name}: ${result.stderr}`);
+    }
+  }
+  console.log(chalk3.gray(`
+   Configured Windows Task(s): ${tasksToCreate.map((t) => t.name).join(", ")}`));
+}
+
+// src/commands/init.ts
+init_ccusage();
+function configureClaudeCodeRetention() {
+  try {
+    const claudeDir = join(homedir(), ".claude");
+    const settingsPath = join(claudeDir, "settings.json");
+    if (!existsSync(claudeDir)) {
+      mkdirSync2(claudeDir, { recursive: true });
+    }
+    let settings = {};
+    if (existsSync(settingsPath)) {
+      try {
+        const content = readFileSync(settingsPath, "utf8");
+        settings = JSON.parse(content);
+      } catch {
+        settings = {};
+      }
+    }
+    settings.cleanupPeriodDays = 99999;
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf8");
+    return true;
+  } catch (error) {
+    console.log(chalk4.yellow(`\u26A0\uFE0F  Could not configure Claude Code settings: ${error.message}`));
+    return false;
+  }
+}
+async function initCommand(options) {
+  console.log(chalk4.bold.cyan("\n\u{1F680} LLM Activity - Provider Setup\n"));
+  let existingConfig = getConfig();
+  if (!existingConfig.token) {
+    console.log(chalk4.yellow("Not logged in yet. Starting login...\n"));
+    await loginCommand();
+    existingConfig = getConfig();
+    if (!existingConfig.token) {
+      console.log(chalk4.red("\u274C Login required to continue."));
+      process.exit(1);
+    }
+    console.log("");
+  }
+  if (existingConfig.providers?.claude?.enabled || existingConfig.providers?.cursor?.enabled || existingConfig.providers?.openai?.enabled) {
+    console.log(chalk4.yellow("\u26A0\uFE0F  Providers already configured!"));
+    const { proceed } = await prompts({
+      type: "confirm",
+      name: "proceed",
+      message: "Do you want to reconfigure?",
+      initial: false
+    });
+    if (!proceed) {
+      console.log(chalk4.gray("Setup cancelled."));
+      return;
+    }
+  }
+  const spinner = ora3("Checking for ccusage...").start();
+  const hasccusage = isCcusageAvailable();
+  if (!hasccusage) {
+    spinner.fail("ccusage not found");
+    console.log(chalk4.yellow("\nccusage is required for Claude usage tracking."));
+    console.log(chalk4.gray("You can install it with: ./dev.sh install-ccusage\n"));
+    const { installNow } = await prompts({
+      type: "confirm",
+      name: "installNow",
+      message: "Would you like to install ccusage now?",
+      initial: true
+    });
+    if (installNow) {
+      console.log(chalk4.cyan("\nInstalling ccusage...\n"));
+      try {
+        execSync3("npm install -g ccusage", { stdio: "inherit" });
+        if (isCcusageAvailable()) {
+          console.log(chalk4.green("\n\u2705 ccusage installed successfully!\n"));
+          console.log(chalk4.gray("Continuing with setup...\n"));
+        } else {
+          console.log(chalk4.yellow("\n\u26A0\uFE0F  Installation completed but ccusage not found in PATH"));
+          console.log(chalk4.gray("You may need to restart your terminal or check your PATH.\n"));
+          console.log(chalk4.gray("Run init again after restarting: leaderboard init\n"));
+          process.exit(1);
+        }
+      } catch (error) {
+        console.log(chalk4.red("\n\u274C Installation failed"));
+        console.log(chalk4.gray(`Error: ${error.message}
+`));
+        console.log(chalk4.yellow("You can try installing manually:"));
+        console.log(chalk4.white("  npm install -g ccusage\n"));
+        console.log(chalk4.gray("Then run init again: leaderboard init\n"));
+        process.exit(1);
+      }
+    } else {
+      console.log(chalk4.yellow("\nYou can still set up without Claude tracking."));
+      console.log(chalk4.gray("You can install ccusage later and re-run: ./dev.sh cli init\n"));
+      const { continueWithout } = await prompts({
+        type: "confirm",
+        name: "continueWithout",
+        message: "Continue setup without Claude tracking?",
+        initial: false
+      });
+      if (!continueWithout) {
+        console.log(chalk4.gray("\nSetup cancelled.\n"));
+        process.exit(0);
+      }
+    }
+  } else {
+    spinner.succeed("ccusage found");
+  }
+  console.log(chalk4.bold("\n\u{1F4CA} Provider Configuration\n"));
+  const { enableClaude } = await prompts({
+    type: "confirm",
+    name: "enableClaude",
+    message: "Enable Claude usage tracking? (via ccusage)",
+    initial: hasccusage
+  });
+  if (enableClaude) {
+    const settingsSpinner = ora3("Configuring Claude Code settings...").start();
+    if (configureClaudeCodeRetention()) {
+      settingsSpinner.succeed("Claude Code configured to retain usage data");
+      console.log(chalk4.gray("   Set cleanupPeriodDays to 99999 in ~/.claude/settings.json"));
+    } else {
+      settingsSpinner.warn("Could not configure Claude Code settings automatically");
+      console.log(chalk4.gray("   You can manually set cleanupPeriodDays to 99999 in ~/.claude/settings.json"));
+    }
+  }
+  const { enableCursor } = await prompts({
+    type: "confirm",
+    name: "enableCursor",
+    message: "Enable Cursor usage tracking?",
+    initial: false
+  });
+  const { enableOpenAI } = await prompts({
+    type: "confirm",
+    name: "enableOpenAI",
+    message: "Enable OpenAI usage tracking?",
+    initial: false
+  });
+  let cursorApiKey, openaiApiKey;
+  if (enableCursor) {
+    const { apiKey } = await prompts({
+      type: "password",
+      name: "apiKey",
+      message: "Cursor API key (optional, leave empty to skip):"
+    });
+    cursorApiKey = apiKey;
+  }
+  if (enableOpenAI) {
+    const { apiKey } = await prompts({
+      type: "password",
+      name: "apiKey",
+      message: "OpenAI API key (optional, leave empty to skip):"
+    });
+    openaiApiKey = apiKey;
+  }
+  saveConfig({
+    ...existingConfig,
+    providers: {
+      claude: { enabled: enableClaude },
+      cursor: { enabled: enableCursor, apiKey: cursorApiKey },
+      openai: { enabled: enableOpenAI, apiKey: openaiApiKey }
+    },
+    createdAt: existingConfig.createdAt || Date.now()
+  });
+  console.log(chalk4.green("\n\u2705 Configuration saved"));
+  if (options.cron !== false) {
+    console.log(chalk4.bold("\n\u23F0 Automatic Sync Setup\n"));
+    const { setupCron } = await prompts({
+      type: "confirm",
+      name: "setupCron",
+      message: "Set up automatic sync? (recommended)",
+      initial: true
+    });
+    if (setupCron) {
+      const { frequency } = await prompts({
+        type: "select",
+        name: "frequency",
+        message: "How often should we sync?",
+        choices: [
+          { title: "Every 30 minutes (recommended)", value: "every-30-min" },
+          { title: "Every hour", value: "hourly" },
+          { title: "Every 6 hours", value: "four-times-daily" },
+          { title: "Daily at midnight", value: "daily" }
+        ],
+        initial: 0
+      });
+      try {
+        await setupCronJob(frequency);
+        console.log(chalk4.green("\u2705 Cron job configured"));
+      } catch (error) {
+        console.log(chalk4.yellow(`
+\u26A0\uFE0F  Could not set up cron job`));
+        if (error.message.includes("not found")) {
+          console.log(chalk4.gray("\nThe CLI needs to be built and installed globally for cron jobs to work."));
+          console.log(chalk4.gray("Run these commands to install:\n"));
+          console.log(chalk4.white("  cd cli"));
+          console.log(chalk4.white("  npm run build"));
+          console.log(chalk4.white("  npm install -g .\n"));
+          console.log(chalk4.gray("Then run init again to set up cron: leaderboard init\n"));
+        } else {
+          console.log(chalk4.gray(`
+Error: ${error.message}
+`));
+        }
+        console.log(chalk4.gray("For now, you can manually run sync with:"));
+        console.log(chalk4.cyan("  ./dev.sh cli sync\n"));
+      }
+    }
+  }
+  const token = existingConfig.token;
+  const graphUrl = `${getApiUrl()}/graph.svg?token=${token}`;
+  console.log(chalk4.bold.green("\n\u{1F389} Setup complete!\n"));
+  console.log(chalk4.bold("Your activity graph URL:\n"));
+  console.log(chalk4.cyan(`  ${graphUrl}
+`));
+  console.log(chalk4.bold("Add to your GitHub README:\n"));
+  console.log(chalk4.gray("  ```markdown"));
+  console.log(chalk4.white(`  ![LLM Activity](${graphUrl})`));
+  console.log(chalk4.gray("  ```\n"));
+  console.log(chalk4.bold("Next steps:\n"));
+  console.log(chalk4.gray("  1. Run your first sync:"), chalk4.cyan("leaderboard sync"));
+  console.log(chalk4.gray("  2. Check status:"), chalk4.cyan("leaderboard status"));
+  console.log(chalk4.gray("  3. View graph:"), chalk4.cyan(`open ${graphUrl}
+`));
+}
+
+// src/commands/sync.ts
+init_esm_shims();
+import chalk5 from "chalk";
+import ora4 from "ora";
+import { createHash } from "crypto";
+import { hostname } from "os";
+init_ccusage();
+import fetch3 from "node-fetch";
+function getDeviceId() {
+  const machineId = hostname();
+  return createHash("sha256").update(machineId).digest("hex");
+}
+async function syncCommand(options) {
+  const config2 = getConfig();
+  if (!config2.token) {
+    console.log(chalk5.red("\u274C Not initialized. Run: leaderboard init"));
+    process.exit(1);
+  }
+  if (!options.force && config2.lastSync) {
+    const hoursSinceSync = (Date.now() - config2.lastSync) / (1e3 * 60 * 60);
+    if (hoursSinceSync < 1) {
+      console.log(chalk5.yellow(`\u23ED\uFE0F  Synced ${Math.round(hoursSinceSync * 60)} minutes ago. Use --force to sync anyway.`));
+      return;
+    }
+  }
+  const days = parseInt(options.days || "365", 10);
+  console.log(chalk5.bold.cyan(`
+\u{1F4CA} Syncing ${days} days of activity...
+`));
+  const allUsageData = [];
+  if (config2.providers?.claude?.enabled) {
+    const spinner = ora4("Fetching Claude usage data...").start();
+    try {
+      const claudeData = await CcusageParser.fetchData({ days });
+      allUsageData.push(...claudeData);
+      spinner.succeed(`Fetched ${claudeData.length} days from Claude`);
+    } catch (error) {
+      spinner.fail(`Failed to fetch Claude data: ${error.message}`);
+    }
+  }
+  if (config2.providers?.cursor?.enabled) {
+    console.log(chalk5.gray("\u23ED\uFE0F  Cursor sync not yet implemented"));
+  }
+  if (config2.providers?.openai?.enabled) {
+    console.log(chalk5.gray("\u23ED\uFE0F  OpenAI sync not yet implemented"));
+  }
+  if (allUsageData.length === 0) {
+    console.log(chalk5.yellow("\n\u26A0\uFE0F  No usage data found"));
+    return;
+  }
+  const stats = calculateStats(allUsageData);
+  console.log(chalk5.gray(`
+\u{1F4C8} Statistics:`));
+  console.log(chalk5.gray(`   Active days: ${stats.activeDays}`));
+  console.log(chalk5.gray(`   Total tokens: ${stats.totalTokens.toLocaleString()}`));
+  console.log(chalk5.gray(`   Total cost: $${stats.totalCost.toFixed(2)}`));
+  const uploadSpinner = ora4("Uploading to cloud...").start();
+  try {
+    const deviceId = getDeviceId();
+    const response = await fetch3(`${getApiUrl()}/api/sync`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        token: config2.token,
+        deviceId,
+        data: allUsageData,
+        timestamp: Date.now()
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`API error: ${response.status} - ${errorText}`);
+    }
+    const result = await response.json();
+    uploadSpinner.succeed("Sync complete");
+    config2.lastSync = Date.now();
+    saveConfig(config2);
+    console.log(chalk5.green("\n\u2705 Successfully synced!"));
+    if (result.graph_urls && Object.keys(result.graph_urls).length > 0) {
+      console.log(chalk5.bold.cyan("\n\u{1F3A8} Your Activity Graphs:\n"));
+      const themes = ["dark", "light"];
+      const views = ["biweekly", "biweekly-compact", "monthly", "yearly"];
+      for (const theme of themes) {
+        console.log(chalk5.bold(`  ${theme === "dark" ? "\u{1F319}" : "\u2600\uFE0F "} ${theme}:`));
+        for (const view of views) {
+          const key = `${theme}-${view}`;
+          if (result.graph_urls[key]) {
+            console.log(chalk5.cyan(`     ${view.padEnd(17)}: ${result.graph_urls[key]}`));
+          }
+        }
+        console.log("");
+      }
+    } else {
+      console.log(chalk5.gray(`
+\u{1F4CA} View your graph:`));
+      console.log(chalk5.cyan(`   ${getApiUrl()}/graph.svg?token=${config2.token}
+`));
+    }
+  } catch (error) {
+    uploadSpinner.fail("Upload failed");
+    console.log(chalk5.red(`
+\u274C Error: ${error.message}`));
+    if (error.message.includes("ECONNREFUSED") || error.message.includes("fetch failed")) {
+      console.log(chalk5.yellow("\n\u26A0\uFE0F  Could not connect to API server."));
+      console.log(chalk5.gray("   Make sure the API is running or check your internet connection."));
+    }
+    process.exit(1);
+  }
+}
+function calculateStats(data) {
+  const uniqueDates = new Set(data.map((d) => d.date));
+  const totalTokens = data.reduce((sum, d) => sum + d.tokensInput + d.tokensOutput, 0);
+  const totalCost = data.reduce((sum, d) => sum + d.cost, 0);
+  return {
+    activeDays: uniqueDates.size,
+    totalTokens,
+    totalCost
+  };
+}
+
+// src/commands/status.ts
+init_esm_shims();
+import chalk6 from "chalk";
+async function statusCommand(options) {
+  const config2 = getConfig();
+  if (!config2.token) {
+    console.log(chalk6.red("\n\u274C Not initialized. Run: leaderboard init\n"));
+    process.exit(1);
+  }
+  console.log(chalk6.bold.cyan("\n\u{1F4CA} LLM Activity Status\n"));
+  if (config2.lastSync) {
+    const lastSyncDate = new Date(config2.lastSync);
+    const hoursSince = (Date.now() - config2.lastSync) / (1e3 * 60 * 60);
+    const timeAgo = hoursSince < 1 ? `${Math.round(hoursSince * 60)} minutes ago` : hoursSince < 24 ? `${Math.round(hoursSince)} hours ago` : `${Math.round(hoursSince / 24)} days ago`;
+    console.log(chalk6.green("\u2705 Synced"), chalk6.gray(timeAgo));
+    console.log(chalk6.gray(`   ${lastSyncDate.toLocaleString()}`));
+  } else {
+    console.log(chalk6.yellow("\u26A0\uFE0F  Never synced"));
+    console.log(chalk6.gray("   Run: leaderboard sync"));
+  }
+  console.log(chalk6.bold("\n\u{1F4E6} Enabled Providers:\n"));
+  const providers = config2.providers || {};
+  if (providers.claude?.enabled) {
+    console.log(chalk6.green("  \u2713 Claude"), chalk6.gray("(via ccusage)"));
+  } else {
+    console.log(chalk6.gray("  \u2717 Claude"));
+  }
+  if (providers.cursor?.enabled) {
+    console.log(chalk6.green("  \u2713 Cursor"));
+  } else {
+    console.log(chalk6.gray("  \u2717 Cursor"));
+  }
+  if (providers.openai?.enabled) {
+    console.log(chalk6.green("  \u2713 OpenAI"));
+  } else {
+    console.log(chalk6.gray("  \u2717 OpenAI"));
+  }
+  console.log(chalk6.bold("\n\u{1F517} Activity Graphs:\n"));
+  console.log(chalk6.gray('  Run "leaderboard sync" to generate your graphs'));
+  console.log(chalk6.gray("  URLs will be displayed after syncing\n"));
+  if (options.verbose) {
+    console.log(chalk6.bold("\u{1F527} Configuration:\n"));
+    console.log(chalk6.gray(`  User ID: ${config2.userId}`));
+    console.log(chalk6.gray(`  Token: ${config2.token?.substring(0, 16)}...`));
+    console.log(chalk6.gray(`  Created: ${config2.createdAt ? new Date(config2.createdAt).toLocaleString() : "unknown"}
+`));
+  }
+  if (config2.lastSync) {
+    const nextSync = new Date(config2.lastSync + 24 * 60 * 60 * 1e3);
+    if (nextSync > /* @__PURE__ */ new Date()) {
+      console.log(chalk6.gray(`\u23F0 Next automatic sync: ${nextSync.toLocaleString()}
+`));
+    }
+  }
+}
+
+// src/commands/config.ts
+init_esm_shims();
+import chalk7 from "chalk";
+import prompts2 from "prompts";
+async function configCommand(options) {
+  if (options.show) {
+    showConfig();
+  } else if (options.reset) {
+    await resetConfigCommand();
+  } else if (options.set) {
+    await setConfigValue(options.set);
+  } else {
+    await interactiveConfig();
+  }
+}
+function maskSecret(value) {
+  if (!value) return "";
+  if (value.length <= 8) return "****";
+  return value.slice(0, 4) + "..." + value.slice(-4);
+}
+function showConfig() {
+  const config2 = getConfig();
+  const safeConfig = {
+    ...config2,
+    token: config2.token ? maskSecret(config2.token) : "",
+    providers: config2.providers ? {
+      claude: config2.providers.claude,
+      cursor: {
+        ...config2.providers.cursor,
+        apiKey: config2.providers.cursor?.apiKey ? maskSecret(config2.providers.cursor.apiKey) : void 0
+      },
+      openai: {
+        ...config2.providers.openai,
+        apiKey: config2.providers.openai?.apiKey ? maskSecret(config2.providers.openai.apiKey) : void 0
+      }
+    } : void 0
+  };
+  console.log(chalk7.bold("Configuration"));
+  console.log(chalk7.dim(`File: ${getConfigPath()}
+`));
+  console.log(JSON.stringify(safeConfig, null, 2));
+  console.log();
+}
+async function resetConfigCommand() {
+  const { confirm } = await prompts2({
+    type: "confirm",
+    name: "confirm",
+    message: "Are you sure you want to reset all configuration?",
+    initial: false
+  });
+  if (confirm) {
+    resetConfig();
+    console.log(chalk7.green("\n\u2705 Configuration reset\n"));
+  } else {
+    console.log(chalk7.gray("\nCancelled\n"));
+  }
+}
+async function setConfigValue(keyValue) {
+  const [key, ...valueParts] = keyValue.split("=");
+  const value = valueParts.join("=");
+  if (!key || value === void 0) {
+    console.log(chalk7.red("\n\u274C Invalid format. Use: --set key=value\n"));
+    process.exit(1);
+  }
+  const config2 = getConfig();
+  const keys = key.split(".");
+  let current = config2;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (!current[keys[i]]) {
+      current[keys[i]] = {};
+    }
+    current = current[keys[i]];
+  }
+  let parsedValue = value;
+  try {
+    parsedValue = JSON.parse(value);
+  } catch {
+  }
+  current[keys[keys.length - 1]] = parsedValue;
+  saveConfig(config2);
+  console.log(chalk7.green(`
+\u2705 Set ${key} = ${value}
+`));
+}
+async function interactiveConfig() {
+  console.log(chalk7.bold.cyan("\n\u2699\uFE0F  Interactive Configuration\n"));
+  const config2 = getConfig();
+  const { action } = await prompts2({
+    type: "select",
+    name: "action",
+    message: "What would you like to configure?",
+    choices: [
+      { title: "View current configuration", value: "show" },
+      { title: "Enable/disable providers", value: "providers" },
+      { title: "Change API keys", value: "apikeys" },
+      { title: "Reset configuration", value: "reset" },
+      { title: "Cancel", value: "cancel" }
+    ]
+  });
+  if (action === "show") {
+    showConfig();
+  } else if (action === "providers") {
+    await configureProviders(config2);
+  } else if (action === "apikeys") {
+    await configureApiKeys(config2);
+  } else if (action === "reset") {
+    await resetConfigCommand();
+  }
+}
+async function configureProviders(config2) {
+  const { enableClaude, enableCursor, enableOpenAI } = await prompts2([
+    {
+      type: "confirm",
+      name: "enableClaude",
+      message: "Enable Claude?",
+      initial: config2.providers?.claude?.enabled || false
+    },
+    {
+      type: "confirm",
+      name: "enableCursor",
+      message: "Enable Cursor?",
+      initial: config2.providers?.cursor?.enabled || false
+    },
+    {
+      type: "confirm",
+      name: "enableOpenAI",
+      message: "Enable OpenAI?",
+      initial: config2.providers?.openai?.enabled || false
+    }
+  ]);
+  config2.providers = {
+    ...config2.providers,
+    claude: { ...config2.providers?.claude, enabled: enableClaude },
+    cursor: { ...config2.providers?.cursor, enabled: enableCursor },
+    openai: { ...config2.providers?.openai, enabled: enableOpenAI }
+  };
+  saveConfig(config2);
+  console.log(chalk7.green("\n\u2705 Providers updated\n"));
+}
+async function configureApiKeys(config2) {
+  const { provider } = await prompts2({
+    type: "select",
+    name: "provider",
+    message: "Which provider?",
+    choices: [
+      { title: "Cursor", value: "cursor" },
+      { title: "OpenAI", value: "openai" }
+    ]
+  });
+  const { apiKey } = await prompts2({
+    type: "password",
+    name: "apiKey",
+    message: `Enter ${provider} API key:`
+  });
+  if (!config2.providers) config2.providers = {};
+  if (!config2.providers[provider]) config2.providers[provider] = {};
+  config2.providers[provider].apiKey = apiKey;
+  saveConfig(config2);
+  console.log(chalk7.green(`
+\u2705 ${provider} API key updated
+`));
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("agent-leaderboard").description("Track and visualize your LLM usage activity in GitHub-style contribution graphs").version("0.1.0");
+program.command("login [provider]").description("Log in with Slack (default) or GitHub").action((provider) => {
+  if (provider === "github") {
+    return loginCommand2({});
+  }
+  return loginCommand();
+});
+program.command("init").description("Initialize LLM Activity tracking (configure providers)").option("--no-cron", "Skip cron job setup").action(initCommand);
+program.command("sync").description("Sync your LLM usage data to the cloud").option("-d, --days <number>", "Number of days to sync", "365").option("-f, --force", "Force sync even if recently synced").action(syncCommand);
+program.command("status").description("Show sync status and statistics").option("-v, --verbose", "Show detailed statistics").action(statusCommand);
+program.command("config").description("Manage configuration").option("-s, --show", "Show current configuration").option("-r, --reset", "Reset configuration").option("--set <key=value>", "Set configuration value").action(configCommand);
+program.command("graph").description("Generate SVG graph locally (for testing)").option("-o, --output <file>", "Output file", "llm-activity.svg").option("-d, --days <number>", "Number of days", "365").action(async (options) => {
+  const { generateLocalGraph: generateLocalGraph2 } = await Promise.resolve().then(() => (init_graph(), graph_exports));
+  await generateLocalGraph2(options);
+});
+if (process.argv.length === 2) {
+  program.help();
+}
+program.parse();