vibestats 1.0.21 → 1.0.23

package/dist/index.js

@@ -4,7 +4,7 @@
 import { defineCommand, runMain } from "citty";
 
 // src/usage/loader.ts
-import { readFileSync, existsSync, readdirSync, statSync, realpathSync } from "fs";
+import { promises as fs } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 
@@ -232,51 +232,73 @@ function calculateCodexCost(modelName, inputTokens, outputTokens, cachedInputTok
 }
 
 // src/usage/loader.ts
+var MAX_RECURSION_DEPTH = 10;
+function toLocalDateString(isoTimestamp) {
+  const date = new Date(isoTimestamp);
+  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 getClaudeDir() {
   return process.env.CLAUDE_HOME || join(homedir(), ".claude");
 }
 function getCodexDir() {
   return join(homedir(), ".codex");
 }
-function findJsonlFiles(dir, visited = /* @__PURE__ */ new Set(), depth = 0, result = []) {
-  if (!existsSync(dir)) return result;
-  if (depth > 10) return result;
-  let realPath;
+async function pathExists(path) {
+  try {
+    await fs.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function safeRealpath(path) {
   try {
-    realPath = realpathSync(dir);
+    return await fs.realpath(path);
   } catch {
-    realPath = dir;
+    return path;
   }
+}
+async function findJsonlFiles(dir, visited = /* @__PURE__ */ new Set(), depth = 0, result = []) {
+  if (!await pathExists(dir)) return result;
+  if (depth > MAX_RECURSION_DEPTH) return result;
+  const realPath = await safeRealpath(dir);
   if (visited.has(realPath)) return result;
   visited.add(realPath);
+  let entries;
   try {
-    const entries = readdirSync(dir);
-    for (const entry of entries) {
-      const fullPath = join(dir, entry);
-      try {
-        const stat = statSync(fullPath);
-        if (stat.isDirectory()) {
-          findJsonlFiles(fullPath, visited, depth + 1, result);
-        } else if (entry.endsWith(".jsonl")) {
-          result.push(fullPath);
-        }
-      } catch {
-      }
-    }
+    entries = await fs.readdir(dir);
   } catch {
+    return result;
+  }
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    let stat;
+    try {
+      stat = await fs.stat(fullPath);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      await findJsonlFiles(fullPath, visited, depth + 1, result);
+    } else if (entry.endsWith(".jsonl")) {
+      result.push(fullPath);
+    }
   }
   return result;
 }
-function parseClaudeJsonl() {
+async function parseClaudeJsonl() {
   const entries = [];
   const seenMessageIds = /* @__PURE__ */ new Set();
   const claudeDir = getClaudeDir();
   const projectsDir = join(claudeDir, "projects");
-  if (!existsSync(projectsDir)) return entries;
-  const jsonlFiles = findJsonlFiles(projectsDir);
+  if (!await pathExists(projectsDir)) return entries;
+  const jsonlFiles = await findJsonlFiles(projectsDir);
   for (const filePath of jsonlFiles) {
     try {
-      const content = readFileSync(filePath, "utf-8");
+      const content = await fs.readFile(filePath, "utf-8");
       const lines = content.split("\n");
       for (const line of lines) {
         if (!line.trim()) continue;
@@ -292,7 +314,7 @@ function parseClaudeJsonl() {
           const model = entry.message.model || "unknown";
           const timestamp = entry.timestamp;
           if (!timestamp) continue;
-          const date = timestamp.split("T")[0];
+          const date = toLocalDateString(timestamp);
           const pricing = getModelPricing(model);
           const inputTokens = usage.input_tokens || 0;
           const outputTokens = usage.output_tokens || 0;
@@ -317,19 +339,20 @@ function parseClaudeJsonl() {
   }
   return entries;
 }
-function parseCodexJsonl() {
+async function parseCodexJsonl() {
   const entries = [];
   const codexDir = getCodexDir();
   const sessionsDir = join(codexDir, "sessions");
   const archivedDir = join(codexDir, "archived_sessions");
-  const jsonlFiles = [
-    ...findJsonlFiles(sessionsDir),
-    ...findJsonlFiles(archivedDir)
-  ];
+  const [sessionFiles, archivedFiles] = await Promise.all([
+    findJsonlFiles(sessionsDir),
+    findJsonlFiles(archivedDir)
+  ]);
+  const jsonlFiles = [...sessionFiles, ...archivedFiles];
   if (jsonlFiles.length === 0) return entries;
   for (const filePath of jsonlFiles) {
     try {
-      const content = readFileSync(filePath, "utf-8");
+      const content = await fs.readFile(filePath, "utf-8");
       const lines = content.split("\n");
       let currentModel = "gpt-5";
       for (const line of lines) {
@@ -346,7 +369,7 @@ function parseCodexJsonl() {
             const usage = info.last_token_usage;
             const timestamp = entry.timestamp;
             if (!timestamp) continue;
-            const date = timestamp.split("T")[0];
+            const date = toLocalDateString(timestamp);
             const pricing = getCodexModelPricing(currentModel);
             const inputTokens = usage.input_tokens || 0;
             const outputTokens = usage.output_tokens || 0;
@@ -356,7 +379,6 @@ function parseCodexJsonl() {
               date,
               model: getCodexModelDisplayName(currentModel),
               inputTokens: inputTokens - cachedInputTokens,
-              // OpenAI input_tokens includes cached, so subtract
               outputTokens,
               cacheWriteTokens: 0,
               cacheReadTokens: cachedInputTokens,
@@ -381,7 +403,6 @@ function filterByDateRange(entries, since, until) {
 }
 function sortModelsByTier(models) {
   const tierPriority = {
-    // Claude models (higher = first)
     "Opus 4.5": 100,
     "Opus 4.1": 99,
     "Opus": 98,
@@ -391,7 +412,6 @@ function sortModelsByTier(models) {
     "Haiku 4.5": 80,
     "Haiku 3.5": 79,
     "Haiku": 78,
-    // OpenAI/Codex models
     "GPT-5.2": 70,
     "GPT-5.1 Max": 69,
     "GPT-5.1": 68,
@@ -526,14 +546,14 @@ function computeModelBreakdown(entries) {
     percentage: totalTokens > 0 ? Math.round(data.tokens / totalTokens * 100) : 0
   })).sort((a, b) => b.tokens - a.tokens);
 }
-function loadUsageStats(options) {
+async function loadUsageStats(options) {
   const { aggregation, since, until, codexOnly, combined } = options;
   let entries = [];
   if (!codexOnly) {
-    entries = entries.concat(parseClaudeJsonl());
+    entries = entries.concat(await parseClaudeJsonl());
   }
   if (codexOnly || combined) {
-    entries = entries.concat(parseCodexJsonl());
+    entries = entries.concat(await parseCodexJsonl());
   }
   if (entries.length === 0) {
     return null;
@@ -733,27 +753,46 @@ function displayTotalOnly(stats, options = {}) {
 }
 
 // src/claude-jsonl-loader.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { promises as fs2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
 function getClaudeDir2() {
   return process.env.CLAUDE_HOME || join2(homedir2(), ".claude");
 }
-function claudeJsonlDataExists() {
-  const claudeDir = getClaudeDir2();
-  const projectsDir = join2(claudeDir, "projects");
-  return existsSync2(projectsDir);
+function toLocalDateString2(isoTimestamp) {
+  const date = new Date(isoTimestamp);
+  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}`;
+}
+async function pathExists2(path) {
+  try {
+    await fs2.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function claudeJsonlDataExists() {
+  const projectsDir = join2(getClaudeDir2(), "projects");
+  return pathExists2(projectsDir);
 }
-function findJsonlFiles2(dir) {
+async function findJsonlFiles2(dir) {
   const files = [];
-  if (!existsSync2(dir)) return files;
-  const entries = readdirSync2(dir);
+  if (!await pathExists2(dir)) return files;
+  let entries;
+  try {
+    entries = await fs2.readdir(dir);
+  } catch {
+    return files;
+  }
   for (const entry of entries) {
     const fullPath = join2(dir, entry);
     try {
-      const stat = statSync2(fullPath);
+      const stat = await fs2.stat(fullPath);
       if (stat.isDirectory()) {
-        files.push(...findJsonlFiles2(fullPath));
+        files.push(...await findJsonlFiles2(fullPath));
       } else if (entry.endsWith(".jsonl")) {
         files.push(fullPath);
       }
@@ -762,13 +801,13 @@ function findJsonlFiles2(dir) {
   }
   return files;
 }
-function loadClaudeStatsFromJsonl() {
+async function loadClaudeStatsFromJsonl() {
   const claudeDir = getClaudeDir2();
   const projectsDir = join2(claudeDir, "projects");
-  if (!claudeJsonlDataExists()) {
+  if (!await claudeJsonlDataExists()) {
     return null;
   }
-  const jsonlFiles = findJsonlFiles2(projectsDir);
+  const jsonlFiles = await findJsonlFiles2(projectsDir);
   if (jsonlFiles.length === 0) {
     return null;
   }
@@ -780,7 +819,7 @@ function loadClaudeStatsFromJsonl() {
   const messageIds = /* @__PURE__ */ new Set();
   for (const filePath of jsonlFiles) {
     try {
-      const content = readFileSync2(filePath, "utf-8");
+      const content = await fs2.readFile(filePath, "utf-8");
       const lines = content.split("\n");
       for (const line of lines) {
         if (!line.trim()) continue;
@@ -808,7 +847,7 @@ function loadClaudeStatsFromJsonl() {
             messageIds.add(messageId);
           }
           if (timestamp) {
-            const date = timestamp.split("T")[0];
+            const date = toLocalDateString2(timestamp);
             const hour = new Date(timestamp).getHours().toString();
             if (!dailyMap.has(date)) {
               dailyMap.set(date, { messageCount: 0, sessionCount: 0, toolCallCount: 0 });
@@ -839,7 +878,6 @@ function loadClaudeStatsFromJsonl() {
       cacheCreationInputTokens: usage.cacheCreationInputTokens,
       webSearchRequests: 0,
       costUSD: 0,
-      // Will be calculated by metrics.ts
       contextWindow: 2e5
     };
   }
@@ -847,16 +885,15 @@ function loadClaudeStatsFromJsonl() {
     date,
     messageCount: data.messageCount,
     sessionCount: 1,
-    // Each day counts as at least 1 session for activity
     toolCallCount: data.toolCallCount
   })).sort((a, b) => a.date.localeCompare(b.date));
   const sessionsByDate = /* @__PURE__ */ new Map();
+  void sessionsByDate;
   return {
     version: 1,
-    lastComputedDate: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    lastComputedDate: toLocalDateString2((/* @__PURE__ */ new Date()).toISOString()),
     dailyActivity,
     dailyModelTokens: [],
-    // Not needed for wrapped stats
     modelUsage: statsCacheModelUsage,
     totalSessions: jsonlFiles.length,
     totalMessages,
@@ -872,37 +909,62 @@ function loadClaudeStatsFromJsonl() {
 }
 
 // src/codex-loader.ts
-import { readFileSync as readFileSync3, existsSync as existsSync3, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { promises as fs3 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join3 } from "path";
 function getCodexDir2() {
   return process.env.CODEX_HOME || join3(homedir3(), ".codex");
 }
-function codexDataExists() {
+function toLocalDateString3(isoTimestamp) {
+  const date = new Date(isoTimestamp);
+  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}`;
+}
+async function pathExists3(path) {
+  try {
+    await fs3.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function codexDataExists() {
   const codexDir = getCodexDir2();
-  if (!existsSync3(codexDir)) return false;
+  if (!await pathExists3(codexDir)) return false;
   const sessionsDir = join3(codexDir, "sessions");
   const archivedDir = join3(codexDir, "archived_sessions");
-  return existsSync3(sessionsDir) || existsSync3(archivedDir);
+  return await pathExists3(sessionsDir) || await pathExists3(archivedDir);
 }
-function findJsonlFiles3(dir) {
+async function findJsonlFiles3(dir) {
   const files = [];
-  if (!existsSync3(dir)) return files;
-  const entries = readdirSync3(dir);
+  if (!await pathExists3(dir)) return files;
+  let entries;
+  try {
+    entries = await fs3.readdir(dir);
+  } catch {
+    return files;
+  }
   for (const entry of entries) {
     const fullPath = join3(dir, entry);
-    const stat = statSync3(fullPath);
+    let stat;
+    try {
+      stat = await fs3.stat(fullPath);
+    } catch {
+      continue;
+    }
     if (stat.isDirectory()) {
-      files.push(...findJsonlFiles3(fullPath));
+      files.push(...await findJsonlFiles3(fullPath));
     } else if (entry.endsWith(".jsonl")) {
       files.push(fullPath);
     }
   }
   return files;
 }
-function parseSessionFile(filePath) {
+async function parseSessionFile(filePath) {
   try {
-    const content = readFileSync3(filePath, "utf-8");
+    const content = await fs3.readFile(filePath, "utf-8");
     const lines = content.trim().split("\n");
     let sessionMeta = null;
     let currentModel = "gpt-5";
@@ -969,29 +1031,29 @@ function parseSessionFile(filePath) {
       model: primaryModel,
       tokenUsage: summedUsage,
       perModelUsage
-      // New: per-model token breakdown
     };
   } catch {
     return null;
   }
 }
-function loadCodexStats() {
+async function loadCodexStats() {
   const codexDir = getCodexDir2();
-  if (!codexDataExists()) {
+  if (!await codexDataExists()) {
     return null;
   }
   const sessionsDir = join3(codexDir, "sessions");
   const archivedDir = join3(codexDir, "archived_sessions");
-  const jsonlFiles = [
-    ...findJsonlFiles3(sessionsDir),
-    ...findJsonlFiles3(archivedDir)
-  ];
+  const [sessionFiles, archivedFiles] = await Promise.all([
+    findJsonlFiles3(sessionsDir),
+    findJsonlFiles3(archivedDir)
+  ]);
+  const jsonlFiles = [...sessionFiles, ...archivedFiles];
   if (jsonlFiles.length === 0) {
     return null;
   }
   const sessions = [];
   for (const file of jsonlFiles) {
-    const session = parseSessionFile(file);
+    const session = await parseSessionFile(file);
     if (session) {
       sessions.push(session);
     }
@@ -1034,7 +1096,7 @@ function loadCodexStats() {
   }
   const dailyMap = /* @__PURE__ */ new Map();
   for (const session of sessions) {
-    const date = session.timestamp.split("T")[0];
+    const date = toLocalDateString3(session.timestamp);
     dailyMap.set(date, (dailyMap.get(date) || 0) + 1);
   }
   const dailyActivity = Array.from(dailyMap.entries()).map(([date, sessionCount]) => ({ date, sessionCount })).sort((a, b) => a.date.localeCompare(b.date));
@@ -1051,23 +1113,23 @@ function loadCodexStats() {
     modelUsage,
     dailyActivity,
     hourCounts,
-    firstSessionDate: sessions[0].timestamp.split("T")[0]
+    firstSessionDate: toLocalDateString3(sessions[0].timestamp)
   };
 }
 
 // src/shared/data-loader.ts
-function loadData(options) {
+async function loadData(options) {
   const { codexOnly, combined } = options;
   let claude = null;
   let codex = null;
   if (!codexOnly) {
-    if (claudeJsonlDataExists()) {
-      claude = loadClaudeStatsFromJsonl();
+    if (await claudeJsonlDataExists()) {
+      claude = await loadClaudeStatsFromJsonl();
     }
   }
   if (codexOnly || combined) {
-    if (codexDataExists()) {
-      codex = loadCodexStats();
+    if (await codexDataExists()) {
+      codex = await loadCodexStats();
     }
   }
   let source = "claude";
@@ -1092,6 +1154,12 @@ function validateData(data, options) {
 }
 
 // src/metrics.ts
+function toLocalDateString4(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 calculateModelCost(modelName, usage) {
   const pricing = getModelPricing(modelName);
   const inputCost = usage.inputTokens / 1e6 * pricing.input;
@@ -1130,7 +1198,7 @@ function calculateStreaks(dailyActivity) {
   let checkDate = today;
   current = 0;
   while (true) {
-    const dateStr = checkDate.toISOString().split("T")[0];
+    const dateStr = toLocalDateString4(checkDate);
     if (dateSet.has(dateStr)) {
       current++;
       checkDate = new Date(checkDate.getTime() - 24 * 60 * 60 * 1e3);
@@ -1705,7 +1773,7 @@ async function createShortlink(params, baseUrl) {
 }
 
 // src/config.ts
-import { readFileSync as readFileSync4, existsSync as existsSync4, writeFileSync } from "fs";
+import { readFileSync, existsSync, writeFileSync } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join4 } from "path";
 var CONFIG_PATH = join4(homedir4(), ".vibestats.json");
@@ -1718,11 +1786,11 @@ var DEFAULT_CONFIG = {
   hideCost: false
 };
 function loadConfig() {
-  if (!existsSync4(CONFIG_PATH)) {
+  if (!existsSync(CONFIG_PATH)) {
     return DEFAULT_CONFIG;
   }
   try {
-    const content = readFileSync4(CONFIG_PATH, "utf-8");
+    const content = readFileSync(CONFIG_PATH, "utf-8");
     const userConfig = JSON.parse(content);
     return mergeConfig(DEFAULT_CONFIG, userConfig);
   } catch {
@@ -1741,7 +1809,7 @@ function mergeConfig(defaults, user) {
   };
 }
 function initConfig() {
-  if (existsSync4(CONFIG_PATH)) {
+  if (existsSync(CONFIG_PATH)) {
     console.log(`Config file already exists at ${CONFIG_PATH}`);
     return;
   }
@@ -1772,6 +1840,41 @@ function resolveOptions(cliArgs, config) {
 }
 
 // src/index.ts
+function createSpinner(label = "Loading vibestats...") {
+  const spinnerFrames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  const orange = "\x1B[38;5;208m";
+  const bold = "\x1B[1m";
+  const reset = "\x1B[0m";
+  let spinnerIdx = 0;
+  let interval = null;
+  const render = () => {
+    const frame = spinnerFrames[spinnerIdx];
+    process.stdout.write(`\r${orange}${frame}${reset} ${bold}${label}${reset}   `);
+    spinnerIdx = (spinnerIdx + 1) % spinnerFrames.length;
+  };
+  const start = () => {
+    if (interval) return;
+    process.stdout.write("\x1B[?25l");
+    render();
+    interval = setInterval(render, 80);
+  };
+  const stop = () => {
+    if (!interval) return;
+    clearInterval(interval);
+    interval = null;
+    process.stdout.write("\r\x1B[2K");
+    process.stdout.write("\x1B[?25h");
+  };
+  const whilePromise = async (promise) => {
+    start();
+    try {
+      return await promise;
+    } finally {
+      stop();
+    }
+  };
+  return { whilePromise, stop };
+}
 var main = defineCommand({
   meta: {
     name: "vibestats",
@@ -1899,13 +2002,16 @@ async function runUsage(args, config) {
   if (args.monthly) aggregation = "monthly";
   else if (args.model) aggregation = "model";
   else if (args.total) aggregation = "total";
-  const stats = loadUsageStats({
-    aggregation,
-    since: args.since,
-    until: args.until,
-    codexOnly: args.codex,
-    combined: args.combined
-  });
+  const spinner = createSpinner("Loading vibestats...");
+  const stats = await spinner.whilePromise(
+    loadUsageStats({
+      aggregation,
+      since: args.since,
+      until: args.until,
+      codexOnly: args.codex,
+      combined: args.combined
+    })
+  );
   if (!stats) {
     if (args.codex) {
       console.error("Error: OpenAI Codex data not found at ~/.codex");
@@ -1959,7 +2065,10 @@ async function runUsage(args, config) {
 }
 async function runWrapped(args, config) {
   const options = resolveOptions(args, config);
-  const data = loadData({ codexOnly: args.codex, combined: args.combined });
+  const spinner = createSpinner("Preparing wrapped...");
+  const data = await spinner.whilePromise(
+    loadData({ codexOnly: args.codex, combined: args.combined })
+  );
   validateData(data, { codexOnly: args.codex, combined: args.combined });
   let claudeStats = null;
   let codexStats = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibestats",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "description": "AI coding stats - usage tracking and annual wrapped for Claude Code & Codex",
   "type": "module",
   "main": "./dist/index.js",