vibestats 1.3.3 → 1.3.5

package/dist/index.js

@@ -3,6 +3,663 @@
 // src/index.ts
 import { defineCommand, runMain } from "citty";
 
+// src/codex-pricing.ts
+var GPT_54_PRICING = { input: 2.5, output: 15, cachedInput: 0.25 };
+var GPT_53_PRICING = { input: 1.75, output: 14, cachedInput: 0.175 };
+var GPT_51_PRICING = { input: 1.25, output: 10, cachedInput: 0.125 };
+var GPT_5_MINI_PRICING = { input: 0.25, output: 2, cachedInput: 0.025 };
+var GPT_5_NANO_PRICING = { input: 0.05, output: 0.4, cachedInput: 5e-3 };
+var GPT_4O_PRICING = { input: 2.5, output: 10, cachedInput: 1.25 };
+var GPT_4O_MINI_PRICING = { input: 0.15, output: 0.6, cachedInput: 0.075 };
+var CODEX_MODEL_DEFINITIONS = [
+  {
+    key: "gpt-5.4",
+    displayName: "GPT-5.4",
+    token: "g54",
+    sortPriority: 77,
+    pricing: GPT_54_PRICING,
+    aliases: ["GPT-5.4"],
+    exactNames: ["gpt-5.4"]
+  },
+  {
+    key: "gpt-5.3-codex-spark",
+    displayName: "GPT-5.3 Codex Spark",
+    token: "g53s",
+    sortPriority: 76,
+    pricing: GPT_53_PRICING,
+    aliases: ["GPT-5.3 Codex Spark"],
+    exactNames: ["gpt-5.3-codex-spark"],
+    includePatterns: [["5.3", "spark"]]
+  },
+  {
+    key: "gpt-5.3-codex",
+    displayName: "GPT-5.3 Codex",
+    token: "g53c",
+    sortPriority: 75,
+    pricing: GPT_53_PRICING,
+    aliases: ["GPT-5.3 Codex"],
+    exactNames: ["gpt-5.3-codex"],
+    includePatterns: [["5.3", "codex"]]
+  },
+  {
+    key: "gpt-5.3",
+    displayName: "GPT-5.3",
+    token: "g53",
+    sortPriority: 74,
+    pricing: GPT_53_PRICING,
+    aliases: ["GPT-5.3"],
+    exactNames: ["gpt-5.3"],
+    includePatterns: [["5.3"]]
+  },
+  {
+    key: "gpt-5.2-codex",
+    displayName: "GPT-5.2 Codex",
+    token: "g52c",
+    sortPriority: 73,
+    pricing: GPT_53_PRICING,
+    aliases: ["GPT-5.2 Codex"],
+    exactNames: ["gpt-5.2-codex"],
+    includePatterns: [["5.2", "codex"]]
+  },
+  {
+    key: "gpt-5.2",
+    displayName: "GPT-5.2",
+    token: "g52",
+    sortPriority: 72,
+    pricing: GPT_53_PRICING,
+    aliases: ["GPT-5.2"],
+    exactNames: ["gpt-5.2"],
+    includePatterns: [["5.2"]]
+  },
+  {
+    key: "gpt-5.1-codex-max",
+    displayName: "GPT-5.1 Codex Max",
+    token: "g51cm",
+    sortPriority: 71,
+    pricing: GPT_51_PRICING,
+    aliases: ["GPT-5.1 Codex Max"],
+    exactNames: ["gpt-5.1-codex-max"],
+    includePatterns: [["5.1", "codex", "max"]]
+  },
+  {
+    key: "legacy-gpt-5.1-max",
+    displayName: "GPT-5.1 Max",
+    token: "g51m",
+    sortPriority: 70,
+    pricing: GPT_51_PRICING,
+    aliases: ["GPT-5.1 Max"]
+  },
+  {
+    key: "gpt-5.1-codex-mini",
+    displayName: "GPT-5.1 Codex Mini",
+    token: "g51cn",
+    sortPriority: 69,
+    pricing: GPT_5_MINI_PRICING,
+    aliases: ["GPT-5.1 Codex Mini"],
+    exactNames: ["gpt-5.1-codex-mini"],
+    includePatterns: [["5.1", "codex", "mini"]]
+  },
+  {
+    key: "legacy-gpt-5.1-mini",
+    displayName: "GPT-5.1 Mini",
+    token: "g51n",
+    sortPriority: 68,
+    pricing: GPT_5_MINI_PRICING,
+    aliases: ["GPT-5.1 Mini"]
+  },
+  {
+    key: "gpt-5.1-codex",
+    displayName: "GPT-5.1 Codex",
+    token: "g51c",
+    sortPriority: 67,
+    pricing: GPT_51_PRICING,
+    aliases: ["GPT-5.1 Codex"],
+    exactNames: ["gpt-5.1-codex"],
+    includePatterns: [["5.1", "codex"]]
+  },
+  {
+    key: "gpt-5.1",
+    displayName: "GPT-5.1",
+    token: "g51",
+    sortPriority: 66,
+    pricing: GPT_51_PRICING,
+    aliases: ["GPT-5.1"],
+    exactNames: ["gpt-5.1"],
+    includePatterns: [["5.1"]]
+  },
+  {
+    key: "gpt-5",
+    displayName: "GPT-5",
+    token: "g5",
+    sortPriority: 64,
+    pricing: GPT_51_PRICING,
+    aliases: ["GPT-5"],
+    exactNames: ["gpt-5"]
+  },
+  {
+    key: "gpt-5-codex",
+    displayName: "GPT-5 Codex",
+    sortPriority: 64,
+    pricing: GPT_51_PRICING,
+    aliases: ["GPT-5 Codex"],
+    exactNames: ["gpt-5-codex"]
+  },
+  {
+    key: "gpt-5-mini",
+    displayName: "GPT-5 Mini",
+    token: "g5n",
+    sortPriority: 63,
+    pricing: GPT_5_MINI_PRICING,
+    aliases: ["GPT-5 Mini"],
+    exactNames: ["gpt-5-mini"]
+  },
+  {
+    key: "gpt-5-codex-mini",
+    displayName: "GPT-5 Mini",
+    token: "g5n",
+    sortPriority: 63,
+    pricing: GPT_5_MINI_PRICING,
+    aliases: ["GPT-5 Codex Mini"],
+    exactNames: ["gpt-5-codex-mini"]
+  },
+  {
+    key: "gpt-5-nano",
+    displayName: "GPT-5 Nano",
+    sortPriority: 62,
+    pricing: GPT_5_NANO_PRICING,
+    aliases: ["GPT-5 Nano"],
+    exactNames: ["gpt-5-nano"]
+  },
+  {
+    key: "gpt-4o",
+    displayName: "GPT-4o",
+    token: "g4o",
+    sortPriority: 60,
+    pricing: GPT_4O_PRICING,
+    aliases: ["GPT-4o"],
+    exactNames: ["gpt-4o"]
+  },
+  {
+    key: "gpt-4o-mini",
+    displayName: "GPT-4o Mini",
+    token: "g4om",
+    sortPriority: 59,
+    pricing: GPT_4O_MINI_PRICING,
+    aliases: ["GPT-4o Mini"],
+    exactNames: ["gpt-4o-mini"]
+  }
+];
+function normalizeName(value) {
+  return value.trim().toLowerCase();
+}
+function findCodexModelDefinition(modelName) {
+  const normalized = normalizeName(modelName);
+  const exactMatch = CODEX_MODEL_DEFINITIONS.find((definition) => {
+    if (normalizeName(definition.displayName) === normalized) {
+      return true;
+    }
+    if (definition.aliases?.some((alias) => normalizeName(alias) === normalized)) {
+      return true;
+    }
+    if (definition.exactNames?.includes(normalized)) {
+      return true;
+    }
+    return false;
+  });
+  if (exactMatch) {
+    return exactMatch;
+  }
+  return CODEX_MODEL_DEFINITIONS.find(
+    (definition) => definition.includePatterns?.some(
+      (pattern) => pattern.every((part) => normalized.includes(part))
+    ) ?? false
+  );
+}
+function formatUnknownCodexDisplayName(modelName) {
+  const normalized = normalizeName(modelName);
+  if (normalized.includes("4o-mini")) return "GPT-4o Mini";
+  if (normalized.includes("4o")) return "GPT-4o";
+  const gpt5Match = normalized.match(/gpt[- ]?5(?:\.(\d+))?/);
+  if (!gpt5Match) {
+    return modelName;
+  }
+  const version = gpt5Match[1] ? `.${gpt5Match[1]}` : "";
+  if (normalized.includes("mini")) return `GPT-5${version} Mini`;
+  if (normalized.includes("nano")) return `GPT-5${version} Nano`;
+  if (normalized.includes("codex")) return `GPT-5${version} Codex`;
+  return `GPT-5${version}`;
+}
+function encodeRawModelToken(displayName) {
+  return `raw_${encodeURIComponent(displayName)}`;
+}
+var CODEX_MODEL_PRICING = CODEX_MODEL_DEFINITIONS.reduce(
+  (acc, definition) => {
+    if (definition.pricing && definition.exactNames?.length) {
+      acc[definition.exactNames[0]] = definition.pricing;
+    }
+    return acc;
+  },
+  {}
+);
+function getCodexModelPricing(modelName) {
+  return findCodexModelDefinition(modelName)?.pricing ?? GPT_51_PRICING;
+}
+function getCodexModelAbbreviation(modelName) {
+  const definition = findCodexModelDefinition(modelName);
+  if (definition?.token) {
+    return definition.token;
+  }
+  return encodeRawModelToken(getCodexModelDisplayName(modelName));
+}
+function getCodexModelDisplayName(modelName) {
+  return findCodexModelDefinition(modelName)?.displayName ?? formatUnknownCodexDisplayName(modelName);
+}
+function getCodexModelSortPriority(modelName) {
+  const definition = findCodexModelDefinition(modelName);
+  if (definition) {
+    return definition.sortPriority;
+  }
+  const displayName = getCodexModelDisplayName(modelName);
+  const gpt5VersionMatch = displayName.match(/^GPT-5\.(\d+)/);
+  if (gpt5VersionMatch) {
+    return 64 + parseInt(gpt5VersionMatch[1], 10);
+  }
+  if (displayName === "GPT-5 Mini") return 63;
+  if (displayName === "GPT-5 Nano") return 62;
+  if (displayName === "GPT-5") return 64;
+  if (displayName === "GPT-4o Mini") return 59;
+  if (displayName === "GPT-4o") return 60;
+  return 0;
+}
+function calculateCodexCost(modelName, inputTokens, outputTokens, cachedInputTokens) {
+  const pricing = getCodexModelPricing(modelName);
+  const regularInputTokens = inputTokens - cachedInputTokens;
+  const inputCost = regularInputTokens / 1e6 * pricing.input;
+  const cachedCost = cachedInputTokens / 1e6 * pricing.cachedInput;
+  const outputCost = outputTokens / 1e6 * pricing.output;
+  return inputCost + cachedCost + outputCost;
+}
+
+// src/url-encoder.ts
+function formatCompactNumber(num) {
+  if (num >= 1e9) {
+    return `${(num / 1e9).toFixed(1)}B`;
+  }
+  if (num >= 1e6) {
+    return `${(num / 1e6).toFixed(1)}M`;
+  }
+  if (num >= 1e3) {
+    return `${(num / 1e3).toFixed(1)}K`;
+  }
+  return num.toString();
+}
+var dayToNumber = {
+  Sunday: 0,
+  Monday: 1,
+  Tuesday: 2,
+  Wednesday: 3,
+  Thursday: 4,
+  Friday: 5,
+  Saturday: 6
+};
+function encodeStatsToUrl(stats, baseUrl = "https://vibestats.wolfai.dev") {
+  const params = new URLSearchParams();
+  params.set("s", stats.sessions.toString());
+  params.set("t", formatCompactNumber(stats.totalTokens));
+  params.set("c", stats.totalCost.toFixed(2));
+  params.set("d", stats.daysActive.toString());
+  params.set("ls", stats.longestStreak.toString());
+  params.set("cs", stats.currentStreak.toString());
+  params.set("ph", stats.peakHour.toString());
+  params.set("pd", (dayToNumber[stats.peakDay] ?? 0).toString());
+  params.set("fm", getModelTokenFromDisplayName(stats.favoriteModel));
+  const mbParts = stats.modelBreakdown.slice(0, 3).map((m) => {
+    const abbr = getModelTokenFromDisplayName(m.model);
+    return `${abbr}:${m.percentage}`;
+  });
+  params.set("mb", mbParts.join(","));
+  if (stats.topTools && stats.topTools.length > 0) {
+    params.set("tt", stats.topTools.slice(0, 5).join(","));
+  }
+  if (stats.developerStyle) {
+    const styleMap = {
+      reader: "r",
+      writer: "w",
+      executor: "e",
+      balanced: "b"
+    };
+    params.set("st", styleMap[stats.developerStyle] || "b");
+  }
+  if (stats.topProject) {
+    params.set("tp", stats.topProject);
+  }
+  if (stats.projectCount) {
+    params.set("pc", stats.projectCount.toString());
+  }
+  params.set("wg", formatCompactNumber(stats.wordsGenerated));
+  const firstDate = new Date(stats.firstSessionDate);
+  params.set("fad", firstDate.toISOString().split("T")[0].replace(/-/g, ""));
+  if (stats.source && stats.source !== "claude") {
+    params.set("src", stats.source);
+  }
+  if (stats.activity) {
+    params.set("act", encodePayload(stats.activity));
+  }
+  return `${baseUrl}/wrapped/?${params.toString()}`;
+}
+function encodeActivityToUrl(payload, baseUrl = "https://vibestats.wolfai.dev") {
+  const params = new URLSearchParams();
+  params.set("activity", encodePayload(payload));
+  if (payload.source !== "claude") {
+    params.set("src", payload.source);
+  }
+  return `${baseUrl}/activity?${params.toString()}`;
+}
+var CLAUDE_DISPLAY_TO_TOKEN = {
+  "Opus 4.6": "o46",
+  "Opus 4.5": "o45",
+  "Opus 4.1": "o41",
+  Opus: "opus",
+  "Sonnet 4.6": "s46",
+  "Sonnet 4.5": "s45",
+  "Sonnet 3.5": "s35",
+  Sonnet: "sonnet",
+  "Haiku 4.5": "h45",
+  "Haiku 3.5": "h35",
+  Haiku: "haiku"
+};
+function getModelTokenFromDisplayName(displayName) {
+  if (CLAUDE_DISPLAY_TO_TOKEN[displayName]) {
+    return CLAUDE_DISPLAY_TO_TOKEN[displayName];
+  }
+  const normalized = displayName.toLowerCase();
+  if (normalized.includes("opus") && normalized.includes("4.6")) return "o46";
+  if (normalized.includes("opus") && normalized.includes("4.5")) return "o45";
+  if (normalized.includes("opus") && normalized.includes("4.1")) return "o41";
+  if (normalized.includes("opus")) return "opus";
+  if (normalized.includes("sonnet") && normalized.includes("4.6")) return "s46";
+  if (normalized.includes("sonnet") && normalized.includes("4.5")) return "s45";
+  if (normalized.includes("sonnet") && normalized.includes("3.5")) return "s35";
+  if (normalized.includes("sonnet")) return "sonnet";
+  if (normalized.includes("haiku") && normalized.includes("4.5")) return "h45";
+  if (normalized.includes("haiku") && normalized.includes("3.5")) return "h35";
+  if (normalized.includes("haiku")) return "haiku";
+  return getCodexModelAbbreviation(displayName);
+}
+function aggregateRowsToMonthly(rows) {
+  const monthMap = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const month = row.key.slice(0, 7);
+    const existing = monthMap.get(month);
+    if (existing) {
+      existing.inputTokens += row.inputTokens;
+      existing.outputTokens += row.outputTokens;
+      existing.cacheWriteTokens += row.cacheWriteTokens;
+      existing.cacheReadTokens += row.cacheReadTokens;
+      existing.totalTokens += row.totalTokens;
+      existing.cost += row.cost;
+    } else {
+      monthMap.set(month, { ...row, key: month });
+    }
+  }
+  return Array.from(monthMap.values()).sort((a, b) => a.key.localeCompare(b.key));
+}
+function encodeUsageToUrl(stats, baseUrl = "https://vibestats.wolfai.dev") {
+  const params = new URLSearchParams();
+  if (stats.source !== "claude") {
+    params.set("src", stats.source);
+  }
+  const formatDateCompact = (d) => d.replace(/-/g, "");
+  const startMs = new Date(stats.dateRange.start).getTime();
+  const endMs = new Date(stats.dateRange.end).getTime();
+  const daySpan = Math.ceil((endMs - startMs) / (1e3 * 60 * 60 * 24));
+  const useMonthly = stats.aggregation === "daily" && daySpan > 31;
+  const aggMap = { daily: "d", monthly: "m", model: "mo", total: "t" };
+  const effectiveAgg = useMonthly ? "monthly" : stats.aggregation;
+  params.set("agg", aggMap[effectiveAgg] || "d");
+  let rowsToEncode;
+  if (useMonthly) {
+    rowsToEncode = aggregateRowsToMonthly(stats.rows);
+  } else {
+    rowsToEncode = stats.rows.slice(-31);
+  }
+  const startDate = useMonthly ? stats.dateRange.start : rowsToEncode[0]?.key || stats.dateRange.start;
+  const endDate = useMonthly ? stats.dateRange.end : rowsToEncode[rowsToEncode.length - 1]?.key || stats.dateRange.end;
+  params.set("dr", `${formatDateCompact(startDate)}-${formatDateCompact(endDate)}`);
+  const rows = rowsToEncode.map((row) => {
+    let key = row.key;
+    if (effectiveAgg === "daily" && row.key.length === 10) {
+      key = row.key.slice(5).replace("-", "");
+    }
+    return [
+      key,
+      formatCompactNumber(row.inputTokens),
+      formatCompactNumber(row.outputTokens),
+      formatCompactNumber(row.cacheWriteTokens),
+      formatCompactNumber(row.cacheReadTokens),
+      formatCompactNumber(row.totalTokens),
+      row.cost.toFixed(2)
+    ].join(":");
+  });
+  params.set("rows", rows.join("|"));
+  const t = stats.totals;
+  params.set("tot", [
+    formatCompactNumber(t.inputTokens),
+    formatCompactNumber(t.outputTokens),
+    formatCompactNumber(t.cacheWriteTokens),
+    formatCompactNumber(t.cacheReadTokens),
+    formatCompactNumber(t.totalTokens),
+    t.cost.toFixed(2)
+  ].join(":"));
+  if (stats.modelBreakdown.length > 0) {
+    const mb = stats.modelBreakdown.slice(0, 5).map((m) => {
+      const abbr = getModelTokenFromDisplayName(m.model);
+      return `${abbr}:${m.percentage}:${m.cost.toFixed(2)}`;
+    });
+    params.set("mb", mb.join(","));
+  }
+  return `${baseUrl}?${params.toString()}`;
+}
+function encodePayload(payload) {
+  return Buffer.from(JSON.stringify(payload), "utf-8").toString("base64url");
+}
+
+// src/activity.ts
+var WEEKDAY_LABELS = ["Mon", "", "", "", "", "", "Sun"];
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+function toDateKey(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function startOfDay(date) {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 12, 0, 0, 0);
+}
+function addDays(date, days) {
+  return new Date(date.getTime() + days * MS_PER_DAY);
+}
+function startOfWeekMonday(date) {
+  const current = startOfDay(date);
+  const day = current.getDay();
+  const delta = day === 0 ? -6 : 1 - day;
+  return addDays(current, delta);
+}
+function endOfWeekSunday(date) {
+  const monday = startOfWeekMonday(date);
+  return addDays(monday, 6);
+}
+function quantile(sortedValues, ratio) {
+  if (sortedValues.length === 0) return 0;
+  const index = Math.min(
+    sortedValues.length - 1,
+    Math.max(0, Math.floor((sortedValues.length - 1) * ratio))
+  );
+  return sortedValues[index] ?? 0;
+}
+function getMetricValue(day, metric) {
+  switch (metric) {
+    case "messages":
+      return day.messageCount;
+    case "sessions":
+      return day.sessionCount;
+    case "tokens":
+    default:
+      return day.totalTokens;
+  }
+}
+function buildLegend(thresholds) {
+  return [
+    { intensity: 0, min: 0, max: 0, label: "No activity" },
+    { intensity: 1, min: 1, max: thresholds[0], label: "Low" },
+    { intensity: 2, min: thresholds[0] + 1, max: thresholds[1], label: "Steady" },
+    { intensity: 3, min: thresholds[1] + 1, max: thresholds[2], label: "Strong" },
+    { intensity: 4, min: thresholds[2] + 1, max: Number.MAX_SAFE_INTEGER, label: "Peak" }
+  ];
+}
+function getIntensity(value, thresholds) {
+  if (value <= 0) return 0;
+  if (value <= thresholds[0]) return 1;
+  if (value <= thresholds[1]) return 2;
+  if (value <= thresholds[2]) return 3;
+  return 4;
+}
+function computeStreaks(days) {
+  let current = 0;
+  let longest = 0;
+  let streak = 0;
+  let activeDays = 0;
+  for (const day of days) {
+    if (day.value > 0) {
+      streak += 1;
+      activeDays += 1;
+      longest = Math.max(longest, streak);
+    } else {
+      streak = 0;
+    }
+  }
+  for (let index = days.length - 1; index >= 0; index -= 1) {
+    if ((days[index]?.value ?? 0) > 0) {
+      current += 1;
+    } else if (current > 0) {
+      break;
+    }
+  }
+  return { current, longest, activeDays };
+}
+function buildActivityGraph(stats, metric, requestedDays = 365) {
+  const today = startOfDay(/* @__PURE__ */ new Date());
+  const endDate = stats.dateRange.end ? startOfDay(new Date(stats.dateRange.end)) : today;
+  const effectiveEnd = endDate > today ? today : endDate;
+  const effectiveStart = addDays(effectiveEnd, -(requestedDays - 1));
+  const paddedStart = startOfWeekMonday(effectiveStart);
+  const paddedEnd = endOfWeekSunday(effectiveEnd);
+  const dayMap = new Map(stats.days.map((day) => [day.date, day]));
+  const orderedDays = [];
+  const positiveValues = [];
+  for (let cursor = new Date(paddedStart); cursor <= paddedEnd; cursor = addDays(cursor, 1)) {
+    const key = toDateKey(cursor);
+    const sourceDay = dayMap.get(key);
+    const value = sourceDay ? getMetricValue(sourceDay, metric) : 0;
+    if (cursor >= effectiveStart && cursor <= effectiveEnd && value > 0) {
+      positiveValues.push(value);
+    }
+    orderedDays.push({
+      date: key,
+      value,
+      intensity: 0,
+      inputTokens: sourceDay?.inputTokens ?? 0,
+      outputTokens: sourceDay?.outputTokens ?? 0,
+      cacheWriteTokens: sourceDay?.cacheWriteTokens ?? 0,
+      cacheReadTokens: sourceDay?.cacheReadTokens ?? 0,
+      totalTokens: sourceDay?.totalTokens ?? 0,
+      sessionCount: sourceDay?.sessionCount ?? 0,
+      messageCount: sourceDay?.messageCount ?? 0
+    });
+  }
+  positiveValues.sort((a, b) => a - b);
+  const thresholds = [
+    Math.max(1, quantile(positiveValues, 0.25)),
+    Math.max(1, quantile(positiveValues, 0.5)),
+    Math.max(1, quantile(positiveValues, 0.75))
+  ];
+  for (const day of orderedDays) {
+    day.intensity = getIntensity(day.value, thresholds);
+  }
+  const weeks = [];
+  for (let index = 0; index < orderedDays.length; index += 7) {
+    weeks.push(orderedDays.slice(index, index + 7));
+  }
+  const monthLabels = [];
+  const seenMonths = /* @__PURE__ */ new Set();
+  for (let weekIndex = 0; weekIndex < weeks.length; weekIndex += 1) {
+    const week = weeks[weekIndex];
+    const firstRealDay = week?.find((day) => day.date >= toDateKey(effectiveStart) && day.date <= toDateKey(effectiveEnd));
+    if (!firstRealDay) continue;
+    const monthKey = firstRealDay.date.slice(0, 7);
+    if (seenMonths.has(monthKey)) continue;
+    seenMonths.add(monthKey);
+    const monthDate = /* @__PURE__ */ new Date(`${monthKey}-01T12:00:00`);
+    monthLabels.push({
+      weekIndex,
+      label: monthDate.toLocaleString("en-US", { month: "short" })
+    });
+  }
+  const visibleDays = orderedDays.filter((day) => day.date >= toDateKey(effectiveStart) && day.date <= toDateKey(effectiveEnd));
+  const streaks = computeStreaks(visibleDays);
+  const recent30Total = visibleDays.slice(-30).reduce((sum, day) => sum + day.value, 0);
+  const favoriteModel = stats.modelBreakdown[0];
+  return {
+    metric,
+    startDate: toDateKey(effectiveStart),
+    endDate: toDateKey(effectiveEnd),
+    weeks,
+    monthLabels,
+    weekdayLabels: WEEKDAY_LABELS,
+    legend: buildLegend(thresholds),
+    summary: {
+      activeDays: streaks.activeDays,
+      currentStreak: streaks.current,
+      longestStreak: streaks.longest,
+      recent30DayTotal: recent30Total,
+      favoriteModel: favoriteModel?.model || "Unknown",
+      favoriteModelTokens: favoriteModel?.tokens || 0,
+      inputTokens: stats.totals.inputTokens,
+      outputTokens: stats.totals.outputTokens,
+      cacheWriteTokens: stats.totals.cacheWriteTokens,
+      cacheReadTokens: stats.totals.cacheReadTokens,
+      totalTokens: stats.totals.totalTokens,
+      totalMessages: stats.totals.messageCount,
+      totalSessions: stats.totals.sessionCount
+    }
+  };
+}
+function buildActivityTitle(source, metric) {
+  const sourceLabel = source === "codex" ? "Codex" : source === "combined" ? "AI Coding" : "Claude";
+  const metricLabel = metric === "tokens" ? "Activity" : metric === "sessions" ? "Session Activity" : "Message Activity";
+  return `${sourceLabel} ${metricLabel}`;
+}
+function buildActivityArtifactPayload(stats, metric, requestedDays = 365) {
+  return {
+    title: buildActivityTitle(stats.source, metric),
+    source: stats.source,
+    activity: buildActivityGraph(stats, metric, requestedDays)
+  };
+}
+function buildActivityArtifact(stats, metric, requestedDays = 365) {
+  return {
+    type: "activity",
+    schemaVersion: 1,
+    source: stats.source,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    renderOptions: {
+      canonicalPath: "activity",
+      theme: "light"
+    },
+    payload: buildActivityArtifactPayload(stats, metric, requestedDays)
+  };
+}
+
 // src/usage/loader.ts
 import { promises as fs } from "fs";
 import { homedir } from "os";
