vibestats 1.3.2 → 1.3.4

package/dist/index.js

@@ -24,6 +24,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 +86,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,6 +108,7 @@ 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";
@@ -108,172 +119,272 @@ function getModelDisplayName(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
+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"]
   },
-  "gpt-5.3-codex-spark": {
-    input: 1.75,
-    output: 14,
-    cachedInput: 0.175
+  {
+    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"]]
   },
-  "gpt-5.3-codex": {
-    input: 1.75,
-    output: 14,
-    cachedInput: 0.175
+  {
+    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"]]
   },
-  // GPT-5.2
-  // Cached input is ~10% of input price (prompt caching discount)
-  "gpt-5.2": {
-    input: 1.75,
-    output: 14,
-    cachedInput: 0.175
+  {
+    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"]]
   },
-  "gpt-5.2-codex": {
-    input: 1.75,
-    output: 14,
-    cachedInput: 0.175
+  {
+    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"]]
   },
-  // GPT-5.1 models
-  "gpt-5.1": {
-    input: 1.25,
-    output: 10,
-    cachedInput: 0.125
+  {
+    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"]]
   },
-  "gpt-5.1-codex": {
-    input: 1.25,
-    output: 10,
-    cachedInput: 0.125
+  {
+    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"]]
   },
-  "gpt-5.1-codex-max": {
-    input: 1.25,
-    output: 10,
-    cachedInput: 0.125
+  {
+    key: "legacy-gpt-5.1-max",
+    displayName: "GPT-5.1 Max",
+    token: "g51m",
+    sortPriority: 70,
+    pricing: GPT_51_PRICING,
+    aliases: ["GPT-5.1 Max"]
   },
-  // GPT-5.1 Mini
-  "gpt-5.1-codex-mini": {
-    input: 0.25,
-    output: 2,
-    cachedInput: 0.025
+  {
+    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"]]
   },
-  // GPT-5 base models
-  "gpt-5": {
-    input: 1.25,
-    output: 10,
-    cachedInput: 0.125
+  {
+    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"]
   },
-  "gpt-5-codex": {
-    input: 1.25,
-    output: 10,
-    cachedInput: 0.125
+  {
+    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"]]
   },
-  // GPT-5 Mini variants
-  "gpt-5-mini": {
-    input: 0.25,
-    output: 2,
-    cachedInput: 0.025
+  {
+    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"]]
   },
-  "gpt-5-codex-mini": {
-    input: 0.25,
-    output: 2,
-    cachedInput: 0.025
+  {
+    key: "gpt-5",
+    displayName: "GPT-5",
+    token: "g5",
+    sortPriority: 64,
+    pricing: GPT_51_PRICING,
+    aliases: ["GPT-5"],
+    exactNames: ["gpt-5"]
   },
-  // GPT-5 Nano
-  "gpt-5-nano": {
-    input: 0.05,
-    output: 0.4,
-    cachedInput: 5e-3
+  {
+    key: "gpt-5-codex",
+    displayName: "GPT-5 Codex",
+    sortPriority: 64,
+    pricing: GPT_51_PRICING,
+    aliases: ["GPT-5 Codex"],
+    exactNames: ["gpt-5-codex"]
   },
-  // GPT-4o (fallback for older sessions)
-  "gpt-4o": {
-    input: 2.5,
-    output: 10,
-    cachedInput: 1.25
+  {
+    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"]
   },
-  "gpt-4o-mini": {
-    input: 0.15,
-    output: 0.6,
-    cachedInput: 0.075
+  {
+    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) {
-  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 findCodexModelDefinition(modelName)?.pricing ?? GPT_51_PRICING;
+}
+function getCodexModelAbbreviation(modelName) {
+  const definition = findCodexModelDefinition(modelName);
+  if (definition?.token) {
+    return definition.token;
   }
-  return CODEX_MODEL_PRICING["gpt-5"];
+  return encodeRawModelToken(getCodexModelDisplayName(modelName));
 }
 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;
+  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);
@@ -479,36 +590,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;
   });
 }
@@ -1633,9 +1730,9 @@ function encodeStatsToUrl(stats, baseUrl = "https://vibestats.wolfai.dev") {
   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));
+  params.set("fm", getModelTokenFromDisplayName(stats.favoriteModel));
   const mbParts = stats.modelBreakdown.slice(0, 3).map((m) => {
-    const abbr = getModelAbbrevFromDisplayName(m.model);
+    const abbr = getModelTokenFromDisplayName(m.model);
     return `${abbr}:${m.percentage}`;
   });
   params.set("mb", mbParts.join(","));
@@ -1665,60 +1762,36 @@ function encodeStatsToUrl(stats, baseUrl = "https://vibestats.wolfai.dev") {
   }
   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];
+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("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.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 displayName.slice(0, 5).toLowerCase();
+  return getCodexModelAbbreviation(displayName);
 }
 function aggregateRowsToMonthly(rows) {
   const monthMap = /* @__PURE__ */ new Map();
@@ -1787,7 +1860,7 @@ function encodeUsageToUrl(stats, baseUrl = "https://vibestats.wolfai.dev") {
   ].join(":"));
   if (stats.modelBreakdown.length > 0) {
     const mb = stats.modelBreakdown.slice(0, 5).map((m) => {
-      const abbr = getModelAbbrevFromDisplayName(m.model);
+      const abbr = getModelTokenFromDisplayName(m.model);
       return `${abbr}:${m.percentage}:${m.cost.toFixed(2)}`;
     });
     params.set("mb", mb.join(","));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibestats",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "description": "AI coding stats - usage tracking and annual wrapped for Claude Code & Codex",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,11 +18,6 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "dev": "tsx src/index.ts",
-    "build": "tsup src/index.ts --format esm --dts --clean --shims",
-    "prepublishOnly": "pnpm build"
-  },
   "keywords": [
     "claude",
     "claude-code",
@@ -50,5 +45,10 @@
   },
   "engines": {
     "node": ">=18.0.0"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsup src/index.ts --format esm --dts --clean --shims",
+    "test": "tsx --test src/**/*.test.ts"
   }
-}
+}