@@ -24,6 +681,13 @@ var MODEL_PRICING = {
     cacheWrite: 6.25,
     cacheRead: 0.5
   },
+  // Sonnet 4.6 (same pricing as Sonnet 4.5)
+  "claude-sonnet-4-6-20260101": {
+    input: 3,
+    output: 15,
+    cacheWrite: 3.75,
+    cacheRead: 0.3
+  },
   // Sonnet 4.5
   "claude-sonnet-4-5-20250929": {
     input: 3,
@@ -79,6 +743,9 @@ function getModelPricing(modelName) {
   if (modelName.includes("opus-4-1") || modelName.includes("opus-4.1") || modelName.includes("opus-4")) {
     return MODEL_PRICING["claude-opus-4-1-20250805"];
   }
+  if (modelName.includes("sonnet-4-6") || modelName.includes("sonnet-4.6")) {
+    return MODEL_PRICING["claude-sonnet-4-6-20260101"];
+  }
   if (modelName.includes("sonnet-4-5") || modelName.includes("sonnet-4.5")) {
     return MODEL_PRICING["claude-sonnet-4-5-20250929"];
   }
@@ -98,190 +765,14 @@ function getModelDisplayName(modelName) {
   if (modelName.includes("opus-4-5") || modelName.includes("opus-4.5")) return "Opus 4.5";
   if (modelName.includes("opus-4-1") || modelName.includes("opus-4.1")) return "Opus 4.1";
   if (modelName.includes("opus")) return "Opus";
+  if (modelName.includes("sonnet-4-6") || modelName.includes("sonnet-4.6")) return "Sonnet 4.6";
   if (modelName.includes("sonnet-4-5") || modelName.includes("sonnet-4.5")) return "Sonnet 4.5";
   if (modelName.includes("sonnet-3-5") || modelName.includes("sonnet-3.5")) return "Sonnet 3.5";
   if (modelName.includes("sonnet")) return "Sonnet";
   if (modelName.includes("haiku-4-5") || modelName.includes("haiku-4.5")) return "Haiku 4.5";
   if (modelName.includes("haiku-3-5") || modelName.includes("haiku-3.5")) return "Haiku 3.5";
   if (modelName.includes("haiku")) return "Haiku";
-  return modelName;
-}
-
-// src/codex-pricing.ts
-var CODEX_MODEL_PRICING = {
-  // GPT-5.3 (latest flagship)
-  "gpt-5.3": {
-    input: 1.75,
-    output: 14,
-    cachedInput: 0.175
-  },
-  "gpt-5.3-codex-spark": {
-    input: 1.75,
-    output: 14,
-    cachedInput: 0.175
-  },
-  "gpt-5.3-codex": {
-    input: 1.75,
-    output: 14,
-    cachedInput: 0.175
-  },
-  // GPT-5.2
-  // Cached input is ~10% of input price (prompt caching discount)
-  "gpt-5.2": {
-    input: 1.75,
-    output: 14,
-    cachedInput: 0.175
-  },
-  "gpt-5.2-codex": {
-    input: 1.75,
-    output: 14,
-    cachedInput: 0.175
-  },
-  // GPT-5.1 models
-  "gpt-5.1": {
-    input: 1.25,
-    output: 10,
-    cachedInput: 0.125
-  },
-  "gpt-5.1-codex": {
-    input: 1.25,
-    output: 10,
-    cachedInput: 0.125
-  },
-  "gpt-5.1-codex-max": {
-    input: 1.25,
-    output: 10,
-    cachedInput: 0.125
-  },
-  // GPT-5.1 Mini
-  "gpt-5.1-codex-mini": {
-    input: 0.25,
-    output: 2,
-    cachedInput: 0.025
-  },
-  // GPT-5 base models
-  "gpt-5": {
-    input: 1.25,
-    output: 10,
-    cachedInput: 0.125
-  },
-  "gpt-5-codex": {
-    input: 1.25,
-    output: 10,
-    cachedInput: 0.125
-  },
-  // GPT-5 Mini variants
-  "gpt-5-mini": {
-    input: 0.25,
-    output: 2,
-    cachedInput: 0.025
-  },
-  "gpt-5-codex-mini": {
-    input: 0.25,
-    output: 2,
-    cachedInput: 0.025
-  },
-  // GPT-5 Nano
-  "gpt-5-nano": {
-    input: 0.05,
-    output: 0.4,
-    cachedInput: 5e-3
-  },
-  // GPT-4o (fallback for older sessions)
-  "gpt-4o": {
-    input: 2.5,
-    output: 10,
-    cachedInput: 1.25
-  },
-  "gpt-4o-mini": {
-    input: 0.15,
-    output: 0.6,
-    cachedInput: 0.075
-  }
-};
-function getCodexModelPricing(modelName) {
-  if (CODEX_MODEL_PRICING[modelName]) {
-    return CODEX_MODEL_PRICING[modelName];
-  }
-  const normalized = modelName.toLowerCase();
-  if (normalized.includes("5.3") && normalized.includes("spark")) {
-    return CODEX_MODEL_PRICING["gpt-5.3-codex-spark"];
-  }
-  if (normalized.includes("5.3") && normalized.includes("codex")) {
-    return CODEX_MODEL_PRICING["gpt-5.3-codex"];
-  }
-  if (normalized.includes("5.3")) {
-    return CODEX_MODEL_PRICING["gpt-5.3"];
-  }
-  if (normalized.includes("5.2") && normalized.includes("codex")) {
-    return CODEX_MODEL_PRICING["gpt-5.2-codex"];
-  }
-  if (normalized.includes("5.2")) {
-    return CODEX_MODEL_PRICING["gpt-5.2"];
-  }
-  if (normalized.includes("5.1") && normalized.includes("codex") && normalized.includes("mini")) {
-    return CODEX_MODEL_PRICING["gpt-5.1-codex-mini"];
-  }
-  if (normalized.includes("5.1") && normalized.includes("codex") && normalized.includes("max")) {
-    return CODEX_MODEL_PRICING["gpt-5.1-codex-max"];
-  }
-  if (normalized.includes("5.1") && normalized.includes("codex")) {
-    return CODEX_MODEL_PRICING["gpt-5.1-codex"];
-  }
-  if (normalized.includes("5.1") && normalized.includes("max")) {
-    return CODEX_MODEL_PRICING["gpt-5.1"];
-  }
-  if (normalized.includes("5.1") && normalized.includes("mini")) {
-    return CODEX_MODEL_PRICING["gpt-5.1-codex-mini"];
-  }
-  if (normalized.includes("5.1")) {
-    return CODEX_MODEL_PRICING["gpt-5.1"];
-  }
-  if (normalized.includes("nano")) {
-    return CODEX_MODEL_PRICING["gpt-5-nano"];
-  }
-  if (normalized.includes("5") && normalized.includes("mini")) {
-    return CODEX_MODEL_PRICING["gpt-5-mini"];
-  }
-  if (normalized.includes("gpt-5") || normalized.includes("gpt5")) {
-    return CODEX_MODEL_PRICING["gpt-5"];
-  }
-  if (normalized.includes("4o-mini")) {
-    return CODEX_MODEL_PRICING["gpt-4o-mini"];
-  }
-  if (normalized.includes("4o")) {
-    return CODEX_MODEL_PRICING["gpt-4o"];
-  }
-  return CODEX_MODEL_PRICING["gpt-5"];
-}
-function getCodexModelDisplayName(modelName) {
-  const normalized = modelName.toLowerCase();
-  if (normalized.includes("5.3") && normalized.includes("spark")) return "GPT-5.3 Codex Spark";
-  if (normalized.includes("5.3") && normalized.includes("codex")) return "GPT-5.3 Codex";
-  if (normalized.includes("5.3")) return "GPT-5.3";
-  if (normalized.includes("5.2") && normalized.includes("codex")) return "GPT-5.2 Codex";
-  if (normalized.includes("5.2")) return "GPT-5.2";
-  if (normalized.includes("5.1") && normalized.includes("codex") && normalized.includes("max")) return "GPT-5.1 Codex Max";
-  if (normalized.includes("5.1") && normalized.includes("codex") && normalized.includes("mini")) return "GPT-5.1 Codex Mini";
-  if (normalized.includes("5.1") && normalized.includes("max")) return "GPT-5.1 Max";
-  if (normalized.includes("5.1") && normalized.includes("mini")) return "GPT-5.1 Mini";
-  if (normalized.includes("5.1") && normalized.includes("codex")) return "GPT-5.1 Codex";
-  if (normalized.includes("5.1")) return "GPT-5.1";
-  if (normalized.includes("nano")) return "GPT-5 Nano";
-  if (normalized.includes("5") && normalized.includes("mini")) return "GPT-5 Mini";
-  if (normalized.includes("5") && normalized.includes("codex")) return "GPT-5 Codex";
-  if (normalized.includes("gpt-5")) return "GPT-5";
-  if (normalized.includes("4o-mini")) return "GPT-4o Mini";
-  if (normalized.includes("4o")) return "GPT-4o";
-  return modelName;
-}
-function calculateCodexCost(modelName, inputTokens, outputTokens, cachedInputTokens) {
-  const pricing = getCodexModelPricing(modelName);
-  const regularInputTokens = inputTokens - cachedInputTokens;
-  const inputCost = regularInputTokens / 1e6 * pricing.input;
-  const cachedCost = cachedInputTokens / 1e6 * pricing.cachedInput;
-  const outputCost = outputTokens / 1e6 * pricing.output;
-  return inputCost + cachedCost + outputCost;
+  return modelName;
 }
 
 // src/usage/loader.ts
@@ -404,6 +895,7 @@ async function parseClaudeJsonl(projectFilter) {
             cacheWriteTokens,
             cacheReadTokens,
             cost,
+            messageCount: 1,
             source: "claude",
             sessionId,
             timestamp
@@ -460,7 +952,10 @@ async function parseCodexJsonl() {
               cacheWriteTokens: 0,
               cacheReadTokens: cachedInputTokens,
               cost,
-              source: "codex"
+              messageCount: 1,
+              source: "codex",
+              sessionId: basename(filePath, ".jsonl"),
+              timestamp
             });
           }
         } catch {
@@ -479,36 +974,22 @@ function filterByDateRange(entries, since, until) {
   });
 }
 function sortModelsByTier(models) {
-  const tierPriority = {
+  const claudeTierPriority = {
     "Opus 4.6": 101,
     "Opus 4.5": 100,
     "Opus 4.1": 99,
     "Opus": 98,
+    "Sonnet 4.6": 91,
     "Sonnet 4.5": 90,
     "Sonnet 3.5": 89,
     "Sonnet": 88,
     "Haiku 4.5": 80,
     "Haiku 3.5": 79,
-    "Haiku": 78,
-    "GPT-5.3 Codex Spark": 76,
-    "GPT-5.3 Codex": 75,
-    "GPT-5.3": 74,
-    "GPT-5.2 Codex": 73,
-    "GPT-5.2": 72,
-    "GPT-5.1 Codex Max": 71,
-    "GPT-5.1 Max": 70,
-    "GPT-5.1 Codex Mini": 69,
-    "GPT-5.1 Mini": 68,
-    "GPT-5.1 Codex": 67,
-    "GPT-5.1": 66,
-    "GPT-5": 64,
-    "GPT-5 Mini": 63,
-    "GPT-4o": 60,
-    "GPT-4o Mini": 59
+    "Haiku": 78
   };
   return models.sort((a, b) => {
-    const priorityA = tierPriority[a] ?? 0;
-    const priorityB = tierPriority[b] ?? 0;
+    const priorityA = claudeTierPriority[a] ?? getCodexModelSortPriority(a);
+    const priorityB = claudeTierPriority[b] ?? getCodexModelSortPriority(b);
     return priorityB - priorityA;
   });
 }
@@ -675,6 +1156,76 @@ function computeModelBreakdown(entries) {
     percentage: totalTokens > 0 ? Math.round(data.tokens / totalTokens * 100) : 0
   })).sort((a, b) => b.tokens - a.tokens);
 }
+function computeActivityStats(entries, source) {
+  const dayMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const existing = dayMap.get(entry.date);
+    if (existing) {
+      existing.inputTokens += entry.inputTokens;
+      existing.outputTokens += entry.outputTokens;
+      existing.cacheWriteTokens += entry.cacheWriteTokens;
+      existing.cacheReadTokens += entry.cacheReadTokens;
+      existing.totalTokens += entry.inputTokens + entry.outputTokens + entry.cacheWriteTokens + entry.cacheReadTokens;
+      existing.messageCount += entry.messageCount;
+      if (entry.sessionId) {
+        existing.sessionCount += 0;
+      }
+    } else {
+      dayMap.set(entry.date, {
+        date: entry.date,
+        inputTokens: entry.inputTokens,
+        outputTokens: entry.outputTokens,
+        cacheWriteTokens: entry.cacheWriteTokens,
+        cacheReadTokens: entry.cacheReadTokens,
+        totalTokens: entry.inputTokens + entry.outputTokens + entry.cacheWriteTokens + entry.cacheReadTokens,
+        sessionCount: 0,
+        messageCount: entry.messageCount
+      });
+    }
+  }
+  const sessionMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.sessionId) continue;
+    const sessions = sessionMap.get(entry.date) || /* @__PURE__ */ new Set();
+    sessions.add(entry.sessionId);
+    sessionMap.set(entry.date, sessions);
+  }
+  const days = Array.from(dayMap.values()).map((day) => ({
+    ...day,
+    sessionCount: sessionMap.get(day.date)?.size || 0
+  })).sort((a, b) => a.date.localeCompare(b.date));
+  const totals = days.reduce(
+    (acc, day) => ({
+      inputTokens: acc.inputTokens + day.inputTokens,
+      outputTokens: acc.outputTokens + day.outputTokens,
+      cacheWriteTokens: acc.cacheWriteTokens + day.cacheWriteTokens,
+      cacheReadTokens: acc.cacheReadTokens + day.cacheReadTokens,
+      totalTokens: acc.totalTokens + day.totalTokens,
+      sessionCount: acc.sessionCount + day.sessionCount,
+      messageCount: acc.messageCount + day.messageCount
+    }),
+    {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheWriteTokens: 0,
+      cacheReadTokens: 0,
+      totalTokens: 0,
+      sessionCount: 0,
+      messageCount: 0
+    }
+  );
+  const dates = days.map((entry) => entry.date);
+  return {
+    source,
+    dateRange: {
+      start: dates[0] || "",
+      end: dates[dates.length - 1] || ""
+    },
+    days,
+    totals,
+    modelBreakdown: computeModelBreakdown(entries)
+  };
+}
 async function loadUsageStats(options) {
   const { aggregation, since, until, codexOnly, combined, projectFilter } = options;
   let entries = [];
@@ -730,6 +1281,28 @@ async function loadUsageStats(options) {
     modelBreakdown
   };
 }
+async function loadActivityStats(options) {
+  const { since, until, codexOnly, combined, projectFilter } = options;
+  let entries = [];
+  if (!codexOnly) {
+    entries = entries.concat(await parseClaudeJsonl(projectFilter));
+  }
+  if (codexOnly || combined) {
+    entries = entries.concat(await parseCodexJsonl());
+  }
+  if (entries.length === 0) {
+    return null;
+  }
+  entries = filterByDateRange(entries, since, until);
+  entries = entries.filter((entry) => !entry.model.toLowerCase().includes("synthetic"));
+  if (entries.length === 0) {
+    return null;
+  }
+  let source = "claude";
+  if (codexOnly) source = "codex";
+  else if (combined) source = "combined";
+  return computeActivityStats(entries, source);
+}
 
 // src/usage/table.ts
 var colors = {
@@ -1601,200 +2174,6 @@ function combineWrappedStats(claude, codex) {
   };
 }
 
-// src/url-encoder.ts
-function formatCompactNumber(num) {
-  if (num >= 1e9) {
-    return `${(num / 1e9).toFixed(1)}B`;
-  }
-  if (num >= 1e6) {
-    return `${(num / 1e6).toFixed(1)}M`;
-  }
-  if (num >= 1e3) {
-    return `${(num / 1e3).toFixed(1)}K`;
-  }
-  return num.toString();
-}
-var dayToNumber = {
-  Sunday: 0,
-  Monday: 1,
-  Tuesday: 2,
-  Wednesday: 3,
-  Thursday: 4,
-  Friday: 5,
-  Saturday: 6
-};
-function encodeStatsToUrl(stats, baseUrl = "https://vibestats.wolfai.dev") {
-  const params = new URLSearchParams();
-  params.set("s", stats.sessions.toString());
-  params.set("t", formatCompactNumber(stats.totalTokens));
-  params.set("c", stats.totalCost.toFixed(2));
-  params.set("d", stats.daysActive.toString());
-  params.set("ls", stats.longestStreak.toString());
-  params.set("cs", stats.currentStreak.toString());
-  params.set("ph", stats.peakHour.toString());
-  params.set("pd", (dayToNumber[stats.peakDay] ?? 0).toString());
-  params.set("fm", getModelAbbrevFromDisplayName(stats.favoriteModel));
-  const mbParts = stats.modelBreakdown.slice(0, 3).map((m) => {
-    const abbr = getModelAbbrevFromDisplayName(m.model);
-    return `${abbr}:${m.percentage}`;
-  });
-  params.set("mb", mbParts.join(","));
-  if (stats.topTools && stats.topTools.length > 0) {
-    params.set("tt", stats.topTools.slice(0, 5).join(","));
-  }
-  if (stats.developerStyle) {
-    const styleMap = {
-      reader: "r",
-      writer: "w",
-      executor: "e",
-      balanced: "b"
-    };
-    params.set("st", styleMap[stats.developerStyle] || "b");
-  }
-  if (stats.topProject) {
-    params.set("tp", stats.topProject);
-  }
-  if (stats.projectCount) {
-    params.set("pc", stats.projectCount.toString());
-  }
-  params.set("wg", formatCompactNumber(stats.wordsGenerated));
-  const firstDate = new Date(stats.firstSessionDate);
-  params.set("fad", firstDate.toISOString().split("T")[0].replace(/-/g, ""));
-  if (stats.source && stats.source !== "claude") {
-    params.set("src", stats.source);
-  }
-  return `${baseUrl}/wrapped/?${params.toString()}`;
-}
-function getModelAbbrevFromDisplayName(displayName) {
-  const map = {
-    // Claude models
-    "Opus 4.5": "o45",
-    "Opus 4.1": "o41",
-    Opus: "opus",
-    "Sonnet 4.5": "s45",
-    "Sonnet 3.5": "s35",
-    Sonnet: "sonnet",
-    "Haiku 4.5": "h45",
-    "Haiku 3.5": "h35",
-    Haiku: "haiku",
-    // Codex/OpenAI models
-    "GPT-5.3 Codex Spark": "g53s",
-    "GPT-5.3 Codex": "g53c",
-    "GPT-5.3": "g53",
-    "GPT-5.2 Codex": "g52c",
-    "GPT-5.2": "g52",
-    "GPT-5.1 Codex Max": "g51cm",
-    "GPT-5.1 Max": "g51m",
-    "GPT-5.1 Codex Mini": "g51cn",
-    "GPT-5.1 Mini": "g51n",
-    "GPT-5.1 Codex": "g51c",
-    "GPT-5.1": "g51",
-    "GPT-5": "g5",
-    "GPT-5 Mini": "g5n",
-    "GPT-4o": "g4o",
-    "GPT-4o Mini": "g4om"
-  };
-  if (map[displayName]) return map[displayName];
-  const normalized = displayName.toLowerCase();
-  if (normalized.includes("5.3") && normalized.includes("spark")) return "g53s";
-  if (normalized.includes("5.3") && normalized.includes("codex")) return "g53c";
-  if (normalized.includes("5.2")) return "g52";
-  if (normalized.includes("5.1") && normalized.includes("codex") && normalized.includes("max")) return "g51cm";
-  if (normalized.includes("5.1") && normalized.includes("max")) return "g51m";
-  if (normalized.includes("5.1") && normalized.includes("codex") && normalized.includes("mini")) return "g51cn";
-  if (normalized.includes("5.1") && normalized.includes("codex")) return "g51c";
-  if (normalized.includes("5.1") && normalized.includes("mini")) return "g51n";
-  if (normalized.includes("5.1")) return "g51";
-  if (normalized.includes("5") && normalized.includes("mini")) return "g5n";
-  if (normalized.includes("gpt-5") || normalized.includes("gpt5")) return "g5";
-  if (normalized.includes("4o") && normalized.includes("mini")) return "g4om";
-  if (normalized.includes("4o")) return "g4o";
-  if (normalized.includes("opus") && normalized.includes("4.5")) return "o45";
-  if (normalized.includes("opus") && normalized.includes("4.1")) return "o41";
-  if (normalized.includes("opus")) return "opus";
-  if (normalized.includes("sonnet") && normalized.includes("4.5")) return "s45";
-  if (normalized.includes("sonnet") && normalized.includes("3.5")) return "s35";
-  if (normalized.includes("sonnet")) return "sonnet";
-  if (normalized.includes("haiku") && normalized.includes("4.5")) return "h45";
-  if (normalized.includes("haiku") && normalized.includes("3.5")) return "h35";
-  if (normalized.includes("haiku")) return "haiku";
-  return displayName.slice(0, 5).toLowerCase();
-}
-function aggregateRowsToMonthly(rows) {
-  const monthMap = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const month = row.key.slice(0, 7);
-    const existing = monthMap.get(month);
-    if (existing) {
-      existing.inputTokens += row.inputTokens;
-      existing.outputTokens += row.outputTokens;
-      existing.cacheWriteTokens += row.cacheWriteTokens;
-      existing.cacheReadTokens += row.cacheReadTokens;
-      existing.totalTokens += row.totalTokens;
-      existing.cost += row.cost;
-    } else {
-      monthMap.set(month, { ...row, key: month });
-    }
-  }
-  return Array.from(monthMap.values()).sort((a, b) => a.key.localeCompare(b.key));
-}
-function encodeUsageToUrl(stats, baseUrl = "https://vibestats.wolfai.dev") {
-  const params = new URLSearchParams();
-  if (stats.source !== "claude") {
-    params.set("src", stats.source);
-  }
-  const formatDateCompact = (d) => d.replace(/-/g, "");
-  const startMs = new Date(stats.dateRange.start).getTime();
-  const endMs = new Date(stats.dateRange.end).getTime();
-  const daySpan = Math.ceil((endMs - startMs) / (1e3 * 60 * 60 * 24));
-  const useMonthly = stats.aggregation === "daily" && daySpan > 31;
-  const aggMap = { daily: "d", monthly: "m", model: "mo", total: "t" };
-  const effectiveAgg = useMonthly ? "monthly" : stats.aggregation;
-  params.set("agg", aggMap[effectiveAgg] || "d");
-  let rowsToEncode;
-  if (useMonthly) {
-    rowsToEncode = aggregateRowsToMonthly(stats.rows);
-  } else {
-    rowsToEncode = stats.rows.slice(-31);
-  }
-  const startDate = useMonthly ? stats.dateRange.start : rowsToEncode[0]?.key || stats.dateRange.start;
-  const endDate = useMonthly ? stats.dateRange.end : rowsToEncode[rowsToEncode.length - 1]?.key || stats.dateRange.end;
-  params.set("dr", `${formatDateCompact(startDate)}-${formatDateCompact(endDate)}`);
-  const rows = rowsToEncode.map((row) => {
-    let key = row.key;
-    if (effectiveAgg === "daily" && row.key.length === 10) {
-      key = row.key.slice(5).replace("-", "");
-    }
-    return [
-      key,
-      formatCompactNumber(row.inputTokens),
-      formatCompactNumber(row.outputTokens),
-      formatCompactNumber(row.cacheWriteTokens),
-      formatCompactNumber(row.cacheReadTokens),
-      formatCompactNumber(row.totalTokens),
-      row.cost.toFixed(2)
-    ].join(":");
-  });
-  params.set("rows", rows.join("|"));
-  const t = stats.totals;
-  params.set("tot", [
-    formatCompactNumber(t.inputTokens),
-    formatCompactNumber(t.outputTokens),
-    formatCompactNumber(t.cacheWriteTokens),
-    formatCompactNumber(t.cacheReadTokens),
-    formatCompactNumber(t.totalTokens),
-    t.cost.toFixed(2)
-  ].join(":"));
-  if (stats.modelBreakdown.length > 0) {
-    const mb = stats.modelBreakdown.slice(0, 5).map((m) => {
-      const abbr = getModelAbbrevFromDisplayName(m.model);
-      return `${abbr}:${m.percentage}:${m.cost.toFixed(2)}`;
-    });
-    params.set("mb", mb.join(","));
-  }
-  return `${baseUrl}?${params.toString()}`;
-}
-
 // src/display.ts
 var colors2 = {
   reset: "\x1B[0m",
@@ -1893,27 +2272,72 @@ function formatHour(hour) {
   if (hour === 12) return "12pm";
   return `${hour - 12}pm`;
 }
+function displayActivityStats(artifact, url, options) {
+  const c = getColors2(options?.theme);
+  const summary = artifact.activity.summary;
+  console.log();
+  console.log(`${c.cyan}${c.bold}\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557${c.reset}`);
+  console.log(`${c.cyan}${c.bold}\u2551${c.reset}                ${c.white}${c.bold}${artifact.title}${c.reset}                 ${c.cyan}${c.bold}\u2551${c.reset}`);
+  console.log(`${c.cyan}${c.bold}\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D${c.reset}`);
+  console.log();
+  console.log(`${c.bold}\u{1F4C8} Activity Heatmap${c.reset}`);
+  console.log(`${c.gray}${"\u2500".repeat(60)}${c.reset}`);
+  console.log(`  Window: ${artifact.activity.startDate} \u2192 ${artifact.activity.endDate}`);
+  console.log(`  Metric: ${artifact.activity.metric}`);
+  console.log(`  Active days: ${c.cyan}${c.bold}${summary.activeDays}${c.reset}`);
+  console.log();
+  console.log(`${c.bold}\u26A1 Highlights${c.reset}`);
+  console.log(`${c.gray}${"\u2500".repeat(60)}${c.reset}`);
+  console.log(`  Current streak: ${c.green}${summary.currentStreak} days${c.reset}`);
+  console.log(`  Longest streak: ${c.cyan}${summary.longestStreak} days${c.reset}`);
+  console.log(`  Recent 30 days: ${c.white}${c.bold}${formatCompactNumber(summary.recent30DayTotal)}${c.reset}`);
+  console.log(`  Favorite model: ${c.amber}${summary.favoriteModel}${c.reset}`);
+  console.log();
+  console.log(`${c.bold}\u{1F517} Share Activity${c.reset}`);
+  console.log(`${c.gray}${"\u2500".repeat(60)}${c.reset}`);
+  if (options?.shortUrl) {
+    console.log(`  ${c.cyan}${c.bold}${options.shortUrl}${c.reset}`);
+    console.log(`  ${c.dim}(Canonical URL: ${url})${c.reset}`);
+  } else {
+    console.log(`  ${c.cyan}${url}${c.reset}`);
+  }
+  if (options?.imageUrl) {
+    console.log(`  Image: ${c.white}${options.imageUrl}${c.reset}`);
+  }
+  console.log();
+}
 
-// src/shortener.ts
-async function createShortlink(params, baseUrl) {
-  const queryString = params.includes("?") ? params.split("?")[1] : params;
+// src/share-client.ts
+function extractLegacyQuery(legacyUrl) {
+  if (!legacyUrl) return null;
+  const queryIndex = legacyUrl.indexOf("?");
+  if (queryIndex === -1) return null;
+  return legacyUrl.slice(queryIndex + 1) || null;
+}
+async function publishArtifact(artifact, baseUrl, legacyUrl) {
   try {
-    const apiUrl = new URL("/api/shorten", baseUrl);
+    const apiUrl = new URL("/vibestats/shares", baseUrl);
     const response = await fetch(apiUrl.toString(), {
       method: "POST",
       headers: {
         "Content-Type": "application/json"
       },
-      body: JSON.stringify({ params: queryString })
+      body: JSON.stringify({
+        artifact,
+        legacyQuery: extractLegacyQuery(legacyUrl)
+      })
     });
     if (!response.ok) {
       return null;
     }
     const data = await response.json();
-    if (data.slug) {
-      return `${baseUrl}/s/${data.slug}`;
-    }
-    return null;
+    return {
+      id: data.id || data.slug,
+      slug: data.slug,
+      url: data.url,
+      shortUrl: data.shortUrl,
+      imageUrl: data.imageUrl || null
+    };
   } catch {
     return null;
   }
@@ -2067,6 +2491,65 @@ function parseLastDaysFlag(args) {
   shorthandDays.sort((a, b) => a - b);
   return shorthandDays[0];
 }
+function parseActivityMetric(value) {
+  if (value === "sessions" || value === "messages" || value === "tokens") {
+    return value;
+  }
+  return "tokens";
+}
+function parseActivityDays(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return Math.round(value);
+  }
+  if (typeof value === "string") {
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return 365;
+}
+function buildUsageArtifact(stats) {
+  return {
+    type: "usage",
+    schemaVersion: 1,
+    source: stats.source,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    renderOptions: {
+      canonicalPath: "usage",
+      theme: "light"
+    },
+    payload: stats
+  };
+}
+function buildWrappedArtifact(stats) {
+  return {
+    type: "wrapped",
+    schemaVersion: 1,
+    source: stats.source || "claude",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    renderOptions: {
+      canonicalPath: "wrapped",
+      theme: "light"
+    },
+    payload: stats
+  };
+}
+async function publishArtifactWithFallback(artifact, baseUrl, fallbackUrl, preferCanonical = false) {
+  const published = await publishArtifact(artifact, baseUrl, fallbackUrl);
+  if (!published) {
+    return {
+      canonicalUrl: fallbackUrl,
+      shareUrl: fallbackUrl,
+      imageUrl: null
+    };
+  }
+  return {
+    canonicalUrl: published.url,
+    shareUrl: preferCanonical ? published.url : published.shortUrl,
+    imageUrl: published.imageUrl || null
+  };
+}
 var main = defineCommand({
   meta: {
     name: "vibestats",
@@ -2081,6 +2564,11 @@ var main = defineCommand({
       description: "Show annual wrapped summary instead of usage stats",
       default: false
     },
+    activity: {
+      type: "boolean",
+      description: "Show the GitHub-style activity graph summary",
+      default: false
+    },
     // Data source
     codex: {
       type: "boolean",
@@ -2147,6 +2635,14 @@ var main = defineCommand({
       description: "Use compact table format (hide cache columns)",
       default: false
     },
+    metric: {
+      type: "string",
+      description: "Activity metric: tokens, sessions, or messages"
+    },
+    days: {
+      type: "string",
+      description: "Number of days to include in the activity graph"
+    },
     // Share option for usage mode
     share: {
       type: "boolean",
@@ -2199,7 +2695,9 @@ var main = defineCommand({
       console.log(JSON.stringify(config, null, 2));
       return;
     }
-    if (args.wrapped) {
+    if (args.activity) {
+      await runActivity(args, config);
+    } else if (args.wrapped) {
       await runWrapped(args, config);
     } else {
       await runUsage(args, config);
@@ -2270,10 +2768,13 @@ async function runUsage(args, config) {
   let shareUrl = null;
   if (args.share) {
     const fullUrl = encodeUsageToUrl(stats, baseUrl);
-    if (!args["no-short"]) {
-      shareUrl = await createShortlink(fullUrl, baseUrl);
-    }
-    shareUrl = shareUrl || fullUrl;
+    const shared = await publishArtifactWithFallback(
+      buildUsageArtifact(stats),
+      baseUrl,
+      fullUrl,
+      Boolean(args["no-short"])
+    );
+    shareUrl = shared.shareUrl;
   }
   if (args.quiet && args.share && shareUrl) {
     console.log(shareUrl);
@@ -2306,9 +2807,14 @@ async function runUsage(args, config) {
 }
 async function runWrapped(args, config) {
   const options = resolveOptions(args, config);
+  const metric = parseActivityMetric(args.metric);
+  const days = parseActivityDays(args.days);
   const spinner = createSpinner("Preparing wrapped...");
-  const data = await spinner.whilePromise(
-    loadData({ codexOnly: args.codex, combined: args.combined })
+  const [data, activityStats] = await spinner.whilePromise(
+    Promise.all([
+      loadData({ codexOnly: args.codex, combined: args.combined }),
+      loadActivityStats({ codexOnly: args.codex, combined: args.combined })
+    ])
   );
   validateData(data, { codexOnly: args.codex, combined: args.combined });
   let claudeStats = null;
@@ -2327,23 +2833,89 @@ async function runWrapped(args, config) {
   } else {
     stats = claudeStats;
   }
-  const url = encodeStatsToUrl(stats, options.baseUrl);
-  let shortUrl = null;
-  if (!args["no-short"]) {
-    shortUrl = await createShortlink(url, options.baseUrl);
+  if (activityStats) {
+    stats.activity = buildActivityGraph(activityStats, metric, days);
   }
+  const legacyUrl = encodeStatsToUrl(stats, options.baseUrl);
+  const published = await publishArtifactWithFallback(
+    buildWrappedArtifact(stats),
+    options.baseUrl,
+    legacyUrl,
+    Boolean(args["no-short"])
+  );
   if (options.outputFormat === "json") {
-    console.log(JSON.stringify({ ...stats, url, shortUrl }, null, 2));
+    console.log(
+      JSON.stringify(
+        {
+          ...stats,
+          url: published.canonicalUrl,
+          shortUrl: published.shareUrl === published.canonicalUrl ? null : published.shareUrl,
+          imageUrl: published.imageUrl
+        },
+        null,
+        2
+      )
+    );
   } else if (options.outputFormat === "quiet") {
-    console.log(shortUrl || url);
+    console.log(published.shareUrl);
   } else {
-    displayWrappedStats(stats, url, {
+    displayWrappedStats(stats, published.canonicalUrl, {
       theme: options.theme,
       hideCost: options.hideCost,
-      shortUrl
+      shortUrl: published.shareUrl === published.canonicalUrl ? null : published.shareUrl,
+      imageUrl: published.imageUrl
     });
   }
 }
+async function runActivity(args, config) {
+  const metric = parseActivityMetric(args.metric);
+  const days = parseActivityDays(args.days);
+  const spinner = createSpinner("Preparing activity graph...");
+  const stats = await spinner.whilePromise(
+    loadActivityStats({
+      codexOnly: args.codex,
+      combined: args.combined,
+      projectFilter: args.project ? process.cwd() : void 0,
+      since: args.since,
+      until: args.until
+    })
+  );
+  if (!stats) {
+    console.error("Error: No activity data found.");
+    process.exit(1);
+  }
+  const artifact = buildActivityArtifact(stats, metric, days);
+  const baseUrl = args.url || config.baseUrl || "https://vibestats.wolfai.dev";
+  const fallbackUrl = encodeActivityToUrl(artifact.payload, baseUrl);
+  let shared = null;
+  if (args.share) {
+    shared = await publishArtifactWithFallback(artifact, baseUrl, fallbackUrl, Boolean(args["no-short"]));
+  }
+  if (args.json) {
+    console.log(
+      JSON.stringify(
+        {
+          ...artifact.payload,
+          url: shared?.canonicalUrl || null,
+          shortUrl: shared && shared.shareUrl !== shared.canonicalUrl ? shared.shareUrl : null,
+          imageUrl: shared?.imageUrl || null
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (args.quiet) {
+    console.log(shared?.shareUrl || fallbackUrl);
+    return;
+  }
+  displayActivityStats(artifact.payload, shared?.canonicalUrl || fallbackUrl, {
+    theme: config.theme,
+    shortUrl: shared && shared.shareUrl !== shared.canonicalUrl ? shared.shareUrl : null,
+    imageUrl: shared?.imageUrl || null
+  });
+}
 function formatNumber2(n) {
   if (n >= 1e9) return `${(n / 1e9).toFixed(1)}B`;
   if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;